Audit your markup in this order: confirm it describes what visitors can see, add what the Google feature you want requires, test the live URL, and recheck after every change. Run the steps on one page at a time, in the same order whether the site runs on WordPress, Shopify, Wix, Squarespace, Webflow or hand-built code.

Good schema markup is accurate, specific, complete for the feature you target, visible on the page, technically valid and maintained. Every check belongs to one of those six qualities, so you can run through a page and stop at the first mismatch. Fix that mismatch before you move on.

Passing every check makes a page eligible for the displays that exist today, and nothing more. Google says correct markup does not guarantee a rich result, and its systems may choose a standard result instead (General Structured Data Guidelines).

Key takeaways

  1. Match the visible pageMark up only what visitors can see, and match names, dates, prices, authors, images and URLs to the page exactly.
  2. Name the consumerA property is required for a specific feature. Google's Article documentation lists no required properties, while Breadcrumb requires itemListElement.
  3. Test in layersCheck JSON syntax and vocabulary, then the feature's requirements, then inspect the live rendered URL after deployment.
  4. Recheck after changesUpdate markup when prices, dates, authors or templates change, and retest after theme, plugin or CMS updates.
  5. Eligibility is not displayGoogle says correct markup does not guarantee a rich result, and Bing and Yandex make similar qualifications.

Make the markup match the visible page

Start by naming the page's one main subject, such as an article, a product or a business, and choose the most specific Schema.org type that describes it. A blog post is a BlogPosting, which Schema.org defines as a subtype of Article; a generic type works, but the specific one says more.

Use JSON-LD unless your platform requires another format. Google supports JSON-LD, Microdata and RDFa and recommends JSON-LD in general, while Bing says it supports JSON-LD and Microdata and does not prefer one over the other (Bing structured data help).

A woman in a bookshop stockroom points a pen at a printed product page while looking at an open laptop
Figure 1. Comparing each value in the markup with the page a visitor sees is the first check.

Then compare the markup with the page, value by value. Google's guidelines say to mark up content that is present and visible to users, to keep it accurate and current, and to avoid fake reviews, fabricated facts, misleading prices, hidden content and irrelevant types. Open the page in one window and the markup in another, and check each of these:

  • The name, headline and description read the same as the visible text.
  • The author, publisher and image are the ones the page shows, and the image URL is absolute, HTTPS, crawlable and indexable.
  • Dates use ISO 8601 format and match the dates a reader sees.
  • Price, currency and availability match the current offer.
  • The page URL in the markup is the same canonical URL used in the canonical tag, the sitemap and your internal links.

Here is a broken example, so you can recognize the failure. The visible page says the mug costs $39.00, but the markup says 29.00. The JSON is valid and the Schema.org vocabulary is correct, so a syntax check passes, yet the markup misrepresents the page. Google's guidelines name misleading prices, and Bing says it uses annotations to validate content, so fix a mismatch like this before you rely on the markup.

json
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Example Stoneware Mug",
  "offers": {
    "@type": "Offer",
    "price": "29.00",
    "priceCurrency": "USD"
  }
}

Change the markup to 39.00, or change the page, and keep both pointing at one source of truth. Never put a fact only in the markup, either. If an answer, price or date matters to a visitor, it belongs in readable text, headings, captions or alt text first, and the JSON-LD describes it second.

Confirm search engines can reach the page and the markup

Markup that a crawler cannot reach does nothing, so check access next. Google's guidelines say not to block the page or its structured data from Googlebot with robots.txt, noindex, login requirements or other access controls. Open the page in a private window; if you need to sign in to see it, so does Googlebot.

Then check what is in the rendered page, not only the source template. If JavaScript generates your JSON-LD, Google's JavaScript structured data guidance covers confirming that the markup appears in the rendered DOM, which is the page structure after scripts run. Server-rendered or statically generated JSON-LD is simpler to verify when your stack allows it, and a slow third-party script is a poor way to deliver markup that could ship with the page.

If you build with Next.js, its JSON-LD guide shows the script tag approach and warns that unsanitized JSON.stringify output can create an injection risk when a value contains HTML-sensitive characters. Sanitize serialized values before they reach the page.

Finally, look for more than one source writing markup for the same thing. A theme, an SEO plugin and a tag manager can each add a description of the same organization or article, and the copies can disagree. Keep one authoritative source per entity. The duplicate schema markup guide covers finding and removing the extra copies, and the guide to checking whether a website has schema shows how to see what a page already outputs.

Check what your platform already adds

Several platforms write markup for you, so inspect the rendered output before adding another block. Squarespace says it automatically adds structured data for blog posts, events, local business, organization, products and websites (Squarespace Help Center). Wix documents preset markups with variables that you can customize (Wix preset markups), and a separate Wix page covers syntax limits and visible-content requirements (Wix troubleshooting).

Shopify's help documentation covers theme-generated structured data, which means your theme may already describe your products (Shopify Help Center). On WordPress, Webflow and HubSpot, check the platform's current documentation and your plugin or theme settings, then view the rendered page source. The WordPress schema guide walks through that inspection for WordPress sites.

When the platform already outputs a type correctly, edit it there instead of pasting a second version. A second description of the same item is the most common source of conflicting markup.

Add the properties each Google feature requires

A property is required only for a named consumer and feature. Schema.org defines which types and properties exist, and Google's feature documentation defines what Google needs before a feature can use the markup. Treat the two as separate checks, and never label a property simply "required".

Article is the clearest case. Google's Article documentation (updated October 2026) lists no required properties, so a checklist must not call any Article property required. It does list recommended ones: author (with name and URL), headline, image, datePublished, dateModified and publisher (with logo). Add them when they are accurate. Google's updates page also records an August 2026 change clarifying that Article markup is open to all page types. Read the full Article documentation before you decide what to include.

This BlogPosting example uses fictional values. Replace every URL, name, date and image with the values on your own page, and delete any recommended property you cannot support. @context and @type are needed for valid JSON-LD, while @id, url and inLanguage are optional for this Google feature; @id is useful if you later connect entities, as the JSON-LD graph guide explains.

json
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "@id": "https://example.com/blog/schema-markup-best-practices/#article",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://example.com/blog/schema-markup-best-practices/"
  },
  "url": "https://example.com/blog/schema-markup-best-practices/",
  "headline": "Schema Markup Best Practices Checklist",
  "description": "A practical checklist for auditing accurate, complete, and maintainable schema markup.",
  "image": [
    "https://example.com/images/schema-markup-checklist-16x9.jpg",
    "https://example.com/images/schema-markup-checklist-4x3.jpg",
    "https://example.com/images/schema-markup-checklist-1x1.jpg"
  ],
  "datePublished": "2026-11-01T09:00:00-06:00",
  "dateModified": "2026-11-10T14:30:00-06:00",
  "author": {
    "@type": "Organization",
    "name": "Example Editorial Team",
    "url": "https://example.com/about/"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Example Publishing",
    "url": "https://example.com/",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/images/example-publishing-logo.png"
    }
  },
  "inLanguage": "en-US"
}

Breadcrumbs work the other way around. Google's Breadcrumb documentation (updated September 2026) requires itemListElement, and the list needs at least two ListItem objects. Each ListItem needs position and name, and item is required on every breadcrumb except the last one, where Google can use the URL of the containing page.

In this example, change the names and URLs to match the trail visitors see on the page, and keep the order identical to the visible breadcrumb. See the breadcrumb schema guide for variations.

json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Blog",
      "item": "https://example.com/blog/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Schema Markup Best Practices Checklist",
      "item": "https://example.com/blog/schema-markup-best-practices/"
    }
  ]
}

Other Google features, such as Product, Event, Recipe and JobPosting, each have their own requirements, and you should not copy them from Article or Breadcrumb. Check the current feature page and the Search gallery first, because a display can be retired while the Schema.org type stays valid. FAQPage is the example: it remains a Schema.org type, but Google says FAQ rich results stopped appearing in Google Search on May 7, 2026 (Google Search documentation updates). The article schema guide and the product schema guide cover those types in more depth.

Keep the markup current after edits and template changes

Treat structured data as part of the page's content system, not a one-time paste. The simplest habit is to generate markup values from the same source as the visible text, so an edit to the page changes both at once.

An illustration of a page card and a markup card linked by a sync arrow, with a mismatched faded card drifting away
Figure 2. Markup stays accurate when it is updated from the same source as the visible page.

Some values need specific care. Keep datePublished as the original publication date, and update dateModified only when the page changes materially. Update prices, currency, availability, shipping, discounts and return information as soon as the visible offer changes. Remove expired events, discontinued products, unavailable services and obsolete claims. Google specifically warns that time-sensitive content must stay current, and that script-generated product markup can be less reliable for fast-changing prices and availability if crawls do not keep pace.

Templates deserve their own routine. When the author, publisher, logo, image, canonical URL or internal links change in a template, the markup on every page that uses it changes too. Retest after any CMS, theme, plugin, code or tag-manager update, and compare the rendered HTML with the visible page. If a template generates markup across many URLs, keep a short release checklist and name one person who owns future updates.

After deployment, watch the rich result reports in Google Search Console and the Markup card in Bing Webmaster Tools. When a report starts showing missing fields, the guide to missing field warnings explains which property to fix.

Run the checks in order

Testing happens twice, because JSON syntax, Schema.org vocabulary, Google feature requirements and an actual search display are four different states, and passing one does not imply the next.

For syntax and vocabulary, paste the markup into the Schema Nova Schema Validator or the Schema Markup Validator. For Google feature requirements, use the Rich Results Test, and for the live page use URL Inspection in Search Console. The Rich Results Test versus Schema Validator guide explains which tool answers which question.

Audit steps for one page

  1. Choose subject and typeName the page's main subject, pick the most specific Schema.org type, and check the current Google feature guide.
  2. Build from visible factsWrite JSON-LD from what the page shows, adding required properties and accurate recommended ones.
  3. Validate syntaxCheck that the JSON parses and that types and properties follow the Schema.org vocabulary.
  4. Check the featureRun Google's Rich Results Test where the feature is supported.
  5. Inspect the live URLPublish, then confirm the markup appears in the rendered page, and request crawling where appropriate.
  6. Monitor and updateWatch Search Console, Bing or Yandex reports, and update the markup whenever page facts change.

Bing reads JSON-LD and Microdata, so the markup you have already checked serves both engines. Test with Bing URL Inspection and its Markup card, which shows the JSON-LD and other formats Bing recognizes, and keep Bingbot access open: Microsoft says Copilot web search uses Bing results (Microsoft Learn). Yandex's Structured Data Validator checks Schema.org, Open Graph, Microformats, Microdata and RDFa, and its Semantic Markup FAQ says not all Schema.org types are supported.

To let ChatGPT Search reach the page, allow OAI-SearchBot in robots.txt (OpenAI crawler documentation). For Perplexity and other systems, keep important facts in clear, crawlable HTML and do not add undocumented AI-only markup. Google says AI Overviews and AI Mode need no special Schema.org markup (Google AI features documentation). See whether AI systems use schema markup for the full comparison.

Run the checklist on one page per template

Start with one representative page for each template: a blog post, a product page, a service page, the home page. Running the checklist on every URL is slower than fixing the template that generates them. Run the order above, fix any mismatch between the markup and the visible page first, then retest and inspect the live URL.

If a page passes and still shows no enhancement, the guide on rich results not showing covers the checks that change the diagnosis, and the rich results and rich snippets guide explains what each display needs. Warnings about missing fields go to the missing field warnings guide.

Recheck provider documentation before you act on any feature requirement, because Google, Bing and Yandex change requirements and displays over time. Google's updates page lists the most recent documentation changes.

Questions people ask

Does schema markup help SEO?

Google says structured data helps it understand a page and can make the page eligible for richer search displays. Google also says eligibility does not guarantee a rich result, better rankings, more traffic or an AI citation, so treat markup as accuracy work rather than a ranking lever.

What is the difference between Schema.org and JSON-LD?

Schema.org is the shared vocabulary of types and properties, such as Article and datePublished. JSON-LD is one format for writing that vocabulary into a page, and Google recommends it in general.

Which properties are required?

It depends on the consumer and the feature. Google's Article documentation lists no required properties, while its Breadcrumb documentation requires itemListElement and the position, name and (except on the last item) item fields on each ListItem.

Is FAQPage markup still useful?

FAQPage remains a valid Schema.org type. Google says FAQ rich results stopped appearing in Google Search on May 7, 2026, so do not add it expecting that display. Add it only when another documented consumer or your own data use justifies it.

Does JSON-LD work outside Google?

Bing says it supports Schema.org in JSON-LD and Microdata. Yandex says its validator recognizes Schema.org, Open Graph, Microformats, Microdata and RDFa, and that not all Schema.org types are supported. Each provider decides which types it uses, so test with that provider's own tool.

Quick check

Choose an answer to see feedback. Nothing is scored or saved.

Question 1 of 3

Your JSON-LD parses correctly, but the page shows $39.00 and the markup says 29.00. Is the markup ready?

Question 2 of 3

A page passes the Rich Results Test but shows no rich result in search. What does that mean?

Question 3 of 3

Which Article properties does Google's Article documentation list as required?

Terms used in the checklist

Select a term to see its definition.

Structured data. Machine-readable information that describes the content of a page.