Breadcrumb Structured Data: How Do You Add BreadcrumbList Markup?

Breadcrumb structured data tells search engines where a page sits in your site hierarchy. When you set it up correctly, Google can show a readable category path in the search result instead of a bare URL. In this guide, Talha Aslan and team walk you through how we add the markup, how we test it, and which mistakes we see most often in audits.

So what does that mean in practice? For instance, picture a product page. A shopper moves from the home page to "Kitchen," then to "Cookware," and finally to a single pot. BreadcrumbList writes that chain in a language machines can parse. In other words, you hand search engines the same path your menu already shows to people.

Google's breadcrumb (BreadcrumbList) structured data documentation says a breadcrumb trail indicates the page's position in the site hierarchy. It also says the trail helps users move up that hierarchy one level at a time. Likewise, Schema.org defines the type as a chain of linked web pages that typically ends with the current page.

How does breadcrumb structured data change your search result?

The most visible change sits in the URL line of the snippet. Without markup, Google often shows your domain plus fragments of the address. With markup, and if Google finds it suitable, that same line can display a clean category path. As a result, searchers see which section of your site a page belongs to before they click.

That said, two limits matter from day one. First, Google's documentation states that the feature is available on desktop in all regions and languages where Google Search is available. It makes no separate promise for mobile, so a different look on phones is normal. Second, Google does not guarantee that any structured data will show up in results.

There is also a quieter benefit beyond appearance. A breadcrumb path spells out parent and child relationships between pages. On sites with deep category trees, this clarifies which topic cluster a page belongs to. In short, the markup is not decoration. It is a machine-readable summary of your site architecture.

Is a visible breadcrumb the same as BreadcrumbList markup?

No. The two work together, but they are different things. The on-screen breadcrumb is the row of links people see, something like "Home › Blog › SEO." The markup is the structured version of that row, which you send to search engines behind the scenes. Put simply, one talks to humans and the other talks to machines.

We covered the design and usability side in our article on why your website needs breadcrumb navigation. For that reason, we skip design here. Instead, this guide stays on the markup and on how Google treats it.

Still, you must keep the two consistent. Google's general structured data guidelines tell you not to mark up content that readers cannot see. Defining a path in code that never appears on the page is therefore a risky choice. The healthiest setup generates the on-screen row and the markup from the same data source.

Which breadcrumb properties are required and which are optional?

According to Google, the container type is BreadcrumbList, and it holds an ordered array called itemListElement. To qualify, you need to define at least two ListItem entries. Each ListItem then also carries a few properties of its own. The table below sums up the fields we see teams mix up most often.

The documentation says item can be a URL or a Thing referenced by ID. Also, if you omit item on the last entry, Google uses the URL of the containing page. In practice, however, we still give the last entry a URL. It makes template bugs much easier to spot.

Should the trail follow your URL structure or the user's path?

Google's advice is clear. A breadcrumb should reflect a typical path a user takes to reach the page, and it does not have to mirror the URL. The distinction sounds small. On older sites, though, it makes a big difference, because URL patterns there often grew out of technical decisions years ago.

As an example scenario, take a flat address such as example.com/product/12345. However, the URL holds no category information. Yet shoppers reach this item through "Home › Kitchen › Cookware." In this case you mark up that category path, not the URL segments. Consequently, the search result matches the map in the shopper's head.

On the other hand, do not read "typical path" as a license to invent. The path should rest on real category relationships and match the on-screen navigation. Adding fake middle layers just to squeeze in keywords misleads users. It can also run against Google's guidelines, so keep clear of it. Keep the trail honest, short and consistent.

How do you add breadcrumb structured data step by step?

Here is the order our team follows in the field. You can apply each step on its own or merge steps to fit your template setup.

1. List your page types: home, category, subcategory, product, blog post and service page.
2. Define the on-screen breadcrumb path for each type and write it down in a table.
3. Pin down the name and the full absolute URL, starting with https, for every step of the path.
4. Pick a format; in most cases JSON-LD offers the easiest maintenance.
5. Generate the markup from a single template partial instead of writing it page by page.
6. Check a few sample pages with the Rich Results Test.
7. Publish, then use the URL Inspection tool to see how Google views the page.
8. Watch the related Search Console report for several weeks.

If you would rather not write the markup from scratch, our schema generator gives you a draft that you can adapt to your template. Keep in mind that a tool only gets you started. Whether names and URLs fill in correctly on every page depends on your template logic.

The step teams skip most often is the second one. They jump straight into code without a path table. Without that table, different developers build different trails, and inconsistencies pile up over time.

Should you choose JSON-LD, Microdata or RDFa?

Google supports all three. Its documentation shows examples in JSON-LD, RDFa and Microdata. It also includes a plain HTML example that only forms part of the visual design and carries no markup. Your choice usually depends on your platform and on who maintains it.

For new builds we usually recommend JSON-LD, because the data block stays independent of the design. However, that independence also sets a trap. A design team changes the visible row while the data block keeps describing the old path. That is why you should feed both outputs from the same variables.

Whatever format you pick, drop the old data-vocabulary.org markup. Google's documentation notes that it is no longer eligible for rich result features. If an older theme still outputs it, switch to the Schema.org equivalent.

Where do you check the markup on WordPress and other platforms?

On off-the-shelf platforms, a theme or an SEO plugin often generates breadcrumb markup automatically. That is a fine starting point. Still, it brings two problems with it. The first is duplicate markup. The second is a trail that reflects the plugin's assumptions instead of your real structure.

Duplication happens like this: the theme outputs one BreadcrumbList, and the SEO plugin adds a second one inside its own graph. If both trails match, the damage is usually small. If one follows categories and the other follows tags, though, you send Google two conflicting signals. So always count how many BreadcrumbList blocks appear in the page source.

Use this short checklist:

• Search the page source for BreadcrumbList and note how many times it appears.
• For each instance, check which taxonomy it follows: category, tag or product group.
• If you disable one, keep the one that produces the same trail as the on-screen row.
• On platforms with a primary category option, set a primary category for every post.

To refresh the general logic of schema types, see our guide on what schema markup is and how structured data supports SEO. That article covers the big picture. Here, we stay on breadcrumbs only.

Can one page have more than one breadcrumb trail?

Yes. Google's documentation explicitly supports multiple breadcrumb trails for a single page. In JSON-LD you use an array of separate BreadcrumbList objects. In Microdata and RDFa you use multiple list blocks. The documentation's example shows a book page that people can reach through two different category paths.

When do you actually need this? For example, a product may live under both "Women › Shoes" and "Deals › Summer Sale." If users arrive through both paths often, two trails can make sense. Adding every tag and every filter as its own trail, on the other hand, only creates noise.

Our rule is simple. A trail goes into the markup only if the on-screen navigation really offers it to users. Do not add hidden alternative paths just to widen coverage. Moreover, many trails make Search Console reports harder to read, since separating the broken trail from the healthy ones takes time.

Should the home page and the current page be in the list?

Google's guidelines say you do not need a ListItem for the top-level path, meaning your domain, or for the page itself. Many sites, however, show a "Home" link and the page's own name in the visible row. In that case, keeping the markup identical to the row is the more consistent choice.

We see two approaches in practice. In the first, the path reads "Home › Category › Product," and all three items appear in the markup. In the second, the home step never appears, and the path starts at the category. Both are valid. What matters is that the visible row and the markup make the same decision.

Also, take care with the last item. If you skip item there, Google uses the page URL. If you give it the wrong URL, for instance a non-canonical version, you create a needless inconsistency. For more on that, read our guide on technical SEO tips, which covers other technical checks worth running.

Does it make sense to add breadcrumbs with Google Tag Manager?

It is technically possible, but it is rarely the first choice for breadcrumbs. Structured data that a tag manager injects only appears after the page loads in the browser. Google can process that kind of content. Even so, markup that already sits in the server HTML stays more predictable.

In practice, the real problem is maintenance. Each page carries a different trail. To build that trail in a tag manager, you need a variable that reads the on-screen row. When the design changes, that variable can quietly return nothing, and you only find out in Search Console.

Still, this route helps when you have no template access and need a temporary fix. We explain the setup in our article on adding schema with Google Tag Manager. Our advice is to treat it as a bridge until the template update ships, not as a permanent solution.

How do you validate breadcrumb markup with the Rich Results Test?

Google's Rich Results Test checks both a public URL and code you paste in. The safest order is to test the code before launch and the live URL after launch. That way you catch both typos and differences that only show up in production.

Focus on these points in the results:

• Whether the tool detects a breadcrumb item at all.
• Whether there are critical errors, since these make the item ineligible.
• Non-critical warnings, which do not block eligibility but are worth fixing for quality.
• Whether the number of detected items matches what you expect, because a surprise second trail points to duplicate markup.

What the test does not tell you matters too. It shows that the markup is technically eligible. It does not promise that Google will display it. The test also looks at one page only. Therefore, test at least one example of every page type, since a category template can work while a blog template fails.

What do URL Inspection and the Search Console report show?

Google's documented order goes like this: validate with the test, deploy a few pages, then use the URL Inspection tool to see how Google views them. At this stage, confirm that robots.txt, a noindex tag or a login wall does not block the page. The documentation also reminds you that recrawling and reindexing can take several days.

Next, open the rich result status report in Search Console. The Search Console Help rich result report overview splits items into valid and invalid. An invalid item has at least one critical issue. Non-critical issues, by contrast, do not invalidate the item but appear as ways to improve its appearance.

If this is your first time in the tool, our guide on what Google Search Console is and how to use it helps you find your way around. After the first launch, your goal is a rising count of valid items and no increase in invalid ones. Check the same chart after every template change too, because a sudden drop in valid items usually traces back to a code change.

What are the most common breadcrumb structured data mistakes?

We see the same mistakes in audit after audit. Most of them are not complex; they simply hide in a template unnoticed. The list below groups the most frequent ones roughly by priority.

• Single-item list: the trail holds only the current page, while Google needs at least two ListItems.
• Missing or empty item: middle steps lose their URL because a template variable stays blank.
• Relative URLs: the markup holds only a path fragment; full absolute URLs are safer.
• Position errors: position appears as text, repeats or skips a number.
• Name mismatch: the menu says "Cookware" while the markup uses a different label.
• Duplicate markup: the theme and a plugin output two different trails.
• Old vocabulary: data-vocabulary.org markup still lingers in the theme.
• Redirecting steps: a middle step points to a URL that redirects or carries noindex.

Some of these mistakes make the data completely unreadable. A missing comma or an unclosed bracket, for instance, breaks the entire block. If you run into that, our article on the unparsable structured data error in Search Console walks through the fix.

How do you prioritize critical and non-critical issues?

The rule is simple: critical issues first, non-critical ones second. A critical issue removes the item's eligibility for rich results. A non-critical issue leaves eligibility intact, although Google notes that fixing it can improve quality. So you spend your time on invalid items first.

The second rule is reach. An error on one page does not weigh the same as a template error that affects hundreds of pages. For that reason, look at the sample URLs in the report and identify which page type they belong to. One template fix often clears hundreds of items at once.

After the fix, retest the live URL and start validation in the report. The Help page explains that the issue details page shows validation progress once validation begins. Finding, fixing and monitoring this kind of template-level issue on your site is exactly what we do; the technical audit within our SEO consulting service covers this work end to end.

How should you structure breadcrumbs on a multilingual site?

On multilingual sites, every language version needs its own trail. The English page uses English names and English URLs. The German page uses German names and German URLs. Pointing a trail in one language to a category URL in another language confuses users and search engines alike.

A common mistake comes from translation plugins. They translate the visible label but leave the markup URLs in the original language. As a result, an English name links to a Turkish category. Test at least one sample page per language, and confirm that all URLs stay inside that language's folder.

Additionally, category trees can differ by market. A product group that stands alone in one market may sit under a parent category in another. Then the trail differs too, and that is perfectly normal. In each language, the markup should follow that language's on-screen navigation.

What names should you give each breadcrumb step?

A step's name should match the label people see for that category in the menu. Short, familiar and unambiguous names work best. For example, "Cookware" is enough. A long label such as "Best Value Cookware Sets and Models" crowds the row and looks like keyword stuffing.

Also, names do not have to match page titles. A category page can carry a more descriptive title, while the breadcrumb uses the short label. What matters is that the same category always goes by the same short name. In other words, you use one name in the menu, in the breadcrumb row and in the markup.

A similar rule applies to the last step. Pasting a long blog headline into it can overflow the row, so some sites shorten it. If you do that, make sure the on-screen row and the markup still use the identical name. Otherwise you break the consistency rule yourself.

How does breadcrumb markup relate to internal linking?

The visible breadcrumb row gives every page a steady link up to its parent categories. That makes it a natural part of your internal link structure. The markup then describes this relationship in structured data. Together they show, consistently, which page sits under which cluster.

However, breadcrumbs alone do not make an internal linking strategy. They only link upward; they do not connect sibling pages or related content. We cover that side in our internal linking strategy guide. Think of breadcrumbs as the skeleton of the strategy and in-content links as the muscle.

Your menu and your trail should also support each other. If the menu shows a page under "Services › SEO" while its breadcrumb says "Blog › SEO," users get confused. To tighten your menu hierarchy, see our website navigation menu design guide.

How would you set up BreadcrumbList on an online store? An example scenario

Example scenario: picture a home goods store on example.com. It has a few thousand products, a three-level category tree and also plenty of filters. Products can belong to more than one category. Its URLs are flat and carry no category information.

In this scenario, we would make a few decisions. First, we would assign every product one primary category, and the breadcrumb would always follow it. Next, we would not give filter pages their own trails, since filter combinations multiply endlessly. If truly visible second paths exist, such as campaign pages, we would add only those as a second trail.

Finally, we would test each page type separately: category, subcategory, product and campaign. For each type, we would confirm that the visible row and the markup carry the same names and URLs. Put simply, testing one product page and assuming the whole store works is the most expensive mistake in ecommerce.

Does breadcrumb structured data directly improve rankings?

No, there is no such guarantee, and we do not offer one either. Google does not even guarantee that structured data will appear in results. The markup helps Google understand the page and makes the snippet easier to read. Rankings, however, depend on content quality, relevance and many other signals.

Misuse, on the other hand, has a cost. Markup that breaks Google's guidelines can lead to a manual action. According to the guidelines, a structured data manual action removes a page's eligibility for rich results but does not change its ranking in web search. So the risk concerns appearance more than rankings. Still, nobody wants to take that risk for nothing.

That is why we position breadcrumb markup as a foundation to get right, not as a guaranteed win. For a wider view of how it fits with other technical work, read our article on technical SEO after AI.

Which checks should you run regularly after launch?

Breadcrumb markup is not something you set once and forget. When you open a new category, change the menu or update the theme, the trail can change as well. We therefore recommend a small but steady review rhythm.

1. After every theme or template update, run one URL per page type through the Rich Results Test.
2. Check the valid and invalid item chart in the Breadcrumbs report in Search Console once a month.
3. Update your path table whenever you open a new category.
4. Review rich result appearance and click-through rate in the Performance report.
5. Keep your sitemap current; Google's documentation lists submitting a sitemap among the steps.

Your own team can run these checks. On sites with large category trees, several languages and multiple templates, though, the work needs a process. We audit, fix and monitor your structured data, breadcrumbs included; for details and a quote, visit our SEO consulting page.

Core guide: What Is Digital Marketing? Its types, examples and how it is done, on one page with an interactive film that travels through the brain.