Schema Markup: The Complete Guide to Structured Data for SEO in 2026

				
					{
  "@context": "https://schema.org",
  "@type": "LocalBusiness",
  "name": "Roots Digital",
  "image": "https://www.rootsdigital.com.sg/logo.png",
  "@id": "https://www.rootsdigital.com.sg",
  "url": "https://www.rootsdigital.com.sg",
  "telephone": "+65-XXXX-XXXX",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "1 Example Street, #01-01",
    "addressLocality": "Singapore",
    "postalCode": "049999",
    "addressCountry": "SG"
  },
  "openingHoursSpecification": {
    "@type": "OpeningHoursSpecification",
    "dayOfWeek": ["Monday","Tuesday","Wednesday","Thursday","Friday"],
    "opens": "09:00",
    "closes": "18:00"
  }
}
				
			

One thing worth knowing: LocalBusiness markup works best when it matches a claimed Google Business Profile. The two reinforce each other for local pack visibility. If local search is a focus for you, our local SEO services page goes deeper on pairing the two.

Article and BlogPosting

Article, and its cousin BlogPosting, marks up editorial content: the headline, author, publish date and featured image. Since Google retired FAQ and HowTo rich results, Article has quietly become one of the most useful types for content sites.

It gives Google clear signals about who wrote a piece and when, which supports both rich-result eligibility and the author-level trust signals that feed AI citations. Pair it with Person markup for the author to get the full benefit. Our SEO content services build this in as standard.

Product (merchant listing vs product snippet)

Product markup describes an item for sale: its price, availability and rating. Google splits it into two rich-result types, and the difference matters.

A product snippet appears on a page where someone can read about an item but not necessarily buy it there, such as a review or a roundup. A merchant listing appears on a page where a shopper can actually make the purchase, and it supports far more fields: shipping, returns, sizing and more.

If you run a store, mark up your product pages as merchant listings to unlock those extra fields. Our e-commerce SEO services cover this in practice.

Review and AggregateRating

Review and AggregateRating produce the star ratings you see under some listings. Review covers a single review; AggregateRating rolls up an average score from many.

There’s a rule that trips people up. You can’t mark up reviews of your own business on your own site and expect stars: self-serving reviews on Organization or LocalBusiness markup don’t qualify. Independent reviews of a specific product, though, still earn rich-result stars.

FAQPage

This is where the biggest recent change lives, so read carefully. FAQPage markup used to produce an expandable list of questions right in the search results. Google fully retired FAQ rich results on 7 May 2026, so that dropdown no longer appears for anyone. This followed an earlier 2023 change that had already limited it to authoritative government and health sites.

So should you still use it? FAQPage remains a valid schema.org type, and Google has confirmed it still parses the markup to understand your page. It no longer earns a visible rich result, but it can still help clarify your content for search and AI systems. Just don’t expect the old accordion, and don’t lose sleep if you drop it.

Breadcrumb

BreadcrumbList markup replaces the raw URL in a search listing with a readable path, such as Home, Services, SEO. It’s one of the highest-value, lowest-effort types you can add.

Two current details worth noting: breadcrumbs still show on desktop results, though Google stopped displaying them on mobile in early 2025, and they also give Google a clean signal about how your site is structured.

Event

Event markup covers anything scheduled: a webinar, a workshop, a conference. It needs a name, a start date and a location, and it can produce event rich cards showing those details directly in search.

If you run recurring events, this type earns its place. Google added more precise event subtypes in recent schema versions, so you can describe conferences and performances specifically rather than as generic events.

Person / Author

Person markup identifies an individual: usually an author, a founder or a team member. Its main job is attribution.

When you connect an article to a real author with a Person type, complete with their name, bio link and sameAs links to their profiles, you strengthen the expertise and trust signals Google associates with your content. This is a small addition that pays off for editorial sites and anyone building author authority.

Website (with WebSite schema for site names)

WebSite markup sits on your homepage and helps Google display your preferred site name in results rather than a guessed one.

A word of caution here, because the picture changed. This type used to power a Sitelinks Search Box, a small search bar under some listings. Google retired the Sitelinks Search Box on 21 November 2024, so that search bar no longer appears. The WebSite markup for site names, though, is still supported and still worth having.

Other useful types (Recipe, Video, JobPosting, Logo)

A few more types are worth a mention depending on what you publish:

• Recipe produces recipe cards with cook times, ratings and images, essential for food sites.
• VideoObject helps Google understand and surface your videos, including key moments.
• JobPosting can place your listings in Google’s job search experience, handy for careers pages.
• Logo tells Google which image is your official logo, often bundled into Organization markup.

Note that HowTo markup no longer earns a rich result either, following its removal in 2023. The schema stays valid, but it won’t produce the step-by-step display it once did.

How to choose the right schema type

With a couple of dozen usable types, the natural instinct is to add as many as possible. Resist it. The wrong schema does more harm than good, and the right one is usually obvious once you know how to look.

Google’s guidance is to match your structured data to the primary element of the page. If a page is mainly a product, use Product. If it’s mainly an article, use Article. Marking up a secondary detail, or stacking three types on one page hoping something sticks, muddies the signal and can lead Google to distrust the markup.

There’s a real cost to getting it wrong. If your schema describes something that isn’t the main point of the page, Google may ignore it, and in cases where the markup doesn’t match visible content, you risk a manual action. So it pays to choose deliberately.

Content-type to schema mapping table

Here’s a quick reference to match common page types to their best-fit schema:

Page type	Best-fit schema
Blog post or article	Article / BlogPosting
Product page (buyable)	Product + Offer (merchant listing)
Product review or roundup	Product + Review / AggregateRating
Local business or location page	LocalBusiness
Homepage / about page	Organization + WebSite
Author or team-member page	Person
Event or webinar page	Event
Careers or job listing	JobPosting
Recipe	Recipe
Video-led page	VideoObject

Use this as a starting point, not a rulebook. Some pages genuinely carry two primary elements, which we cover just below.

Reference Google’s rich results and search gallery

When you’re unsure whether a type is worth adding, check whether Google actually turns it into a rich result. Google keeps a search gallery of structured data types that lists every feature it currently supports, with the required and recommended fields for each.

This is the single most reliable source, because it’s Google’s own and it’s kept current. If a type isn’t in the gallery, it won’t produce a rich result, however valid the schema is. Start there before you invest time in any implementation.

Look at what competitors mark up

The search results themselves tell you which schema Google rewards for your target query. If every page ranking for your keyword shows review stars or breadcrumbs, that’s a strong hint about what Google expects to see.

To check a competitor’s markup, open their page, view the source, and search the code for application/ld+json. You’ll see exactly which types they’ve implemented. It’s a fast way to spot a type you’ve overlooked, or to confirm you’re not missing something the whole results page is using. If you want to build this into a wider keyword strategy, our keyword research services tie schema choices to search intent.

Nested and multiple schema on one page

Sometimes a single type isn’t the whole story. Schema can be nested, meaning one type sits inside another. An Article can contain a Person as its author and an Organization as its publisher, all in one block. That’s not stacking unrelated types; it’s describing one thing properly.

Using genuinely separate types on one page is different. Google’s advice is to pick the one that matches your primary content rather than piling on Article plus FAQPage plus HowTo and hoping for the best. If a page could reasonably show two rich-result types, lead with the one you most want to appear and let the nested detail support it.

Schema markup formats: JSON-LD vs Microdata vs RDFa

You can write schema.org vocabulary in three formats, and the choice is straightforward.

JSON-LD keeps your structured data in a single script block, separate from your visible HTML. It’s the easiest to add, read and maintain, and it’s the format Google recommends. Nearly every example in this guide uses it.

Microdata and RDFa work differently. They weave the markup directly into your HTML tags, wrapping each piece of visible content in extra attributes. Both are older, harder to maintain, and easier to break. There’s rarely a reason to choose them for a new implementation.

So the short version: use JSON-LD unless you have a specific technical constraint forcing you elsewhere.

How to add schema markup to your website

There’s no single right way to add schema. The best method depends on your platform and how comfortable you are with code. Here are the options, from most hands-on to most automated.

Generate it manually (write JSON-LD by hand)

If you’re comfortable with code, you can write the JSON-LD yourself and paste it into your page. Start from a schema.org type, fill in the properties that match your content, and drop the finished script block into the page.

This gives you complete control, which matters for custom types or unusual pages. The trade-off is that it doesn’t scale: hand-writing markup for a thousand product pages isn’t realistic, and every edit is manual.

Use a schema generator

A generator gives you a form: pick a type, fill in the fields, and it outputs valid JSON-LD to paste in. It’s the sweet spot for people who want accuracy without writing code from scratch.

Google’s own Structured Data Markup Helper lets you tag elements on a page visually and generates the markup for you. Third-party generators from Merkle and others cover a wider range of types. Whichever you use, validate the output before publishing, since a generator only knows what you tell it.

Use an AI tool (ChatGPT / Gemini / Claude)

You can also ask an AI assistant to write schema for you. Give it your page content and the type you want, and it will produce a JSON-LD block in seconds. This is genuinely useful for a first draft or an unfamiliar type.

One rule applies without exception: validate anything an AI generates before you publish it. These tools can invent properties or miss required fields, so treat their output as a starting point, not a finished result. Run it through a validator, which we cover shortly.

Add it via your CMS or a plugin

Most modern content platforms handle schema for you, either out of the box or through an add-on. This is how the majority of sites should approach it, because the markup then updates automatically as your content changes. The exact path depends on your platform.

WordPress – Rank Math

Rank Math includes a schema generator in the free version. Enable the Schema module, and a Schema tab appears in every post and page editor. From there you open the Schema Generator, pick a type, and fill in the fields. You can also set a site-wide default schema type under Titles and Meta, so new posts start with the right markup.

WordPress – Yoast SEO

Yoast takes a more automatic approach. It builds a single connected schema graph for your whole site, covering Organisation, WebSite, author and article markup without manual setup. You set your brand details once under Search Appearance, and choose the content type per page from the Schema tab in the Yoast meta box. Its FAQ and How-to blocks add the matching markup as you build the page.

WordPress – Schema Pro / Schema & Structured Data for WP & AMP

If you need types the SEO plugins don’t cover, a dedicated schema plugin fills the gap. Schema Pro and the free “Schema & Structured Data for WP & AMP” both let you map schema types to page templates once, then apply them across the site. They’re a good fit when your needs go beyond the built-in article and product types.

Shopify

Shopify themes emit Product structured data automatically, so your product pages carry basic markup out of the box. For broader coverage, apps such as Smart SEO or JSON-LD for SEO add types like Organisation, Breadcrumb and FAQ across the store. If you run a store, our e-commerce SEO services can help you get this right.

Wix

Wix generates structured data for standard pages and lets you add custom JSON-LD under its SEO tools, in the structured data settings. For repeated markup across many pages, Wix’s custom-code features or a dedicated schema app handle it more efficiently than page-by-page editing.

Squarespace

Squarespace produces basic schema for blog posts, products and events automatically. For anything more, you add custom JSON-LD through Code Injection: the header area for site-wide markup, or a code block for a single page. Validate after adding, since Code Injection doesn’t check your syntax.

Webflow

Webflow has no built-in schema, so you add JSON-LD yourself through the custom-code area of a page’s settings or an embed element. Its real strength is dynamic markup: you can pull values from CMS fields so that every item in a collection generates its own valid schema automatically.

Magento

Magento offers some structured data through its themes, though coverage varies by version and template. Most stores extend it with an extension that adds Product, Review and Organisation markup, or with custom development for full control.

Deploy via Google Tag Manager

If you can’t edit your templates directly, Google Tag Manager is an officially supported route. You add a Custom HTML tag containing your JSON-LD block and fire it on the pages you want.

Google recommends pulling values from the page using GTM variables rather than typing them into the tag, so your markup can’t drift out of sync with the visible content. One caution: for fast-changing Product data like price and stock, Google warns that markup generated this way can make shopping crawls less reliable. For those pages, server-side markup is the safer choice.

Where to place the code (head vs body)

A common question is whether JSON-LD belongs in the head or the body. Google has confirmed either works, so you don’t need to worry about which section you use.

One preference does matter, though, and it’s about how the markup is rendered rather than where it sits. Schema that’s written into the page on the server is more reliable than schema injected later by JavaScript, for reasons we get into next when we look at AI crawlers.

How to validate and test your schema markup

Never publish schema without testing it first. A single missing required field can stop a rich result from ever showing, and you won’t get an error message in your face, just silence. Two free tools cover almost every case.

Google’s Rich Results Test

The Rich Results Test is Google’s own tool, and it answers the question that matters most: can this page earn a Google rich result? Paste a URL or a code snippet, and it tells you which rich-result types your markup qualifies for, plus any errors or warnings holding you back. Start here whenever your goal is a rich result.

Schema.org validator

The Schema Markup Validator checks your markup against the full schema.org vocabulary, not just Google’s supported subset. Use it when you’re working with types Google doesn’t turn into rich results, or when you want a pure syntax check. It replaced Google’s old Structured Data Testing Tool, so if any guide still points you there, it’s out of date.

Fixing errors vs warnings

Both tools sort issues into two buckets, and the difference decides your priority. An error means the markup is invalid and won’t produce a rich result until you fix it: usually a missing required field or a wrong data type. A warning flags a recommended field you’ve left out. Warnings won’t block the rich result, but filling them in gives Google more to work with. Fix every error; treat warnings as a to-do list.

How to check whether your site already has schema markup

Maybe you’ve inherited a site, or you’re just not sure what’s already in place. Checking is quick, and here’s how to do it.

The fastest method is to view your page’s source code. Open the page, view source, and search the code for application/ld+json. Each block you find is a piece of schema already on the page, and you can read the type to see what it describes.

For a friendlier read, paste the URL into the Rich Results Test or the Schema Markup Validator. Both parse the live page and lay out every type they detect, which is easier than scanning raw code. Some browser SEO extensions also flag structured data as you browse, handy for spot-checking as you go.

If you find markup you didn’t expect, that’s common: many themes and plugins add basic schema automatically. The thing to watch for is duplicate markup, where two plugins both output an Organization block, for instance. That’s worth cleaning up so Google sees one clear signal.

How to monitor and maintain schema at scale

Adding schema once isn’t the end of it. Prices change, events pass, pages get rebuilt, and markup that was right last year can quietly go stale. On a large site, you need a way to catch this.

Google Search Console enhancement reports

Google Search Console has an Enhancements section that tracks the schema types Google actively monitors, such as breadcrumbs, products, reviews and videos. Each report shows which URLs are valid, which have warnings, and which have errors, drawn from Google’s own crawl of your site.

This is your early-warning system. If a template change breaks your product markup, the error count climbs here, and you can catch it before it costs you rich results across hundreds of pages.

Auditing schema across a whole site

For a full picture, an SEO crawler can check structured data across every page at once, flagging missing, broken or inconsistent markup in bulk. That’s far more practical than testing pages one at a time when you have thousands of them.

If you’d rather have someone handle the audit for you, our free SEO audit covers structured data alongside the rest of your technical setup.

Is schema markup still relevant in the age of AI search?

It’s a fair question. Google fills more of the results page with AI Overviews, people ask ChatGPT and Perplexity instead of searching, and Google has retired several schema types. So does markup still earn its keep? The short answer is yes, but for reasons that have shifted.

Start with what Google actually says. Its own guidance is blunt: there’s no special schema you need to add for AI Overviews or AI Mode. These features draw from the same index as normal search, so your existing SEO fundamentals are what make you eligible. Anyone selling you “AI schema” is selling folklore, because there’s no such type.

So how do AI systems use schema at all? Mostly indirectly, and it helps to be honest about the mechanics. Most large language models read a page’s text, and structured data written into that page is text they can read. But an experiment that fed models a schema-only fact found they treated it as plain text rather than trusted structured data. So schema isn’t a magic input that AI systems weight above your visible content.

Google’s own AI answers are a partial exception. Because they’re built on Google’s index, and that index does parse structured data, clean markup can shape how Google understands and represents your page in an AI Overview. But that’s Google using its existing pipeline, not the markup speaking directly to the model.

There’s a technical trap worth knowing about, and it’s the most actionable point here. Most AI crawlers don’t run JavaScript. Research tracking hundreds of millions of crawler visits found that bots like GPTBot, ClaudeBot and PerplexityBot read only your raw HTML and leave, while Googlebot renders JavaScript and they don’t.

So if your schema is injected by JavaScript after the page loads, those crawlers never see it. The fix is to serve your structured data as static markup written into the page on the server. This is why placement of the code matters less than how it’s rendered.

The bigger payoff is about entities. Clear Organization, Person and WebSite markup helps search and AI systems connect your brand, your authors and your site into recognised entities. That entity clarity, reinforced by @id and sameAs links, is what makes an AI system more confident about who you are and more likely to represent you accurately. It’s a trust and clarity signal, not a ranking switch.

So schema remains worth the effort, just with realistic expectations. It won’t force an AI citation, but it removes ambiguity about your content and your brand, which is exactly what these systems need. If getting cited in AI answers is a priority for you, our AI SEO services focus on precisely this kind of work.

Schema markup best practices

A few habits keep your structured data working and out of trouble. Follow these and you’ll avoid most of the problems people run into.

Only mark up what’s actually on the page

Schema describes visible content, not content you wish were there. If you mark up a review, a price or an FAQ that a visitor can’t see on the page, you’re breaking Google’s guidelines and risking a manual action. Every property should point to something a person can read.

Use the most specific type available

When a specific type fits, use it over a generic one. Restaurant tells Google more than LocalBusiness, and BlogPosting is clearer than Article for a blog. The more precise your type, the better search and AI systems understand the page.

Keep markup accurate and up to date

Structured data goes stale. A price changes, an event passes, a product sells out. When your markup and your page disagree, Google trusts neither. Build a habit of updating schema whenever the underlying content changes, and automate it through your CMS where you can.

Match structured data to visible content

This is the rule behind several others, so it’s worth stating plainly. The facts in your markup must match what’s on the page: the same price, the same rating, the same headline. Mismatches are one of the most common reasons Google issues a structured-data manual action.

Always validate before and after publishing

Test your markup before it goes live, then test it again on the published URL. Templates behave differently in production, and a plugin update can change your output without warning. A quick check after publishing catches problems while they’re still easy to fix.

Prefer static (server-rendered) JSON-LD for AI-crawler visibility

As covered earlier, most AI crawlers don’t run JavaScript. If AI visibility matters to you, serve your JSON-LD as static markup written into the page on the server, rather than injecting it with client-side script. Your markup is only useful if the crawler can actually see it.

Common schema markup mistakes to avoid

Most schema problems come down to a handful of repeat offenders. Here’s what to watch for.

Using the wrong schema type for the page

Choosing a type because it earns a nice rich result, rather than because it matches the page, backfires. Google matches your markup against your primary content, and a mismatch means the schema gets ignored at best. Pick the type that describes what the page actually is.

Marking up content that isn’t visible to users

Hiding data in your markup that doesn’t appear on the page counts as a form of cloaking, and it’s a direct guidelines violation. If you want to mark something up, put it on the page first.

Leaving validation errors unfixed

An error means the markup is invalid, so the rich result simply won’t show. It’s tempting to publish and move on, but an unfixed error makes the whole block worthless. Clear errors before you consider a page done.

Wrong sameAs / @id references

Entity markup relies on accurate references. A sameAs link pointing to the wrong profile, or an @id that doesn’t line up across your pages, confuses the entity signal you’re trying to build. Double-check that these point where you intend, because a wrong reference can attach your brand to someone else’s.

Relying on JS-injected schema for AI crawlers

We’ve said it before, and it’s worth repeating as a mistake in its own right. Schema added only through client-side JavaScript is invisible to the AI crawlers that don’t render it. For anything you want cited in AI answers, static markup is the only reliable route.

Schema markup examples (copy-and-adapt JSON-LD)

Here are three ready-to-adapt blocks. Swap in your own values, then validate before publishing.

Article:

				
					{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Schema Markup: The Complete Guide to Structured Data for SEO",
  "author": {
    "@type": "Person",
    "name": "Author Name",
    "url": "https://www.example.com/author/"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Roots Digital",
    "logo": {
      "@type": "ImageObject",
      "url": "https://www.rootsdigital.com.sg/logo.png"
    }
  },
  "datePublished": "2026-08-07",
  "dateModified": "2026-08-07"
}
				
			

				
					{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Example Product",
  "image": "https://www.example.com/product.jpg",
  "description": "A short description of the product.",
  "brand": { "@type": "Brand", "name": "Example Brand" },
  "offers": {
    "@type": "Offer",
    "priceCurrency": "SGD",
    "price": "99.00",
    "availability": "https://schema.org/InStock"
  }
}
				
			

				
					{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [{
    "@type": "Question",
    "name": "What is schema markup?",
    "acceptedAnswer": {
      "@type": "Answer",
      "text": "Schema markup is structured data you add to a page's HTML to help search engines and AI systems understand what your content means."
    }
  }]
}