Schema Markup in 2026: The Complete JSON-LD Guide to Rich Results & AI Citations

Administrator in Search Engine Optimization Jun 01 / 3 months ago

Schema markup is structured data, almost always written in JSON-LD, that you add to a page so search engines and AI systems know exactly what your content is. It might be an article, a product, a recipe, a local business, or a person.

Google has confirmed that schema is not a direct ranking factor, which is accurate but rather misses the point. Markup does two things in 2026 that matter enormously: it qualifies your pages for rich results, and it hands AI engines clean, machine readable facts they can quote and cite.

The payoff is measurable, though the size of it varies wildly. Google's own structured data documentation cites Rotten Tomatoes measuring a 25 percent higher click through rate on pages with structured data, and Nestle reporting 82 percent higher click through on pages that show as rich results. Those are the wins Google chose to publish, so treat them as a ceiling rather than an average. The direction is what holds.

This guide covers the format that matters and the types worth your time. It covers what Google retired in 2026, a copy ready example, and the free tools that catch errors before you ship. You also get a decision walkthrough, the mistakes that break most setups, and a monthly audit that takes twenty minutes.

It pairs directly with our guide to ranking in AI search and Google AI Overviews, where structured data does much of the heavy lifting.

What does schema markup actually do?

Think of schema as a label maker for the web. A heading that reads Tissot PRX Powermatic 80 is just text to a crawler. It could be a watch, a band, or a font. Wrap that page in Product schema with a name, price, currency, stock status, and rating, and the doubt disappears. The engine knows what the page is, and it can show those details as a rich result.

The same clarity helps AI systems. ChatGPT, Perplexity, Gemini, and Google AI Overviews all need to work out what a page covers, who wrote it, and which brands it names. Clean markup answers those questions in a form no machine misreads. Prose leaves room for guesswork. JSON-LD does not.

Here is the part people consistently miss: schema does not make your content better, it makes your content legible. A thin page remains thin regardless, while a genuinely strong page becomes visible to every system that reads it.

Why should you use JSON-LD and nothing else?

There are three ways to add structured data: JSON-LD, Microdata, and RDFa. In 2026, only one of them is genuinely worth learning.

JSON-LD is the format Google recommends, and it is the industry default. It sits in its own block, apart from your visible HTML. That separation is the whole point. You can template it, debug it, version it, and hand it to a developer without touching the design.

Microdata puts attributes inside your markup. It still works, and older sites can keep it. But it breaks the moment someone edits a template. RDFa is close in spirit and lives mostly in academic projects. For any new build, pick JSON-LD.

How do you pick your first schema type?

Most people freeze at this stage, because the schema.org vocabulary lists more than 800 types when you realistically need about five. Start with the question your page answers, rather than with the template name.

If the page is about your company

Use Organization, which covers your home page and your about page. Start here, because every other type can point back to it.

If the page teaches or explains something

Use Article, or BlogPosting for a dated post, and populate the headline, author, publish date, and modified date. Skip HowTo entirely, because Google stopped showing HowTo rich results back in 2023.

If the page sells something

Use Product, with a nested Offer for price and stock status, and add AggregateRating only when genuine reviews already sit on the page.

If the page serves a place

Use LocalBusiness, adding the address, opening hours, and service area. For a chain, mark up each location page individually.

If the page is a hub or a list

Use BreadcrumbList so crawlers understand your hierarchy, and add ItemList whenever the page genuinely is an ordered set.

Those five cover roughly 80 percent of real work. Run the tree once per template, not once per URL. A blog with 400 posts needs one Article template, not 400 hand written blocks. Add niche types like MedicalWebPage, LegalService, JobPosting, or Recipe only when the content truly fits. Check Google's structured data gallery first, because eligibility changes far more often than the vocabulary does.

Why is sameAs the most under used element in schema markup?

If you do one thing beyond the basics, make it this one. Add the sameAs property to your Organization schema, and point it at authoritative profiles that already establish who you are, including Wikipedia, Wikidata, LinkedIn, Crunchbase, and your verified social accounts.

What sameAs actually solves

Search engines and AI models do not store your brand as a string. They store it as an entity, a node with facts attached. Their hard problem is deciding whether the Nova Labs on your site is the same Nova Labs on LinkedIn. That job is called entity resolution.

An ambiguous brand name costs you twice. Facts get split across two shadow entities, and neither one looks trustworthy. The sameAs property closes that gap in a single line.

How to build a sameAs list that works

• List only profiles you control or that describe you accurately.
• Put the most trusted source first. Wikidata beats a social profile.
• Use each profile's canonical URL, never a redirect or a share link.
• Keep the list short. Six strong entries beat thirty weak ones.
• Repeat the same list on every page carrying Organization schema.

Consistency is the quiet requirement. If your home page lists five profiles and your blog template lists three, you have handed a crawler a reason to doubt both. Strong entity signals drive the AI citation confidence we covered in the GEO guide. Keep your social preview tags in step too. Our Open Graph Generator makes that a two minute job.

What did Google deprecate in 2026?

Google has spent three years quietly retiring rich result types, and in 2026 the biggest one finally disappeared.

HowTo rich results were pulled back in 2023. FAQ rich results were cut that same year to a narrow carve out for well known government and health sites. Then, on 7 May 2026, Google closed that carve out too. FAQ rich results no longer appear in Google Search for any site.

Google also said in November 2025 that it would drop a batch of lesser used features from January 2026. Practice problem structured data was on that list.

What this does not mean

Schema markup is emphatically not dead, and Google has repeatedly confirmed that it still supports and uses structured data. A handful of display formats disappeared, but the underlying format did not.

So what about your FAQ blocks?

Keep writing FAQ content, because readers genuinely use it and AI engines particularly favor it: a question followed by a tight answer is the easiest thing on any page to extract and cite. Just stop expecting FAQPage schema to earn you an accordion in Google's results, because no eligible site exception remains.

Leaving old FAQPage markup in place is harmless. It is still a valid schema.org type, and unused markup does not hurt Search. But do not spend another hour on it.

Why does schema markup matter for AI citations?

This is the part most schema guides skip. Rich results were the whole reason to add markup for a decade. In 2026 they are only half the reason. AI answer engines pull candidate sources, then decide which ones to name. Structured data helps at both steps.

Retrieval: arriving as facts, not as a wall of text

Retrieval systems favor content they can chunk cleanly. A page with proper Article markup arrives with a headline, an author, a date, and a publisher already separated, whereas a page without it arrives as one long blob that has to be parsed and guessed at. Guessing costs confidence.

Attribution: getting named instead of absorbed

Here is the outcome that actually pays. An AI system can use your information and never name you, which happens constantly. What makes a citation likelier is a publisher entity the model can resolve. Organization schema with sameAs hands it a brand it can match against its own knowledge graph. A brand it recognizes is a brand it will name.

Freshness: why the date fields matter

ChatGPT, Perplexity, and Google AI Overviews all lean on recency for anything time sensitive. Your datePublished and dateModified values are the cleanest freshness signal you can send, so set them properly and only move dateModified when you have genuinely changed the content. A date that shifts every night quickly stops meaning anything.

None of this guarantees a citation, it simply removes the reasons to skip you. That is the honest framing, and it still earns the afternoon it costs.

What does a copy ready JSON-LD block look like?

Here is a small, valid Article block you can adapt today. Wrap the JSON below in a script tag whose type attribute is set to application/ld+json. Put that block in the page head or body. Then swap in your real values.

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Schema Markup in 2026: The Complete JSON-LD Guide",
  "image": ["https://example.com/img/schema-guide.jpg"],
  "author": { "@type": "Person", "name": "Your Name" },
  "publisher": {
    "@type": "Organization",
    "name": "Your Brand",
    "sameAs": [
      "https://www.wikidata.org/wiki/Q12345678",
      "https://www.linkedin.com/company/your-brand"
    ]
  },
  "datePublished": "2026-06-01",
  "dateModified": "2026-07-29"
}

Two details there are easy to miss. The publisher is a nested Organization, not a plain string, which is what lets the sameAs array work. And the image field is an array, so you can pass more than one crop.

Before it ships, paste your JSON-LD into our JSON Validator to catch syntax errors. Then tidy the indentation with the JSON Formatter or the JSON Beautifier. For a long or deeply nested block, the JSON Viewer and the JSON Editor make the structure far easier to read.

Which mistakes break schema most often?

Four failures account for most broken markup. Each one shows up differently when you test, so the signature is worth learning.

Marking up content users cannot see

Do not mark up anything that is not visible on the page, because hidden ratings and invented prices count as spam and Google can issue a manual action. This particular failure usually passes validation cleanly, which is exactly the trap: the tool checks syntax, not honesty.

Missing required properties

A Product with no offer, review, or rating cannot show a price or stars, because Google requires at least one of those three. Article is different. Google lists no required properties for Article at all, so a missing author is a yellow warning, not a red error. Learn that difference in the Rich Results Test, because red means the page is ineligible for that rich result while yellow means a recommended field is simply absent. Fix everything red first.

Broken JSON before schema even runs

A trailing comma or a curly quote pasted from a word processor stops the parser dead. The symptom is distinctive, because Google reports no structured data whatsoever rather than a field level error. Run the block through our JSON Validator and the cause appears at once.

Two blocks fighting each other

Plugins do this constantly. A theme adds Article schema, an SEO plugin adds it again, and the page now claims two different authors. Validators list duplicate entries for the same type. Pick one source of truth and switch the other off.

One rule covers all four. Correct markup is necessary but never sufficient. Google decides rich result eligibility from its structured data guidelines, your content quality, and the rules for that specific type, so a technically valid block still earns nothing on a weak page. Fill in every property you can back up. Leave out the rest.

How do you test, ship, and keep schema healthy?

Always test before you publish. The order matters more than the tools.

• Check the raw JSON for syntax errors first.
• Run the block through the Schema Markup Validator for vocabulary errors.
• Run the live URL through Google's Rich Results Test to confirm eligibility.
• Deploy to one template, not the whole site.
• Re-test the live page, because your CMS may change your output.

That last step is the one people skip, and it is the one that catches breakage nobody predicted. Content management systems strip attributes, escape characters, and reorder blocks in ways nobody documents. After you publish, nudge crawlers with our Online Ping Website Tool.

Your twenty minute monthly audit

Schema rots. CMS updates, theme changes, and plugin conflicts break JSON-LD output more often than anyone expects, and nothing tells you when it happens. Run this once a month.

• Pick one live URL per template. Home, post, product, category.
• Test each with the Rich Results Test, not with pasted code.
• Read the Search Console enhancement reports for new errors.
• Diff your sameAs list. Profiles get renamed and companies get acquired.
• Confirm modified dates on your top pages reflect real edits.
• Re-check overall page health with our Website SEO Score Checker.

Log what you find. One line a month becomes a pattern within a quarter, and patterns are how you catch the plugin that keeps breaking things.

Where does schema fit in the bigger picture?

Structured data is one important layer of a healthy site, but it is emphatically not the entire site.

Pair it with the page level work in our on page SEO checklist for 2026. Keep titles and descriptions sharp with the Meta Tag Generator and the Meta Tag Analyzer. Make sure pages load fast using our guide to Core Web Vitals. If you are still building a stack, our roundup of the 30 best SEO tools covers what is worth paying for.

Read the source too. The schema.org vocabulary defines what exists. Google's documentation defines what Google shows. They are not the same document, and confusing them is why people build markup that validates perfectly and displays nothing.

Frequently asked questions

Is schema markup a Google ranking factor?

Not directly. Google has confirmed structured data is not a ranking signal on its own. But schema markup qualifies pages for rich results and feeds AI engines clean facts, and both lift clicks. The visibility gain is real, even though the ranking factor label does not apply.

Should I still use FAQPage schema in 2026?

Not for rich results. Since 7 May 2026, FAQ rich results no longer appear in Google Search for any site, including the government and health domains that kept them after the 2023 restriction. FAQPage is still a valid type, so old markup is harmless. Keep the FAQ content for readers.

Which schema types should a blog or small business start with?

Start with Organization and its sameAs links. Add Article or BlogPosting for content pages, then BreadcrumbList for hierarchy. Add Product or LocalBusiness depending on what you sell. Build each at template level. Move into specialist types only when your content clearly fits them.

How do I check if my schema is working?

Validate the raw JSON first, because most failures are syntax. Then run the live URL through Google's Rich Results Test and the Schema Markup Validator. Check the Search Console enhancement reports every month. Site changes break markup silently, so testing once at launch is never enough.

Does structured data help with ChatGPT and Google AI Overviews?

It helps, though nothing guarantees a citation. Clear Article markup lets retrieval systems chunk your page into facts instead of text. Organization schema with sameAs gives a model a brand it can resolve and name. Accurate date fields signal freshness, which matters for time sensitive topics.

Should I use a plugin or write JSON-LD by hand?

A plugin is the right call for most sites. Yoast, Rank Math, and Shopify all output solid defaults, and they update when Google changes the rules. Write JSON-LD by hand only for pages a plugin cannot model. Either way, run one source of truth, because duplicate blocks cause more trouble than missing ones.

Final thoughts

Schema markup quietly decides how clearly machines understand your site. In 2026 those machines include search engines and the AI systems answering questions on their behalf. So stick to JSON-LD. Build the core types at template level. Lead with a strong Organization entity and a clean sameAs list. Validate before you ship, then audit monthly. My prediction for the next two years is straightforward: rich results will continue shrinking, while entity clarity keeps growing in value. Which type are you going to fix first?