Quick answer: Structured data is standardized, machine-readable information that describes a web page and its content. In SEO, schema markup commonly uses the Schema.org vocabulary and JSON-LD format to identify products, articles, organizations, and other entities. It helps search engines interpret content and can enable eligible rich results, but does not guarantee them.
Key facts
- Schema.org defines types and properties; it is a vocabulary, not an implementation format. Schemas
- Google supports JSON-LD, Microdata, and RDFa, recommending JSON-LD when practical. Introduction to structured data markup in Google Search
- Google rich-result eligibility requires feature-specific properties, not just valid Schema.org markup. Introduction to structured data markup in Google Search
- Passing validation does not guarantee a rich result. General structured data guidelines
- Google stopped displaying FAQ rich results on May 7, 2026. Latest Google Search documentation updates — Deprecating the FAQ rich result feature
TL;DR: Implement accurate JSON-LD for relevant, supported content types, validate both the schema and Google’s feature requirements, and monitor the deployed pages without promising rich results.
- Structured data
- Standardized, machine-readable information describing a page and classifying its content.
- Schema.org
- A shared vocabulary of types and properties used to describe entities and their relationships.
- JSON-LD
- A JSON-based linked-data format used to embed structured data in web pages.
- Rich result
- A Google Search presentation with enhancements beyond a standard text result, available only for supported features and eligible content.

What is structured data in SEO?
Structured data is a standard way to describe a page in a form machines can read. It helps search engines understand the page. In SEO, schema markup labels things such as products, recipes, and events. These labels add context to the page’s text, as explained by Google Search Central.
Content, vocabulary, and format
Schema markup connects page content to shared terms. A format then carries those terms in the page’s code.
| Layer | What it means |
|---|---|
| Information | The facts being described, such as a product’s name or an event’s location. |
| Vocabulary | Schema.org supplies types and properties that label those facts. |
| Format | JSON-LD, Microdata, or RDFa adds the markup to the page. |
Schema.org groups its types from broad to more specific. Each type has properties that describe it. See the Schema.org documentation for the full vocabulary.
Types and properties: a product example
A type says what something is. A property describes it or links it to something else. For a shop page, Product identifies the item. Its offers property links to an Offer. The offer’s price and availability describe the sale details, not the product itself.
Schema markup does not have to use Microdata. Google supports Microdata, RDFa, and JSON-LD. It recommends JSON-LD when practical because it is usually easier to add and maintain. See Google Search Central.
For more on entity identity and Knowledge Graph links, see entity SEO.
Why structured data matters—and what it cannot promise
Structured data can help Google understand a page. It can also help a page qualify for a rich result. These are different from a promise of display or better performance.
What structured data can help with
- Clearer meaning. Markup gives Google clear labels for the page’s content. This helps it understand what the page contains, as explained by Google Search Central.
- Rich-result eligibility. A page must include all required properties for the Google feature it targets. Valid Schema.org markup alone is not enough. Check the feature’s requirements in Google Search Central.
For example, Product markup can describe an item and its sale details. The fields needed for a Google search feature depend on that feature’s rules.
What markup cannot promise
An eligible page may receive a rich result, but Google may not show one. This is true even after the page passes the Rich Results Test. Google’s structured data policies explain this limit.
Treat any change in clicks or click-through rate as something to measure, not an automatic outcome.
The broader search-feature landscape includes formats with different rules. Markup is not a route into every search feature.
Do not assume markup will lead to AI citations or voice answers. See how AI search works for more context.
Which schema types should you use?
Choose a type that describes what visitors can see on the page. Use Article for editorial content. Use Product with Offer for an item and its sale details. Choose for accuracy, not for an assumed search appearance.
| Schema type | Suitable visible content |
|---|---|
| Article | News stories, blog posts, or editorial articles. |
| Product with Offer | A product with its price, stock status, and sale details. |
| Recipe | Ingredients and cooking steps. |
| Event | An event’s dates, venue, and attendance details. |
| Organization or LocalBusiness | Organization: name, logo, URL, and identity profiles. LocalBusiness: address, phone number, and opening hours. |
| BreadcrumbList | A breadcrumb trail showing the page’s place within the site. |
LocalBusiness markup does not promise Maps visibility. Local-page optimization covers the wider page.
BreadcrumbList describes a trail. Site architecture and navigation define the site structure behind it.
Schema types are not search features
Schema.org defines types and properties. It does not define which Google search features are supported. Check the current feature rules in Google Search Central before you build markup for a rich result.
Google stopped displaying FAQ rich results on May 7, 2026. The earlier limit to government and health sites no longer applies. Do not recommend FAQPage as a current Google rich-result tactic. See Google Search updates.
On January 23, 2025, Google began removing breadcrumbs from mobile search results worldwide. Desktop breadcrumb display and structured-data support remained in place. See Google’s breadcrumb update.
Implement JSON-LD from the page’s actual content
Start with the page, not a list of fields you hope to fill. Map its visible content to schema properties. Then generate and test the markup.
Build from the page’s content
First, check what your theme, plugins, and custom code already produce. Avoid adding a second tool that creates conflicting values.
Choose a type from Schema.org. If you want to target a Google feature, check its required fields in Google Search Central too.
Use the same content source for the page and its markup. This helps keep changing details, such as stock status, in sync. The data must match what visitors can see, under Google’s content policies.
Illustrative Product and Offer example
Imagine a shop page with the title Blue mug, the description A blue ceramic mug., and a stock label that says In stock. The complete snippet below describes only those sample details. It shows how Product links to Offer. It is not a complete Google rich-result example and omits price rather than inventing one.
<script type=”application/ld+json”> { “@context”: “https://schema.org”, “@type”: “Product”, “name”: “Blue mug”, “description”: “A blue ceramic mug.”, “offers”: { “@type”: “Offer”, “availability”: “https://schema.org/InStock” } } </script>
Field-mapping and test checklist
- Name: Map the visible product title to name.
- Description: Map the visible description to description.
- Stock: Map the page’s “In stock” label to offers.availability.
- Other fields: Add real sale details only when the page shows them. Check all required fields for your target feature.
- Schema check: Test the snippet with Schema Markup Validator.
- Google check: Use Rich Results Test to check supported features and missing required fields.
- Live check: Test a published sample page. Compare the output with the page before rolling it out more widely.
Google recommends these tools for their separate roles in its structured data guidance. See the validation section below for the full test sequence.
Common mistakes that undermine eligibility
Markup can fail for different reasons. Broken code, missing fields, and misleading content need different fixes.
Separate technical errors from eligibility failures
- Syntax errors: Missing commas or unmatched braces can break JSON-LD. Fix these before checking the data itself.
- Missing requirements: Valid Schema.org markup may lack fields needed for a Google rich result. Check the feature rules in Google Search Central.
- Policy violations: Hidden claims, fake ratings, old offers, and irrelevant markup can harm eligibility. They may pass a code check but still break Google’s structured data policies.
Check relevance, consistency, and access
The facts in the markup must match visible page content. The JSON-LD script itself does not need to appear as text to visitors. If several tools create markup, check for conflicting prices, stock details, or names.
Do not treat Review and AggregateRating as shortcuts to stars. Check the rules for the item and the review content before adding them.
Google must be able to access the page. Robots.txt blocking, noindex directives, and other access limits can prevent rich-result eligibility. See Google’s access requirements.
Distinguish retired features from invalid markup
See “Schema types are not search features” above for the distinction.
Test before launch and after updates. Check content accuracy and current feature rules as well as code.
How do you validate structured data?
Use Schema Markup Validator for general Schema.org checks. Use Rich Results Test for supported Google rich-result features. Google Search Central recommends these tools for those roles.
Use each validator for its purpose
The tools answer different questions. Schema Markup Validator checks general markup. Rich Results Test checks it against supported Google features. A valid schema type may have no matching Google rich result.
For Google eligibility, include every required property for the feature. See Google’s structured data introduction.
Follow a repeatable test sequence
- Test draft code. Use each tool for its purpose before you publish.
- Test the live URL. Check the published page, not just the draft snippet.
- Inspect the detected items. Fix critical errors and missing required fields first. Review warnings about recommended fields. Add values only when they are accurate and useful.
- Compare values by hand. Check the markup against the visible page. Remove hidden, misleading, or outdated claims, as required by Google’s structured data policies.
Retest after changes
Repeat the tests after changes to templates, plugins, or content fields. A passing result does not prove that every quality rule is met. It also does not ensure rich-result display. See Google’s policies.
A technical SEO audit covers wider site checks beyond markup.
Monitor coverage, search appearance, and ongoing accuracy
After launch, check where markup appears and whether it stays accurate. Track search appearance separately from code quality.
- Check coverage. Confirm that the intended templates produce markup. Where Search Console has an enhancement report, review unresolved critical issues. Not every schema type has its own report.
- Check accuracy. Compare live values with the page. Remove hidden, misleading, or old details, as required by Google’s policies.
- Assign an owner. Make someone responsible for retesting after releases. Keep prices, stock status, business details, and event data in sync.
For setup, see Google Search Console.
Interpret search appearance carefully
Search metrics show what happened. They do not prove that markup caused the change.
Use available Search appearance filters to review impressions, clicks, and click-through rate. Compare similar page groups. Split results by device where useful.
Record launch dates. Account for shifts in rankings, demand, and search design. See the breadcrumb change above for an example of a device-specific search change.
For ways to assess causes, see analyzing SEO data.
Investigate missing rich results
See “What markup cannot promise” above for the limits of eligibility.
Before changing correct code, check current feature support and content rules. Review crawl status too. Confirm that the page has no access blocks or noindex directive, as required by Google’s policies.
Frequently asked questions
Can I add structured data without editing code?
Yes. A CMS with built-in support, or a suitable plugin, can add markup through settings and form fields. Check what your site already produces before adding another tool. The data still needs to match the page, under Google’s content policies. Test the published page after making changes.
Should JSON-LD go in the head or body of a page?
JSON-LD can go in either the head or body. Choose the place your CMS or templates can maintain most easily. Google recommends JSON-LD when practical because it is usually easier to add and maintain. See Google’s structured data introduction.
Does structured data slow down a website?
Markup adds data to a page. Its effect on speed depends on its size and how the site creates or loads it. Keep it relevant and avoid duplicate output. Test page speed before and after launch. Check any extra scripts from your chosen tool separately from the markup itself.
Do search engines other than Google use Schema.org markup?
Yes, but support varies by search engine and feature. Schema.org provides shared terms for things such as products, organizations, and events. Do not assume Google’s feature rules apply elsewhere. Check each search engine’s own guidance.