Breadcrumb Schema: BreadcrumbList Guide (2026)

Breadcrumb schema is BreadcrumbList structured data that describes where a page sits in your site’s hierarchy, as an ordered list of ListItem entries, each with a position, a name and usually a URL. Google uses it to categorize the page and to show a breadcrumb trail in place of the raw URL in desktop search results. Since January 2025, Google no longer shows breadcrumbs on mobile, which changes the payoff but not the syntax.

This guide is for developers and SEOs adding or fixing breadcrumb markup. It covers the current display rules, whether the markup is still worth it, the exact properties Google requires, how to match the visible trail, and the errors that come up most.

On this page

• What is breadcrumb schema?
• How Google shows breadcrumbs since January 2025
• Is breadcrumb schema still worth adding?
• BreadcrumbList syntax: the properties Google requires
• Should breadcrumbs follow the URL or the user’s path?
• Multiple breadcrumb trails on one page
• Common breadcrumb schema errors
• Getting breadcrumb schema right sitewide

What is breadcrumb schema?

Breadcrumb schema is markup using the schema.org BreadcrumbList type, which schema.org defines as “an ItemList consisting of a chain of linked Web pages, typically described using at least their URL and their name, and typically ending with the current page”. Its usage figure, based on Google’s web index, is more than 10 million domains, which makes it one of the most widely deployed types.

Google’s breadcrumb documentation explains the purpose: a breadcrumb trail “indicates the page’s position in the site hierarchy”, and Google uses the markup “to categorize the information from the page in search results”. The same page can be reached from very different queries, and the breadcrumb tells Google which section it belongs to.

It’s one of the simplest types to implement because every value already exists in your navigation. It’s also one of the easiest to get subtly wrong, because the markup and the visible trail are often built by different parts of the template.

How Google shows breadcrumbs since January 2025

On desktop, Google shows the domain followed by the breadcrumb trail. On mobile, it shows the domain only. Google announced the change on January 23, 2025, explaining that the breadcrumb “isn’t as useful to people who are searching on mobile devices, as it gets cut off on smaller screens”. The diagram below shows the difference.

Scroll the diagram sideways to see all of it.

Google was explicit that site owners don’t need to do anything: “If you’re using breadcrumb markup, there’s nothing you need to do, as we continue to support breadcrumb markup for use in desktop search results.” The breadcrumb rich result report in Search Console continues, and the markup is still testable in the Rich Results Test. The current documentation reflects this, listing the feature as “available on desktop in all regions and languages where Google Search is available”.

Is breadcrumb schema still worth adding?

Yes, for any site with more than one level of content, as long as you don’t expect miracles. It costs almost nothing when it’s generated from the same data as your visible breadcrumbs, and it still shapes how desktop results display.

The honest trade-offs:

• It isn’t a ranking factor on its own. Google describes the markup as a way to categorize and display the page, not to rank it.
• Mobile visibility is gone. If most of your search traffic is mobile, the visible payoff is smaller than it was before 2025.
• It states hierarchy explicitly. That helps engines, and AI systems reading the page, understand which section a page belongs to. Our structured data for AI search guide lists BreadcrumbList among the types worth having for that reason.
• Google stores site-hierarchy data separately. The 2024 leak of Google’s internal API documentation, analyzed by iPullRank, includes a QualitySitemapTargetGroup.breadcrumbTarget attribute. Google stores this attribute; the leak does not show how much it is weighted, and it doesn’t say that it comes from markup.

The best argument for breadcrumbs is still the visible ones. A clear trail helps people and gives you natural internal links up the hierarchy; the markup just describes it.

BreadcrumbList syntax: the properties Google requires

A BreadcrumbList needs at least two ListItem entries, each with a position and a name, and an item URL on every entry except the last. Those are Google’s requirements from its documentation:

The diagram below maps a visible trail to its markup.

Scroll the diagram sideways to see all of it.

Here is that trail as JSON-LD, following Google’s own example:

{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Books",
      "item": "https://example.com/books"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Science Fiction",
      "item": "https://example.com/books/sciencefiction"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Award Winners"
    }
  ]
}

If you publish a connected @graph, give the list an @id and reference it from your WebPage node’s breadcrumb property, as shown in our JSON-LD guide. Schema.org defines breadcrumb as “a set of links that can help a user understand and navigate a website hierarchy”.

Should breadcrumbs follow the URL or the user’s path?

Follow the user’s path. Google’s guidelines say: “We recommend providing breadcrumbs that represent a typical user path to a page, instead of mirroring the URL structure.” They add that you don’t need a ListItem for the top-level path (your domain) or for the page itself.

That matters most on sites with flat or technical URLs. The comparison below shows the difference.

Scroll the diagram sideways to see all of it.

The other half of the rule comes from Google’s general structured data guidelines: don’t mark up content that isn’t visible to readers. If your markup describes a trail the page doesn’t show, you’re describing invisible content. Build the visible breadcrumb and the JSON-LD from the same function in your template so they can’t disagree.

Multiple breadcrumb trails on one page

When a page genuinely sits in two places, you can publish two BreadcrumbList items. Google’s documentation uses a book that’s reachable both as Books › Science Fiction › Award Winners and as Literature › Award Winners, and marks up each trail as its own list.

Use this sparingly. It suits products listed in two real categories or articles filed under two sections. It doesn’t suit inventing extra trails to add keywords, and each trail should correspond to navigation a visitor can actually follow.

Common breadcrumb schema errors

Most breadcrumb problems are template bugs rather than misunderstandings. The ones that come up most:

• A single ListItem. Google requires at least two. A homepage-only trail isn’t a trail.
• Missing item on a middle crumb. Only the last item can omit its URL.
• Positions that don’t start at 1 or skip numbers, usually from a loop index that starts at 0.
• Relative URLs such as /books in item. Use absolute URLs, as Google’s examples do.
• Markup that disagrees with the visible trail, often because a plugin builds the JSON-LD from the URL while the theme builds the visible trail from categories.
• Legacy data-vocabulary.org markup. Google’s documentation notes it is “no longer eligible for Google rich result features”. Use schema.org.

The Schema Markup Validator catches syntax and vocabulary problems; the Rich Results Test catches Google’s required properties. Neither can tell you whether the trail makes sense, so read a few by eye.

How do you monitor breadcrumb markup after launch?

Use Search Console’s breadcrumb report, which Google kept after the mobile change. Google’s rich result report overview explains how to read it:

• Find it under Enhancements in the Search Console navigation. The report appears only once Google has found valid markup of a supported type on your property.
• Read items, not pages. The counts are structured data items, so a page with two trails counts twice.
• Fix critical issues first. Items with a critical issue are invalid and can’t appear as a rich result. Non-critical issues are listed separately under ways to improve item appearance.
• Don’t expect a full list. Google says the reports “show a sample of detected items”, so use the URL Inspection tool to check a specific page that isn’t listed.
• Validate the fix. After you correct a template, request validation from the issue page so Google rechecks the affected items.

The pattern to watch for is a sudden rise in invalid items after a release. That usually means a template change broke the markup on every page that uses it, which is exactly the kind of fault breadcrumbs are prone to, because they’re built in one shared component. A drop in valid items without a matching rise in invalid ones usually means the markup has disappeared altogether, often after a theme or plugin update. Either way, the fix belongs in the template, not on individual pages.

Getting breadcrumb schema right sitewide

Breadcrumb schema belongs in templates, not on individual pages. Generate the visible breadcrumb and the BreadcrumbList from one source, run a few URLs per template through the Rich Results Test after each release, and watch the breadcrumb report in Search Console for jumps in invalid items.

Treat it as part of your information architecture. If your breadcrumbs are hard to define, the problem is usually the site structure, which shows up in redesigns and migrations as well; our website redesign SEO guide covers keeping hierarchy and URLs stable through a rebuild. For framework-specific setups, see Astro SEO and WordPress SEO.

If your breadcrumbs, visible or marked up, disagree across templates, our schema markup service rebuilds them from one source and connects them to the rest of your structured data graph.