Check website

Breadcrumb schema: examples and setup

·4 min read

Breadcrumb schema is BreadcrumbList markup that tells search engines where a page sits in your site, such as Home, then Shoes, then Running shoes. Google uses breadcrumb schema to replace the raw URL in a desktop result with that trail, and since January 2025 it no longer shows breadcrumbs on mobile results. You need one BreadcrumbList with at least two ListItem entries, each with a position, a name and an item URL, and the last one can skip the URL.

It is one of the cheapest pieces of markup to get right. Most sites that get it wrong do so with labels, not syntax.

What breadcrumb schema does in Google today

Breadcrumb schema shows a readable path above the title of a desktop result instead of a URL. On January 22, 2025, Google updated its breadcrumb documentation to say breadcrumbs appear only on desktop, because it found the feature less useful to people searching on mobile. The Search Central changelog records the change.

So the visible payoff is smaller than it was. I still add it to every site with more than two levels of pages, for two reasons. Desktop results still show it, and the markup states your site's hierarchy in a form machines don't have to guess at. It costs a few lines of JSON per template.

Required BreadcrumbList properties

Google wants one BreadcrumbList whose itemListElement is an array of at least two ListItem objects. Each ListItem takes these properties.

Property What it holds Rule
position The crumb's place in the trail, starting at 1 Set it on every item
name The label people see, such as "Running shoes" Set it on every item
item The URL of the page that crumb stands for Every item except the last

The last item is the current page. If you leave out its item, Google uses the URL of the page the markup sits on. Order comes from position, not from the array order, so number them carefully when a template builds the list in a loop.

A BreadcrumbList JSON-LD example

This is the breadcrumb structured data for a product category page three levels deep. It goes in a <script type="application/ld+json"> tag anywhere in the page. If JSON-LD itself is new to you, start with what JSON-LD is and how it works.

{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://example.com/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Shoes",
      "item": "https://example.com/shoes"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Running shoes"
    }
  ]
}

Use absolute URLs in item. Relative paths are a common reason a trail fails validation after a template change.

Multiple breadcrumb trails on one page

A page that people reach through two paths can carry two trails. Put each trail in its own BreadcrumbList and wrap them in a JSON array inside one script tag, or use two script tags. Google's own example does this for a book listed under both Books and Literature.

Keep it to trails your navigation actually offers. A product that lives under "Shoes > Running" and also under "Sale" can have both. Inventing extra trails for keyword coverage adds nothing, because each trail still has to match a path a visitor can follow.

How to build a breadcrumb trail from a URL path

A URL path is a fine starting point and a poor final answer. Take https://example.com/shoes/running-shoes. Splitting the path gives you three crumbs:

  1. Home, at https://example.com/
  2. "shoes", at https://example.com/shoes
  3. "running shoes", at https://example.com/shoes/running-shoes

The URLs are right. The labels are slugs with the hyphens removed, and they rarely match what your page shows. Google's documentation recommends trails that represent a typical user path to a page instead of mirroring the URL structure. That matters on sites where URLs are flat (/p/12345) or carry folders no visitor ever sees, like /en-us/ or /catalog/. Drop those segments and give every crumb a page that exists. A crumb pointing at a path that returns 404 is worse than no crumb.

Why the labels should match the visible breadcrumbs

The name in your markup should read exactly like the breadcrumb on the page. If the page says "Running Shoes" and the markup says "running-shoes", or the markup lists a category the page never shows, you are describing navigation that isn't there. Google's structured data rules ask that markup reflect the visible content, and a mismatch is the easiest kind to spot.

The cleanest setup is one data source for both. Have the template that prints the visible breadcrumb also print the JSON-LD from the same array. Then a renamed category updates both at once and they can't drift.

After you ship it, run a page through the Rich Results Test to confirm Google reads the trail. For how breadcrumbs fit with the rest of your markup, see the schema markup guide.

Build breadcrumb schema for your pages

The Breadcrumb Schema Builder takes a trail you type, one crumb per line as Name | URL, or a page URL. From a URL it makes one crumb per path segment and turns the hyphens in each segment into spaces for the labels, so edit the names to match your visible breadcrumbs before you publish.

It returns BreadcrumbList JSON-LD and checks it against the same validator rules as our Schema Markup Checker, including a missing position, name or item URL on any crumb but the last. Nothing is fetched from your site. Each run costs 3 credits.

Keep reading