Beyond Product markup, add an OnlineStore or Organization entity for the store, one store-wide return policy, one store-wide shipping policy, and BreadcrumbList markup on pages that show a visible path. Add shipping or return details to a single product only where it differs from those policies. A matching Merchant Center feed is worth adding when you want Shopping tab visibility or more controlled product updates.
Work in this order: the store graph first, then one product page, then breadcrumbs, then testing. Google says structured data can make pages eligible for supported search features but does not guarantee a display, and Bing says annotations do not guarantee rich snippets. Treat the markup as an accurate description of your pages, not a promise of placement.
Describe the store, its returns and its shipping once
Start with the entity that owns everything else. OnlineStore is a Schema.org subtype of Organization for an ecommerce site, so it carries the same properties: name, url, logo, contact details, an address when one applies, and sameAs links to profiles that really belong to you. Put it on the homepage or on a page that describes the business. Google's Organization documentation lists no required properties for that feature, and recommends the business details above. The Organization schema guide covers the properties in more depth.
The example below is one connected graph for a fictional shop. The store points to a return policy and a shipping service by @id, a stable URL-style identifier that lets one entity refer to another instead of repeating it. Replace every value with your own, and keep the policy @id values pointing at real policy pages on your domain.

{
"@context": "https://schema.org",
"@graph": [
{
"@type": "OnlineStore",
"@id": "https://example.com/#store",
"name": "Example Lantern Shop",
"url": "https://example.com/",
"logo": "https://example.com/images/logo.png",
"telephone": "+1-555-010-0147",
"sameAs": ["https://social.example.com/example-lantern-shop"],
"hasMerchantReturnPolicy": { "@id": "https://example.com/policies/returns#policy" },
"hasShippingService": { "@id": "https://example.com/policies/shipping#service" }
},
{
"@type": "MerchantReturnPolicy",
"@id": "https://example.com/policies/returns#policy",
"applicableCountry": "US",
"returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
"merchantReturnDays": 30,
"returnMethod": "https://schema.org/ReturnByMail",
"returnFees": "https://schema.org/FreeReturn",
"merchantReturnLink": "https://example.com/policies/returns"
},
{
"@type": "ShippingService",
"@id": "https://example.com/policies/shipping#service",
"name": "Standard shipping",
"fulfillmentType": "https://schema.org/FulfillmentTypeDelivery",
"shippingConditions": [
{
"@type": "ShippingConditions",
"shippingDestination": { "@type": "DefinedRegion", "addressCountry": "US" },
"shippingRate": { "@type": "MonetaryAmount", "value": 0, "currency": "USD" },
"transitTime": {
"@type": "ServicePeriod",
"duration": {
"@type": "QuantitativeValue",
"minValue": 3,
"maxValue": 5,
"unitCode": "DAY"
}
}
}
]
}
]
}A standard return policy belongs under the organization through hasMerchantReturnPolicy. For Google's return policy feature, applicableCountry and returnPolicyCategory are required, and merchantReturnDays is required when the policy uses MerchantReturnFiniteReturnWindow. Use product-level return markup only for exceptions, or when the store has no standard policy.
A standard shipping policy belongs under the organization through hasShippingService. Google's shipping policy documentation lists shippingConditions as required for that feature, with destinations, rates and delivery times described inside it. If the same shipping rules cover most of your catalog, one ShippingService is easier to maintain than a copy on every product page.
Precedence matters when you also use other settings. Google's November 2025 announcement on sharing shipping and returns policies says Search Console policy settings can take precedence over organization-level markup. Its merchant listing documentation says product-level feed data has the strongest precedence, followed by Content API settings and then Merchant Center or Search Console settings. Decide which source controls each policy, and change it there.
Add Product, Offer and product-level shipping on each product page
A product page carries the Product entity with an Offer inside it. Google requires name, image and offers for merchant listings, and the Offer needs price and priceCurrency, or an equivalent priceSpecification, for an active price. Fields such as sku, brand.name, description, availability, itemCondition and url are recommended or optional. The Product schema guide walks through each property, and the Product schema generator builds the block from your own details.
The next example shows a single product with shipping details that differ from the store policy. The seller points back to the store entity by @id, so the product and the store stay connected. For a product that follows your global shipping and return policies, remove the shippingDetails and hasMerchantReturnPolicy lines and the OfferShippingDetails entity. Change the price, currency, availability and delivery times to match what the page shows today.
{
"@context": "https://schema.org",
"@graph": [
{
"@type": "Product",
"@id": "https://example.com/products/aurora-lantern#product",
"name": "Aurora Desk Lantern",
"image": [
"https://example.com/images/aurora-lantern-1x1.jpg",
"https://example.com/images/aurora-lantern-4x3.jpg",
"https://example.com/images/aurora-lantern-16x9.jpg"
],
"description": "A fictional rechargeable desk lantern with three brightness settings.",
"sku": "AURORA-001",
"brand": { "@type": "Brand", "name": "Example Lantern Shop" },
"offers": {
"@type": "Offer",
"url": "https://example.com/products/aurora-lantern",
"price": 49.95,
"priceCurrency": "USD",
"availability": "https://schema.org/InStock",
"itemCondition": "https://schema.org/NewCondition",
"seller": { "@id": "https://example.com/#store" },
"shippingDetails": { "@id": "https://example.com/products/aurora-lantern#shipping" },
"hasMerchantReturnPolicy": { "@id": "https://example.com/policies/returns#policy" }
}
},
{
"@type": "OfferShippingDetails",
"@id": "https://example.com/products/aurora-lantern#shipping",
"shippingRate": { "@type": "MonetaryAmount", "value": 0, "currency": "USD" },
"shippingDestination": { "@type": "DefinedRegion", "addressCountry": "US" },
"deliveryTime": {
"@type": "ShippingDeliveryTime",
"handlingTime": { "@type": "QuantitativeValue", "minValue": 0, "maxValue": 1, "unitCode": "DAY" },
"transitTime": { "@type": "QuantitativeValue", "minValue": 3, "maxValue": 5, "unitCode": "DAY" }
}
}
]
}For Google's shipping details enhancement, OfferShippingDetails needs deliveryTime, shippingDestination, shippingRate and the shipping currency. Inside deliveryTime, handlingTime and transitTime are recommended. A schema.org property can be perfectly valid and still not be required by a given Google feature. If your products come in sizes or colors, the product variant schema guide explains how to describe them.
Add breadcrumbs to product and category pages
Use BreadcrumbList on any page with a meaningful path through the site, and only when the page shows that path. Google requires itemListElement and at least two items. Each ListItem needs a position and a name, plus an item URL on every entry except the last, where Google can use the current page URL. Google recommends describing the typical path a visitor takes, not mechanically copying the URL structure.
The example matches the lantern page above. Change the names and URLs to the path your page actually shows, and keep the final item as the product itself. The breadcrumb schema guide covers sites with more than one route to a product, and the breadcrumb schema generator builds the list from your own trail.
{
"@context": "https://schema.org",
"@type": "BreadcrumbList",
"@id": "https://example.com/products/aurora-lantern#breadcrumbs",
"itemListElement": [
{ "@type": "ListItem", "position": 1, "name": "Home", "item": "https://example.com/" },
{
"@type": "ListItem",
"position": 2,
"name": "Lighting",
"item": "https://example.com/collections/lighting"
},
{
"@type": "ListItem",
"position": 3,
"name": "Aurora Desk Lantern",
"item": "https://example.com/products/aurora-lantern"
}
]
}Mark up category pages for what they show
A category or collection page is a list of products, not one product. Google says Product rich result eligibility is focused on pages for a single product or variants of one product, and it recommends product pages over product-listing or category pages. Putting one Product on a category page, or a price taken from the first item in the grid, describes something the page does not offer.
Give the category page the vocabulary that fits it. Add BreadcrumbList when visible breadcrumbs exist. Add CollectionPage or WebPage only when the page genuinely represents that entity. Add ItemList only when the page visibly presents an ordered or curated list and the markup mirrors it. Google has no rich result feature for generic category page ItemList markup comparable to merchant listings, so treat that markup as Schema.org vocabulary, not a promised display.
What matters most on a category page is plain HTML: visible links to each product and clear category copy. Leave out prices, ratings, reviews, inventory and shipping rules that are not visible and accurate on the page. Do not mark up hidden products, products sold only through another retailer, or reviews you wrote about your own business.
Keep prices, stock and policies matching the page and the feed
Use page markup and a Merchant Center feed together when you can. Google says structured data helps it understand and verify product data, while Merchant Center gives it a commerce-specific data source, and that Merchant Center is required for some surfaces, including the Shopping tab. A JSON-LD block on its own does not replace the feed when you want those surfaces.

Each of these values should say the same thing in the visible page, the JSON-LD and the feed: the product title and description, the product URL and canonical URL, identifiers such as SKU, GTIN (a global trade item identifier) or MPN, the price and currency, availability, variants, shipping cost and delivery time, the return policy, and the product images. A mismatch can produce warnings, stale prices, the wrong stock status or conflicting shipping information.
The practical habit is to change the source that controls the data, then test the page and the feed again. If your platform generates the markup from the product record, edit the record, not the output. If a developer hand-writes the JSON-LD, generate the price and availability from the same database fields that print them on the page, so a sale or a sell-out cannot update one and miss the other.
Check what your platform already outputs
A platform may already write Product markup for you, so inspect the rendered page before adding anything. Open the live product page, view the page source or use a testing tool, and list every Product, Offer and BreadcrumbList block you can see. Wix's support documentation describes preset product markup for Wix Stores and its product fields, and its ecommerce SEO article mentions shipping details and breadcrumbs.
For other platforms, the output depends on the current theme, apps and plugins, so read the rendered HTML and the platform's SEO settings instead of assuming. The platform guides cover installation routes: Shopify, WordPress, Wix, Squarespace, Webflow and HubSpot.
If two sources describe the same product, remove or disable one before adding more. Two competing Product graphs on one page can disagree about price or availability, and the duplicate schema markup guide shows how to find and resolve them. When the platform's graph is close but incomplete, extending it is usually cleaner than adding a second one beside it.
On a hand-built site, render the JSON-LD on the server. The Next.js documentation (updated February 2026) covers rendering JSON-LD in layout.js or page.js, sanitizing serialized values, and testing with Google's Rich Results Test or the Schema Markup Validator. The Next.js and React guide goes further, and the schema graph builder can assemble a connected graph like the ones above.
If your business also serves customers at a physical address, the local business schema guide covers that side.
Validate each page and keep it current
Test one page of each kind: the homepage, a product page, a category page and the policy pages. Google's Rich Results Test checks eligibility for Google features, and the Schema Markup Validator checks vocabulary relationships. They answer different questions, and the Schema Nova validator can check JSON syntax before either one. The Rich Results Test versus Schema Validator guide explains when to use which.
After deployment, inspect the live URL in Search Console, request recrawling when appropriate, and keep the sitemap current. Then keep the markup current. Whenever a price, a stock status, a delivery time or a return window changes, the page, the markup and the feed should change together. Google's support list also shifts over time; its documentation updates page is the place to watch for retired or changed features.
Make product markup readable for Bing and AI search
Bing reads JSON-LD, Microdata and RDFa, so the same product, offer and breadcrumb markup serves both engines. Bing's structured data documentation and its webmaster guidelines stress accurate structured data, visible content and clear HTML, and Bing Webmaster Tools offers validation and monitoring. If you sell to Yandex users, its semantic markup validator checks the same markup.
To appear in ChatGPT Search, allow OAI-SearchBot to crawl the site. Whichever system you target, keep products, policies and prices visible in HTML. Markup does not promise a display, a citation or traffic. See whether AI systems use schema markup for the comparison, and the rich results guide for what to expect from Google's displays.
Questions people ask
Do I need Merchant Center if I already use JSON-LD?
Google says structured data and Merchant Center can be used together, and that Merchant Center is required for some surfaces, including the Shopping tab. JSON-LD describes the page; the feed gives Google a separate commerce data source. Keep both in step when you use both.
Should OnlineStore go on every page?
Put it on the homepage or a page that describes the business, with a stable @id such as https://example.com/#store. Product pages can then point to it from seller instead of describing the store again. The guide on Organization schema across pages covers the question in detail.
Can I use Product schema on a category page?
Google says Product rich result eligibility is focused on pages for a single product or variants of one product, so a category page is not the place for it. Use BreadcrumbList, and CollectionPage or ItemList only when they match what the page visibly shows.
Should every product have its own shipping markup?
Not when one policy covers most of the catalog. Put a ShippingService under the store, and add OfferShippingDetails to a product only where its rate, destination or delivery time differs. The same approach applies to return policies.
What should I do when platform markup duplicates my own?
Inspect the rendered page and list every product and breadcrumb graph. Keep one source for each entity, remove or disable the extra one, and test again with the Rich Results Test and the Schema Markup Validator.
