Breadcrumbs for SEO: 2026 BreadcrumbList Guide
Breadcrumbs show where a page sits in a site, and a common mistake is marking up a trail that does not match what the visitor sees. Another is a trail that copies the URL folders instead of the real hierarchy. This guide covers what Google reads, which properties it needs and how to test the result. The examples are fictional and come from Portland, Munich and Seoul.
What is a breadcrumb trail and why does it matter?
A breadcrumb trail shows a page's position in the site hierarchy, and it may help users understand and explore a site. A visitor can climb up one level at a time, starting from the last breadcrumb in the trail. Google reads the same idea from markup to learn where the page belongs.
Think of the small line of links above a page title, such as Home, Shop, Chairs, where each step is a parent of the next one. That gives a visitor a quick way back and gives a crawler a clear picture of how your pages relate to each other. The official Google breadcrumb documentation is short, so read it once before you build anything.
How does Google use this markup in search results?
Google Search uses breadcrumb markup in the body of a page to categorize the information from that page in search results. People reach one page through very different queries, and the trail places the content in the context of the search. Google says the feature is available on desktop in all regions and languages where Google Search is available.
The documentation does not promise a ranking boost or a click lift, so do not sell this work as either one. What the documentation describes is that Google uses the trail to categorize the page in search results, and Google does not guarantee that any feature built from structured data will show up. Treat your breadcrumbs as a good description of your pages and let the display follow. Wider markup basics live in our JSON-LD schema markup guide.
Should a breadcrumb follow the URL path or the real hierarchy?
Google recommends breadcrumbs that represent a typical user path to a page, instead of mirroring the URL structure. A trail built from URL folders can look tidy yet describe a route nobody walks. Build the breadcrumb trail from the way people move through your categories, and let the site hierarchy you teach customers be the one you describe to Google.
Our take: location-based breadcrumbs usually beat path-mirroring ones, because a URL is an address while a breadcrumb is a map. Picture a fictional furniture shop in Portland, Oregon, whose chair sits at a flat address with no folders, yet the visible breadcrumb trail still reads Home, Living room, Chairs, since that is how shoppers browse. Clean addresses matter too, and our SEO friendly URL structure guide shows how to keep them tidy without tying them to the trail.
Which properties does Google require for the list?
A BreadcrumbList is the container, and it needs an itemListElement that holds at least two ListItem entries. Each ListItem needs a position, a name and an item URL. The last item in the trail may leave out the item, and Google then uses the URL of the containing page.
The table below follows the Google documentation.
| Property | What it holds | Google status |
|---|---|---|
| itemListElement | The ordered array of breadcrumbs | Required |
| ListItem | One breadcrumb, at least two per list | Required |
| position | The place in the trail, where 1 is the start | Required |
| name | The title shown to the user | Required |
| item | The URL of the page for that breadcrumb | Required except on the last item |
| item on the last ListItem | Google falls back to the containing page URL | Not required on the last item |
The status column is copied from the Google breadcrumb documentation. The formal type definition lives at schema.org BreadcrumbList. You do not need a ListItem for your domain root or for the page itself. If you give item as a Thing with its own name instead of a plain URL, the name is not required either. Old markup from data-vocabulary is no longer eligible for rich result features, so migrate it.
How do you mark up a page that has several paths?
If there are multiple ways to navigate to a page, you can specify multiple breadcrumb trails for that single page. Each trail is its own BreadcrumbList with its own ordered items. Google gives an example where one award page is reached through a genre route and through a broader literature route.
Take a fictional bookshop in Portland, Oregon, whose page for a prize winning novel sits under Books, Science Fiction, Award Winners and also under Literature, Award Winners. Both routes are real, so both breadcrumb trails are valid, but you should never invent a path that visitors cannot follow. Pages that attract several routes often belong to a bigger topic hub, which our content clusters and pillar pages guide explains in detail.
What does a good trail look like on a shop, a blog or a docs site?
A shop trail follows the category tree, such as Home, Category, Subcategory, Product. A blog trail is usually shorter, such as Home, Topic, Post. A docs trail follows the sections a reader uses to find a guide. In every case the labels should match the words visible on the page.
Shops carry the most risk because products live in many categories, so choose one primary path for each product and keep it stable while filters stay out of the breadcrumb trail. Faceted URLs create their own mess, which is covered in our faceted navigation guide. Category pages deserve the same care, and our ecommerce category page guide shows what to put on them.
Does a flat blog need breadcrumbs at all?
A flat blog with no real categories usually needs only a short trail such as Home, Post title. Extra levels that do not exist in your navigation add noise and can describe a hierarchy you do not have. Add depth only when readers can click through those parent pages.
Our take: do not invent levels to look serious. Many small blogs use two items and that is fine, because the minimum is two ListItem entries, and a topic step belongs in the middle only when your posts group into real hub pages. A thin or missing topic page is a reason to leave that step out. A big site needs deeper planning, which our site architecture and crawl depth guide covers.
How do you add the markup to a page step by step?
Add the required properties, follow the guidelines, then validate with the Rich Results Test. Deploy a few pages and test them with URL Inspection, making sure the page is not blocked by robots.txt, noindex or a login. Then submit a sitemap so Google learns about future changes.
Here is a fictional case in Munich, where a recipe site groups dishes under Home, Mains, Pasta. The developer builds the visible breadcrumb trail first and then generates the markup from the same data, so the two cannot drift apart. A short checklist keeps the rollout honest.
- Build the visible trail from your real category tree.
- Generate the markup from the same data as the visible links.
- Give every ListItem a position, a name and an item URL.
- Leave the final item URL out only when you want the page URL used.
- Validate the markup in Google's testing tool before you deploy.
- Inspect a few live pages and submit an updated sitemap.
If you use a CMS, a plugin may be easier than hand coding. If you use JavaScript to build the page, Google has a separate guide on generating structured data with scripts. Our on-page SEO checklist shows where this step fits in the wider routine.
How do you test the markup with Search Console and Google tools?
Paste the URL into the Rich Results Test and fix any critical errors. After launch, use the URL Inspection tool to see how Google reads the page. Then watch the rich result status report in Search Console to track valid and invalid items.
Google suggests checking Search Console in three cases, which are after the first deployment, after new templates or code updates, and during periodic traffic reviews. A jump in invalid items may mean a new template broke, while a drop in valid items without more errors can mean the markup is no longer on the page. The Performance report shows how often a page appears as a rich result. If this tool is new to you, start with our Search Console guide, and use the structured data debugging guide when errors pile up.
Why is Google not showing my trail?
Google does not guarantee that features built from structured data will appear. Check that the page is crawlable, that the markup has no errors, and that it follows the guidelines. A clean test result does not rule out guideline problems, because spammy content or spammy markup can still keep a trail from showing and the Rich Results Test may not catch them.
Work through the causes in order. First, open the page and confirm the breadcrumb trail is visible to a visitor, and then run the live page through the test tool. Next, look at the rich result status report for new errors after a template change. A structured data manual action means Google ignores the markup, although the page can still appear in results, and you should allow time for recrawling and reindexing before you judge the outcome. A broader audit helps here, and our technical SEO audit guide lays out a repeatable process.
How should a Korean site think about trails and Naver?
A site in Seoul, South Korea should still add valid markup for Google, but it should not treat Google as the only audience. Korean searchers often use Naver, which has its own tools and habits. Build the trail once, then plan separate work for Naver and for Korean language labels.
Take a fictional clothing shop in Seoul, South Korea, which labels every breadcrumb trail step in Korean so that a visitor sees the same words in the page and in the markup. The team then reads our Naver SEO guide for Korea to decide what else matters on that engine. We do not claim that Naver reads Google markup in any specific way, so test where your visitors search.
How do you keep breadcrumbs healthy over time?
Treat the trail as a living feature of the site. Recheck it after each template change, keep the markup in step with the visible links, and watch the rich result status report. Fix a broken parent page before the trail points visitors to a dead end.
Trails drift when a team renames a category, the visible link updates, and the markup keeps the old name. Parent pages should keep their internal links, so check how they are linked with the Search Console links report and the plan in our internal linking strategy. Duplicate pages cause another quiet problem, which the canonical tags guide explains. A template change can also shift layout and slow the page, so keep an eye on page experience, as the Core Web Vitals guide shows. Star markup follows its own rules, which we cover in our review snippet guide. Keep the routine boring and repeatable, and you avoid the mistake of a trail that no longer matches the page.
Frequently asked questions about breadcrumbs
Do breadcrumbs improve my rankings?
Google's documentation does not say that breadcrumb markup changes where a page ranks. It says Google uses the markup to categorize the page in search results. Treat the breadcrumb trail as a presentation and navigation feature. Focus on a clear hierarchy, accurate labels and a page that answers the search. Those habits help visitors whether or not Google shows the trail on a given result.
Do I need a ListItem for my home page?
No. Google says it is not required to include a ListItem for the top level path, which is your domain or host name, and it is not required for the page itself. Many sites still show Home as the first visible step because it helps people. You can show it to visitors and leave it out of the markup if your template makes that easier, as long as the list still has at least two ListItem entries.
How many items must a trail have?
A BreadcrumbList must contain at least two ListItem entries. A two step trail such as Home and Post title meets that minimum. Longer breadcrumb trails are fine when your site has those levels, and you number the items with position, where 1 signifies the beginning of the trail. Keep the order in step with the links a visitor sees on the page.
What happens if I leave item off the last breadcrumb?
Nothing breaks. If the breadcrumb is the last item in the trail, item is not required. When you leave it out, Google uses the URL of the containing page. Every earlier breadcrumb still needs an item URL. Many teams add it to the last step as well, because a complete list is easier to read and to debug later, and it keeps every breadcrumb in the trail consistent.
Can I still use data-vocabulary markup?
No. Google states that data-vocabulary.org markup is no longer eligible for rich result features. If an old theme or plugin still outputs it, switch to schema.org BreadcrumbList in JSON-LD, RDFa or Microdata, which are the formats shown in the documentation. After the switch, test a few pages and watch Search Console for errors, and keep the old template until the new breadcrumb output has passed every check.
Can one page carry more than one trail?
Yes. When there are multiple ways to navigate to a page, you can specify multiple trails for that single page. Each one is a separate BreadcrumbList. Use this only when the routes are real, for example one path through a genre and another through a general topic. Do not add paths that visitors cannot follow, because the markup should describe your navigation honestly.
Where does Google say the feature is available?
Google says the feature is available on desktop in all regions and languages where Google Search is available. In practice that includes the USA, Europe and South Korea, though the documentation names desktop only. The documentation does not describe other engines, so a Korean site should check Naver separately. Keep your breadcrumb labels in the language of the page, and test your key templates after each release so a small change does not remove the markup unnoticed.
What if I get a structured data manual action?
If you receive a structured data manual action against a page, Google ignores the structured data on it, although the page can still appear in search results. Open the Manual Actions report in Search Console, fix the markup and review the guidelines again. Spammy content or spammy markup can cause this problem, and a syntax test will not catch those issues, so review the breadcrumb markup on your pages with care.
Which markup formats can I use?
The documentation shows examples in JSON-LD, RDFa and Microdata, plus a plain HTML trail for the visible links. Pick the format your team can maintain, and keep it identical across templates. Our take: JSON-LD is the easiest to generate from the same data as the visible trail. Whichever format you choose, validate it before release and again after template changes, so the breadcrumb markup stays correct as your site grows.