What is Schema Markup

Schema markup is code you add to a web page to describe its content in a standard format that search engines can read. It uses the Schema.org vocabulary to spell out facts a machine would otherwise have to guess.

Examples include "this page is a product that costs $49," "this is a bakery open until 6pm," or "this article was written by this person." That helps search engines understand your page and can make it eligible for rich results in Google.

I work with schema markup every day as a consultant, and the same confusion comes up again and again. People aren't sure what it is, what format to use, and whether it actually helps SEO or AI search. This guide answers all three in plain language, with real code you can copy.

What is schema markup?

Schema markup is a type of structured data. It labels the information on your page so machines don't have to interpret it on their own.

When you read a bakery's contact page, you instantly know which text is the address, which is the phone number and which are the opening hours. A search engine sees a block of text and has to infer all of that. Schema markup removes the guesswork by stating each fact explicitly.

The "schema" part refers to Schema.org, a shared vocabulary founded in 2011 by Google, Microsoft, Yahoo and Yandex. It defines hundreds of types (such as Person, Product, Event and Recipe) and the properties each one can have (such as name, price, startDate). Because the major search engines agreed on it, you mark up your content once and they can all understand it.

A simple schema markup example

Here is JSON-LD schema markup for a local cafe homepage:

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "@id": "https://revalcafe.ee/#organization",
  "name": "Reval Cafe",
  "url": "https://revalcafe.ee/",
  "subOrganization": [
    {
      "@type": "CafeOrCoffeeShop",
      "@id": "https://revalcafe.ee/#kumu-branch",
      "name": "Reval Cafe – Kumu",
      "telephone": "+372 602 6164",
      "address": {
        "@type": "PostalAddress",
        "streetAddress": "Weizenbergi 34 / Valge 1",
        "addressLocality": "Tallinn",
        "postalCode": "77000",
        "addressCountry": "EE"
      }
    },
    {
      "@type": "CafeOrCoffeeShop",
      "@id": "https://revalcafe.ee/#telliskivi-branch",
      "name": "Reval Cafe – Telliskivi",
      "telephone": "+372 600 12154",
      "address": {
        "@type": "PostalAddress",
        "streetAddress": "Telliskivi 51i",
        "addressLocality": "Tallinn",
        "postalCode": "10412",
        "addressCountry": "EE"
      }
    }
  ]
}

Here's what each part does:

• @context tells machines you are using the Schema.org vocabulary.
• @type says what the thing is. CafeOrCoffeeShop is a more specific type of LocalBusiness, and the more specific type is usually the better choice.
• Properties like name, telephone and address describe the cafe. Some properties contain their own typed object, such as PostalAddress, which is how schema expresses relationships between things.

All of this information should also be visible on the page. Schema markup describes your content; it doesn't replace it.

Schema markup vs structured data vs rich results

These three terms are often used interchangeably, but they mean different things:

The key point is that schema markup makes a page eligible for rich results, but it doesn't guarantee them. Google decides whether to show one based on the query, the page's quality and whether the markup follows its guidelines.

How does schema markup work?

Schema markup works in three layers:

1. Vocabulary. Schema.org defines the types and properties you can use.
2. Format. JSON-LD, Microdata or RDFa determines how you write that vocabulary into your HTML.
3. Consumption. Search engines crawl the page, parse the markup and use it to understand the entities on the page and how they relate. Google may then use it for rich results and knowledge panels.

Take a recipe page. With Recipe markup, you can specify the cooking time, ingredients, calories and rating. Google can then display that information directly in search results as a recipe rich result, so searchers see the key details before they click.

One thing schema markup does not do is directly boost your rankings. Google has said repeatedly that structured data is not a ranking factor. Its value comes from helping search engines understand your content and from qualifying for more visible, more clickable search results.

What are the formats of schema markup?

Schema markup can be written in three formats: JSON-LD, Microdata and RDFa. Google supports all three and treats them equally as long as the markup is valid.

Below is the same Person schema markup written in each format so you can compare them.

1. JSON-LD (JavaScript Object Notation for Linked Data)

JSON-LD (JavaScript Object Notation for Linked Data) sits in its own <script type="application/ld+json"> block, separate from your visible HTML. It uses a JavaScript-style syntax, but the browser doesn't run it as code. It's simply data that search engines read.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Person",
  "name": "Aubrey Yung",
  "jobTitle": "SEO Manager and Schema Markup Consultant",
  "url": "https://aubreyyung.com/",
  "sameAs": [
    "https://www.linkedin.com/in/aubreyyung",
    "https://github.com/aubreyyung"
  ]
}
</script>

2. Microdata

Microdata is an HTML specification used to nest structured data within HTML content. It adds attributes such as itemscope, itemtype and itemprop directly to your existing HTML elements.

It’s more integrated with the HTML code than JSON-LD, which makes it somewhat more complex to implement.

<div itemscope itemtype="https://schema.org/Person">
  <span itemprop="name">Aubrey Yung</span>
  <span itemprop="jobTitle">SEO Manager and Schema Markup Consultant</span>
  <a itemprop="url" href="https://aubreyyung.com/about/">About me</a>
</div>

3. RDFa (Resource Description Framework in Attributes)

RDFa (Resource Description Framework in Attributes) works in a similar way to Microdata, using attributes like vocab, typeof and property.

<div vocab="https://schema.org/" typeof="Person">
  <span property="name">Aubrey Yung</span>
  <span property="jobTitle">SEO Manager and Schema Markup Consultant</span>
  <a property="url" href="https://aubreyyung.com/about/">About me</a>
</div>

How to implement RDFa for Schema.org Markup

Which format should you use?

Use JSON-LD unless you have a specific reason not to. Google recommends it because it's the easiest to implement and maintain at scale.

JSON-LD also has practical advantages:

• Because it's separate from your HTML, a redesign won't accidentally break it.
• It can be generated by a CMS, plugin or tag manager without touching your templates.
• It's much easier to read and debug.

Microdata and RDFa still make sense when your CMS outputs them natively or when you need the markup tied directly to visible elements.

Types of schema markup

Schema.org contains over 800 types, but you'll only ever use a small fraction of them. If you're curious which types the web actually uses, I track this on my Schema.org usage stats page.

It helps to think about schema types in two groups.

Types that can earn Google rich results

Google maintains a search gallery of the structured data features it currently supports. The most commonly used are:

• Article: news, blog and sports articles
• Breadcrumb: your page's position in the site hierarchy
• Product: price, availability and review ratings
• Review snippet: star ratings for products, recipes, software, local businesses and more
• Local business: business details such as hours and location in knowledge panels
• Organization: logo, legal name and contact details
• Event: concerts, festivals and other dated events
• Recipe: cooking times, ratings and images
• Video: video details, key moments and live streams
• Job posting: listings in Google's job search experience
• Software app: app ratings and details
• Profile page and Discussion forum: creator and community content

Other supported features include Carousel, Course list, Dataset, Education Q&A, Employer aggregate rating, Image metadata, Math solver, Movie, Q&A, Speakable, Paywalled content and Vacation rental.

This list changes, so always check Google's gallery before implementing.

For example, Google has retired a number of rich results in recent years:

• HowTo rich results were removed in 2023.
• In 2025, Google retired several more, including Course Info, Claim Review, Estimated Salary, Learning Video, Special Announcement and Vehicle Listing.
• In May 2026, FAQ rich results were removed entirely, after being restricted to government and health sites since 2023.

The markup for retired types is still valid Schema.org, and leaving it on your pages won't hurt you. It just no longer produces a visual result in Google.

Types that build understanding (without a visual result)

Some of the most valuable schema doesn't produce anything you can see in search results. Organization, Person and WebSite markup help search engines connect your brand, your people and your website as entities.

For example, you can use the sameAs property to link to your official social profiles. That helps Google understand that your LinkedIn page, your website and your brand are the same entity. This is the foundation of entity SEO and Knowledge Graph presence.

Example: how I use schema markup for my own knowledge panel

I'm not a celebrity, and there's no Wikipedia article about me. That's the same position most consultants, freelancers and small businesses are in. With no single authoritative source saying who "Aubrey Yung" is, Google has to piece my identity together from across the web: my website, LinkedIn, GitHub, conference pages and other profiles.

Schema markup is how I make that job easier. My About page uses ProfilePage schema with a nested Person entity, and it acts as the definitive description of me.

Three details do most of the work here:

• A stable @id. Every article on my site uses this same ID in its author property. That tells Google all my content comes from one person, rather than several people who happen to share a name.
• sameAs links to profiles I control. These connect my website to my other official profiles, so Google can confirm they all describe the same entity.
• Consistent facts. My name, job title and focus areas match what those other profiles say, so everything corroborates everything else.

Schema markup didn't create that knowledge panel on its own. Google builds knowledge panels from many sources. What the markup did was give Google a clear, machine-readable source of truth to check those other sources against. That's exactly what it can do for your brand too.

Does schema markup help SEO?

Yes, but indirectly, and it's worth being precise about how. Schema markup helps SEO in four ways:

1. Better understanding. It removes ambiguity about what your page is and who is behind it.
2. Rich result eligibility. Rich results take up more space in search results and give searchers useful details up front, which can improve click-through rate.
3. Entity and brand signals. Organization and Person markup support how search engines understand your brand across the web.
4. Local and ecommerce visibility. Local businesses can clarify hours and locations, and online stores can surface price and availability.

What it won't do is push a weak page up the rankings simply by being there. For a deeper look, read my guide to the benefits of schema markup.

What about schema markup and AI search?

This is where there's the most hype, so here is what the evidence actually says.

Google's documentation on AI features states that you don't need any special schema.org structured data to appear in AI Overviews or AI Mode. The same SEO fundamentals apply. An Ahrefs study published in May 2026 tracked 1,885 pages that added schema. It found no meaningful lift in citations across Google AI Overviews, AI Mode or ChatGPT.

That doesn't make schema pointless for AI search. Clean, accurate structured data still describes your entities unambiguously, and that's useful for any system that reads the web. But treat schema as good technical hygiene, not a shortcut to AI citations. Clear, helpful, well-structured visible content matters far more.

How to add schema markup to your website

There are three common ways to add schema markup:

• CMS plugins. On WordPress, plugins like Yoast SEO and Rank Math generate basic schema automatically. Shopify themes and most modern CMSs also output some schema by default. Check what yours already produces before adding more, so you don't end up with duplicate or conflicting markup.
• Manually in your code. Add a JSON-LD block to the <head> or <body> of your page template.
• Google Tag Manager. This is useful when you can't edit templates directly. Here's my guide to adding schema markup with Google Tag Manager.

How to implement schema markup manually, step by step

1. Choose the right type. Match the schema type to what the page is actually about, such as Product for a product page or Article for a blog post. Use the most specific type that fits.
2. Check the requirements. If you're targeting a rich result, read Google's documentation for that feature and note the required and recommended properties.
3. Generate the markup. Write it by hand or use a generator. I've built free generators for Organization, Person, WebSite, Local Business and Software Application schema. For other types, try the Schema Markup Generator by Merkle.
4. Customise it. Add details specific to your page, and make sure every value matches what visitors can see.
5. Add it to the page. Paste it into your template, CMS field or tag manager.
6. Validate it. Test before and after publishing (see the next section).

How to check your schema markup

Two free tools cover most needs:

• Rich Results Test shows which Google rich results your page is eligible for and flags errors in required properties.
• Schema Markup Validator checks all Schema.org markup, including types Google doesn't use for rich results.

After launch, monitor the rich result reports in Google Search Console to catch errors that appear over time, for example when a template changes. For a full walkthrough, see how to check schema markup.

Common schema markup mistakes

These are the issues I see most often in audits:

• Marking up content that isn't on the page. Reviews, prices or FAQs that exist only in the markup go against Google's guidelines and can lead to a manual action.
• Using the wrong type. An example is using Product markup on a category page or Review markup for reviews you wrote about yourself.
• Letting data go stale. Old prices, past event dates or sold-out items marked as in stock all erode trust.
• Duplicate or conflicting markup. This usually happens when a theme, a plugin and a custom script each output their own Organization block.
• Missing required properties. Without them, the page won't qualify for the rich result you were aiming for.
• Chasing retired features. Adding FAQ or HowTo markup purely to win a rich result no longer works in Google.

Conclusion

Schema markup is a standardised way to describe your content to machines. It doesn't directly improve rankings, but it does help search engines understand what your pages are and who is behind them, and it unlocks rich results that can make your listings stand out.

Start with the essentials: Organization or Person markup for your site, plus the type that matches your most important pages. Use JSON-LD, keep it accurate, and validate it whenever your templates change.

Need help with a more complex implementation? Get in touch.