Short answer: schema markup does not make an AI engine cite you, and none of the crawler documentation from OpenAI, Anthropic, Perplexity or Google says it does. What it does is state a small number of facts unambiguously: who you are, what a product costs and whether it is available, who wrote a page and when. A handful of types earn their keep for that (Organization with sameAs, Product or ProductGroup with offers, Article with author and dates, and FAQPage over questions the page actually shows). Three checks matter more than which types you pick: the markup must be in the server-rendered HTML, there must be one graph rather than three competing ones, and every fact in it must match what a reader sees.
What schema markup can and cannot do for AI search
Treat structured data as disambiguation, not as a ranking lever. An answer engine that has fetched your page already has the prose; markup adds a version of a few facts that does not depend on parsing that prose. That is most useful exactly where ambiguity costs you: a brand name shared with something else, a product with variants, a price that appears in three places on the page.
It cannot compensate for problems upstream of it. If an engine's search agent is blocked, or the content only appears after JavaScript runs, the markup never arrives either. And it cannot substitute for corroboration: a model needs the same fact from independent places before it will state it confidently, and a claim that exists only on your own domain is the weakest form of evidence you can offer, however well it is marked up.
So the useful question is not "which schema ranks" but "which facts about us are ambiguous, and where". For a brand that shares its name with something else, the answer is identity. For a shop with variants, it is price and availability. For a publisher, it is authorship and dates. Pick the markup that answers your own ambiguity, and skip the rest.
The schema markup types that do real work
| Type | What it pins down | Watch for |
|---|---|---|
Organization | Your official name, URL, logo, and sameAs links to profiles that are really yours. This is the entity anchor. | Duplicate or conflicting Organization nodes from several plugins or apps. |
Product / ProductGroup with offers | Price, currency and availability, which are otherwise buried in layout. | Multi-variant products on Shopify emit ProductGroup, not Product, and the offers shape differs. |
Article with author and dates | Who wrote the page and when it was published and modified. | Modified dates bumped by every deploy, which state a change that never happened. |
FAQPage | Questions and answers as discrete pairs. | Only over questions and answers the page visibly displays. |
BreadcrumbList | Where the page sits in the site. | Breadcrumbs that disagree with the URLs in your sitemap. |
Everything else is optional. Adding more types than you can keep accurate creates more places for markup and page to disagree. Our guide to FAQ schema that works covers the one type people most often get wrong.
Organization and sameAs: the part most sites leave empty
sameAs is the field doing the entity work, and it is the one most sites leave nearly blank. Links to the profiles you control are what connect "the name on this page" to an organisation that exists elsewhere. Organization markup with a logo, a founding date and links to your official profiles, plus a claimed entry in a public knowledge graph, lets you state your identity in a form machines already trust. It is one of the few levers a brand can pull without waiting for coverage.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Organization",
"@id": "https://example.com/#organization",
"name": "Example Outdoor Co.",
"url": "https://example.com/",
"logo": "https://example.com/logo.png",
"description": "Example Outdoor Co. makes waterproof hiking jackets for cold, wet climates.",
"sameAs": [
"https://www.linkedin.com/company/example-outdoor",
"https://www.youtube.com/@exampleoutdoor"
]
}
</script>
Use the same name and the same one-sentence description you use everywhere else. Spelling variants and a legal name that differs from the trading name are exactly the ambiguity this block exists to remove. Only list profiles you actually control. Entity and sameAs explains which links to include and which to leave out.
The @id line is what lets the rest of your markup point at this node instead of repeating it. An Article's publisher and a Product's brand can both reference https://example.com/#organization, so the site describes itself once and every other page inherits that description. Without it, each template tends to emit its own slightly different Organization, and the graph contradicts itself.
Your platform's defaults are thinner than you think
Most sites assume their platform handles schema. Usually it handles part of it, or none:
| Platform | What you get by default | How to add the rest |
|---|---|---|
| Shopify | No JSON-LD is injected for you. | Call the structured_data Liquid filter on product and article objects and wrap the output in a script tag yourself. Organization and FAQPage are hand-written Liquid or an app. |
| WordPress | Core emits no schema.org markup for content. | Theme, SEO plugin, schema plugin, or your own JSON-LD on the wp_head hook. The usual failure is duplicate graphs, not missing ones. |
| Webflow | No documented automatic output. | Custom code in the head, site-wide or per page, or an Embed on a collection template that fills JSON-LD from CMS fields. Both custom-code fields need a paid Site plan. |
| HubSpot | No documented automatic output. | JSON-LD in the template inside the require_head HubL tag, filled from HubL variables, with dates formatted by datetimeformat. |
The primary references are Shopify's structured_data filter, the WordPress wp_head hook and HubSpot's guide to structured data in HubSpot. Platform-by-platform detail is on our Shopify and WordPress pages.
A sensible order of work is the same on every platform. First find out what is already emitted, because on WordPress in particular the problem is usually a surplus rather than a gap. Then decide which single source owns the Organization node and switch the others off. Only after that add the types your own ambiguity calls for, in templates rather than page by page, so that new pages inherit them without anyone remembering to.
One Shopify detail catches almost every audit: the structured_data filter emits ProductGroup rather than Product when a product has multiple variants. A checker that insists "@type must be Product" will report a false failure on every variant-bearing product in the catalogue.
Four patterns that hurt
- Markup injected by JavaScript. Most AI crawlers do not execute JavaScript. JSON-LD added by a tag manager or a client-side script after load is absent from the HTML they receive, however correct it looks in a browser inspector.
- Several competing graphs. A theme, an SEO plugin and an app can each emit their own Organization or Article node with slightly different names, logos or dates. Two descriptions of the same entity that disagree are worse than one.
- Markup that describes content the page does not show. FAQPage over answers that are not on the page, or a price in the markup that differs from the visible one, is a claim the page itself contradicts. If an answer is worth marking up, it is worth showing.
- Dates that move on their own. A
dateModifiedthat the build pipeline refreshes on every deploy claims an update that never happened, and it is a claim a crawler can check against the page. Questions that imply a current answer favour dated, recently updated pages, so a fake date is not neutral: it spends credibility you need for the real updates.
None of these failures is visible from inside your CMS, which shows you the template rather than the delivered page. That is why the next step tests the response itself.
How to verify the schema markup you actually ship
Check the JSON-LD your page delivers, not what your template intends to deliver. From a terminal:
# 1. Is the JSON-LD in the HTML a non-JavaScript crawler receives?
curl -s https://example.com/ | grep -c 'application/ld+json'
# 2. How many Organization nodes does the page ship? It should be one.
curl -s https://example.com/ | grep -o '"@type": *"Organization"' | wc -l
Then read the extracted blocks against the visible page: the name, price, availability, author and dates must match what a reader sees. On Shopify, open a multi-variant product and expect ProductGroup. On WordPress, count the Organization nodes on any post; there must be exactly one, and the plugin emitting the duplicate should be switched off. Re-run these checks after every theme, plugin or template change, because that is when markup and content quietly drift apart. If the site has several templates, such as home, product, article and collection pages, test one page of each, because each template can ship different markup.