Breadcrumbs

TL;DR — Breadcrumbs are the little navigation trail near the top of a page — Home > Category > Page — that tells you where you are on a site. For SEO they do two things: every link in the trail is a real internal link that helps Google understand and pass value through your site, and special code behind them (structured data) can make Google show that readable path in desktop search results instead of a long URL.

What breadcrumbs are

Breadcrumbs are a secondary navigation element. They show your position in a site’s hierarchy as a trail, usually near the top of the page:

Home > Books > Science Fiction > Award Winners

The name comes from Hansel and Gretel dropping breadcrumbs to find their way back. Each step before the current page is a clickable link, so you can jump “up” a level without hunting through the menu.

Why they help SEO

There are two separate things going on, and it’s worth keeping them apart:

• The visible links. Each breadcrumb is a normal <a href> link. That means breadcrumbs are a form of internal linking — they connect your pages together and help Google find and understand them. Google’s Gary Illyes confirmed Google treats these like any other link.
• The code behind them. When you add structured data (a small block of BreadcrumbList code), Google can show your breadcrumb path in the desktop search result instead of the raw URL. That’s friendlier and can earn more clicks.

Where you see breadcrumbs

Two places:

1. On the page — the trail itself, helping visitors navigate.
2. In Google’s results — on desktop, the readable path can appear above the page title in place of the URL. (On mobile, Google stopped showing this in January 2025 and now shows just your domain — more on that in the Advanced tab.)

The thing most people get wrong

The structured data doesn’t replace your real links. Some people think adding the BreadcrumbList code is enough on its own. It isn’t — Google’s John Mueller said the URLs inside structured data aren’t used the same way as normal internal links. So you want both: actual clickable breadcrumb links and the structured data describing them.

Want the implementation details — the JSON-LD template, the January 2025 mobile change, the different breadcrumb types, and how to test them? Switch to the Advanced tab.

TL;DR — Breadcrumbs work on two layers. The HTML layer (visible <a href> links) is internal linking — Gary Illyes said Google treats breadcrumb links as normal links in PageRank computation. The structured-data layer (BreadcrumbList JSON-LD) drives the readable path in Google’s desktop snippet and helps engines read your hierarchy — but Mueller was explicit that the URLs in structured data are not used the same way as real internal links, so schema is not a substitute for the HTML. In January 2025 Google removed breadcrumbs from mobile SERPs (root domain only now); desktop display, schema processing, crawling, and PageRank are all unchanged. Use location-based breadcrumbs, render them server-side, match the visible text to the schema name, and test with the Rich Results Test plus Search Console’s Breadcrumbs report.

What a breadcrumb actually is

A breadcrumb is a secondary navigation trail that reflects a page’s position in the site hierarchy — Home > Category > Subcategory > Current Page. It’s “secondary” because it complements your main navigation rather than replacing it. The value for SEO comes from two distinct layers that I’ll keep separate throughout this piece, because conflating them is where most mistakes start.

The two-layer architecture

Layer 1 — the HTML. The visible breadcrumb is a <nav> containing real <a href> anchor links. That makes it internal linking, and it’s the part that passes value. Gary Illyes was asked directly about this in 2017 and said Google likes breadcrumbs and treats them “as normal links in, e.g., PageRank computation.” So a breadcrumb trail is a systematic, sitewide internal-linking pattern — every product page links up to its category, every category up to the hub, and so on. That distributes PageRank toward your important hub pages and gives crawlers consistent paths deeper into the site.

Layer 2 — the structured data. BreadcrumbList JSON-LD annotates that trail so Google can (a) show the readable path in desktop search snippets and (b) better understand your hierarchy, including when multiple navigation paths lead to the same page. This is the part that affects how your result looks.

The trap is assuming Layer 2 makes Layer 1 optional. It doesn’t. John Mueller put it plainly in 2022: “just because there is structured data in a page somewhere, I wouldn’t see that as a replacement for normal internal linking,” and “even if in the structured data, you also provide URLs, we don’t use those URLs in the same way as we would use normal internal links.” So the schema is not a shortcut around real HTML links. You implement both.

Types of breadcrumbs

• Location-based (hierarchy) — shows where the page sits in the site structure, identical for every visitor. This is the standard, and the only type that’s genuinely useful for SEO.
• Attribute-based — shows characteristics of the page, common on ecommerce and faceted navigation (Home > Shoes > Running > Size 10). Useful when a product can be reached by attribute filtering.
• History-based (path) — reflects the individual user’s clickstream (“you came from here”). It’s per-user and inconsistent, so it sends no reliable hierarchy signal — skip it for SEO.

Which one should you use? Google’s own guidance is the spine here: provide breadcrumbs reflecting a typical user navigation path, not necessarily a literal mirror of your URL structure. Location-based is how most sites satisfy that in practice, because it’s the one stable path every visitor sees regardless of how they arrived. Attribute-based is the exception you reach for on filtered/faceted pages where the “typical path” genuinely runs through an attribute. History-based never satisfies the guidance — it isn’t a typical path, it’s a user’s path.

How Google uses breadcrumbs in the SERP

When BreadcrumbList markup is present and valid, Google can replace the green URL in a desktop result with the breadcrumb path. Google uses the markup “to categorize the information in the search result,” and the display works across all regions and languages where Search is available — on desktop. Note the standard caveats: at least two ListItem entries are required, and a valid markup never guarantees the rich result.

The January 2025 mobile change — what actually changed

On January 23, 2025, Google announced it would “no longer show breadcrumbs on mobile search results in all languages and regions where Google Search is available (they continue to appear on desktop search results).” The stated reason: the breadcrumb element “isn’t as useful to people who are searching on mobile devices, as it gets cut off on smaller screens.” Mobile results now show the root domain (e.g., example.com) instead of the path.

Here’s the part that matters, because it generated a wave of “do breadcrumbs still matter?” panic:

• What changed: the visual snippet on mobile — root domain instead of path.
• What did NOT change: desktop SERP breadcrumbs still display; the structured data is still processed; the Search Console Breadcrumbs report still works; markup is still testable in the Rich Results Test; and the crawling, internal-link, and PageRank value is completely untouched. Google explicitly said no action is required — keep using BreadcrumbList.

My read: the SERP display was always the smallest of the three reasons to use breadcrumbs. The internal-linking value (PageRank, crawl paths) and the UX value didn’t move an inch, so removing breadcrumbs over a mobile-snippet cosmetic change would be a mistake.

Implementing BreadcrumbList structured data

Use JSON-LD — it’s Google’s preferred format and the easiest to maintain separately from your markup. (Microdata and RDFa are still supported; the old data-vocabulary.org vocabulary is deprecated — use schema.org.)

Required shape:

• BreadcrumbList.itemListElement — an array of ListItem objects.
• ListItem.position — an integer starting at 1, ascending.
• ListItem.name — the display text.
• ListItem.item — the absolute URL. It’s optional on the final breadcrumb because Google uses the current page’s URL there.

The full template is in the Cheat Sheets tab.

Common implementation errors (and they’re frequent):

• Missing item on a non-final breadcrumb.
• Relative URLs where absolute URLs are required.
• Non-sequential position integers.
• Visible breadcrumb text that doesn’t match the schema name.
• Client-side, JS-only rendering that Googlebot may not execute — render server-side so the breadcrumb is in the initial HTML.
• Linking to non-canonical URLs with tracking parameters.
• Using deprecated data-vocabulary.org markup.

Testing and monitoring

• Rich Results Test (search.google.com/test/rich-results) — validate the markup and catch errors before and after deployment.
• URL Inspection tool (Search Console) — confirm how Google actually fetched and interpreted the live page.
• Search Console › Enhancements › Breadcrumbs — monitor valid vs. invalid items across the site post-launch; this report kept working after the January 2025 change. Allow several days after publishing for crawling and indexing to catch up.

Keep the scope of “valid” honest: per Google’s general structured-data guidelines, passing validation makes a page eligible for the supported treatment — it does not guarantee the breadcrumb will display, that rankings will improve, that traffic will follow, or that an AI-generated answer will cite the page. Treat a clean Rich Results Test as “no known errors,” not a promise of outcome.

Breadcrumbs and Bing

Bing supports the shared schema.org vocabulary, including BreadcrumbList, and can surface breadcrumb rich results from the same markup. The practical takeaway: you implement one JSON-LD block and it serves both Google and Bing — there’s no Bing-specific breadcrumb format to maintain.

Best practices

• Use real HTML links, not structured data alone — the schema doesn’t replace internal linking.
• Don’t link the current page (the final breadcrumb is the page you’re on).
• Match the visible text to the schema name so the two layers agree.
• Render server-side so the breadcrumb is in the HTML Googlebot first receives.
• Keep it consistent with your taxonomy — breadcrumbs that reflect typical navigation paths reinforce a clean hierarchy.
• Put breadcrumbs on hub and category pages too, not just deep pages — they reinforce hierarchy and surface deeper content everywhere.

When you don’t need them

Genuinely flat sites — a handful of pages with no hierarchy, single-level brochure sites, or standalone landing pages — gain little from breadcrumbs. The moment you have two or more levels of hierarchy (which is most content sites, news sites, documentation, and any ecommerce catalog), they earn their keep.

Breadcrumbs are one piece of how you wire a site together. They sit alongside your broader internal linking, your URL and folder structure, and sitewide navigation — all of which shape how both people and crawlers move through your hierarchy.

AI summary

A condensed take on the Advanced version:

• Breadcrumbs are a hierarchy navigation trail (Home > Category > Page) that works on two layers: visible HTML <a href> links, and BreadcrumbList JSON-LD.
• HTML layer = internal linking. Gary Illyes (2017): Google treats breadcrumb links as normal links in PageRank computation.
• Structured-data layer = SERP display + hierarchy signal. But John Mueller (2022): structured-data URLs are not used the same way as normal internal links — schema is not a substitute for HTML links. Use both.
• January 2025: Google removed breadcrumbs from mobile SERPs (root domain only). Desktop display, schema processing, the Search Console Breadcrumbs report, crawling, and PageRank are all unchanged. No action required.
• Implementation: JSON-LD; itemListElement of ListItems with position (integer from 1), name, and item (absolute URL; optional on the final item). data-vocabulary.org is deprecated — use schema.org. Render server-side.
• Types: location-based (the SEO standard), attribute-based (ecommerce/facets), history-based (per-user; not for SEO).
• Test with the Rich Results Test; monitor in Search Console › Enhancements › Breadcrumbs. Bing reads the same schema.org markup.

Official documentation

Primary-source documentation from the search engines and schema.org.

Google

• Breadcrumb (BreadcrumbList) structured data — the required properties, JSON-LD example, multi-path guidance, and testing steps.
• Simplifying breadcrumbs on mobile search (Jan 23, 2025) — the announcement that mobile SERPs no longer show the breadcrumb path.
• Rich Results Test — validate BreadcrumbList markup.
• Rich result report overview (Search Console help) — monitoring valid/invalid breadcrumb items post-deployment (breadcrumbs appear as one of the Enhancements reports Search Console tracks).

Schema.org

• BreadcrumbList — the vocabulary: a chain of linked pages typically ending with the current page.
• ListItem — position, name, and item.

Bing / Microsoft

• Marking up your site with structured data — Bing’s support for schema.org markup, including BreadcrumbList.

Quotes from the source

On-the-record statements from Google. Each deep link jumps to the quoted passage on the source page.

Gary Illyes, Google — breadcrumb links pass PageRank (2017)

• “We like them. We treat them as normal links in, e.g., PageRank computation.” — Gary Illyes, on breadcrumb navigation links. Read the coverage

John Mueller, Google — structured data is not a replacement for internal links (March 16, 2022)

• “So just because there is structured data in a page somewhere, I wouldn’t see that as a replacement for normal internal linking.” Jump to context
• “Even if in the structured data, you also provide URLs, we don’t use those URLs in the same way as we would use normal internal links.” Jump to context

Google Search Central Blog — the January 2025 mobile change

• “Starting today, we’re rolling out a change to no longer show breadcrumbs on mobile search results in all languages and regions where Google Search is available (they continue to appear on desktop search results).” Jump to quote
• “We found that the breadcrumb element isn’t as useful to people who are searching on mobile devices, as it gets cut off on smaller screens.” Jump to quote

Google Search Central docs — what the markup is for

• “A breadcrumb trail on a page indicates the page’s position in the site hierarchy, and it may help users understand and explore a site effectively.” Jump to quote

Breadcrumb implementation checklist

A pass to confirm both layers are right:

• Visible breadcrumb is a real <nav> with <a href> links (not just text or JS-only).
• The trail is exposed as a labeled navigation landmark (e.g., a <nav> with aria-label="Breadcrumb" wrapping an ordered list) per the WAI-ARIA breadcrumb pattern.
• The current page is marked with aria-current="page" in the trail.
• BreadcrumbList JSON-LD is present and rendered server-side (in the initial HTML).
• At least two ListItem entries.
• position integers start at 1 and ascend with no gaps.
• Every non-final ListItem has an absolute item URL (final item may omit it).
• item URLs are canonical — no tracking parameters or non-canonical variants.
• Visible breadcrumb text matches the schema name.
• Using schema.org vocabulary, not deprecated data-vocabulary.org.
• The current page is not linked in its own breadcrumb.
• Breadcrumbs reflect typical navigation paths, consistent with your taxonomy.
• Validated in the Rich Results Test; live URL checked with URL Inspection.
• Search Console › Enhancements › Breadcrumbs reviewed for invalid items after launch.

The mental models

1. Two layers, two jobs. The HTML links do the linking job (PageRank, crawl paths). The structured data does the display + hierarchy-signal job. Diagnose problems by asking which layer is broken: missing value/equity → check the HTML links; missing or wrong SERP path → check the JSON-LD.

2. Schema annotates, it doesn’t replace. BreadcrumbList describes links that already exist — it isn’t itself a set of internal links. Mueller’s rule: structured-data URLs aren’t used like normal internal links. So never delete real breadcrumb links and “keep the schema.”

3. Display ≠ value. The SERP breadcrumb is the visible payoff, but the durable value is internal linking and UX. That’s why the January 2025 mobile removal changed how results look without changing what breadcrumbs do.

4. Location, not history. For SEO, breadcrumbs should describe where a page sits (consistent for everyone), not where a user came from (per-user). Hierarchy is a signal; clickstream isn’t.

5. Match the layers. Visible text, schema name, and the canonical URL should all agree. Mismatches are the most common reason a valid-looking breadcrumb fails to render or reports as invalid.

BreadcrumbList JSON-LD — template

Drop this in the page <head> or <body>, rendered server-side. Keep the name text matching the visible breadcrumb and use absolute, canonical URLs. The final item omits item because Google uses the current page’s URL.

<script type="application/ld+json">
{
  "@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"
    }
  ]
}
</script>

Property quick reference

Fast facts

• Format: JSON-LD (preferred). data-vocabulary.org is deprecated → use schema.org.
• SERP display: desktop only since Jan 2025; mobile shows root domain.
• Schema still processed on mobile; no action required after the change.
• Test: Rich Results Test. Monitor: Search Console › Enhancements › Breadcrumbs.
• Same markup serves Bing (shared schema.org vocabulary).

Schema without visible breadcrumb links

BreadcrumbList describes a trail, but it does not replace navigation. Users and crawlers should get ordinary HTML links that follow the same hierarchy. Add markup to the visible component instead of publishing a hidden schema-only structure.

A trail based on the user’s click history

History-based breadcrumbs change according to how someone arrived. They do not represent one stable location in the architecture, so they are a poor basis for internal linking and structured data. Use a location-based hierarchy for SEO.

Inventing levels that are not real destinations

A breadcrumb such as Home > Shoes > Running > Page is misleading if /shoes/ or /shoes/running/ is not a useful, reachable category. Every linked ancestor should be a genuine destination, not a label added only to make the trail look complete.

Letting HTML and JSON-LD disagree

If the visible trail says one thing while the structured data names different levels or URLs, the implementation tells two stories. Generate both from the same hierarchy source and test them together.

Using breadcrumb changes as a URL-migration shortcut

Changing a breadcrumb URL does not redirect an old address, update canonicals, or repair links elsewhere. Treat navigation, schema, redirects, and canonicalization as separate release checks.

Example: one hierarchy in HTML and JSON-LD

The visible links and structured data below describe the same simplified path. The current page is text in the navigation and the final ListItem names it.

<nav aria-label="Breadcrumb">
  <ol>
    <li><a href="/">Home</a></li>
    <li><a href="/shoes/">Shoes</a></li>
    <li aria-current="page">Trail shoes</li>
  </ol>
</nav>

<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":"Shoes","item":"https://example.com/shoes/"},
    {"@type":"ListItem","position":3,"name":"Trail shoes"}
  ]
}
</script>

This is illustrative markup, not a promise that Google will show a breadcrumb in a particular result.

Example: a misleading trail

Home > Sale > Popular > Shoes > Trail shoes

If “Sale” and “Popular” are temporary filters rather than stable ancestors, the trail mixes merchandising states with hierarchy. A durable location trail would usually be closer to Home > Shoes > Trail shoes; promotional paths can remain separate links.

Prompt: reconcile breadcrumbs across a template

Review the visible breadcrumb HTML, BreadcrumbList JSON-LD, canonical URL, and expected
site hierarchy below. Return one row per position with the visible label/URL, schema
label/URL, expected label/URL, and a mismatch finding. Check that positions are ordered,
ancestor URLs are absolute in JSON-LD, the current page is represented consistently,
and every linked ancestor is a real destination. Do not invent missing hierarchy
levels. Provide corrected HTML and JSON-LD only from the supplied expected hierarchy.

Expected hierarchy:
[PASTE POSITION | LABEL | CANONICAL URL]

Visible HTML:
[PASTE BREADCRUMB HTML]

JSON-LD:
[PASTE BREADCRUMBLIST]

Prompt: plan breadcrumb rules for multiple page types

Create deterministic breadcrumb rules for these page templates. For each template,
state the parent source of truth, label source, URL source, behavior for the current
page, and treatment of filters or temporary campaign pages. Flag any page that has
multiple plausible parents for a human decision. Keep the trail location-based and do
not infer categories that are absent from the supplied taxonomy.

Templates and taxonomy:
[PASTE TEMPLATE | TAXONOMY FIELDS | EXAMPLE CANONICAL URL]

Tools for implementing and testing breadcrumbs

• Schema Validator checks pasted JSON-LD or full HTML for vocabulary, required properties, graph references, and correctable markup problems before you ship it.
• Schema Generator produces a clean starting block when you need to draft structured data, but the generated trail still has to match the site’s real visible hierarchy.
• Google Rich Results Test shows whether Google can parse the supported markup on a URL or code sample. A valid result is eligibility evidence, not a display promise.
• Search Console’s Breadcrumbs enhancement report helps find detected errors across Google-known pages after release. It does not replace crawling your own templates.
• A crawler with structured-data extraction is the scalable comparison layer: export visible breadcrumb links, JSON-LD positions, canonical URLs, and status codes so template-level disagreement becomes obvious.

Validate a breadcrumb implementation

Measure breadcrumb health, not just rich-result display

Breadcrumb appearance in search is not a reliable standalone KPI because Google controls display and removed breadcrumbs from mobile results. Measure implementation, navigation, and template coverage directly.

Test yourself: Breadcrumbs

Five quick questions on what breadcrumbs do and how to implement them. Pick an answer for each, then check.

Resources worth your time

My related writing

• Internal Links for SEO: A Complete Guide — where breadcrumbs fit as a sitewide internal-linking pattern.
• Sitelinks: What They Are & How to Get Them — the related navigation surfaces Google can build from your structure.
• Website Migration: The Definitive Guide — breadcrumbs among the internal links that change during a move.
• Mobile-First Indexing: A Complete Guide — why some mobile templates trimmed breadcrumbs to save space.
• The Beginner’s Guide to Technical SEO — the broader picture breadcrumbs sit inside.

My speaking

• How Search Works (SlideShare) — my walkthrough of crawling, rendering, indexing, and ranking, and where structure signals like breadcrumbs come in. (Standing disclaimer: “This is my understanding of systems… not going to be 100% complete or accurate.”)

From around the industry

• Breadcrumb (BreadcrumbList) structured data (Google) — the canonical implementation reference.
• Simplifying breadcrumbs on mobile search (Google Search Central Blog) — the January 2025 mobile-removal announcement.
• Google no longer shows breadcrumbs in mobile search results (Search Engine Land) — Barry Schwartz’s coverage and impact assessment.
• Breadcrumbs in SEO: What Google’s Mobile Change Actually Means (Sitebulb) — a focused explainer of the change.
• Are Breadcrumbs A Google Ranking Factor? (Search Engine Journal) — the ranking-factor question, answered.
• Breadcrumb Navigation Increasingly Useful (Nielsen Norman Group) — the UX research: benefits, no downsides in user testing.
• SEO breadcrumbs guide (Search Engine Land) — types, best practices, and schema.

Breadcrumbs

Breadcrumbs are a secondary navigation trail (Home > Category > Page) that shows where a page sits in a site's hierarchy. They create internal links that pass PageRank, and when marked up with BreadcrumbList structured data they can drive the path Google shows in desktop search results.

Related: Internal Link, Structured Data

Breadcrumbs

Breadcrumbs are a secondary navigation element that shows a user’s position in a website’s hierarchy as a horizontal trail — typically near the top of a page in the form Home > Category > Subcategory > Current Page. The name comes from the Hansel and Gretel fairy tale.

In SEO, breadcrumbs matter on two layers that work together:

• The HTML layer — the visible <nav> with real <a href> links. These are internal links, and Gary Illyes confirmed Google treats them as normal links in PageRank computation. They distribute link equity and create crawl paths through your hierarchy.
• The structured data layer — BreadcrumbList JSON-LD. This is what can replace the URL in Google’s desktop search snippet with a readable path, and it helps engines understand site structure. John Mueller has been clear that structured data URLs are not used the same way as normal internal links, so the schema doesn’t replace the HTML links — you want both.

The most common type is location-based (where the page sits in the hierarchy, consistent for every visitor). Attribute-based breadcrumbs suit ecommerce and faceted navigation; history-based trails follow an individual user’s path and aren’t useful for SEO.

In January 2025 Google stopped showing breadcrumbs in mobile search results (mobile now shows the root domain only); desktop is unchanged, and the markup is still processed. Test breadcrumbs with the Rich Results Test and monitor them in Search Console’s Breadcrumbs enhancement report.

Related: Internal Link, Structured Data

Changelog