MerchantReturnPolicy Schema

TL;DR — MerchantReturnPolicy is a bit of code that tells Google your return policy — how many days customers have to return something, who pays return shipping, and what refund they get. You don’t put it on a page by itself; you attach it to your business (Organization) or to a specific product (Offer) using a property called hasMerchantReturnPolicy. It can make your return details show up right in search results, but it isn’t required to get a product listing, and it won’t make you rank higher.

What it is

When shoppers are deciding whether to buy, the return policy is one of the first things they check. MerchantReturnPolicy is structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. — a small block of machine-readable code — that spells out your return policy so Google can read it: the return window, the fees, how customers return things, and what refund they get. When Google can read it clearly, it can show that information right in the product’s search listing and in knowledge panelsThe Knowledge Graph is Google's database of entities — people, places, organizations, and things — and the factual relationships between them. It's separate from any single website's structured data: your schema markup is one of many possible inputs to the graph, not the graph itself., so people don’t have to click through to a policy page to find out.

It’s part of the broader structured data family (the schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. vocabulary, usually written in a format called JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal.). If you’ve read about Product or Offer schema for ecommerce pages, this is the piece that describes returns.

The one thing to understand first

MerchantReturnPolicy is never marked up on its own. It’s not a page type like Product. Instead, you nest it inside something else using a property called hasMerchantReturnPolicy, and you have two choices for where:

• Under Organization — one standard return policy for your whole business, set once, applied to most or all products. This is the easy path for most sites.
• Under Offer — a return policy for one specific product, used only when that product’s policy is different from your standard one.

Think of it as an attribute of your business or a product, not a page in its own right.

What you have to include

Once you decide to use it, Google gives you two options for the required information — pick whichever fits:

• Option A: the country the policy applies to (applicableCountry) plus the type of policy (returnPolicyCategory — basically “you have X days,” “unlimited time,” or “no returns”). If you say “X days,” you also have to say how many (merchantReturnDays).
• Option B: just a link to your return-policy page (merchantReturnLink).

Option B is the simplest — if keeping detailed markup current sounds like a chore, a link to your policy page is a valid way to do it.

What most people get wrong

You don’t need this to get a product listing in Google. Some guides frame return-policy markup as a 2026 “requirement” for product rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show.. It isn’t — it’s a recommended enhancement. Skipping it doesn’t disqualify your product from appearing; it just means the returns detail won’t show. Like all structured data, it doesn’t make you rank higher either.

And here’s the sneaky part: if you also set a return policy in Google Merchant Center or Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results., those settings win over the code on your page. You could have flawless markup and still see a different policy displayed. More on that in the Advanced tab.

Want the full picture — the exact property list, the applicableCountry vs. returnPolicyCountry trap, seasonal overrides, and the four-way precedence hierarchy that decides which policy actually shows? Switch to the Advanced tab.

TL;DR — MerchantReturnPolicy is a nested, property-level type, not a standalone markup: it’s the value of hasMerchantReturnPolicy on Organization (site-wide default) or Offer (per-product override). Required is a two-option choice — applicableCountry + returnPolicyCategory, or merchantReturnLink; and MerchantReturnFiniteReturnWindow makes merchantReturnDays required. applicableCountry (where the policy applies) is not returnPolicyCountry (where the item physically ships back to) — that conflation is spreading and it’s wrong. It is not a base-eligibility requirement for Product rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. — it’s a recommended enhancement gating only the returns display. And a return policy can be defined in four places with a strict precedence order (Content API → Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads./Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. settings → product-level markup → organization-level markup), where Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. settings override your on-page structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. entirely.

What it actually is — a nested type, not a listing type

This is the mental model everything else hangs on. MerchantReturnPolicy is not a schema you mark up on its own as the primary type of a page, the way you would Product or JobPosting. It’s a property-level type: an instance of it is the value of the hasMerchantReturnPolicy property, attached to one of two parent types.

Google’s own docs lay out the two levels explicitly: “A standard return policy for your business that applies to most or all products you sell can be specified using the MerchantReturnPolicy structured data type nested under the Organization structured data type using the hasMerchantReturnPolicy property. If you need to override your standard return policy for a specific product, specify one or more instances of MerchantReturnPolicy under the Offer type.”

So it’s a companion to the Product/Offer types, not a competitor to them. If you’ve read my commerce schema hub\"Commerce schema\" is a practitioner label — not an official Google or schema.org category — for the schema.org listing types that power transactional rich results: Product, ProductGroup, and JobPosting. — my practitioner label for the schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. listing types (Product, ProductGroup, JobPosting) that earn their own rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. — MerchantReturnPolicy is deliberately not in that group. Those are the pages you mark up; this is a property you attach to them.

Required properties: a two-option choice

Once you use it, Google requires one of two options — “choose the option that best suits your use case”:

Option A — structured details:

• applicableCountry (Text) — “The country code that the return policy applies to (where the product is sold and will be returned from). Use the two-letter ISO 3166-1 alpha-2 country code formatting. You can specify up to 50 countries.”
• returnPolicyCategory (MerchantReturnEnumeration) — the type of return policy, one of three enum values (below).

Option B — just a link:

• merchantReturnLink (URL) — “Specify the URL of a web page that describes the return policy to your customers. This can be your own return policy, or a third-party policy from a service that handles your returns.”

Option B is the escape hatch for merchants who can’t keep detailed markup current — point at the policy page and be done.

The three returnPolicyCategory values

Straight from Google’s docs, these are the only three valid values, and they must be the full schema.org URL, not plain text like “30 days” (using plain text is one of the most common validation errors):

• https://schema.org/MerchantReturnFiniteReturnWindow — “There’s a set number of days to return a product.”
• https://schema.org/MerchantReturnUnlimitedWindow — “There’s an unlimited amount of time to return a product.”
• https://schema.org/MerchantReturnNotPermitted — “Returns aren’t permitted.”

When merchantReturnDays becomes required

There’s one conditional requirement to remember: “If you use MerchantReturnFiniteReturnWindow, then the merchantReturnDays property is required.” So a finite window without a day count is invalid — if you say customers have a set number of days, you have to say how many.

applicableCountry vs. returnPolicyCountry — the property everyone confuses

This is worth its own section, because a factual error is actively spreading through secondary SEO content — including some higher-authority coverage that framed returnPolicyCountry as “now required.” It isn’t. Here’s the distinction, straight from the live doc:

• applicableCountry is required (as part of Option A) and describes where the policy applies — where the product is sold and returnable from.
• returnPolicyCountry is recommended, not required, and describes something different: “The country where the product has to be sent to for returns. This country can be different from the country where the product was originally shipped or sent to.”

Google’s own example makes the difference concrete: "applicableCountry": ["DE", "AT", "CH"], "returnPolicyCountry": "IE" — i.e., the policy applies to (and products are returnable from) Germany, Austria, and Switzerland, but the physical return address is in Ireland. Two different concepts, two different properties. If a source tells you returnPolicyCountry is required, check it against Google’s return-policy doc — the required field is applicableCountry.

Recommended enrichment properties

Beyond the required minimum, these recommended properties make the returns display richer. All are enum-based:

• returnFees (ReturnFeesEnumeration): FreeReturn, ReturnFeesCustomerResponsibility, or ReturnShippingFees (a merchant-charged shipping fee — specify the non-zero amount with returnShippingFeesAmount).
• returnMethod (ReturnMethodEnumeration): ReturnAtKiosk, ReturnByMail, ReturnInStore.
• refundType (RefundTypeEnumeration): ExchangeRefund, FullRefund, StoreCreditRefund.
• restockingFee (MonetaryAmount or Number) — a percentage or fixed amount.
• returnLabelSource (ReturnLabelSourceEnumeration): ReturnLabelCustomerResponsibility, ReturnLabelDownloadAndPrint, ReturnLabelInBox.
• itemCondition, returnPolicyCountry, and itemDefectReturnShippingFeesAmount round out the common set.

Worth knowing: schema.org’s vocabulary for MerchantReturnPolicy is larger than this list — it also defines properties like customerRemorseReturnFees, inStoreReturnsOffered, and validForMemberTier that don’t appear in Google’s own return-policy doc. Schema.org validity and Google support are two different things. Stick to the properties Google’s docs actually list if your goal is the returns rich-result feature — the broader vocabulary exists, but Google hasn’t documented that it reads it.

Seasonal overrides for holiday windows

Return policies often loosen over the holidays, and there’s a property for exactly that: returnPolicySeasonalOverride (MerchantReturnPolicySeasonal). It lets you specify a different policy for a date range — its own returnPolicyCategory, merchantReturnDays, and startDate/endDate — without touching your standard policy. A retailer running an extended-holiday-returns window can layer that on top of the year-round default.

Organization-level vs. Offer-level: which to use

• Organization-level (hasMerchantReturnPolicy under Organization) is for your standard, business-wide policy. Set it once and it applies broadly. This is the right default for most sites, and it exists specifically so you don’t have to repeat the policy on every product page. Google recommends using one of the OnlineStore or LocalBusiness subtypes of Organization for this.
• Offer-level (hasMerchantReturnPolicy under Offer) is only for genuine exceptions — a specific product whose return terms differ from your standard.

And a caution from the precedence rules below: product-level (Offer) markup always wins over organization-level, so a stale or incorrect Offer-level override will silently beat a correct organization-level default. Don’t sprinkle Offer-level policies “to be safe.”

Is MerchantReturnPolicy required for Product rich results?

No — and this is the myth most worth busting. Google’s Product intro doc lists it as a recommended enhancement, not a base-eligibility requirement: “In addition to structured data for the individual products that you sell, we also recommend you add structured data defining the policies of your ecommerce business, nested under Organization markupOrganization schema (schema.org/Organization) is structured data that describes the business or entity itself — name, logo, official URL, social profiles, contact info, and identifiers — rather than a page's content. Google says it can help disambiguate your brand and some properties can influence visual elements like Knowledge Panel/attribution; it has no required properties and doesn't guarantee a Knowledge Panel.: Merchant return policy: Specify the return policy (or policies) for your business.” On the merchant-listing doc, hasMerchantReturnPolicy is a recommended property of Offer, not one of the required properties (like price and priceCurrency) that gate baseline eligibility.

Translation: omitting return-policy markup doesn’t disqualify a page from product snippets or merchant listings. It only means the returns enhancement won’t show. It’s an add-on, not an entry ticket. And per the broader structured data hubStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding., none of it is a ranking factor — it earns eligibility for an appearance, not position.

It’s also worth being precise about what “correct markup” actually proves. Valid schema.org syntax, Google-documented support for a property, syntactically valid JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal., rich-result eligibility, and the policy actually displaying in Search are five separate states — passing one doesn’t guarantee the next. And none of them are a ranking signal, a legal compliance guarantee, or a promise that an AI shoppingAI shopping optimization is the practice of making a merchant's products discoverable, recommendable, and buyable across AI shopping surfaces — ChatGPT, Google AI Mode, Gemini, Copilot, and Perplexity — by treating the structured product feed as a first-class optimization surface alongside the human-facing webpage, not a replacement for it. surface will read or honor the policy the way Search does — Google’s docs don’t claim any of that.

The precedence hierarchy — the real differentiator

Here’s the part almost no competing guide explains clearly. A return policy can be defined in four different places, and when more than one exists, only one wins. Google states the order of precedence, “from strongest to weakest”:

1. Content API for Shopping (return settings)
2. Settings in Merchant Center or Search Console
3. Product-level merchant listing markup (Offer)
4. Organization-level markup

I re-verified this exact order against Google’s live doc in July 2026, and it hasn’t changed since the November 2025 update below — but this is a doc family that moves, so re-check it against the live page rather than trusting any snapshot, including this one, indefinitely.

Google says it plainly: “if you provide both return policy markup on your site and return policy settings in Search Console, Google will only use the information provided in Search Console.” So your on-page structured data sits at the bottom of the stack — a Merchant Center or Search Console setting silently overrides it. This is the single most common source of “my markup is perfect but the wrong policy shows” confusion, and it’s why the first thing to check when a displayed policy disagrees with your code is whether something’s set in Search Console or Merchant Center.

Do you even need markup? Merchant Center and Search Console alternatives

Google is upfront that markup isn’t the only path, and often not the best one: “Retailer return policies can get complicated and may change frequently. If you’re having trouble indicating and keeping your return details up-to-date with markup and have a Google Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads. account, consider configuring your return policies in Google Merchant Center. You can alternatively configure account-level return policies in Search Console, which get automatically added to Merchant Center.”

So the decision is genuinely three-way: markup (Organization or Offer), Merchant Center settings, or Search Console settings. If you already have a Merchant Center account, Google recommends configuring returns there instead of in markup — it’s easier to keep current, and it outranks markup anyway.

Recent changes: the 2024–2025 timeline

This doc family moves fast, so the history matters:

• 2023 — Google enabled return-policy structured data for individual products (Offer-level) — the starting point, per Google’s own later framing.
• June 11, 2024 — Google added organization-level hasMerchantReturnPolicy support, so you could set one business-wide policy instead of repeating it per product. The Google Shopping engineers who announced it (Irina Tuduce, Pascal Fleury, and Johan Linder) framed it around merchants without a Merchant Center account: “Adding a return policy to your organization structured data is especially important if you don’t have a Merchant Center account and want the ability to provide a return policy for your business.”
• November 12, 2025 — Google expanded the Search Console “Shipping and returns” feature to all websites identified as online merchants (previously it required a Merchant Center account), and added organization-level shipping policy markup. Their note on precedence is worth pinning to the fridge: “It’s important to note that settings configured in Search Console will take precedence over structured data on your site.”

One clarification on that November 2025 update: the new shipping policy markup is a separate type from MerchantReturnPolicy — don’t conflate returns and shipping. Shipping policy is its own structured-data path (a ShippingService-style type). This article is about returns; shipping is a sibling topic.

How Bing handles this — spoiler, it doesn’t (specifically)

Be honest about the asymmetry. Bing’s Webmaster ToolsThe free, first-party consoles search engines give site owners — Google Search Console and Bing Webmaster Tools — to see how their pages are crawled, indexed, and ranked, and to fix problems. The legacy name is 'webmaster tools.' validate schema.org markup generically and Bing reads structured data, but Bing publishes no MerchantReturnPolicy-specific required/recommended property table, no dedicated returns rich-result feature, and no equivalent to Google’s shopping knowledge-panel returns display. Bing’s ecommerce guidance lives in its Shopping-ads feed specs, not in schema.org returns markup. This mirrors the same pattern I noted for Product, ProductGroup, and JobPosting in the commerce hub: Bing validates generically; Google builds dedicated features on top. So implement returns markup for Google — and don’t expect a parallel Bing feature.

Common mistakes and Search Console warnings

The recurring ones:

• Plain-text enum values. returnPolicyCategory must be the full https://schema.org/... URL, not “30 days” or “finite.” Same for returnFees, returnMethod, and refundType.
• Finite window with no day count. MerchantReturnFiniteReturnWindow without merchantReturnDays is invalid.
• Confusing applicableCountry with returnPolicyCountry (see above).
• “Missing field hasMerchantReturnPolicy (in offers).” This Search Console warning means the returns enhancement is unavailable because the property is absent — but map it to the precedence hierarchy before you panic-add markup: if you’ve set returns in Search Console or Merchant Center, that’s what shows anyway, and the markup warning may be moot.
• Markup/visible-content mismatch. As with all structured data, the policy in your markup should match what’s actually on the page.
• Repeating return markup on every product page when an Organization-level policy would cover them all — the entire point of the 2024 launch.

Where this fits

MerchantReturnPolicy is a companion deep-dive to the commerce schema hub\"Commerce schema\" is a practitioner label — not an official Google or schema.org category — for the schema.org listing types that power transactional rich results: Product, ProductGroup, and JobPosting. (Product, ProductGroup, JobPosting) — it’s the property-level type you attach to Offer and Organization, not a fourth listing type. It sits inside the broader structured data for SEOStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. subcluster alongside schema markupSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor., JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal., and rich results, which in turn lives in the on-page SEO cluster. Shipping-policy markup — the sibling that shipped alongside the November 2025 update — is a separate type worth its own treatment.

AI summary

A condensed take on the Advanced version:

• It’s a nested, property-level type, not a standalone markup. MerchantReturnPolicy is the value of hasMerchantReturnPolicy on Organization (one site-wide policy) or Offer (a per-product override). It’s a companion to Product/Offer, not a fourth listing type like Product/ProductGroup/JobPosting.
• Required is a two-option choice: applicableCountry + returnPolicyCategory, or just merchantReturnLink. If returnPolicyCategory is MerchantReturnFiniteReturnWindow, then merchantReturnDays is required too.
• Three returnPolicyCategory enum values: FiniteReturnWindow (set number of days), UnlimitedWindow, NotPermitted — always the full schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. URL, never plain text.
• applicableCountry ≠ returnPolicyCountry. The first (required) is where the policy applies / product is sold and returnable from; the second (recommended) is where the item physically ships back to. Secondary sources conflate them — the live doc doesn’t.
• Not required for baseline Product rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show.. It’s a recommended enhancement that gates only the returns display — omitting it doesn’t disqualify a page from product snippets or merchant listings. Not a ranking factor either.
• Precedence, strongest → weakest: Content API for Shopping → Merchant Center/Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. settings → product-level (Offer) markup → organization-level markup. Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. settings override your on-page markup entirely.
• Recommended enrichment: returnFees, returnMethod, refundType, restockingFee, returnLabelSource, plus seasonal overrides (returnPolicySeasonalOverride) for holiday windows. Schema.org’s vocabulary is broader than this (e.g. customerRemorseReturnFees, validForMemberTier) — stick to properties Google’s own docs list if the goal is the Search enhancement.
• Five separate states, not one: valid schema.org syntax, Google-documented property support, valid JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal., rich-result eligibility, and actual display in Search don’t guarantee each other. None of them are a ranking signal, a legal compliance guarantee, or a promise an AI shoppingAI shopping optimization is the practice of making a merchant's products discoverable, recommendable, and buyable across AI shopping surfaces — ChatGPT, Google AI Mode, Gemini, Copilot, and Perplexity — by treating the structured product feed as a first-class optimization surface alongside the human-facing webpage, not a replacement for it. surface honors the policy.
• Timeline: Offer-level (2023) → organization-level launch (June 2024) → Search Console “Shipping and returns” opened to all identified merchants + org-level shipping markup (Nov 2025). The new shipping markup is a separate type from returns.
• Bing: validates schema generically but has no MerchantReturnPolicy-specific feature or property table.

Official documentation

Primary-source documentation from Google and schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor..

Google

• Merchant Return Policy (MerchantReturnPolicy) Structured Data — the canonical reference: required/recommended properties, the three returnPolicyCategory enums, seasonal overrides, and the precedence hierarchy.
• Introduction to Product Structured Data — where return policy sits as a recommended enhancement, not a base-eligibility requirement.
• How to Add Merchant Listing Structured Data — hasMerchantReturnPolicy as a recommended Offer property.
• Adding markup support for organization-level return policies (blog, June 11, 2024) — the org-level launch, by Google ShoppingGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads. engineers Irina Tuduce, Pascal Fleury, and Johan Linder.
• More ways to share your shipping and returns policies with Google (blog, Nov 12, 2025) — Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. “Shipping and returns” opened to all identified online merchants; precedence restated.
• Set up your return policies for Shopping ads and free listings (Merchant Center Help) — the non-markup alternative.

schema.org

• schema.org/MerchantReturnPolicy — the vocabulary definition and full property list.
• schema.org/hasMerchantReturnPolicy — the property that nests it under Organization / Product / Offer.

Bing / Microsoft

• Marking Up Your Site with Structured Data — Bing Webmaster Help — generic schema.org support; note there’s no MerchantReturnPolicy-specific spec or feature.

Quotes from the source

On-the-record statements from Google. Each link is a deep link that jumps to the quoted passage on the source page.

Google — the two implementation levels

• “A standard return policy for your business that applies to most or all products you sell can be specified using the MerchantReturnPolicy structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. type nested under the Organization structured data type using the hasMerchantReturnPolicy property. If you need to override your standard return policy for a specific product, specify one or more instances of MerchantReturnPolicy under the Offer type.” — Google Search Central docs. Jump to quote

Google — the required two-option choice

• “applicableCountry … The country code that the return policy applies to (where the product is sold and will be returned from). Use the two-letter ISO 3166-1 alpha-2Two-letter country codes used in hreflang region targeting (us, gb, au). country code formatting. You can specify up to 50 countries.” Jump to quote
• “If you use MerchantReturnFiniteReturnWindow, then the merchantReturnDays property is required.” Jump to quote

Google — applicableCountry vs. returnPolicyCountry

• “returnPolicyCountry … The country where the product has to be sent to for returns. This country can be different from the country where the product was originally shipped or sent to.” Jump to quote

Google — the precedence hierarchy (the accuracy spine)

• “Google uses the following order of precedence (from strongest to weakest): Content API for Shopping (return settings), Settings in Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads. or Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results., Product-level merchant listing markup, Organization-level markup.” Jump to quote
• “Retailer return policies can get complicated and may change frequently. If you’re having trouble indicating and keeping your return details up-to-date with markup and have a Google Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads. account, consider configuring your return policies in Google Merchant Center.” Jump to quote

Google — the single-page recommendation

• “We recommend placing return information on a single page on your site that describes the return policy of your business. You don’t need to include it on every page of your site.” Jump to quote

Google Shopping engineering team (Irina Tuduce, Pascal Fleury, Johan Linder) — the June 2024 organization-level launch

• “A return policy is a major factor considered by shoppers when buying products online, and so last year we enabled the extraction of structured data return policies for individual products. Today we’re adding support for return policies at the organization level as well.” Jump to quote
• “Adding a return policy to your organization structured data is especially important if you don’t have a Merchant Center account and want the ability to provide a return policy for your business.” Jump to quote

Google — the November 2025 expansion

• “It’s important to note that settings configured in Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. will take precedence over structured data on your site.” Jump to quote

Where should I define my return policy?

The genuinely confusing part of this topic isn’t the property names — it’s that a return policy can live in four places that override each other. Answer for your situation and you’ll land on the right method (and avoid the “my markup is perfect but the wrong policy shows” trap).

MerchantReturnPolicy — cheat sheet

Where it attaches (it’s never standalone)

Required — pick one option

Plus the conditional: MerchantReturnFiniteReturnWindow → merchantReturnDays required.

The three returnPolicyCategory values (full schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. URL, never plain text)

Two properties people confuse

Precedence — strongest to weakest (only one wins)

1. Content API for Shopping (return settings)
2. Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads. / Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. settings ← these override your markup
3. Product-level (Offer) markup
4. Organization-level markup

Fast facts

• Not required for baseline Product rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. — it’s a recommended enhancement gating only the returns display. Not a ranking factor.
• Recommended enrichment: returnFees, returnMethod, refundType, restockingFee, returnLabelSource.
• Holiday windows: returnPolicySeasonalOverride.
• Org-level launched June 2024; Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. “Shipping and returns” opened to all identified merchants Nov 2025.
• Bing: validates generically, no dedicated returns feature.
• Shipping-policy markup is a separate type — don’t conflate with returns.

Return-policy markup mistakes

• Publishing MerchantReturnPolicy as a standalone entity. Attach it through hasMerchantReturnPolicy on Organization or Offer.
• Confusing applicableCountry with returnPolicyCountry. The first says where the policy applies; the second says where an item is sent back.
• Omitting merchantReturnDays for a finite window. Add it when returnPolicyCategory declares a finite return period.
• Letting markup contradict Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads. or Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. settings. Audit all policy sources and their precedence before changing one layer.
• Marking up a policy users cannot find. Structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. must agree with visible, current return terms and the linked policy page.

MerchantReturnPolicy implementation checklist

• Decide whether the policy is organization-wide or an offer-level exception.
• Inventory policy values in Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads., Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results., feeds/API, product markupProduct schema (schema.org/Product) is structured data that tells search engines a page's product name, price, availability, and reviews so it can appear in Shopping-style rich results. It's separate from a Google Merchant Center feed, though Google reconciles the two., and organization markupOrganization schema (schema.org/Organization) is structured data that describes the business or entity itself — name, logo, official URL, social profiles, contact info, and identifiers — rather than a page's content. Google says it can help disambiguate your brand and some properties can influence visual elements like Knowledge Panel/attribution; it has no required properties and doesn't guarantee a Knowledge Panel..
• Confirm which source wins under the applicable precedence rules.
• Attach the object through hasMerchantReturnPolicy; do not publish it alone.
• Supply either the required country/category path or merchantReturnLink as appropriate.
• Add merchantReturnDays for a finite window.
• Keep applicableCountry separate from returnPolicyCountry.
• Match fees, methods, refund type, window, and exceptions to visible policy text.
• Validate representative standard-policy and exception products before rollout.

The scope → source → consistency framework

1. Scope: use Organization for the default policy and Offer only for a genuine product-level exception.
2. Source: identify the controlling system—Content API/feed, Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads./Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. setting, product markupProduct schema (schema.org/Product) is structured data that tells search engines a page's product name, price, availability, and reviews so it can appear in Shopping-style rich results. It's separate from a Google Merchant Center feed, though Google reconciles the two., or organization markupOrganization schema (schema.org/Organization) is structured data that describes the business or entity itself — name, logo, official URL, social profiles, contact info, and identifiers — rather than a page's content. Google says it can help disambiguate your brand and some properties can influence visual elements like Knowledge Panel/attribution; it has no required properties and doesn't guarantee a Knowledge Panel..
3. Consistency: make the winning machine-readable values, on-page policy, checkout behavior, and customer-service terms agree.

When displayed return information is wrong, inspect precedence before editing JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal.. Correct markup at a lower-priority layer may never become the value Google uses.

Prove a return-policy implementation

Graph-placement test

Test to run: validate representative organization and product pages and inspect the entity graph. Expected result: each policy is connected through hasMerchantReturnPolicy to the intended Organization or Offer. Failure interpretation: the entity is standalone, duplicated, or attached at the wrong scope. Monitoring window: immediate after deployment. Rollback trigger: product exceptions overwrite or conflict with the sitewide policy unintentionally.

Required-property test

Test to run: validate each policy category and country variant. Expected result: required properties are present, including merchantReturnDays for finite windows. Failure interpretation: the policy path is incomplete or uses the wrong property. Monitoring window: every policy/template change. Rollback trigger: invalid values are published across the catalog.

Cross-source consistency test

Test to run: compare visible policy text, JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal., feed/API values, and Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads./Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. settings for the same product and country. Expected result: the controlling source and customer-facing terms agree. Failure interpretation: a higher-precedence source is stale or regional scope is mismatched. Monitoring window: every policy launch and scheduled quarterly review. Rollback trigger: search-displayed terms promise conditions the merchant does not honor.

Worked JSON-LD examples

These are illustrative structures showing where MerchantReturnPolicy nests and which properties go where. Validate any real implementation in the Rich Results Test and check it against Google’s return-policy doc, since the property tables change.

1. Organization-level — one site-wide policy (Option A, finite window)

{
  "@context": "https://schema.org",
  "@type": "OnlineStore",
  "name": "Example Store",
  "url": "https://example.com",
  "hasMerchantReturnPolicy": {
    "@type": "MerchantReturnPolicy",
    "applicableCountry": ["US", "CA"],
    "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
    "merchantReturnDays": 30,
    "returnMethod": "https://schema.org/ReturnByMail",
    "returnFees": "https://schema.org/FreeReturn",
    "refundType": "https://schema.org/FullRefund"
  }
}

Note the finite window pairs with merchantReturnDays: 30 — required together. The enum values are full schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. URLs, not plain text.

2. Organization-level — Option B, just a link

{
  "@context": "https://schema.org",
  "@type": "OnlineStore",
  "name": "Example Store",
  "hasMerchantReturnPolicy": {
    "@type": "MerchantReturnPolicy",
    "merchantReturnLink": "https://example.com/returns"
  }
}

The escape hatch: if you can’t keep detailed markup current, a link to your policy page is valid on its own.

3. Offer-level override — one product with a different policy

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Final-Sale Widget",
  "offers": {
    "@type": "Offer",
    "price": "19.99",
    "priceCurrency": "USD",
    "hasMerchantReturnPolicy": {
      "@type": "MerchantReturnPolicy",
      "applicableCountry": "US",
      "returnPolicyCategory": "https://schema.org/MerchantReturnNotPermitted"
    }
  }
}

Offer-level wins over an organization-level default — here, a final-sale item that overrides a site-wide 30-day policy with “no returns.”

4. applicableCountry vs. returnPolicyCountry — Google’s own example shape

{
  "@type": "MerchantReturnPolicy",
  "applicableCountry": ["DE", "AT", "CH"],
  "returnPolicyCountry": "IE",
  "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
  "merchantReturnDays": 14
}

The policy applies to Germany, Austria, and Switzerland (applicableCountry), but the physical return address is Ireland (returnPolicyCountry) — two different concepts, two different properties.

5. Seasonal override for holiday returns

{
  "@type": "MerchantReturnPolicy",
  "applicableCountry": "US",
  "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
  "merchantReturnDays": 30,
  "returnPolicySeasonalOverride": {
    "@type": "MerchantReturnPolicySeasonal",
    "startDate": "2026-11-01",
    "endDate": "2026-12-31",
    "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
    "merchantReturnDays": 60
  }
}

A year-round 30-day window with an extended 60-day holiday window layered on top for a fixed date range.

Resources worth your time

My related writing

• Structured Data: What It Is and How to Use It — my Ahrefs guide to schema typesSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor., JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal., validation, and the “not a ranking factor” reality that applies to returns markup too.
• The Beginner’s Guide to Technical SEO — where structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. fits into the broader technical picture.

My speaking

• How Search Works (SlideShare) — my walkthrough of crawlingCrawling is how search engines use automated bots (like Googlebot and Bingbot) to discover URLs and download pages. A page has to be crawlable to be indexed, but crawling on its own isn't a ranking factor., renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM., indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed., and ranking; useful context for where markup gets read. (My standing disclaimer applies: “This is my understanding of systems… not going to be 100% complete or accurate.”)

Official

• Google’s Merchant Return Policy structured data doc — the canonical reference for properties, enums, and the precedence hierarchy.
• Google’s Adding markup support for organization-level return policies (June 2024) and More ways to share your shipping and returns policies (Nov 2025) — the two launch posts that shaped the current state.
• schema.org/MerchantReturnPolicy — the vocabulary source of truth.

From around the industry

• Google Clarifies Organization Merchant Returns Structured Data (Search Engine Journal, Roger Montti, June 2024) — coverage of the org-level launch and how the defaults/precedence work.
• Google shipping and returns policies in Search Console or using new markup (Search Engine Land, Nov 2025) — coverage of the November 2025 Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. expansion.
• Google adds new return policy structured data support for merchant listing (Search Engine Land, Barry Schwartz) — coverage of the original 2023 Offer-level launch.
• Google Adds Organization Level Return Policy Structured Data Support (Search Engine Roundtable) — a concise write-up of the June 2024 change.
• Set up your return policies for Shopping ads and free listings (Google Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads. Help) — the non-markup path, straight from the source.

Test yourself: MerchantReturnPolicy Schema

Five quick questions on how return-policy structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. works. Pick an answer for each, then check.

MerchantReturnPolicy Schema

MerchantReturnPolicy (schema.org/MerchantReturnPolicy) is the structured-data type that describes a return policy — window, fees, methods, refund type, and conditions — nested under Organization (site-wide default) or Offer (per-product override) via the hasMerchantReturnPolicy property, so Google can show return details in product rich results and knowledge panels.

Related: Commerce Schema, Product Schema, Structured Data, Schema Markup, Rich Results

MerchantReturnPolicy Schema

MerchantReturnPolicy is the schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. type that describes a business’s product return policy — the return window, fees, methods, refund type, and conditions — in machine-readable form. It’s never marked up on its own as a page’s primary type. Instead it’s nested as the value of the hasMerchantReturnPolicy property, either under Organization (one standard policy for most or all of your products) or under Offer (a per-product override, using a smaller subset of properties). This makes it a companion, property-level type to Product/Offer, not a standalone listing type like Product or JobPosting.

When you use it, Google requires you to pick one of two options: applicableCountry (up to 50 ISO 3166-1 alpha-2Two-letter country codes used in hreflang region targeting (us, gb, au). country codes, describing where the policy applies and the product is sold and returnable from) plus returnPolicyCategory (one of MerchantReturnFiniteReturnWindow, MerchantReturnUnlimitedWindow, or MerchantReturnNotPermitted); or, alternatively, just merchantReturnLink (a URL to a return-policy page). If you choose MerchantReturnFiniteReturnWindow, then merchantReturnDays also becomes required. A separate, recommended property, returnPolicyCountry, describes the country a product must be physically shipped back to — commonly confused with applicableCountry, but distinct.

MerchantReturnPolicy is a recommended enhancement, not a requirement for baseline Product rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. — omitting it doesn’t disqualify a page from product snippets or merchant listings; it only gates the returns display itself. And it’s one of four places a return policy can be configured (Content API for Shopping, Merchant CenterGoogle Merchant Center (GMC) is a free platform where retailers upload and manage product data so their products can appear across Google — Shopping, organic Search product grids, Images, Lens, and AI surfaces. Since 2020 it powers free (organic) product listings, not just paid Shopping ads./Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. settings, product-level markup, and organization-level markup), which follow a defined order of precedence — settings configured in Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. take precedence over on-page structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding..

Related: Commerce Schema, Product Schema, Structured Data, Schema Markup, Rich Results

Changelog