Schema markup is structured data code you add to a page so machines can read what the content means, not just what it says. The vocabulary comes from Schema.org, a project the major search engines maintain together, and Google uses it to power rich results like star ratings, prices, and event dates. The word "Avatar" could be a film, a profile picture, or a spiritual concept; schema is how you remove the guesswork. In 2026 the audience for that clarity includes AI engines deciding whom to cite, not just search crawlers deciding what to rank. This post covers both halves of the title: what schema markup is and what it genuinely earns, then a complete walkthrough for adding structured data to your own website, whatever it runs on.
The short version
- Schema markup describes your content to search engines and AI systems in a shared vocabulary.
- It is not a ranking factor. It earns richer listings, correct understanding, and accurate citations.
- Use JSON-LD, connect your types into one graph, validate before shipping, and mark up only visible content.
- HowTo and most FAQ rich results are gone, so aim at the types that still pay.
What structured data actually does
A crawler reading your page sees text and has to infer everything else: whether "4.8" is a rating or a version number, whether a date is publication or an event, whether the name in the byline is a person or a company. Structured data replaces that inference with declarations. You state, in a machine-readable block, this page is a blog post, this person wrote it, this organization published it, on this date. Three audiences consume those declarations. Search engines use them to qualify pages for rich results and to build entity records like Knowledge Panels. Other platforms read them for previews and feeds. And AI answer engines lean on them to resolve who you are and what your pages claim before deciding whether to cite you.
One boundary keeps the whole system honest and gets missed constantly: Google has confirmed structured data is not a ranking factor. Markup changes how your listing can look and how well machines understand you. It does not move your position. Anyone selling schema as a rankings lever, or as the secret to AI visibility, is selling.
Why JSON-LD won the format war
Schema can be written as JSON-LD, Microdata, or RDFa. JSON-LD sits in a single script tag in the head, separate from your visible HTML, so it cannot break your layout and stays easy to edit and validate. Microdata and RDFa weave attributes through the markup itself, which is exactly as pleasant to maintain as it sounds. Google recommends JSON-LD, every generator and plugin emits it, and there is no modern reason to pick anything else for a new build.
The types worth adding in 2026
| Type | Use it on | What it can earn |
|---|---|---|
| Article / BlogPosting | Editorial content | Correct authorship, dates, and headline in results and AI citations |
| Product | Ecommerce pages | Price, availability, and rating in listings; the highest-impact type on any store |
| LocalBusiness | Location and contact pages | Address, hours, and phone tied to the right entity in Search and Maps |
| Organization | Sitewide, defined once | Knowledge Panel eligibility and entity recognition across every page |
| BreadcrumbList | Every page in a hierarchy | Your site structure shown in the listing instead of a raw URL |
| Review / AggregateRating | Pages with genuine reviews | Star ratings in listings; fabricated ones invite a manual action |
| VideoObject, Event, Recipe | Pages where that content lives | The matching rich result, when the content is really on the page |
| FAQPage | Real question sections | Machine-readable Q&A; the visual dropdown is gone for most sites |
Two honest corrections to what older articles promise, this one's previous version included. Google retired HowTo rich results in 2023, and since the same year FAQ rich results display only for well-known government and health sites. FAQPage markup still helps machines parse your questions and answers, but the dropdown in the listing is gone for most sites, so stop choosing schema types for a visual reward that no longer exists.
Where to start depends on the site you run
Schema advice fails when it hands every site the same list, because the payoff is concentrated differently per business model. A local service business gets the most from Organization plus LocalBusiness with exact name, address, and phone, because entity resolution across Search, Maps, and AI answers is its whole visibility game; Product markup is irrelevant to it. A store lives or dies on Product markup with live price and availability, because those feed shopping surfaces directly, and everything else is secondary. A publisher starts with Article and Person, because authorship and dates are what its listings and citations run on. A software company usually needs Organization, Article for its content, and honest Review markup where real ratings exist. Sequence your rollout by that logic: the type your revenue depends on first, done completely, then the supporting cast. Ten half-filled types earn less than two finished ones.
How to add structured data to your website
The walkthrough below works for any site. The only step that changes by platform is where the code physically goes, covered in step four.
-
Decide the types per template, not per page
Map your templates to types once: posts get BlogPosting plus BreadcrumbList, location pages get LocalBusiness, the whole site gets one Organization node. Working per template means every future page inherits correct markup, and it stops the drift that comes from hand-decorating pages one at a time.
-
Gather the facts each type requires
Every type has required and recommended properties, listed in Google's structured data documentation. For a post: headline, author, dates, image, publisher, canonical URL. For a business: name, address, phone, hours. Missing a required property makes the type ineligible rather than partially eligible, so collect everything before writing code.
-
Build the JSON-LD block
Start from the worked examples below or Google's own snippets and swap in your facts. Keep one rule absolute: every value in the block must appear on the visible page. Markup describing content a visitor cannot see violates Google's guidelines outright.
-
Put it in the page head for your platform
Hand-coded and framework sites: add the script tag to the template head, filled from the same variables that render the visible content, so the two can never disagree. WordPress: Yoast and Rank Math generate Article, Organization, and breadcrumb markup automatically, so check their output before adding anything by hand. Shopify and most ecommerce platforms emit Product markup from the theme; verify it rather than duplicating it.
-
Validate before publishing
Run the URL or the pasted code through Google's Rich Results Test for eligibility and the Schema.org validator for vocabulary errors. JSON fails as a block, not a line, so one missing comma silently kills everything, which is why validation is a publishing gate and not a nice-to-have.
-
Watch Search Console after it ships
The enhancements reports flag structured data errors across the whole site as Google recrawls, and they confirm when rich results start appearing. Expect days to a few weeks. Recheck after any theme, plugin, or template change, because those are what quietly break markup months later.
A worked example for a blog post
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "BlogPosting",
"headline": "Your Post Title",
"image": "https://example.com/featured.jpg",
"datePublished": "2026-01-11",
"dateModified": "2026-08-12",
"author": { "@type": "Person", "name": "Author Name" },
"publisher": { "@type": "Organization", "name": "Company Name" },
"mainEntityOfPage": "https://example.com/blog/your-post/"
}
</script>BlogPosting is the specific subtype; Article works identically for Google's purposes. The pattern is the same for every type: name the type, fill its properties with facts that appear on the page, nothing more.
Connecting types into one graph
Real pages carry several types at once, and the difference between amateur and professional markup is whether those types connect. The @graph pattern bundles the nodes into one block, and @id references link them: the LocalBusiness points to its parent Organization, the WebPage says what it is about. Connected nodes let a machine assemble one coherent entity from your whole site instead of meeting a stranger on every page.
{
"@context": "https://schema.org",
"@graph": [
{
"@type": "Organization",
"@id": "https://example.com/#org",
"name": "Business Name",
"url": "https://example.com/",
"sameAs": ["https://www.linkedin.com/company/example"]
},
{
"@type": "LocalBusiness",
"@id": "https://example.com/#location",
"parentOrganization": { "@id": "https://example.com/#org" },
"name": "Business Name",
"telephone": "+1-555-555-5555",
"address": {
"@type": "PostalAddress",
"streetAddress": "123 Main Street",
"addressLocality": "City",
"addressRegion": "State",
"postalCode": "12345",
"addressCountry": "US"
},
"priceRange": "$$"
},
{
"@type": "WebPage",
"@id": "https://example.com/services/#page",
"about": { "@id": "https://example.com/#org" }
}
]
}The habit that makes this maintainable: define each entity once and reference it everywhere. On our own builds the Organization node is generated from one data file and every page references its @id, so an address change is one edit, not a hunt through templates. If you find yourself pasting the same organization block into ten templates, stop and centralize it first; drift between copies is where most real-site schema errors come from.
Keeping markup alive after launch
Schema fails quietly, which makes maintenance the underrated half of the job. Nothing on the visible page breaks when a plugin update changes its output, a theme swap drops the head include, or a price in the markup stops matching the price on the page. The visitors notice nothing; the machines notice everything. Three habits keep a site honest. Generate markup from the same variables that render the visible content, so the two cannot disagree by construction. Recheck the enhancements reports in Search Console after every platform or template change, not on a calendar. And when content changes meaning, a service retired, an address moved, an author departed, treat the markup as part of the edit, because a machine reading stale declarations against fresh copy learns exactly one thing: this site cannot be trusted on details.
The mistakes that cost sites their rich results
- Marking up content that is not visible on the page, which violates Google's guidelines outright.
- Fake reviews and inflated ratings, the fastest route to a manual action.
- The wrong type for the content, like a service page marked as an Article.
- Missing required properties, which makes the type ineligible rather than partially eligible.
- Duplicate markup from a plugin and hand-written code describing the same thing twice, differently.
- One missing comma, because JSON fails as a block, not a line.
- Never validating, so all of the above ships unnoticed.
Why schema matters more as AI reads the web
Structured data is also how you state who wrote your content and what entity stands behind it, which feeds the experience and trust signals Google evaluates. Person schema ties authors to their credentials, Organization schema ties the site to a real company. The same clarity serves AI engines choosing sources to cite, which is the territory of generative engine optimization: an engine that can resolve your entity cleanly quotes you with confidence, and an engine that cannot hedges or skips you. Schema is disambiguation infrastructure, not a citation switch, and that is exactly why it belongs in the permanent layer of your site. On our own builds it is generated per template as part of technical SEO, so it can never drift from the visible content.
Questions people ask about schema markup
Does schema markup directly improve rankings?
No. Google has confirmed structured data is not a ranking factor. The payoff comes from richer listings that win more clicks, from search engines understanding your content correctly, and from AI systems citing you accurately.
Which schema format should I use?
JSON-LD, in every new build. It lives in a script tag separate from your visible HTML, which makes it easier to add, maintain, and validate, and it is the format Google explicitly recommends. Microdata and RDFa still work but offer nothing extra.
What schema type should a blog post use?
Article or BlogPosting. BlogPosting is the more specific subtype and Google treats the two essentially the same, so either is fine. NewsArticle is only for actual time-sensitive news.
Can I use several schema types on one page?
Yes, and most real pages should. A post typically carries BlogPosting plus BreadcrumbList, and a location page might carry LocalBusiness, Organization, and WebPage nodes. Bundle them in one graph, connect them with @id references, and make sure each type describes content actually on the page.
Do I need a plugin to add schema in WordPress?
Usually a plugin is the practical route. Yoast and Rank Math generate Article, Organization, and breadcrumb markup automatically and keep it valid through updates. Check what your plugin already outputs before writing any code, because duplicate markup from two sources is a common source of errors.
How long until schema shows up in search results?
Google has to recrawl and revalidate the page first, which usually takes days to a few weeks. Valid markup makes you eligible for rich results; it never guarantees them. Google decides per query.
