Choose each schema type by the main purpose of the page, not from the full schema.org list. A bakery's home page needs Bakery, a product page needs Product, a blog post needs BlogPosting, and a software page needs SoftwareApplication. Add BreadcrumbList where a page sits inside a section of the site, and leave the other hundreds of types alone until a page genuinely calls for one.
Work in this order: decide what the page is about, pick the most specific accurate type, read the matching Google feature page for its required properties, add the JSON-LD, and test it.
A single site usually mixes types, because the home page, a product page and a blog post each have a different job.
Start with the type that matches the page
These are the five starting points, one per site type. Each page gets the type for what it shows, so a store's home page and its product pages carry different markup.
- Local business: the most specific
LocalBusinesssubtype, such asBakery,RestaurantorDentist, plusBreadcrumbList. The local business schema generator builds it. - Online store:
Producton each individual product page, with an accurate price, availability, image and seller. Use the product schema generator. - Blog or publisher:
ArticleorBlogPostingplusBreadcrumbList, addingVideoObjectwhen a video is a prominent part of the page. The article schema generator covers the first two. - Service business:
Organizationwhen it operates mainly online, orLocalBusinessor a subtype when it has a physical location or serves customers locally, plusBreadcrumbList. The organization schema generator and the service schema generator cover both pieces. - SaaS company:
Organizationon the company page, andSoftwareApplicationorWebApplicationon the page that describes the software.
Use only types that describe content visitors can see on the page. Google's general structured data guidelines recommend the most specific applicable type and every required property for the matching Search feature. They also say structured data does not guarantee a rich result, so treat a type as a way to be eligible, never as a promise.
Schema.org types and Google features are two layers
Schema.org is the shared vocabulary. It lists hundreds of types, each with its own properties, and a type is valid markup whether or not any search engine builds a feature around it. A Person or a ProfilePage is still correct schema.org even when it triggers no special display.
Google Search adds a second layer. Its structured data gallery lists the features it supports, and each feature page names the properties that feature requires. A property that is required for one Google feature may be optional vocabulary everywhere else, so always pair a type with the feature you want to qualify for.
Google is not the only reader of this markup. Bing Webmaster Tools documents structured data with schema.org in JSON-LD, Microdata and RDFa. Use the markup that is accurate for the page, and read the provider's documentation for the feature you want.
For the plain definition, read what schema markup is. For the vocabulary question, see schema markup versus structured data. For what markup can and cannot do for search, read whether schema markup helps SEO.
Subtypes inherit from broader types
Schema.org types form a hierarchy, and a subtype inherits the meaning and properties of its parent. A Bakery is a FoodEstablishment, which is a LocalBusiness, which is an Organization. A BlogPosting is an Article, which is a CreativeWork. A WebApplication is a SoftwareApplication, and an OnlineStore is an OnlineBusiness, which is an Organization.
The practical rule is to pick the most specific type that is accurate. A bakery should use Bakery, not only Organization. A software company should not mark its company identity as a Product. A service company with no eligible physical business presence should not call itself a LocalBusiness. The schema.org hierarchy shows every parent and child.
Google allows more than one type in an array when the item really has several identities. Use that sparingly and only when each type is accurate, as in this fictional home services company, described on Google's LocalBusiness documentation.
{
"@context": "https://schema.org",
"@type": ["Electrician", "Plumber", "Locksmith"],
"name": "Example Home Services"
}Replace the three types with the trades the business genuinely offers, and drop the array entirely if only one applies.
Local businesses: pick the subtype that names the business
A business with a storefront, an address and opening hours starts with the closest LocalBusiness subtype. Google lists name and address as required for its LocalBusiness feature, and recommends url, telephone, priceRange, image, sameAs and opening hours when they are accurate and visible. Fill in the full PostalAddress so the address matches the one printed on the page.
A small travel agency with a street-level office is a good example of the decision. Its home page describes the business, so it takes a LocalBusiness subtype. Its individual tour pages describe things that can be sold, so they take their own types. The home page and the tour page do not need the same markup.

The example below is a fictional bakery. Replace the name, URLs, address, phone number, price range and hours with the details that appear on your own page, and delete any property you cannot fill truthfully.
{
"@context": "https://schema.org",
"@type": "Bakery",
"@id": "https://example.com/#bakery",
"name": "Example Bakery",
"url": "https://example.com/",
"telephone": "+1-555-010-0100",
"priceRange": "$$",
"image": "https://example.com/images/example-bakery.jpg",
"address": {
"@type": "PostalAddress",
"streetAddress": "100 Example Street",
"addressLocality": "Exampleville",
"addressRegion": "EX",
"postalCode": "00000",
"addressCountry": "US"
},
"openingHoursSpecification": [
{
"@type": "OpeningHoursSpecification",
"dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
"opens": "07:00",
"closes": "17:00"
}
]
}Venues that host events can add the Event type on each event page, using Google's event documentation for location, status and offer requirements. The event schema generator builds the markup.
Be careful with reviews. Add review or rating markup only when the page shows genuine reviews and Google's review snippet rules allow that context. The review schema generator is for real, visible reviews.
Online stores: put Product on each product page
Product markup belongs on the page for one product. Google's merchant listing documentation requires a name, an image and an Offer with an active price for merchant listings. It asks for an Offer, not an AggregateOffer. Currency, availability, a product URL, a description and the brand are recommended, and sku or a GTIN helps identify the item.
A category page that lists thirty products should not carry a single Product for the whole category. Each product page carries its own item, and the category page can stay plain or use item-level markup for what it actually displays. Google's product snippet documentation covers the lighter feature for pages that are not merchant listings.
Before adding anything, look at what your platform already outputs. Shopify's help center says current supported themes commonly include microdata for products, prices, availability and reviews, so a second hand-written block can duplicate it. The guide to adding schema markup walks through finding and replacing existing output.
{
"@context": "https://schema.org",
"@type": "Product",
"@id": "https://example.com/products/example-mug/#product",
"name": "Example Ceramic Mug",
"image": ["https://example.com/images/example-mug.jpg"],
"description": "A fictional ceramic mug with a blue exterior and white interior.",
"sku": "EX-MUG-001",
"brand": {
"@type": "Brand",
"name": "Example Bakery"
},
"offers": {
"@type": "Offer",
"url": "https://example.com/products/example-mug/",
"price": "18.00",
"priceCurrency": "USD",
"availability": "https://schema.org/InStock",
"itemCondition": "https://schema.org/NewCondition"
}
}Change the price, currency and availability whenever the product page changes, because the markup has to match what shoppers see. Leave out aggregateRating and review unless the page displays genuine ones.
Blogs and publishers: Article, BlogPosting and Person
Google's Article documentation lists no required properties for Article, NewsArticle or BlogPosting. It recommends a headline, an image, datePublished, dateModified where relevant, an author with a name and a URL, and a publisher. Use NewsArticle only for genuine news, and BlogPosting for a blog post.
The author is usually a nested Person, with name, url and optionally jobTitle, worksFor or sameAs. A Person is a real individual, so describe only real people. A publication written by an organization can name the Organization as author instead. The person schema generator builds a standalone profile when an author page needs one.
When a video is a meaningful part of the page, add VideoObject as well. Google's video documentation lists its required and recommended properties. Do not add it for a decorative embed that visitors are unlikely to watch.
Service businesses and SaaS companies
A business that serves customers mostly online starts with Organization. Google lists no required properties for it, and recommends fields such as name, url, logo, sameAs, address, telephone, legalName and alternateName. Place it on the home page or the page that describes the organization, and use a more specific subtype such as OnlineStore or NewsMediaOrganization where one fits.
If the business has a location or serves a local area, use LocalBusiness or a subtype instead. Mark up an individual service page with Service only when the page really describes that service, and keep prices, testimonials and service areas the same as the visible text.
A SaaS company uses Organization on its company or About page. The page that describes the software uses SoftwareApplication or a subtype such as WebApplication. Google's software app documentation requires a name, offers.price, and either an aggregateRating or a review for that rich result.
In the example below the rating numbers are placeholders. Publish ratings only when they are genuine, visible on the page and supported by real users. Delete the aggregateRating block rather than invent one.
{
"@context": "https://schema.org",
"@type": ["SoftwareApplication", "WebApplication"],
"@id": "https://example.com/product/example-app/#software",
"name": "Example App",
"url": "https://example.com/product/example-app/",
"description": "A fictional web application for organizing bakery orders.",
"applicationCategory": "BusinessApplication",
"operatingSystem": "Web browser",
"offers": {
"@type": "Offer",
"price": "0",
"priceCurrency": "USD"
},
"aggregateRating": {
"@type": "AggregateRating",
"ratingValue": "4.5",
"ratingCount": "24"
}
}Use Product for software only when the page describes something that meets Google's product or merchant listing requirements.
BreadcrumbList, Organization and WebSite describe context
Some types describe where a page sits instead of what it sells. BreadcrumbList is a trail from the home page down to the current page, and it should follow a normal path a visitor would take, not necessarily the raw URL. Google's breadcrumb documentation requires itemListElement with at least two ListItem objects, each with a position and a name. The last item can leave out item, because Google can use the page's own URL.
{
"@context": "https://schema.org",
"@type": "BreadcrumbList",
"itemListElement": [
{
"@type": "ListItem",
"position": 1,
"name": "Home",
"item": "https://example.com/"
},
{
"@type": "ListItem",
"position": 2,
"name": "Guides",
"item": "https://example.com/guides/"
},
{
"@type": "ListItem",
"position": 3,
"name": "Example Guide"
}
]
}Swap the names and URLs for the real path to the page, and add or remove items to match the depth. The breadcrumb schema generator builds the list from your own trail.
WebSite describes the site as its own entity and supports the site name and the link between the site and its organization. Several types can connect through shared @id values, which the schema graph builder can assemble.
Required and recommended properties depend on the feature
"Required" has a specific meaning here. It means required by the matching Google feature page, not required by schema.org and not a guarantee that Google will display the result. A recommended property gives extra context, and you should add it only when it is accurate and visible.
Organization and Article have no required properties in Google's current documentation. LocalBusiness requires a name and an address. A merchant listing requires a name, an image and an active offer price. A Software App result requires a name, a price, and a rating or review. A breadcrumb requires at least two list items.
When several features apply to one page, add the properties for each. A product page that shows genuine reviews can carry the Product and its review, plus a BreadcrumbList. For examples of more combinations, see JSON-LD schema examples. To pick between formats, read JSON-LD, Microdata and RDFa.
Display changes to know about before choosing a type
Several Google features have been retired, and each change has a date. Google's documentation updates page says FAQ rich results stopped showing in Google Search in May 2026. FAQPage remains a valid schema.org type, and a visible FAQ section can still help your visitors, but adding FAQ markup is no longer a route to a Google rich result.
Google's HowTo and FAQ announcement says HowTo rich results are no longer shown. The sitelinks search box was removed globally starting November 21, 2024, according to Google's announcement, while WebSite markup for site names remains supported.
Dataset is a similar case. Google's changelog (June 12, 2026) says it is used for Dataset Search and is not a general Google Search rich result. Because support changes, read the feature page on the day you publish.
Set up each page in order
Take one page at a time. Name its main purpose, choose the most specific accurate type, and open that type's Google feature page. Add the required properties, then the recommended ones that match what the page shows. Keep every marked-up value visible and current, and update the markup when the page changes.
Add the JSON-LD with the method your platform supports. Squarespace's help center describes automatic structured data for blog posts, events, local businesses, organizations, products and websites. Webflow offers a schema markup field and a custom code option, and warns against adding the same markup in both places, according to its help article (updated January 27, 2026).

Wix pages use JSON-LD, with limits on length and syntax described in the Wix help center. HubSpot allows code snippets in a page's head HTML, depending on permissions, as its knowledge base (updated February 11, 2026) explains. Next.js recommends a native script tag in layout.js or page.js and sanitizing serialized JSON, per its JSON-LD guide (updated March 2, 2026).
Then test the page. Google's Rich Results Test can read JSON-LD, RDFa and Microdata, and it separates syntax errors from detected rich result items. The Schema Nova validator and schema checker are free ways to test code before or after publishing. After the page is live, inspect its URL in Search Console and watch for errors.
A passing test means the markup is written correctly and eligible for the feature. It does not guarantee a rich result, a ranking, traffic or an AI citation. Google's help page on missing features lists reasons a feature can be absent even when the markup is valid, including indexing, crawling, policy, device, location and query. The full list of tools is on the tools index.
Questions people ask
What schema markup should a local business use?
Use the most specific LocalBusiness subtype that accurately describes the business, such as Bakery, Restaurant or Dentist. Include the name and a complete address, then add the URL, telephone number, hours, image and price range when they are accurate and visible. Add BreadcrumbList for pages that sit inside a section.
Can one page contain more than one schema type?
Yes, when each type is accurate. A product page can have Product and BreadcrumbList, and a blog post can have BlogPosting, a nested Person author and a VideoObject. Google also allows an array of types on one item, such as several trades, but only when each one really applies.
What is the difference between Article and BlogPosting?
BlogPosting is a subtype of Article, so it inherits everything Article has. Use BlogPosting for a blog post, and NewsArticle only for genuine news. Google lists no required properties for any of the three, and recommends the headline, image, dates, author and publisher.
Does valid schema markup guarantee a rich result?
No. Google says structured data does not guarantee a rich result, and it decides whether and when a feature appears. Valid markup shows the code is written correctly and the page is eligible for the matching feature.
Is BreadcrumbList still supported?
Yes. Google still documents BreadcrumbList as a feature. It needs at least two list items, and each item needs a position and a name.
