Schema Markup for SEO: A Beginner’s Guide With Examples

Schema markup for SEO is code you add to a page, usually as a JSON-LD script, that labels the facts on that page in the schema.org vocabulary so search engines can read them without guessing. It tells Google “this is the headline, this is the author, this is the price.” Done right, it helps Google understand the page and can make it eligible for rich results like review stars, event dates or recipe cards. It doesn’t guarantee those results, and it isn’t a ranking shortcut.

I’m starting with that last line on purpose. Most of the schema mistakes I find in audits come from people expecting markup to push a page up the rankings. It does something narrower and still useful. This guide covers what that is, which format to use, which types Google still shows in October 2026, a complete example, and how to test it.

What Does Schema Markup Actually Change in Search?

Two things, according to Google’s introduction to structured data. The first is understanding. Google uses the markup it finds to understand what a page is about and to gather facts about people, products, businesses and other things.

The second is presentation. Markup can make a page eligible for a richer listing in the results. Google’s own case studies on that page show why people care: Rotten Tomatoes saw a 25% higher click-through rate on pages with structured data, and Nestlé measured an 82% higher click-through rate on pages that showed as rich results.

Notice the word “eligible”, though. Google says adding recommended properties makes it “more likely” your page appears with enhanced display. More likely, not certain. Google decides per search whether a rich result helps, so perfectly valid markup can still produce a plain blue link.

Schema, Structured Data and JSON-LD: Which Word Means What?

Beginners get stuck here because people use these words loosely. Here’s how they fit together.

So “schema markup” and “structured data” mean the same thing in practice. JSON-LD is just the way you write it.

JSON-LD vs Microdata: Which Format Should You Use?

Use JSON-LD. Google supports three formats, JSON-LD, Microdata and RDFa, and it recommends JSON-LD because it’s the easiest to implement and maintain at scale. That matches my experience completely.

The difference is where the code lives. JSON-LD sits in one block, separate from your visible HTML. Microdata and RDFa are attributes woven into the HTML tags themselves. Here’s a breadcrumb trail written in Microdata, so you can see what I mean:

<ol itemscope itemtype="https://schema.org/BreadcrumbList">
  <li itemprop="itemListElement" itemscope itemtype="https://schema.org/ListItem">
    <a itemprop="item" href="https://www.example.com/blog/"><span itemprop="name">Blog</span></a>
    <meta itemprop="position" content="1" />
  </li>
</ol>

Every redesign that touches that list can break the markup. With JSON-LD, a developer can change the template freely and the script stays intact. The one honest case for Microdata is an old theme that already outputs it correctly. If it validates, I leave it alone rather than create two competing versions.

Three Questions That Decide Your Schema Setup

Before you add anything, answer these. They decide which types you need, and they stop you from marking up things you shouldn’t.

1. What kind of page is it? An article, a product, a local business, an event and a recipe each have their own type. One page can carry several, but each must describe something real on that page.
2. What can a visitor actually see? Google’s structured data policies say plainly: “Don’t mark up content that is not visible to readers of the page.” If the hours aren’t on the page, they don’t go in the markup.
3. What does your CMS already output? WordPress SEO plugins, Shopify themes and review apps often add schema automatically. Check before you add more, or you’ll end up with duplicates.

If you run a blog or publish articles, follow the main path below. If you’re a local business or a store, read the branches after it.

Which Schema Types Does Google Still Show as Rich Results?

This is where old tutorials do real damage. Google has retired several rich results, and markup for a retired feature earns you nothing in Search. Here’s the current picture from Google’s search gallery and changelog.

And the ones to stop adding:

Existing FAQ markup won’t hurt you, so there’s no emergency. I just wouldn’t pay anyone to add new FAQ or HowTo markup in 2026.

The Main Path: Add Article and Breadcrumb Markup to a Blog Post

For a typical blog post, I add two types: BlogPosting for the article itself and BreadcrumbList for its place in the site. Google says Article markup has no required properties, but it recommends headline, image, datePublished, dateModified and author. For breadcrumbs, each item needs a position and a name, and every item except the last needs an item URL.

Here’s a complete JSON-LD example for an invented post on example.com. Paste it in the page’s head or body, then swap every value for facts that appear on your own page.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "BlogPosting",
      "@id": "https://www.example.com/blog/how-to-store-coffee/#article",
      "headline": "How to Store Coffee Beans So They Stay Fresh",
      "image": [
        "https://www.example.com/images/coffee-16x9.jpg",
        "https://www.example.com/images/coffee-4x3.jpg",
        "https://www.example.com/images/coffee-1x1.jpg"
      ],
      "datePublished": "2026-09-14T09:00:00+00:00",
      "dateModified": "2026-10-02T11:30:00+00:00",
      "author": {
        "@type": "Person",
        "name": "Jane Doe",
        "url": "https://www.example.com/about/jane-doe/"
      },
      "publisher": {
        "@type": "Organization",
        "name": "Example Coffee Co",
        "logo": {
          "@type": "ImageObject",
          "url": "https://www.example.com/images/logo.png"
        }
      },
      "mainEntityOfPage": "https://www.example.com/blog/how-to-store-coffee/"
    },
    {
      "@type": "BreadcrumbList",
      "itemListElement": [
        {
          "@type": "ListItem",
          "position": 1,
          "name": "Blog",
          "item": "https://www.example.com/blog/"
        },
        {
          "@type": "ListItem",
          "position": 2,
          "name": "Coffee Storage",
          "item": "https://www.example.com/blog/storage/"
        },
        {
          "@type": "ListItem",
          "position": 3,
          "name": "How to Store Coffee Beans So They Stay Fresh"
        }
      ]
    }
  ]
}
</script>

A few choices here are deliberate. The @graph array lets one script hold both types cleanly. The three images cover the 16×9, 4×3 and 1×1 ratios Google recommends. The author’s name holds only the name, with no job title, because Google asks for exactly that, and author.url points to a real bio page. The last breadcrumb has no item, which Google allows for the current page.

If your WordPress SEO plugin already outputs Article and breadcrumb schema, then don’t paste this in as well. Check the plugin’s output in the Rich Results Test first, and fill gaps in its settings instead.

Branch 1: When You’re a Local Business

If customers visit you or you serve a local area, then LocalBusiness markup on your home or location page is the main type, using the most specific subtype schema.org offers, such as Dentist or Plumber. Google lists name and address as required.

The big trap is reviews. Google’s review snippet guidelines say that if the business “controls the reviews about itself”, its pages using LocalBusiness or Organization markup are “ineligible for star review feature.” That includes testimonials you embed through a widget. Self-serving review markup won’t earn stars, and fake ratings can bring a manual action.

I’ve already published a full LocalBusiness JSON-LD example, along with the AI search side of structured data, in schema markup for AI search. Use that one rather than reinventing it.

Branch 2: When You Run an Online Store

If your pages sell products, then Product markup matters more than anything above, and it’s detailed enough to deserve its own guide. Price, availability, shipping, returns and variants all have specific rules, and Google treats a page where people can buy differently from an editorial review.

I cover all of it, including what Shopify and WooCommerce output by default, in my product schema markup guide.

How Do You Test Schema Markup?

I run three checks, in this order, because each catches something the others miss.

1. Rich Results Test (search.google.com/test/rich-results). Paste a URL or a code snippet. It shows which Google rich results the page is eligible for, plus errors and warnings. It only reports on types Google supports.
2. Schema Markup Validator (validator.schema.org). It checks your markup against the whole schema.org vocabulary, so it’s the right tool for types Google doesn’t display.
3. Google Search Console. After publishing, URL Inspection shows what Google read from the live page. The rich result reports then flag errors across every page that uses a type, which is how you spot a broken template.

Errors block eligibility. Warnings usually mean a recommended property is missing, and I fix those when the information is really on the page.

What Are the Most Common Schema Markup Mistakes?

These are the problems I see most when I audit a site’s structured data. None of them are exotic.

• Marking up invisible content. Hours, prices or FAQs that exist only in the script break Google’s policies. If it’s not on the page, take it out of the markup.
• Self-serving reviews. A business marking up its own testimonials to get stars. See Branch 1.
• Duplicate blocks. The theme, the SEO plugin and a review app each output their own Organization or Product schema with different details. Pick one source and switch the others off.
• The wrong type. Marking a service page as a Product, or a blog post about recipes as a Recipe, misrepresents the page.
• Marking up only some items. Google’s policies say to mark up all instances, such as every visible review, not just the five-star ones.
• Still adding FAQ and HowTo. Old checklists keep recommending them. They no longer earn rich results.

What happens if you get it badly wrong? Google’s policies say a structured data manual action means a page “loses eligibility for appearance as a rich result” but that “it doesn’t affect how the page ranks in Google web search.” So the cost is the rich result, not your rankings. That’s still a cost worth avoiding.

The Schema Markup for SEO Decision Matrix

When Should You Hand This to a Specialist?

On a mainstream CMS with a good SEO plugin, you can handle schema markup for SEO basics like Article, breadcrumb and Organization markup yourself in an afternoon. I’d bring in help when markup has to be generated from a product database, when you have many locations, or when your pages build content with JavaScript and you’re not sure what Google sees.

Structured data is part of the technical checks in our complete SEO service, and our technical SEO service handles it on its own for sites that need template-level fixes. If you’d like a first look at your setup, start with the free SEO audit.

Frequently Asked Questions

Does Schema Markup Improve SEO Rankings?

Not directly, as far as Google’s documentation goes. Google describes structured data as a way to understand pages and to qualify them for rich results. A rich result can raise click-through rate, which is where most of the real value comes from.

Do I Need a Plugin to Add Schema Markup?

No. You can paste a JSON-LD script into any page. On WordPress, an SEO plugin is often easier because it fills in titles, dates and authors automatically. Whatever you use, test the output and avoid running two tools that both add schema.

Should I Remove My Existing FAQ Schema?

There’s no need to rush. FAQ rich results stopped showing in Google from May 7, 2026, but leftover FAQ markup won’t harm the page. I’d simply stop adding new FAQ markup and clean it up during your next template change.

Can One Page Have More Than One Schema Type?

Yes, as long as each type describes something real on that page. A blog post with BlogPosting and BreadcrumbList is normal. Wrapping them in one @graph block, like the example above, keeps things tidy.

Last updated: October 2026 by Mizanur Rahman