Breadcrumb Navigation

Quick definition

Breadcrumb navigation is a line of links that shows where the current page sits inside a website. On an online shop, a typical trail reads Home > Women > Shoes > Trail running shoes. Every item except the last links to a parent page, and the last item names the page you are on.

The name comes from the fairy tale in which Hansel and Gretel drop crumbs to find their way home. On a website the trail does a similar job. A visitor who lands on a deep page from search sees at a glance where they are and can move up to a broader page with one click. For search engines, the same trail is a set of crawlable internal links and, with structured data, a machine-readable description of the hierarchy.

Three kinds of breadcrumbs

People use the word for three different patterns, and only one of them is what SEO advice usually means.

• Hierarchy-based breadcrumbs follow the structure of the site: Home > Guides > Technical SEO > Canonical tags. They stay the same no matter how the visitor arrived. This is the standard pattern.
• Attribute-based breadcrumbs describe a filtered view, which is common in e-commerce: Shoes > Trail running > Waterproof > Size 42. They help shoppers see which filters are active. Each filter combination can also create its own URL, so these trails need the same care as the filter pages themselves.
• History-based breadcrumbs list the pages the visitor clicked through during the session. They repeat what the browser's back button already does, change from visit to visit, and give crawlers nothing stable to follow. Most sites are better off without them.

When this page says "breadcrumbs" without a qualifier, it means the hierarchy-based kind.

What breadcrumbs do for visitors

Search sends people straight to deep pages. Someone looking for a specific trail shoe may land on a product page without ever seeing the homepage or the category menu. The trail answers two questions at once: where am I, and what else is around here?

Usability guidance, for example from Nielsen Norman Group, treats breadcrumbs as secondary navigation. They help on sites with several levels of hierarchy, but they never replace the main menu or on-page links. A site with two levels gains little from a trail. A shop with five category levels gains a lot.

On small screens, long trails wrap onto several lines and push the main content down. Common solutions are a horizontally scrollable trail, truncating the middle items, or showing only the direct parent as a link such as "Back to Shoes". Whatever you choose, the parent link should stay tappable and readable.

What breadcrumbs do for SEO

Google does not publish a ranking weight for breadcrumbs, and you should be skeptical of anyone who promises one. Their value is practical and comes from three places.

They are internal links

Every breadcrumb item is an ordinary HTML link from a deep page to its parents. A category page with 300 products receives a link from each of them. That helps crawlers find and revisit the category, and it makes the hierarchy explicit in the internal link graph. Because the anchor text is the category name, those links also carry a short, descriptive label for the target page.

They express the hierarchy consistently

When navigation, breadcrumbs, and categories agree, the structure of the site is easy to read for people and for machines. A product that sits in "Trail running shoes" in the menu but shows "Sale > Misc" in its trail sends mixed signals and confuses visitors.

They can change how a result looks

With BreadcrumbList structured data, Google can show a breadcrumb trail in a result instead of the raw URL path. Google's documentation says it uses breadcrumb markup in the page body to categorize the page's information in search results. Display is never guaranteed, and the appearance changes over time. In January 2025, Google announced that mobile results would show only the domain in the visible URL line, while desktop results can still show the breadcrumb-style trail. The markup itself remains supported.

Breadcrumbs are not a copy of the URL

Google recommends breadcrumbs that represent a typical user path to a page, instead of mirroring the URL structure. That distinction matters on sites with short or technical URLs.

For example, a product may live at /p/48213 while its trail reads Home > Women > Shoes > Trail running shoes. A blog post may sit at /blog/2026/10/crawl-budget-myths while its trail reads Home > Blog > Technical SEO. In both cases the trail describes where the page belongs for a reader, and that is what it should do. Clean URL structure still helps, but breadcrumbs do not need to wait for a URL migration.

Some pages can genuinely be reached through several paths. A rain jacket might belong to both "Outdoor" and "Women's jackets". Google's documentation allows more than one trail in the markup for such cases. In practice, most shops show one primary trail on the page, pick it to match the category they treat as canonical, and keep the markup identical to what is visible.

BreadcrumbList structured data

Breadcrumb markup uses the schema.org type BreadcrumbList. Each step is a ListItem with a position, a name, and an item that holds the URL. JSON-LD is usually the easiest format to generate from templates:

json{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Women",
      "item": "https://www.example.com/women/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Shoes",
      "item": "https://www.example.com/women/shoes/"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Trail running shoes"
    }
  ]
}

The block goes into a <script type="application/ld+json"> element. A few details are worth knowing:

• Positions start at 1 and run in order from the broadest page to the current one.
• The last item may omit item. Google then uses the URL of the page that contains the markup.
• Use absolute URLs, and point them at the canonical version of each category.
• Google's examples start with a category rather than the homepage. Whatever you choose, keep the markup and the visible trail consistent.

Microdata and RDFa work too. The format matters less than the rule behind all of Google's structured data guidelines: the markup has to describe content that visitors can see. A JSON-LD trail for a page without any visible breadcrumbs, or with a different trail on screen, is the kind of mismatch that can make the page ineligible for the breadcrumb display in results.

Accessible breadcrumb HTML

The WAI-ARIA Authoring Practices describe a simple, robust pattern. The trail sits in a nav element with a label, the items form an ordered list, and the current page is marked with aria-current:

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

Add the separators with CSS rather than as text characters. Otherwise screen readers may announce "greater than" between every item. Many sites render the last item as plain text instead of a link, which is also fine, as long as it is clearly the current page.

This HTML pattern and the JSON-LD block do different jobs. The HTML is what people and crawlers follow. The structured data describes that same trail to search features.

Rendering, canonicals, and link targets

Breadcrumbs only help crawlers if the links are present in the HTML that search engines process. A trail built with real <a href> elements in the server response is the safest option. A trail injected by client-side JavaScript usually works for Google, but it depends on rendering, and JavaScript rendering adds another place where things can break. Navigation should also never wait for a scroll or a click. A breadcrumb component that is lazy-loaded only after interaction may simply not exist for a crawler that does not scroll.

The link targets need the same care as any internal link. Each breadcrumb URL should return status 200, be indexable, and match the category's canonical URL. Typical leaks are links to parameter versions of a category, to old URLs that now redirect, or to filtered views marked noindex. When a category moves, update the template so that thousands of trails do not route through a redirect.

What breadcrumbs do not do

Breadcrumbs reflect a site structure. They do not create one. If categories are inconsistent or a product appears in a dozen overlapping groups, a trail will only make that visible.

They also do not replace an XML sitemap, the main menu, or contextual links in the body text. And they only affect Google's results. How a page looks when someone shares it on LinkedIn or in Slack comes from Open Graph tags, not from breadcrumb markup.

A worked example

Consider a sporting goods shop with this setup: product URLs like /product/48213, a category tree of four levels, and a theme that prints the trail Home > Products > Item.

That trail is technically present and practically useless. It links every product to the same generic "Products" page, the anchor text says nothing, and the structured data repeats the same two levels for 20,000 URLs.

After the fix, each product shows the trail of its primary category: Home > Running > Trail running shoes > [product name]. The category links point to the canonical category URLs, the JSON-LD lists the same three parent steps, and on mobile the trail collapses to a single "Back to Trail running shoes" link. Visitors can now step up one level, and every category page receives links from the products it actually contains.

Common mistakes

• using history-based trails that change with every visit
• linking every page to the same generic parent instead of its real category
• marking up a trail in JSON-LD that is not visible on the page
• showing one trail on screen and a different one in the structured data
• pointing breadcrumb links at redirected, parameterized, or noindexed URLs
• loading the trail only after a scroll or click
• printing separators as text so that screen readers announce them
• treating breadcrumbs as a ranking trick instead of navigation
• expecting breadcrumb markup to change social media link previews

A practical check

1. Open a sample of deep pages from each template: product, category, article, and filtered view.
2. Check that the visible trail matches the page's real place in the hierarchy.
3. Confirm that each breadcrumb item is a crawlable <a href> link in the rendered HTML.
4. Verify that every link target returns 200, is indexable, and is the canonical URL.
5. Test the BreadcrumbList markup with Google's Rich Results Test and compare it with the visible trail.
6. Review the Breadcrumbs report in Search Console for errors across the whole site.
7. Check the trail on a phone: does it wrap, truncate, or push the content down?
8. Run a screen reader or the browser's accessibility tree over the trail and listen for separator noise.
9. Repeat the check after template releases, since one theme change can affect every page at once.

The Crawl Foundry perspective

Breadcrumbs are internal links, so the most useful evidence is a list of the links that actually exist in the rendered page. Crawl Foundry's crawler checks the rendered HTML and shows internal links as it found them in the DOM, with source, target, anchor text, and position. For breadcrumbs, that answers concrete questions: do product pages link to their category, which anchor text do those links carry, and do any targets point at the wrong URL?

The crawler keeps a crawl history, and runs can be compared. That helps after a theme or template release, when one change can rewrite every trail on the site. If you want to look at your own trails this way, the Site Audit overview explains how a crawl is set up. Site Audit is a paid data action, and the price is shown before you start.

For the structured data itself, Google's Rich Results Test and the Breadcrumbs report in Search Console remain the authority on whether Google can read your BreadcrumbList markup.

Related terms

• Schema markup
• Anchor text
• Link equity
• Rich snippet
• Content siloing
• E-commerce SEO
• Mobile SEO
• URL structure

Review sources

• Google Search Central: Breadcrumb (BreadcrumbList) structured data
• Google Search Central: General structured data guidelines
• Google Search Central: Link best practices
• Schema.org: BreadcrumbList
• W3C WAI-ARIA Authoring Practices: Breadcrumb pattern
• MDN Web Docs: aria-current
• Nielsen Norman Group: Breadcrumbs, design guidelines