How does the BreadcrumbList Schema generator work?
This breadcrumb schema generator is suitable for online stores, blogs, catalogs, service websites, documentation, and other projects with a hierarchical structure. Before publishing, it's recommended to check the code in Google Rich Results Test and Schema Markup Validator to detect errors in properties and syntax.
The breadcrumb schema generator collects data from each navigation level and converts it into a ready-made Schema.org object. The user enters page titles, adds URLs, and arranges elements in the order in which the visitor moves from a general section to a more specific one.
After filling in the fields, the breadcrumblist schema generator creates JSON-LD with the BreadcrumbList and ListItem types. The resulting code can be copied, validated, and added to a page template, CMS, or server-side rendering.
What data needs to be added?
Each element in the chain is given a clear page name and address. This is sufficient for the breadcrumbs schema generator to generate the basic properties of the structured data and correctly position the elements within the array.
Before generating, it's a good idea to check that the links open correctly and correspond to the current canonical URLs. If the site structure has recently changed, it's best to replace old redirected URLs with the final URLs.
Element name – name
The name property conveys the name of a specific level in the navigation chain. For a store category, this might be "Smartphones", for a blog, "SEO", and for a service website, the name of the corresponding category.
The name should be human-readable and consistent with the actual structure of the site. Avoid turning the name into a set of search queries or adding unnecessary words to increase keyword density.
Page URL – item
The item property contains the address of the page corresponding to a specific BreadcrumbList level. It's best to specify an absolute canonical URL without advertising GET parameters, timestamps, or technical URL variations.
It's a good idea to check links before publishing markup, especially after moving a site or changing its structure. The item property for the last element in the chain can be omitted if it represents the current page.
How to add multiple levels?
Each new level is added in the order in which the user logically navigates the site structure. For example, an online store's navigation chain might look like "Home → Catalog → Smartphones → Phone Model".
The number of levels depends on the actual project architecture, so there's no need to artificially lengthen the chain. The main thing is that the transition from the general section to the specific page remains clear and consistent.
Common Mistakes in Breadcrumb Schema
Most issues are related to incorrect URLs, inconsistencies, and discrepancies between actual navigation and JSON-LD. The BreadcrumbList syntax itself is relatively simple, making it easy to spot errors before publishing.
Before implementation, test several different types of pages. For an online store, it's worth examining categories, subcategories, and products separately, as the depth of the chain typically varies.
Position numbering starts from 0
BreadcrumbList positions must start at 1, not 0. Subsequent items continue to be numbered sequentially in the order they appear within the breadcrumb.
If the generator automatically assigns values, manually editing them is usually unnecessary. With custom server-side generation, this rule must be taken into account in the template logic.
The order of elements is violated
Elements should move from the most general to the most specific level. A category shouldn't appear after a product page if the actual site hierarchy is structured the opposite way.
Errors of this type often appear after moving sections or changing the directory structure. After making major edits to BreadcrumbList, it's a good idea to recheck it.
Non-canonical URLs are used
In structured data, it's best to use the primary page address, which matches the canonical. URLs with UTM tags, sorting, time parameters, and other technical values should not be added.
If a single page is accessible at multiple URLs, BreadcrumbList shouldn't accidentally switch between duplicates. Consistent links simplify the structure.
BreadcrumbList includes 301, 404, or deleted pages.
Each link should lead to the current page without unnecessary redirect chains. After a site migration, old URLs sometimes remain in the markup, even though the user navigation already includes the new addresses.
Before mass implementation, it's helpful to check the list of links with a crawler or internal checker. This helps identify redirects and 404 errors before re-indexing.
Schema describes a fictitious hierarchy
Don't create additional categories just to satisfy search engine crawlers. If a visitor can't explain the path through the site's structure, the markup will begin to diverge from the actual page content.
BreadcrumbList should convey existing relationships between documents. Artificially expanding the breadcrumb chain doesn't make the page more informative for search engines.
Different implementations of Schema are duplicated
The CMS, SEO plugin, and custom code sometimes output multiple BreadcrumbList objects simultaneously. If they have different names, URLs, or positions, the search engine receives inconsistent data.
Before adding new JSON-LD, check the source HTML and existing microdata. It's best to remove the old implementation or convert it to a single data source.
There is a syntax error in JSON-LD
A missing comma, incorrect quotes, or an unclosed object make JSON-LD invalid. Such errors are especially common after manually editing already-generated code.
After any changes, re-run validation. This takes less time than searching for the problem after publishing and re-crawling the page.
How to use the ready-made Breadcrumb Schema?
Working with ready-made markup consists of several sequential steps: filling in the levels, checking the order, copying the code, implementing it, and then validating it. Skipping the check often results in a technical error being discovered only after publication.
The Breadcrumbs schema generator reduces manual work, but the accuracy of the source data still depends on the user. Before implementation, ensure that the names and links reflect the current site structure.
Add Navigation Levels
First, add pages in logical order from the general level to the specific level. Add a title for each element, and for those levels where one is required, provide the full URL.
Don't automatically import every folder from the address bar. If the technical URL structure differs from user navigation, use the actual page hierarchy as a guide.
Check the order of elements
After filling out the form, check the sequence of elements and position values. The first level should be assigned position 1, the second 2, and subsequent levels should continue the numbering without breaks.
Review the intermediate categories separately. If one no longer exists or is redirected, it's best to replace it with a current page before generating the URL.
Copy JSON-LD
After generation, copy the resulting JSON-LD in its entirety, including the opening and closing script tags. Do not remove individual properties unless you understand their role in the Schema.org structure.
Before handing over the code to the developer, you can save the example along with the page URL. This will simplify post-implementation testing and help compare the expected structure with the actual result.
Add the code to the page
The code can be embedded directly into the HTML, via a CMS template, or via server-side generation. For large sites, manually inserting it on each page quickly becomes inconvenient and increases the risk of discrepancies.
It's best to pass BreadcrumbList values from the same data used to build the site's navigation. Then, changes to categories and URLs will be reflected synchronously in the structured data.
Check the result
After publishing, open the page in the validator and ensure that the markup is indeed present in the final HTML. Validating the source template alone is not enough, especially if the data is generated dynamically.
Additionally, check the canonical URL, the response status of all pages, and whether the visible navigation path matches. It's best to fix any errors before the next full crawl of the site.
What we actually did
Dental clinic · Kyiv and Chernihiv
+44% clicks from search
A domain with no history on a website builder. We built the semantic core for both cities, reworked the landing pages and built the link profile from zero. Four months: 34.8k clicks, impressions 1.32 → 1.76M, DR 0 → 41.
E-commerce · international
+96% clicks in two months
A catalog of digital 3D models. We clustered the semantics, rebuilt the hub pages and closed duplicates and indexing errors. Google users 247 → 532, CTR 2.4% → 4%.
Medical center · Ukraine
+68.75% visibility in the first month
Narrow visibility and a small semantic core at the start. Semantics, landing page structure, metadata and internal linking, then gradual link building.
Answers to your questions
What is BreadcrumbList Schema Generator?
The BreadcrumbList Schema Generator creates JSON-LD for a page's breadcrumb. The user adds level names and URLs, and the service automatically generates the BreadcrumbList, ListItem, position, name, and item.
This breadcrumblist schema generator is convenient for quickly preparing an example and checking the structure before deployment. After generation, the code should still be checked with a validator and on the actual page.
How many elements should be in a BreadcrumbList?
A proper chain requires multiple levels of related links, and Google's breadcrumb feature guidelines call for a minimum of two ListItems. Each subsequent item should logically continue the previous navigation level.
There's no need to add additional elements for the sake of quantity. If the page structure consists of only one independent level, the need for a BreadcrumbList should be reconsidered.
Is it necessary to start breadcrumbs from the home page?
No, the homepage can be used as the first element, but it's not a requirement for every implementation. The breadcrumb trail should reflect the normal navigation structure of the specific site.
If the actual path begins with a specific section, it can be used as the first level. The main thing is that the sequence remains logical and understandable.
Do I need to specify a URL for the last item in BreadcrumbList?
The URL of the last ListItem can be omitted if the element represents the current page. This preserves its name and correct position within the chain.
If you do add an address, it's best to use the canonical URL of the current page. Avoid passing a technical duplicate or link via a redirect.
Is it possible to use BreadcrumbList without visible breadcrumbs?
Structured data should correspond to the actual content and architecture of the site. Creating a separate, fictitious hierarchy solely for search engine crawlers is not recommended.
If the visible navigation is constructed differently, it's important to check whether it complies with JSON-LD. The user-defined structure remains the primary guideline.
Where to place the JSON-LD code for BreadcrumbList?
JSON-LD can be added to the <head> or <body> of the resulting HTML page. For search engines, accessibility and correct markup are more important than choosing between these two locations.
On sites with SSR or a custom CMS, it's more convenient to generate code using a template. This way, the BreadcrumbList updates along with the page data and doesn't require manual edits.
How to check breadcrumb markings?
You can first check the code in Google Rich Results Test, then run it through Schema Markup Validator. After publishing, it's advisable to check the actual URL, not just the copied JSON-LD.
For indexed pages, URL Inspection in Google Search Console is also useful. It helps you check the page's accessibility and see which version of the document the search engine receives.
Does BreadcrumbList guarantee that breadcrumbs will show up in Google?
No, correct structured data does not guarantee a specific search result format. The search engine independently chooses which elements to use when generating the search results.
The purpose of markup is to correctly convey the page structure. It's impossible to promise snippet changes or ranking gains after implementing BreadcrumbList.
Is it possible to create multiple BreadcrumbList chains for one page?
Yes, multiple paths are possible if a page truly belongs to multiple logical paths within the site. Each path must be consistent with the actual architecture and user-accessible navigation.
Don't create additional chains without a practical reason. The simpler and more accurate the structured data reflects the site, the easier it is to maintain.
Which is better for breadcrumbs: JSON-LD or Microdata?
Both formats can be used for the BreadcrumbList, but JSON-LD is more conveniently separated from the HTML navigation component. It's easier to generate on the server and update without changing the visual layout.
Microdata is suitable for projects where Schema.org is already embedded directly into the HTML. For new implementations, the choice usually depends on the CMS architecture and page rendering method.
Related services
FAQ Schema Generator
The FAQ Schema generator creates valid FAQPage JSON-LD markup. Add questions and answers, copy the code, and validate it online at Schema.org.
Article Schema Generator
Free Article Schema Generator: Generate JSON-LD for Article, BlogPosting, and NewsArticle, copy the code, and validate the markup before publishing.
Product Schema Generator
Online Product Schema Generator: create JSON-LD microdata for your product with price, availability, brand, rating, and offer information. Copy the code and test it before publishing.
A correct BreadcrumbList should replicate the actual site logic, use actual URLs, and maintain a consistent element order. After generation, the position, names, canonical URL, and resulting JSON-LD should be checked in validators.
Add navigation levels to the generator, generate the finished Schema markup, and validate it before publishing. For larger sites, it's best to transfer the verified structure to the automatically generated CMS or SSR so that the data updates along with the pages.
We reply within one business day. No newsletters, no “just a reminder” calls.
He will look at the site himself instead of passing it to a manager.
More on: BreadcrumbList Schema Generator
What is BreadcrumbList Schema?
BreadcrumbList is a Schema.org type designed to describe a hierarchical chain of pages. This markup shows search engines how a particular page ranks relative to categories, sections, and other levels of the site.
Search engines can use this structured data when processing the page and generating the URL representation in search results. Correct markup doesn't necessarily mean the search engine will show breadcrumbs in every snippet.
How is Schema markup different from regular breadcrumbs?
Regular breadcrumbs are visible to the user directly on the page. They help navigate to a parent category, section, or other hierarchy level without having to return through the site's main menu.
The breadcrumb markup generator creates a machine-readable description of such a breadcrumb chain. Visible navigation and JSON-LD must convey the same structural logic to prevent search engines from receiving inconsistent data.
Why do we need BreadcrumbList structured data?
The Breadcrumb structured data generator helps explicitly convey to search engines the relationship between a page and its parent sections. This is especially useful for large sites, where the URL doesn't always fully reflect the logical hierarchy of the content.
The markup provides search engines with structured context about the site's navigation. It also helps maintain a consistent BreadcrumbList format across thousands of pages when automatically generated via CMS templates.
What elements does a BreadcrumbList consist of?
The basis of the markup is a BreadcrumbList object, which contains an array of navigation elements. Each level receives its own position, title, and, if necessary, a link to the corresponding page.
The schema breadcrumb generator collects these values automatically and reduces the risk of syntax errors. The user only needs to check the correctness of the structure and the URL's correspondence to the actual website pages.
BreadcrumbList
The BreadcrumbList is specified in the @type property and tells the Schema.org processor what type of data it is looking at. The @context property typically contains the address of the https://schema.org dictionary.
A single object collects the entire navigation chain for a specific page. Its contents should describe the actual site hierarchy, not a separate structure created solely for search engine crawlers.
itemListElement
itemListElement contains an array of elements that make up the user's path. Each array element describes a separate page or level in the structure and is assigned its own ListItem type.
The order of elements within the array should follow a logical progression from the most general page to the most specific. This array should also be updated as the site structure changes.
ListItem
Each ListItem represents a separate step of the breadcrumb trail. For example, in a catalog breadcrumb trail, the individual items would be the "Catalog" section, the "Laptops" category, and a specific device model.
The Breadcrumblist schema generator creates the required number of such objects after adding levels to the form. Before copying the markup, it's a good idea to check that no elements have been accidentally added to the chain.
position
The position property specifies the ordinal position of an element within the BreadcrumbList. Numbering starts with one and continues sequentially according to the page layout.
If there are four elements, the values should be listed as 1, 2, 3, and 4, without gaps or repetitions. Incorrect ordering complicates the interpretation of the chain and must be corrected before implementing the code.
name
The name property contains the readable title of the section or page. It should convey the same meaning as the user sees in the navigation or in the name of the corresponding site category.
Short and descriptive names are usually more convenient than long SEO phrases. For a store, you might use "Laptops" rather than an extended structure with all the commercial keywords in the category.
item
The item specifies the absolute URL of the page corresponding to a specific level of the chain. It's best to use the canonical URL if the site contains parameters, duplicates, or multiple technical variations of the same page.
The last ListItem may not have an item property. If a URL is specified, it must point directly to the corresponding page without an intermediate 301 redirect.
How to build a breadcrumb chain correctly?
A proper navigation path reflects a clear user path through the site structure. For a product page, this might be a catalog, category, subcategory, and product, while for an article, this might be a blog, topic section, and publication.
Don't add levels just to increase the length of the BreadcrumbList. Each element should correspond to a real part of the navigation, which can be explained through the site architecture and the relationships between pages.
I don't build BreadcrumbList by simply copying URL segments. I first check the actual user path, canonical URL, and parent sections, then set the position and check the links. After implementation, I always run Rich Results Test and Schema Markup Validator to find errors before the search engine crawls the page again.
Do I need to repeat the URL structure?
No, the navigation hierarchy doesn't have to exactly follow the page's URL structure. The URL /catalog/product-123/ could correspond to the chain "Home → Catalog → Smartphones → Product 123" if that's how the site's navigation is structured.
It's more useful for a search engine to obtain a logical user path than a mechanical listing of directories from the address bar. Moreover, all specified levels must exist in the actual project structure.
Is it necessary to add a home page?
The homepage is often included as the first level, as this is familiar to users and is found in many interfaces. However, the top level of the domain is not a required element of the BreadcrumbList in all cases.
If site navigation begins with a specific section, the markup can be built according to this logic. The solution should be based on a realistic structure, not a one-size-fits-all template.
Do I need to add the current page?
The current page may appear as the last element if it matches the selected breadcrumb structure. Its presence is not considered a requirement for a valid BreadcrumbList.
If the current page is the last one added, the item property can be omitted. The title and correct position will still describe its place in the navigation chain.
Is it possible to use multiple BreadcrumbList on one page?
Multiple chains are allowed when a page truly belongs to multiple logical hierarchies. For example, a product can be located in multiple catalog sections simultaneously, as long as such a structure is accessible to the user.
There's no need to add multiple variants just to increase the volume of structured data. Each chain should have a clear purpose and correspond to the actual site architecture.
JSON-LD, Microdata, or RDFa – Which Format to Choose?
Schema.org supports several methods for transmitting structured data, including JSON-LD, Microdata, and RDFa. JSON-LD is generally more convenient for automatically generating a BreadcrumbList, as the code can be written separately from the visual HTML navigation.
Microdata and RDFa are also used on live websites, so they shouldn't be considered invalid formats. The choice depends on the project architecture, the page rendering method, and the current implementation of microdata markup.
JSON-LD
JSON-LD is placed as a separate block and does not require Schema.org properties to be added directly to each HTML breadcrumb element. This approach is convenient for supporting in templates and dynamic applications.
Seo-Gen's primary generator format is JSON-LD. It's easier to copy, verify, update, and automatically generate on the server when the page structure changes.
Microdata
Microdata adds Schema.org properties directly to the navigation HTML markup. This is done using the itemscope, itemtype, and itemprop attributes associated with specific page elements.
This option remains functional, but with complex layouts, maintaining it may require more HTML changes. This is especially noticeable when updating website components or templates.
RDFa
RDFa also embeds structured properties in HTML and can describe BreadcrumbList. This format is less common in modern generator implementations, but remains part of the supported markup methods.
If a website already uses a unified RDFa approach, there's no need to change the entire project just for breadcrumbs. A new JSON-LD implementation is usually technically easier to maintain.
Where to insert BreadcrumbList JSON-LD?
JSON-LD can be placed in the <head> or <body> of the resulting HTML document. For SEO, it's more important that the search engine crawler receives the correct block on the page and that its content matches the actual data.
It's best to determine the insertion location based on the project architecture. On sites with templates or SSR, it's more convenient to automatically generate the markup along with the rest of the page's metadata.
Placement in <head>
Placing JSON-LD within the <head> is convenient when structured data is generated simultaneously with the Title, Description, Canonical, and other SEO elements. This approach is often used in server-side templates.
The code should be included in the final HTML of the page, which is received by the search robot. After implementation, open the generated document and check for the presence of the required BreadcrumbList object.
Placement in <body>
JSON-LD can also be placed within the <body> if this implementation is more convenient for a specific project. The mere placement of the block in this part of the document does not invalidate valid Schema markup.
When dynamically adding data via JavaScript, you must additionally check whether the search engine receives the final data after rendering. This risk is usually lower with SSR.
Generation via CMS or SSR
On a large site, it's best to automatically generate the BreadcrumbList based on the page structure, its parent categories, and canonical URLs. Manually populating thousands of pages almost inevitably leads to outdated links.
When a category or route changes, the data should be updated along with the page itself. This approach reduces the risk of a situation where the navigation has already changed, but the JSON-LD continues to reference old sections.
How to test BreadcrumbList Schema?
After implementation, the markup should be verified in at least two ways: using Google's tool and the independent Schema.org checker. This helps separate search engine requirements from the overall correctness of the dictionary.
It's also useful to look at the actual HTML of the page and ensure that the schema breadcrumb generator passed the same values that were specified when the object was created.
Google Rich Results Test
The Google Rich Results Test shows whether Google recognizes supported structured data on the page being tested or in the submitted code. The tool is easy to use immediately after generation and after publication.
A successful check means that no critical errors were detected in the corresponding implementation. It does not guarantee the specific appearance of the search result.
Schema Markup Validator
Schema Markup Validator validates Schema.org structure and properties independently of Google search results. It's easy to spot incorrect types, missing relationships, and syntax issues.
If the code passes both checks, the next step is testing the actual page. The markup in the generator and the markup after implementation sometimes differ due to templates or CMS data processing.
Google Search Console
Once indexed, the page can be checked using URL Inspection in Google Search Console. This tool helps you see if the URL is accessible to the robot and check which version of the page the search engine receives.
When implementing on a large scale, it's helpful to monitor structured data reports and individual page templates. A single template error can affect a large section of the site at once.
BreadcrumbList Examples for Different Website Types
The breadcrumb structure depends on the type of project and the depth of its architecture. There's no universal scheme for every website, so the generator must work with the levels actually present in the navigation.
Below are sample templates that can be used as a guide when filling out the form. The names and URLs in the working draft should be replaced with the actual page data.
| Site type | Example of a chain |
|---|---|
| Online store | Home → Catalog → Smartphones → Phone Model |
| Blog | Home → Blog → SEO → Article |
| Services website | Home → Services → SEO → Technical SEO Audit |
| Documentation | Documentation → API → Authentication → OAuth |
The flow remains the same: general section → more specific category → final page. The number of intermediate levels depends on the actual structure of the specific project.
Online store
For an online store, BreadcrumbList typically maps the path from the catalog to the category, subcategory, and product page. With a large product range, this layout helps clearly describe the product's location within the structure.
If a single product appears in multiple categories, you should focus on the actual navigation and the chosen canonical logic. Don't automatically add all possible categories to a single chain.
Blog
In a blog, a chain often consists of a homepage, a publications section, a category, and a specific article. If a simpler architecture is used, there's no need to add an extra category level.
The section title should correspond to the actual thematic grouping of publications. After moving an article to a different section, the BreadcrumbList should also be updated.
Services website
On a service website, the structure can include a general section, a service area, and a specific service. For example, "Home → Services → SEO → Technical SEO Audit" provides a clear flow for both users and search engines.
If a service is located directly within the main section, there's no need to artificially create an additional level. Navigation should be consistent with the site's architecture.
Documentation or SaaS
Documentation often uses a deep hierarchy consisting of product section, documentation category, subsection, and specific instruction. Correct ordering is especially important here due to the large number of related pages.
Whenever documentation versions or API routes change, old URLs must be promptly removed. Automatic generation via the CMS significantly simplifies this maintenance.
When should you use BreadcrumbList Schema?
BreadcrumbList is useful for websites where pages are linked in a clear hierarchy. These include online stores, catalogs, corporate websites with service categories, blogs, portals, knowledge bases, and documentation.
For a single-page landing page or a flat site without a nested structure, using BreadcrumbList is often impractical. The markup should describe the existing navigation, so adding it formally to every page isn't necessary.
A suitable scenario can be identified using a simple diagram:
- If a page has a clear parent section and multiple levels of navigation, a BreadcrumbList is usually appropriate;
- If the page exists separately and is not part of a logical hierarchy, there is no need to create an artificial chain;
- If the site structure changes automatically, it is advisable to generate the markup from the same CMS data;
- If the URL contains parameters or duplicates, it is better to pass the canonical URL in the item.
Once you've selected the appropriate pages, you can use the breadcrumb schema generator to prepare the code and test the implementation separately on each main site template. This process reduces the risk of widespread errors.
What does the Breadcrumb JSON-LD Generator produce?
The Breadcrumb json ld generator creates a block containing the Schema.org context, the BreadcrumbList type, and the itemListElement array. Each array element is described using a ListItem.
A ListItem typically contains a position, name, and item. This format is separate from the page's HTML navigation, making it convenient to automatically generate via a CMS or SSR without changing the visual layout of the breadcrumbs.