What Schema Markup Actually Does
Schema markup is structured data, almost always JSON-LD in a script tag, that restates the facts already visible on a page in a vocabulary machines can parse without guessing. A human reads your byline and infers the author; a crawler reads "author": {"@type": "Person", ...} and knows. That is the entire mechanism. It is unglamorous, and it is one of the few AEO levers where you control every variable.
One honest note up front: this page is a working generator’s worth of material in guide form, with copy-ready JSON-LD templates below, not an input form that emits markup for you. Where an interactive check does exist is verification: AEO Goal’s free AI visibility scan fetches your homepage live and reports whether your JSON-LD parses, which schema types are present, whether an Organization entity resolves, and how many sameAs links it carries, with no signup.
Why this matters for Answer Engine Optimization: AI engines assembling an answer must first decide what your page is and who stands behind it. Clean entity markup removes ambiguity from that decision. It will not make a weak page citable, but ambiguity about who you are is a tax on every page you publish.
The One Rule Before Any Template
Mark up only what a reader can already see on the page. Every guideline Google publishes about structured data reduces to this, and violations are the main way schema backfires: markup that misrepresents page content can earn a manual action, and self-serving reviews (rating yourself on your own Organization markup) are explicitly ineligible for rich results. A schema generator that lets you type in ratings, awards, or FAQs that appear nowhere on the page is generating liabilities.
Organization: Your Entity Anchor
This belongs on your homepage. Its job is disambiguation: telling every engine which real-world entity this domain represents, and proving it by linking the profiles that corroborate you.
{
"@context": "https://schema.org",
"@type": "Organization",
"@id": "https://www.example.com/#organization",
"name": "Example Company",
"url": "https://www.example.com/",
"logo": "https://www.example.com/images/logo.png",
"description": "One factual sentence about what the company does.",
"sameAs": [
"https://www.linkedin.com/company/example-company",
"https://github.com/example-company",
"https://www.crunchbase.com/organization/example-company"
]
}Two details carry most of the value. The @id gives the entity a stable address that other markup on your site can point back to, so every page resolves to one unambiguous brand node instead of scattered fragments. The sameAs array is your disambiguation cluster: list the official profiles that verifiably belong to you (registries, social accounts, knowledge bases), and nothing that does not. The free scan counts these links because a bare Organization node with no corroboration does much less work than one anchored to the wider web.
Article: Authorship And Freshness
For blog posts and editorial pages. This is where E-E-A-T-relevant facts (who wrote it, when, on whose behalf) become machine-readable.
{
"@context": "https://schema.org",
"@type": "Article",
"headline": "The Exact Headline Visible On The Page",
"author": {
"@type": "Person",
"name": "Jane Author",
"url": "https://www.example.com/authors/jane-author"
},
"publisher": { "@id": "https://www.example.com/#organization" },
"datePublished": "2026-05-12",
"dateModified": "2026-09-01",
"mainEntityOfPage": "https://www.example.com/blog/post-slug"
}Note the publisher field: it references the Organization @id rather than repeating the whole node, which is how the entity graph stays consistent site-wide. And keep dateModified truthful. It should change when the content meaningfully changes, not on every deploy. Recency-weighted retrieval systems read freshness signals, and the free scan checks whether any dateModified or datePublished signal is present at all, but a dateModified that updates nightly while the content never changes is the kind of pattern that erodes trust in everything else you declare.
FAQPage: Useful, With A Big Caveat
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "A question that appears verbatim on the page?",
"acceptedAnswer": {
"@type": "Answer",
"text": "The answer, matching what the page visibly says."
}
},
{
"@type": "Question",
"name": "A second visible question?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Its visible answer."
}
}
]
}The caveat: in August 2023, Google restricted FAQ rich results to well-known, authoritative government and health websites. For everyone else, FAQPage markup no longer produces the expandable question snippets in Google results. In the same update, Google deprecated HowTo rich results entirely. If a schema tool or agency is still selling FAQ markup as a Google rich-result play for a SaaS or ecommerce site, that pitch is three years stale.
So why include the template? Because rich results were never the only consumer. FAQPage markup remains valid schema.org vocabulary that makes question-answer pairs explicit for any machine reader, and question-shaped content is precisely what answer engines mine. Treat it as low-cost machine clarity on pages whose visible content is already Q&A-shaped, not as a snippet trick.
What “Eligibility” Really Means
Google’s own documentation is blunt on this: valid structured data makes a page eligible for rich results and does not guarantee them. Google weighs the markup alongside content quality, site history, and query context, and it regularly changes which rich result types exist at all, as the FAQ and HowTo history shows.
The same logic extends to AI engines, with even less ceremony. No engine publishes a contract that JSON-LD earns citations. What markup does is reduce interpretation errors: the engine spends no inference deciding who the author is, which company the page belongs to, or when it was last true. On the margin, a source that is cheap to interpret and consistent with its visible content is a safer thing to cite. That margin is the honest case for schema, and it is worth having; anything stronger is a sales pitch. Whether marked-up pages actually get quoted is a measurable question, which is what AI citation tracking answers per page and per engine.
Verify, Then Keep It True
Syntax first: run new markup through Google’s Rich Results Test or the Schema.org validator before it ships. A JSON-LD block with a trailing comma fails silently in production; browsers do not render script errors from data blocks, so nothing looks wrong while engines read nothing.
Then verify the live page. The free scan reports what an engine-like fetch actually finds on your homepage: whether JSON-LD parses, the schema types present, whether an Organization node exists, the sameAs count, whether FAQ markup is present, and whether freshness signals exist, alongside the crawlability context (robots.txt AI-bot access, llms.txt, canonical, metadata) that determines whether engines reach the markup at all. A technical SEO audit covers that surrounding layer in depth.
Finally, treat schema as code with an owner. Facts drift: authors leave, products rename, pricing changes. Review markup whenever the facts it declares change, and re-scan after every fix. This is AEO Goal’s agent loop applied to structured data: the scan finds the gap, the fix ships, the re-check proves it landed.
Common Mistakes
Markup describing content that is not on the page. The cardinal violation, and the one with real penalty risk.
Invented reviews, ratings, or awards. Self-serving review markup is ineligible by policy, and fabricated ratings are the fastest way to convert markup from asset to liability.
Orphan nodes. An Article whose publisher is a retyped name string instead of an @id reference, on a site whose Organization lives only on the homepage, gives engines fragments instead of a graph.
Set-and-forget. Markup validated once in 2024 and never reviewed since now declares stale facts with high confidence.
Chasing exotic types. Twelve schema types on one page, most half-filled, help less than three types filled truthfully. Match the type to what the page visibly is.
Frequently Asked Questions
Should schema go in the head or the body? Google accepts JSON-LD in either; the head is the convention and keeps templates tidy. What matters is that it ships in the server-rendered HTML rather than depending on client-side JavaScript that some crawlers never execute.
Do AI engines actually read JSON-LD? Engines that crawl the web receive it with every page fetch, and entity-level consistency is visible in how they describe brands. What no one outside those companies can honestly tell you is the weight it carries, which is why the defensible position is: keep it accurate, keep it cheap to maintain, and measure citations rather than assuming.
Is Microdata or RDFa better than JSON-LD? All three are valid; JSON-LD is Google’s recommended format and by far the easiest to template, validate, and diff in code review. There is no measurable case for the others in a new build.