🍞 Breadcrumb Schema Generator

Last updated: April 12, 2026

Breadcrumb Schema Generator

Enter your page hierarchy to generate BreadcrumbList JSON-LD for Google rich results.

# Page Name Page URL
JSON-LD Output
Google Search Preview

Paste the generated script tag inside the <head> of your page. The last item's URL is optional per Google's spec.

How to Use a Breadcrumb Schema Generator to Win Breadcrumb Rich Results in Google

If you have ever noticed a website in Google search results where the URL line shows something like Home › Blog › Tutorial Name instead of a raw URL like https://example.com/blog/tutorial-name/, you have seen breadcrumb rich results in action. These small navigational trails appear directly in the SERP snippet and they are powered by structured data — specifically, BreadcrumbList JSON-LD schema markup. This guide walks you through exactly how to generate this schema correctly and deploy it on any page.

What Is BreadcrumbList Schema and Why Does It Matter?

BreadcrumbList is a vocabulary type defined by Schema.org that describes the hierarchical position of a page within a website. When you mark up a page with BreadcrumbList JSON-LD, you are telling Google: "This page sits at position 3 in a trail that goes Home → Category → This Page." Google then has enough context to potentially display that trail under your blue link in search results.

The SEO value is real. Breadcrumb trails improve click-through rates because they signal site structure to searchers, help users understand what kind of page they are about to visit, and give your result a more prominent visual footprint in the SERP. For e-commerce sites, blogs with deep category structures, and documentation sites, breadcrumb markup is one of the simplest structured data wins available.

The Anatomy of a BreadcrumbList JSON-LD Block

Before you generate anything, it helps to understand what the output looks like and why each part exists. A correctly formed BreadcrumbList looks like this:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://example.com/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://example.com/blog/"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "How to Bake Bread",
      "item": "https://example.com/blog/how-to-bake-bread/"
    }
  ]
}
</script>

Each object inside itemListElement is a ListItem. The three required properties are:

  • position — An integer starting at 1. This determines the order in which items appear in the trail. Never skip numbers or start from 0.
  • name — The human-readable label that Google will display in the search result. Keep it short and descriptive.
  • item — The full, canonical URL of that breadcrumb level. This must be an absolute URL including the protocol (https://). For the last item (the current page), Google's documentation says the URL is technically optional, but including it is best practice.

Step-by-Step: Generating Your Breadcrumb Schema

Step 1: Map your page hierarchy before you open the tool. Start from the homepage and trace the exact path a visitor takes to reach the page you are marking up. For a product page on a clothing store, the chain might be: Home → Women's → Dresses → Summer Maxi Dress. Write this out first — rushing into the tool without clarity about your hierarchy is the most common source of errors.

Step 2: Collect the canonical URLs for each level. Open each page in your browser and copy the canonical URL from the address bar (or from the <link rel="canonical"> tag in the page source). These must exactly match your canonical URLs — if you use trailing slashes, include them; if you do not, exclude them. Inconsistency between your schema URLs and your canonical tags will create confusion for Google.

Step 3: Enter rows in order in the generator. Start with position 1 (always your homepage) and work toward the deepest page. Enter the name in the first field and the full URL in the second. Add as many rows as your hierarchy has levels. Most sites use between 2 and 5 levels — going beyond 6 or 7 levels is unusual and may indicate overly complex URL structures.

Step 4: Generate and review the output. Click Generate Schema. The tool produces a complete <script type="application/ld+json"> block. Review it for typos in names and verify that all URLs end correctly. Also check the search preview to confirm the trail reads naturally in the order you intend.

Step 5: Paste the script into your page's <head> section. Copy the generated code and paste it inside the <head> tag of your HTML. In WordPress you can do this via a plugin like Rank Math or Yoast (which has built-in breadcrumb schema support), through a header/footer plugin, or in your theme's header.php. In Next.js or other React frameworks, use the next/head component. In plain HTML, paste it directly.

Step 6: Validate with Google's Rich Results Test. Navigate to search.google.com/test/rich-results, enter your page URL (or paste the HTML), and run the test. Confirm that Google detects the BreadcrumbList with no errors. Warnings are acceptable; errors mean the schema will not be eligible for rich results.

Common Mistakes That Break Breadcrumb Schema

Using relative URLs instead of absolute URLs. The item field must always be a full URL. Writing /blog/post/ instead of https://example.com/blog/post/ will cause validation errors.

Starting positions at 0. The Schema.org specification is clear: positions start at 1. A schema with "position": 0 for the homepage will fail Google's validator.

Mismatch between schema URLs and canonical URLs. If your canonical tag says https://example.com/blog/post/ but your schema says https://www.example.com/blog/post/, you have a conflict. Pick one version (with or without www) and use it consistently.

Putting the same position number on two items. Each position value in the list must be unique. Using 1, 2, 2, 3 is invalid.

Using this on pages that lack visible breadcrumb navigation. Google recommends that your JSON-LD breadcrumb schema corresponds to an actual visible breadcrumb UI on the page. While the schema alone can sometimes trigger rich results, having the visual breadcrumb present reduces the risk of the structured data being ignored or penalized.

One Schema Per Page, Not Per Site

A critical distinction: breadcrumb schema is page-level markup, not site-level. The schema on your homepage only has one item (position 1, the homepage itself). The schema on a category page has two items. The schema on a blog post three levels deep has three items. Each page gets its own unique schema reflecting its specific position in the hierarchy. Do not use the same generic breadcrumb block on every page of your site.

Once properly implemented, give Google a few weeks of recrawling before expecting the breadcrumb trail to appear consistently in search results. Google does not guarantee rich results even with valid schema, but correct BreadcrumbList markup significantly increases the probability of your pages showing that useful navigational trail to searchers.

FAQ

Does the last breadcrumb item need a URL in the schema?
Technically, Google's specification marks the URL (item property) as optional for the last ListItem — which represents the current page. However, it is best practice to always include it. Including the URL ensures the schema is consistent across all items and avoids any edge cases where validators flag it as incomplete. Since you already have the canonical URL of the current page, there is no reason to omit it.
Should I use JSON-LD or Microdata for breadcrumb schema?
Google recommends JSON-LD as the preferred format for all structured data, including BreadcrumbList. It is far easier to implement because it lives entirely inside a script tag in the head, completely separate from your HTML markup. Microdata requires embedding schema attributes directly into your HTML elements, making templates messy and harder to maintain. Use JSON-LD — it is cleaner, safer, and fully supported.
Can I have multiple BreadcrumbList schemas on the same page?
Yes — if a page can logically be reached through more than one navigation path, you can include multiple BreadcrumbList blocks to represent alternate paths. For example, a product might sit under both Women > Shoes and Sale > Shoes. Google can interpret multiple breadcrumb trails and may choose the most relevant one to display. Keep each block as its own separate script tag with a complete, valid JSON-LD structure.
Why is my breadcrumb schema valid but not showing in Google search results?
Google does not guarantee rich results even when structured data is valid. Several factors affect whether breadcrumbs appear in SERPs: the page must be indexed, Google must have crawled it recently since you added the schema, the page needs sufficient authority, and Google may algorithmically decide the standard URL display is more appropriate for certain queries. Continue publishing quality content, ensure your page is indexed via Google Search Console, and check the Enhancement report under Search Console's Breadcrumbs section to monitor status.
Do breadcrumb schema URLs need to actually exist as real pages?
Yes. Every URL listed in your BreadcrumbList must resolve to an actual, accessible page. Linking to a URL that returns a 404 or redirects repeatedly will cause Google to distrust the schema. If your breadcrumb trail passes through a category page, that category page must exist, load correctly, and ideally also carry its own BreadcrumbList schema appropriate to its own level in the hierarchy.
Is breadcrumb schema the same as breadcrumb navigation in HTML?
They are related but separate things. Breadcrumb navigation is the visible UI element on your page — a row of links usually styled near the top of content. Breadcrumb schema (JSON-LD) is machine-readable structured data that tells Google about your page hierarchy. Best practice is to have both: visible breadcrumb navigation using semantic HTML (an ordered list or nav element) and the corresponding JSON-LD in the head. Google explicitly recommends that your structured data reflect visible content on the page.