Breadcrumb Schema Generator

A free breadcrumb schema generator

Breadcrumbs are the little trail of links near the top of a page: Home › Blog › SEO › This article. They tell a visitor where they are, and they give them a way back up. Add the matching structured data and they do one more job: Google can replace the plain URL in your search result with that readable path.

This breadcrumb schema generator writes that markup for you. Paste a page URL and the tool splits the path into levels, tidies the names, and produces valid BreadcrumbList JSON-LD. You can rename each level, reorder them, add or remove steps, and see both the trail and a mock search result update as you type. It also gives you matching accessible HTML so the breadcrumbs on the page and the markup describing them always agree.

It's free, needs no sign-up, and everything runs in your browser.

How to use the generator

1. Paste your page URLEach folder in the path becomes a level, and the tool converts slugs like seo-basics into readable names like "Seo Basics".
2. Fix the namesRename each level to match the breadcrumb a visitor actually sees. "Seo Basics" probably needs to be "SEO Basics".
3. Adjust the trailAdd a missing level, remove one that doesn't exist on your site, or move levels up and down.
4. Copy the codeTake the JSON-LD for the page head, and the HTML breadcrumbs for the top of the page if you don't already have them.
5. Test itRun the page through Google's Rich Results Test once it's live.

What is breadcrumb schema?

Breadcrumb schema is structured data that uses the BreadcrumbList type from schema.org. It lists each step of the path as a ListItem with a position, a name and a URL. Here's the shape of it:

<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": "Blog",
      "item": "https://example.com/blog/" },
    { "@type": "ListItem", "position": 3, "name": "Breadcrumb guide" }
  ]
}
</script>

Positions start at 1 and must run in order. The last item is the current page, and its item URL is optional, which is why the tool lets you include it or leave it off.

Why breadcrumbs matter

• Better search results. Google can show the breadcrumb path instead of the URL, which reads better and tells searchers what kind of page they're about to open.
• Lower bounce rate. A visitor who lands deep in your site from search can move up a level instead of hitting the back button.
• Internal linking. Every breadcrumb is a link to a category page, which spreads authority through your site structure without any extra work.
• Crawl clarity. Breadcrumbs make your hierarchy explicit, which helps search engines understand how pages relate.
• Accessibility and usability. Used properly, with a labelled <nav> element, they give screen reader users a clear sense of position.
• Mobile. On a small screen, where your main navigation is hidden behind a menu icon, breadcrumbs are often the only visible structure.

The three kinds of breadcrumbs

Hierarchy breadcrumbs are the ones to mark up. History breadcrumbs change per visitor, so they can't be described by static structured data, and attribute breadcrumbs only make sense if those filter pages are meant to be indexed.

Rules that keep breadcrumb markup valid

• Reflect a real path to the page. The markup should describe how a user would navigate to it, not an invented route.
• Match what's visible. The safest approach by far is to show breadcrumbs on the page and mark up exactly those.
• Use absolute URLs including the protocol and domain.
• Keep positions sequential from 1 upwards with no gaps or repeats.
• Point at working pages. Every URL in the trail should return a 200 status, not a redirect or a 404.
• Keep names short. Google truncates long breadcrumb names in results, so "Running shoes" beats "Our complete range of running shoes".
• One trail per path. If a page genuinely sits in two categories you may add two BreadcrumbList objects, and Google may show either.

Common breadcrumb mistakes

• Markup with no visible breadcrumbs. Technically it may still work, but it's fragile and easy to get wrong.
• The trail doesn't match the URL structure. If your URL is /blog/seo/post but your breadcrumb says Home › Marketing › Post, decide which is right and fix the other.
• Starting without Home. Most trails should begin at the homepage.
• Making the current page a link to itself. Show the last item as plain text; the URL in the markup is optional.
• Relative URLs such as /blog/, which are a frequent cause of validation errors.
• Duplicate markup. A theme and an SEO plugin both adding BreadcrumbList is common; check the page source.
• Stale trails after a restructure. When categories change, the markup has to change with them.

Adding breadcrumbs to your site

WordPress

Yoast and Rank Math both generate breadcrumbs and their BreadcrumbList markup once you enable the feature, and both let you set what the trail shows for each post type. If your theme already prints breadcrumbs, make sure only one of them is outputting schema. Use the generator here for custom pages, landing pages or anywhere the plugin's trail is wrong.

Shopify and other platforms

Most themes include breadcrumbs on product and collection pages, though not all of them add structured data. Paste one of your product URLs into the tool, compare the output with what's in your page source, and add the JSON-LD to the theme template if it's missing.

Custom sites

Generate the trail server-side from the page's position in your content tree, so it's always correct, and output both the visible HTML and the JSON-LD from the same data. That single habit prevents almost every breadcrumb bug.

Writing the HTML breadcrumbs

The markup describes something; that something should exist. Use an ordered list inside a labelled nav element so screen readers announce it properly, mark the current page with aria-current="page", and separate items with CSS rather than typed characters so the separators aren't read aloud. The generator produces exactly this structure, ready to paste:

<nav aria-label="Breadcrumb">
  <ol>
    <li><a href="https://example.com/">Home</a></li>
    <li><a href="https://example.com/blog/">Blog</a></li>
    <li><span aria-current="page">Breadcrumb guide</span></li>
  </ol>
</nav>

Testing and troubleshooting

Run the live page through the Rich Results Test. If it reports the breadcrumb but you never see it in search, that's normal: Google decides case by case whether to show a rich result, and breadcrumbs appear more often for deeper pages on well-structured sites than for a homepage.

If it reports errors, the usual culprits are relative URLs, positions that don't start at 1, a missing name, or two BreadcrumbList blocks contradicting each other. Search Console's enhancement reports will show the same problems across every affected URL once Google recrawls, which is the fastest way to catch a template-wide mistake.

For the wider picture, our schema markup generator covers the other structured data types a page usually needs, and the crawler checker confirms the URLs in your trail actually respond.

Breadcrumbs and site structure

A breadcrumb trail is only as good as the structure behind it. If your URLs are flat, with every page sitting directly at the root, there is no hierarchy to describe and breadcrumbs add little. If your structure is five levels deep with categories nobody uses, the trail just makes that confusion visible.

The useful middle ground for most sites is two or three levels below the homepage. A blog works well as Home › Category › Post. A shop works as Home › Department › Category › Product. Anything deeper tends to mean your categories are too narrow, and anything flatter usually means related content is not grouped at all.

Because every breadcrumb is an internal link, the trail also quietly shapes how authority moves around your site. Category pages that appear in thousands of breadcrumbs pick up a lot of internal links, which is exactly what you want if those categories are pages you would like to rank. If your breadcrumbs point at categories you never want in search, that is a sign the structure and the strategy disagree.

Keeping trails accurate over time

Breadcrumb markup breaks quietly. A category gets renamed, a section is merged into another, a template is edited, and the trail keeps describing a structure that no longer exists. Nothing visibly fails, so nobody notices until the enhancement report in Search Console fills with errors.

• Generate the trail from your content structure, not from hard-coded strings in a template.
• Re-check after every restructure, including category renames and URL changes.
• Make sure every URL in the trail returns 200, not a redirect left over from an old slug.
• Spot-check a page from each template once a quarter: a post, a category, a product, a landing page.
• Watch for duplicate markup after installing or updating an SEO plugin.

Five minutes of checking is cheaper than finding out months later that every product page on the site has been describing the wrong category.

Frequently asked questions

Build your breadcrumb markup

It takes a minute per template and improves how every page below it looks in search. Go back to the breadcrumb schema generator, paste a URL and copy the code.

More free tools from BlogDada