What Is a Breadcrumb?

A breadcrumb is a trail of internal links that shows where the current page sits within a site's structure. The name comes from the Hansel and Gretel fairy tale: the children scattered breadcrumbs to find their way home, and this bar does the same thing on a website, tracing the way back to the homepage.

It usually sits right below the header, in small, understated type, because its job is to support the main navigation, not replace it. Every link in the chain leads somewhere except the last one, which stands for the page the visitor is already on and goes nowhere.

It matters most for anyone who lands on an inner page straight from search or an external link, without passing through the sitemap or the homepage first. For them, the breadcrumb is the only visual clue about where that page sits in the bigger picture, and it's part of the UX even though almost nobody notices it consciously.

Both usually sit near the top of the page, which is why they get mixed up. The table below shows what each one actually answers.

Main navigation is fixed: it looks the same on every page and offers the same options no matter where the user is. A breadcrumb changes on every page, because it describes one specific path rather than a menu of options. Neither replaces the other: a site with a deep structure that only has a main menu forces users to click down level by level every time, while a breadcrumb lets them jump straight to the level they need.

There are three basic types, depending on what the path is built from.

The most common is the hierarchical or location-based breadcrumb: it reflects a page's position in the site tree regardless of how the user got there. It's what shows up on blogs and content pages, something like Home > Category > Article. The attribute-based version shows up mostly on online stores, when a user filters a catalog by brand, color, or price; the path then reflects the active filters rather than a folder on the site. The history-based breadcrumb used to show the last pages a user had visited, essentially the browser's back button turned into a bar; it's rare today, because it duplicates something the browser already handles on its own.

Technically, a breadcrumb is marked up with the BreadcrumbList type from Schema.org in JSON-LD, a block of structured data kept separate from the visible HTML. Each level is defined as a ListItem, with a numeric position starting at 1, a name, and, except for the last level, a URL. Google recommends the marked-up path match a user's typical route to the page rather than the literal URL structure, and it doesn't require an item for the root domain or for the current page itself.

The main reason is usability: it cuts down the feeling of being lost on a large site and removes the need for the browser's back button when someone wants to jump up a level. On catalogs with thousands of pages, it's one of the cheapest ways to give context without redesigning the main menu, and it works the same way whether someone lands on the page through the homepage, a mid-level category, or straight from a Google search.

There's also a visibility reason tied to search. Google still shows that path in place of the full URL in the search result, but only in desktop search; it doesn't appear this way in mobile results. A BreadcrumbList marked up with structured data doesn't decide rankings on its own, though it can turn into a visible rich snippet if Google decides to use it.

Finally, every breadcrumb adds one more internal link to a page's parent categories, which strengthens crawling across the site and helps indexing reach deep pages that would otherwise depend only on the main menu or the sitemap.

• Use BreadcrumbList in JSON-LD, the format Google documents first and the easiest to maintain apart from the visible HTML.
• Match the path to a user's typical route to the page, not necessarily the literal URL structure, when the two differ.
• Start the position at 1 and don't skip numbers: every ListItem needs a consecutive position.
• Skip an item for the root domain and for the current page: Google requires neither, and they just add noise.
• Keep the visible breadcrumb consistent with the marked-up BreadcrumbList; if what users see doesn't match the markup, Google can disregard the data.
• Validate the markup with the Rich Results Test before publishing, then check Search Console for errors afterward, as part of routine technical SEO.

• Marking up a breadcrumb that doesn't match what the user actually sees on screen; Google treats that as invalid structured data.
• Copying the URL's folder structure as the navigation path, even when no user actually clicks through it that way in practice.
• Using the breadcrumb as the only navigation system on a site without a clear hierarchy: without a logical structure behind it, the path doesn't help anyone.
• Confusing the breadcrumb marked up in the HTML with what shows up in the SERP: the markup decides what appears there, not the other way around.
• Assuming it will always show up in the search result: Google decides case by case and only ever shows it in desktop search.