Breadcrumb Schema Markup Generator

Show Home > Category > Page paths in Google SERP snippets — generate valid BreadcrumbList schema markup in seconds.

ProductArticleFAQOrganizationLocal BusinessBreadcrumb

Site navigation path — shows "Home > Category > Page" in Google Search snippets.

1
2

Minimum 2 items required. Position is set automatically. URL is optional for the last (current) item.

JSON-LD output
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": []
}
</script>
Missing required fields
  • At least two breadcrumb items with names
Test in Google

How to use the Breadcrumb Schema Markup Generator

  1. The first breadcrumb item is pre-filled as "Home" — update the URL to your actual homepage address.
  2. Add breadcrumb items for each level of your site hierarchy: Home > Category > Subcategory > Page.
  3. Enter the name as it appears in your visible navigation — Google compares schema names against the breadcrumb trail users see on the page.
  4. Enter the full URL for each level. The URL for the last item (current page) is optional — Google uses the canonical URL as a fallback.
  5. Click "Add item" to add deeper hierarchy levels. Minimum two items are required for the schema to be valid.
  6. Copy the generated JSON-LD block and paste it into the <head> of the page whose breadcrumb path you are describing.
  7. Validate with the Google Rich Results Test — you should see "BreadcrumbList" as an eligible rich result.

How the Breadcrumb Schema Markup Generator works

Breadcrumb schema markup is a JSON-LD script block that describes the navigation hierarchy leading to the current page. Instead of letting Google guess the site structure from your HTML navigation, you give it an explicit, machine-readable path: Home → Category → Subcategory → Page. The generator builds this block in your browser — you add items, the JSON-LD updates live, and you paste the result into your page.

The practical SERP effect is visible and immediate: instead of showing a raw URL like `example.com/electronics/headphones/sony-wh1000xm5`, Google displays a clean breadcrumb trail: `example.com › Electronics › Headphones › Sony WH-1000XM5`. This makes the snippet more readable at a glance and communicates site structure to users before they click.

Breadcrumb schema — three levels
<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": "Electronics",
      "item": "https://example.com/electronics/"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Sony WH-1000XM5"
    }
  ]
}
</script>

What Breadcrumb Schema changes in Google Search results

The URL line in a standard Google snippet shows the raw page address — functional but hard to read. Breadcrumb schema replaces that raw URL with a human-readable navigation path, making your result look more organized and trustworthy at a glance. The effect appears in standard search results, mobile search, and Google Discover.

  • Readable path instead of raw URL — "example.com › Headphones › Sony WH-1000XM5" instead of "example.com/products/headphones/sony-wh1000xm5-black-variant". Cleaner, more scannable.
  • Site structure signal for Google — breadcrumb schema tells Google's crawler exactly how your pages relate to each other. This reinforces internal linking signals and helps Google understand your site architecture during indexing.
  • Improved CTR on category pages — category pages benefit most, since the breadcrumb path communicates context that a URL slug alone often cannot.
  • Mobile SERP display — on mobile, breadcrumbs appear as a separate line above the title in some layouts, giving your result more visual weight.
  • Consistent anchor text for internal links — the name field in breadcrumb schema can reinforce the anchor text signals of your internal navigation links.
  • Multi-path product pages — for products in multiple categories, multiple BreadcrumbList blocks on one page let Google choose the most relevant path for each query context.

BreadcrumbList fields — what each one does

BreadcrumbList has a minimal required structure — a list of ListItem objects, each with position, name, and optionally item (the URL). The simplicity is intentional: the schema is designed to be easy to implement correctly on any page type.

FieldRequiredDescription
@type: BreadcrumbListYesRoot type identifier — must be exactly "BreadcrumbList"
itemListElementYesArray of ListItem objects — one per breadcrumb level
@type: ListItemYesType of each item — must be exactly "ListItem"
positionYesInteger starting at 1 — order must be sequential with no gaps
nameYesDisplay label for this breadcrumb level — shown in SERP
itemRecommendedFull absolute URL of this level — optional for the last (current) item

The item field (URL) is technically optional for the last breadcrumb — Google uses the page's canonical URL as a fallback. For all other levels it is strongly recommended: the URL tells Google that the named breadcrumb corresponds to a real, indexable page in your site hierarchy.

Common Breadcrumb Schema mistakes and how to avoid them

Schema structure mistakes

  • Non-sequential positions — positions must be 1, 2, 3... with no gaps or duplicates. If you have four levels, position values must be exactly 1, 2, 3, 4. Skipping from 1 to 3 or repeating position 2 makes the schema invalid.
  • Relative URLs instead of absolute — item must always be a full URL including protocol: `https://example.com/category/` not `/category/`. Google rejects relative URLs in breadcrumb schema.
  • Fragment URLs — item values like `https://example.com/page#section` are not supported. Breadcrumb URLs must be the canonical page URL without hash fragments.
  • Only one item — BreadcrumbList requires at least two items to be valid. A single-item breadcrumb ("Home" alone) is not a list and will not generate a Rich Result.

Content mismatch mistakes

  • Names that don't match visible breadcrumbs — Google verifies that the name values in the schema correspond to what users see in the breadcrumb navigation on the page. If your schema says "Electronics" but the visible breadcrumb shows "All Electronics & Gadgets", Google may reject the markup.
  • Schema breadcrumb differs from page URL structure — if the item URL in your schema doesn't match the actual canonical URL of that category page, Google's entity graph becomes confused about which page the breadcrumb level represents.
  • Breadcrumb schema on pages without visible breadcrumbs — some implementations add BreadcrumbList schema to pages that have no visible breadcrumb navigation. This violates Google's requirement that schema content must be visible to users.

Technical deep dive: multiple paths and combining with other schemas

Multiple breadcrumb paths: a product page accessible from two different categories can have two separate BreadcrumbList blocks on the same page. For example, a headphone product might appear under both Electronics → Headphones and Brands → Sony. Add two separate `<script type="application/ld+json">` blocks, each describing one path. Google reads both and may choose which path to display based on the query context — showing the Electronics path for a product-category query and the Sony path for a brand query.

Combining with Product or Article schema: BreadcrumbList is designed to coexist with other schema types on the same page. A product page typically combines Product schema (for price, availability, ratings) and BreadcrumbList (for the navigation path). An article page combines Article schema (for author, date, publisher) and BreadcrumbList. Keep each type in its own `<script>` block — Google reads them independently.

Breadcrumb schema vs visible breadcrumb HTML: many sites implement breadcrumbs using visible `<nav>` elements with `<ol>` and `<li>` tags. Having both the visible HTML breadcrumb and the JSON-LD schema is the recommended approach — they reinforce each other. The JSON-LD does not need to be written as Microdata in the HTML. However, the name and URL values in the JSON-LD must accurately reflect what the visible breadcrumb shows.

Multiple BreadcrumbList paths on one product page
<!-- Path 1: via category -->
<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": "Electronics", "item": "https://example.com/electronics/" },
    { "@type": "ListItem", "position": 3, "name": "Headphones",  "item": "https://example.com/electronics/headphones/" },
    { "@type": "ListItem", "position": 4, "name": "Sony WH-1000XM5" }
  ]
}
</script>

<!-- Path 2: via brand -->
<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": "Sony",  "item": "https://example.com/brands/sony/" },
    { "@type": "ListItem", "position": 3, "name": "Sony WH-1000XM5" }
  ]
}
</script>

Frequently Asked Questions

Does Google require Breadcrumb schema to show breadcrumbs in search results?
No — Google can generate breadcrumb-style URL display from your site structure and HTML navigation without schema. However, schema gives you explicit control over what text appears at each level and which URL each level maps to. Without schema, Google may show a truncated, auto-generated path that does not match your intended navigation labels. Schema ensures consistency.
Does Breadcrumb schema improve search rankings?
Not directly — structured data is not a ranking factor. However, breadcrumb schema improves how your snippet looks in the SERP by replacing raw URLs with readable navigation paths. More readable snippets tend to have higher click-through rates, and higher CTR is an indirect positive signal for Google. The site structure signal from breadcrumb schema also helps Google crawl and understand your content hierarchy more efficiently.
Is the item (URL) field required for the last breadcrumb?
No — the item field is optional for the last ListItem because it represents the current page. Google uses the page's canonical URL as a fallback. For all other items (parent levels), providing the item URL is strongly recommended: it explicitly maps each breadcrumb name to a real indexable page, which helps Google understand your site structure.
What is the minimum number of breadcrumb items required?
Two items are the minimum for a valid BreadcrumbList. A single-item list (only "Home") is not a breadcrumb trail and will not generate a Rich Result. Most pages benefit from three or four levels: Home > Category > Page, or Home > Category > Subcategory > Page.
Can I use Breadcrumb schema on the homepage?
It is not useful on the homepage itself — the homepage is the root of the breadcrumb hierarchy, so there is no trail leading to it. Breadcrumb schema is intended for pages at depth 2 or greater in your site structure. Adding a single-item BreadcrumbList on the homepage would be invalid anyway (requires at least two items).
What if my site has a flat structure with no category hierarchy?
You can still use a two-level breadcrumb: Home > Page Name. Even without a middle category layer, this gives Google an explicit path and shows a clean name in the SERP instead of a raw URL slug. For a very flat site (only homepage + direct children), this is the simplest valid implementation.
Can I have multiple BreadcrumbList schemas on one page?
Yes — multiple BreadcrumbList blocks are supported on a single page, each in its own <script> tag. This is useful for products or articles that are accessible through multiple navigation paths (e.g., a product in two categories, or an article in two topic sections). Google reads all paths and may choose which to display based on the search query context.
Can breadcrumb names in the schema differ from the visible breadcrumbs on the page?
Minor differences are tolerated — Google does a fuzzy match, not an exact string match. However, significant differences will cause the markup to be rejected. If your visible breadcrumb shows "Wireless Headphones" and your schema says "Headphones", that is likely acceptable. If the schema says "Electronics Accessories" while the page shows nothing similar, Google will flag it as a mismatch.
Should I use absolute or relative URLs in the item field?
Always use absolute URLs — the full address including protocol and domain: https://example.com/category/. Relative URLs like /category/ are not supported in schema.org structured data. Google requires absolute URLs for all item fields in BreadcrumbList.
How does Breadcrumb schema interact with Product or Article schema on the same page?
They coexist independently in separate <script type="application/ld+json"> blocks. A product page typically has both Product schema (for price, availability) and BreadcrumbList (for the navigation path). Google reads each block separately and may generate rich results from both simultaneously — the price/rating information from Product schema and the breadcrumb trail from BreadcrumbList.
What happens if the breadcrumb position numbers are not sequential?
The schema becomes invalid. Position values must be consecutive integers starting at 1 with no gaps or duplicates: 1, 2, 3, 4. If you skip a number (1, 2, 4) or repeat one (1, 2, 2, 3), Google's validator will flag the schema as having an error and may not generate the rich result. The generator assigns positions automatically in the correct order.
Do I need breadcrumb schema if I already have a visible breadcrumb navigation on the page?
Having a visible HTML breadcrumb does not automatically generate schema — they are independent. You need both: the visible breadcrumb for users and accessibility, and the JSON-LD schema for explicit machine-readable communication with Google. Adding schema to pages that already have visible breadcrumbs is straightforward and low-risk. The schema values must accurately reflect what the visible breadcrumb shows.