Guide : ItemList Schema

TL;DR — ItemList is a bit of schema.org code que dit “ce page is a liste of choses, in ce order.” The two important parts are the liste of entries (itemListElement) and a rank number on chaque un (position). By itself it fait pas obtenir vous a fancy résultat de recherche — Google’s swipeable Carousel is construit on top of ItemList, and seulement montre up quand vous pair it with un of a few spécifique content types (recipes, movies, courses, restaurants). It won’t aider vous rank plus élevé, soit.

Ce que ItemList schema is

Quand vous construire a “Top 10” page, or a recipe roundup, or a liste of courses, vous peut voir it’s a liste. A moteur de recherche mostly sees a wall of text and some HTML. ItemList is a petit block of structured-data code que spells it out: “ce is a liste, ici are the items, and here’s the order ils go in.”

Schema.org describes it as “A liste of items of quelconque sort—Par exemple, Top 10 Movies À propos de Weathermen, or Top 100 Party Songs.” It aussi adds a clarifying line worth remembering: “Pas to be confused with HTML listes, qui are souvent utilisé seulement pour formatting.” An ordinary <ol> or <ul> rend a liste regarder comme a liste; ItemList rend it mean a liste to a machine.

Two properties do almost tout the fonctionner:

• itemListElement — the liste of entries. Chaque entry is usually a ListItem.
• position — a number starting at 1 que dit où chaque entry ranks in the liste.

The un chose everyone obtient incorrect

Ajout ItemList by itself ne fait pas obtenir vous a special résultat de recherche. Ce is the top misconception, so it’s worth stating plainly. ItemList is the mechanism; the visible payoff — a swipeable définir of cards in Google’s results — is a separate fonctionnalité appelé a Carousel. And a carousel seulement apparaît quand vous combine ItemList with un of a short, Google-controlled liste of content types (pour the classic carousel: Course liste, Movie, Recipe, Restaurant). A generic “Top 10 blog posts” page marked up with plain ItemList doesn’t earn que afficher.

There’s aussi a family connection que surprises personnes: breadcrumbs utiliser the même mechanism. BreadcrumbList — the schema behind ceux “Home › Category › Page” trails — is technically a type of ItemList. Même itemListElement, même position. Une fois vous apprendre un, you’ve mostly learned the autre.

Pourquoi c’est important (and ce que it doesn’t do)

• It peut faire vous eligible pour a carousel — si vous have a pris en charge content type and everything sinon is correct. Eligible isn’t the même as guaranteed, soit: Google dit plainly it doesn’t guarantee que fonctionnalités consuming données structurées va en réalité montrer up in résultats de recherche.
• It helps machines comprendre votre page is a structured liste. That’s the container’s job — I’m pas going to claim a broader “helps AI systems lire votre page” payoff on top of que sans Google publishing something spécifique to point to.
• It fait pas améliorer votre rankings. Comme tout données structurées, ItemList n’est pas a ranking factor. Google has been consistent on ce pour années.

Vouloir the complet picture — the two implementation patterns, the exact pris en charge types, the newer geo-limited beta carousel, how BreadcrumbList fits in, and the courant validation échecs? Switch to the Avancé tab.

TL;DR — ItemList is schema.org’s generic ordered-list container; itemListElement

• a 1-fondé position do the fonctionner, with itemListOrder and numberOfItems as lesser-used extras (numberOfItems matters pour paginated listes). It is pas itself a rich result — Google’s Carousel is construit on top of it and seulement fires with a pris en charge companion type: Course liste, Movie, Recipe, Restaurant pour the classic carousel, and LocalBusiness/Product/Event pour a newer beta that’s geo-gated to the EEA, Turkey, and South Africa. Two patterns: summary-page (url-only ListItems) and all-in-one (nested items). Rules: 2+ items (3+ pour the beta), tout the même type on the classic carousel (the beta permet mixing), markup doit match visible content. BreadcrumbList is formally a subtype of ItemList (with HowToSection, HowToStep, OfferCatalog) — the detail la plupart guides miss. And données structurées n’est pas a ranking factor — its payoff is eligibility and understanding, pas position.

Ce que ItemList en réalité is

Schema.org’s definition is deliberately broad: “A liste of items of quelconque sort—Par exemple, Top 10 Movies À propos de Weathermen, or Top 100 Party Songs.” The line que explique pourquoi the type nécessite to exist is the suivant un: “Pas to be confused with HTML listes, qui are souvent utilisé seulement pour formatting.” An <ol>/<ul> conveys “ces are a liste, in ce order” purely by visual convention. ItemList declares the container (ItemList), chaque entry (ListItem), and chaque entry’s rank (position) as données a machine peut lire sans inferring anything from layout.

Two properties do the heavy lifting:

• itemListElement — the array of entries. Schema.org: “Pour itemListElement valeurs, vous pouvez utiliser simple strings (e.g. ‘Peter’, ‘Paul’, ‘Mary’), existing entities, or utiliser ListItem.” Pour anything que veut une URL or a position (i.e. anything aiming at a rich result), vous utiliser ListItem.
• position — a 1-fondé integer giving chaque ListItem its rank.

Two plus are documented but skipped by la plupart guides:

• itemListOrder — “Type of ordering (e.g. Ascending, Descending, Unordered).” A declaration, pas something Google enforces.
• numberOfItems — “The number of items in an ItemList. Remarque que some descriptions pourrait pas entièrement décrire tout items in a liste.” Ce un earns its garder on paginated listes: a “Top 100” split à travers five pages peut utiliser numberOfItems to state the complet count même though quelconque un page marks up seulement twenty entries.

(There’s aussi aggregateElement pour holding aggregate ratings/offers à travers the liste — genuinely niche; you’ll rarely touch it.)

The two implementation patterns

Google’s carousel documentation describes two shapes, and qui un vous utiliser changements ce que chaque ListItem semble comme:

Summary page and multiple detail pages

A summary page listes chaque item briefly, and chaque entry liens out to a dedicated detail page. Ici the ListItem is minimal — Google: the summary page defines an ItemList où chaque ListItem has seulement three properties: @type (définir to ListItem), position (the position in the liste), and url (l’URL canonique of the item’s detail page). The complet per-item données structurées (the Recipe, the Movie, etc.) lives on chaque detail page.

All-in-one summary page

Everything lives on un page, so chaque ListItem carries a nested item containing the complet companion-type markup (the whole Recipe object, pour instance) plutôt que simplement a url. Utiliser ce quand là are aucun separate detail pages.

ItemList n’est pas the Carousel — ce is the core distinction

Here’s the accuracy spine of the whole topic. ItemList is a container; Carousel is a rich result construit on top of it. ItemList alone, with aucun pris en charge companion type, fait pas produce a distinct “list” rich result in classic Recherche Google. Google’s docs are explicit que carousel eligibility exige les deux pieces.

Classic Carousel — the pris en charge types

To be eligible pour a host carousel rich result, vous ajouter ItemList données structurées in combination with un of a petit, Google-controlled définir of pris en charge fonctionnalités. As of Google’s current (2026) documentation, que liste is:

• Course liste
• Movie
• Recipe
• Restaurant

That’s it pour the classic carousel. Autre types — Product, BlogPosting, Event — peut carry ItemList markup pour organization and machine understanding, but que alone fait pas faire les classic-carousel-eligible.

Carousels (Beta) — the newer, geo-gated program

There’s a second, newer program — Carousels (Beta) — que Google describes as “a list-like rich result que personnes peut scroll horizontally to voir plus entities from a donné site.” It’s the plus actively-evolving partie of ce fonctionnalité area, and it differs from the classic carousel in three important façons:

• Différent pris en charge types: ItemList combined with LocalBusiness and its subtypes (Restaurant, Hotel, VacationRental), Product, or Event — a broader and différent définir que the classic four.
• Geographically limited: it’s disponible seulement in EEA countries, Turkey, and South Africa, on desktop and mobile, with the eligible requête types varying by region. Ce is pas a global fonctionnalité — a caveat worth stating plainly, since several third-party write-ups discuss it as si it’s généralement disponible.
• A plus élevé minimum: the beta exige a summary page plus detail pages with au moins three itemListElement.item entries, versus the classic carousel’s two.
• Mixing is allowed: unlike the classic carousel’s strict same-type rule, Google’s beta documentation dit vous “peut mix and match différent types of entities (pour exemple, hotels, restaurants), si nécessaire pour votre scenario” — don’t carry the classic same-type assumption over quand you’re working with the beta.

Treat the beta as “watch this space” plutôt que a stable, universal fonctionnalité.

How BreadcrumbList (and a few others) relate to ItemList

Ce is the unique la plupart under-covered, differentiating fact à propos de ItemList, and it clears up a courant point of confusion: BreadcrumbList n’est pas a separate, unrelated schema type — it is formally a subtype of ItemList. Schema.org states it directement: “A BreadcrumbList is an ItemList consisting of a chain of lié Web pages, typically décrit en utilisant au moins leur URL and leur nom, and typically ending with the current page.” And schema.org’s propre “More specific Types” liste pour ItemList is exactly four entries: BreadcrumbList, HowToSection, HowToStep, and OfferCatalog.

Practically, que signifie the itemListElement + position mechanics vous utiliser pour a carousel are literally the même ones vous utiliser pour breadcrumbs — seulement the outer @type (BreadcrumbList vs. plain ItemList) and the semantic objectif modifier. Google frames breadcrumbs the même façon: to specify breadcrumbs, vous define a BreadcrumbList containing at least two ListItems. Si you’ve implemented un, vous déjà comprendre the autre. (The breadcrumb side of ce family lives in its propre deep dive, and the visible carousel result is the subject of a sibling carousel piece — les deux sit in ce même structured-data sub-cluster.)

Implementation requirements and courant validation échecs

La plupart carousel/ItemList échecs come bas to a handful of documented rules:

• Minimum item count. Google exige the itemListElement array to contain two or plus ListItem elements pour the classic carousel (three or plus pour the beta). Un item n’est pas a liste.
• Same-type rule (classic carousel) — the frequent réel causer of échecs. Google: “Tout items in the liste doit be of the même type. Par exemple, si a liste is à propos de recipes, seulement inclure Recipe items. Don’t mix différent types.” A liste que mixes Recipes and Products won’t validate as a classic carousel. Ce rule is spécifique to the classic program — the beta ci-dessus explicitly permits mixing entity types, so don’t carry the same-type assumption over quand that’s the program you’re targeting.
• Visible-content parity. A general structured-data policy that’s appelé out specifically ici: the text visible to the utilisateur doit be similaire to the information in the structured données. Vous pouvez’t mark up items que aren’t genuinely represented in the visible page.
• Same-domain URLs. A host carousel montre cards from the même site; the item URLs devrait be on votre propre domain.
• Standard structured-data hygiene s’applique. JSON-LD is Google’s recommended format, tout requis properties pour votre companion type doit be présent (“Items que are manquant requis properties ne sont pas eligible pour résultats enrichis”), and vous doit pas block the marked-up pages from Googlebot via robots.txt or noindex. Ces are the même general guidelines que govern every rich-result type — the broader structured-data hub covers les in complet.

Fait ItemList schema affecter rankings? (Aucun.)

Short réponse: aucun. Données structurées n’est pas a ranking factor, and que inclut ItemList. Ce is Google’s consistent, repeated position. At Search Central Live APAC 2025, Gary Illyes made the point que “excessive or redundant schema seulement adds page bloat and has aucun additional ranking benefits,” framing schema as an aid to entity understanding and machine fonctionnalités — explicitly pas partie of the ranking traiter. Google’s standing position à travers recent années is the même: données structurées n’est pas a ranking signal, and même in cas of structured-data misuse the consequence is loss of rich-result eligibility (via a manual action), pas a ranking penalty.

Où fait the valeur come from, alors? Two places: rich-result eligibility (a carousel peut lift click-through, pas position) and machine understanding. On the second point, John Mueller — speaking personally, and explicitly “not official guidance” — noted in early 2026 que some fonctionnalités genuinely benefit from données structurées, giving the exemple que “pricing, shipping, availability pour shopping is basically impossible to lire in élevé fidelity & accurately from a text page.” That’s the honest frame: ItemList helps machines comprendre a structured liste; it ne fait pas rank it plus élevé.

ItemList vs. CollectionPage — a rapide disambiguation

Ces obtenir confused parce que les deux appliquer to “listing” pages, but ils réponse différent questions. ItemList describes an ordered liste of discrete items — the entries and leur positions. CollectionPage is a page type que represents a themed collection; it’s à propos de page-level semantics (“this page is a collection of things”) plutôt que the ordering of spécifique liste items. They’re pas mutually exclusive — a category page peut be a CollectionPage que aussi contient an ItemList of its products — but reach pour ItemList quand ce que vous vouloir to express is “here are the ranked items,” and CollectionPage quand vous vouloir to express “ce page is a curated collection.”

Où ce fits

ItemList is a deep dive sous the broader données structurées hub, alongside the sibling pieces on the visible carousel rich result (ItemList’s principal Google application) and on BreadcrumbList (formally a subtype of the very même mechanism). Pour the fundamentals que govern every type ici — the schema.org vocabulary, JSON-LD, the “not a ranking factor” spine, and the shrinking liste of pris en charge résultats enrichis — voir the Données structurées hub. Que sub-cluster lives à l’intérieur the broader on-page SEO cluster.

AI summary

A condensed prendre on the Avancé version:

• ItemList = a generic schema.org liste container. “A list of items of any sort.” itemListElement (the entries, usually ListItem) + a 1-fondé position do the fonctionner; itemListOrder and numberOfItems are lesser-used extras (numberOfItems matters pour paginated listes).
• ItemList n’est pas a rich result by itself. Google’s Carousel is construit on top of it and seulement fires with a pris en charge companion type. Ce container-vs-rich-result distinction is the top misconception.
• Classic Carousel pris en charge types: Course liste, Movie, Recipe, Restaurant — pair un with ItemList to be eligible (jamais guaranteed).
• Carousels (Beta) is a separate, newer program: LocalBusiness/Product/Event, geo-gated to the EEA, Turkey, and South Africa, minimum three entities. Pas globally disponible.
• Two implementation patterns: summary-page (ListItems with simplement @type/position/url, detail markup on separate pages) and all-in-one (chaque ListItem nests the complet item).
• BreadcrumbList is a formal SUBTYPE of ItemList (with HowToSection, HowToStep, OfferCatalog). Breadcrumbs and carousels share the exact même itemListElement/position mechanics.
• Rules que causer la plupart échecs: 2+ items (3+ beta), tout the même type on the classic carousel (the beta permet mixing), and markup doit match visible content.
• Pas a ranking factor. Illyes (2025): redundant schema is “page bloat” with “aucun additional ranking benefits.” Valeur = rich-result eligibility + machine understanding; misuse costs eligibility, pas rankings. Mueller (personally, “not official guidance”) notes schema helps pour hard-to-parse données comme pricing/availability.
• ItemList vs. CollectionPage: ItemList = an ordered liste of discrete items; CollectionPage = une page type pour a themed collection. Pas mutually exclusive.

Documentation officielle

Primary-source documentation from Google and schema.org.

Google

• Carousel (ItemList) Données structurées — the classic host carousel: pris en charge types (Course liste, Movie, Recipe, Restaurant), the summary-page vs. all-in-one patterns, the 2+ items and same-type rules.
• Carousels (Beta) Données structurées — the newer, geo-gated program (LocalBusiness/Product/Event; EEA, Turkey, South Africa; 3+ entities).
• Breadcrumb (BreadcrumbList) Données structurées — the breadcrumb application of the même ItemList mechanism.
• Données structurées General Guidelines — the policies que appliquer to ItemList as to every type: visibility, accuracy, requis properties, aucun robots.txt/noindex blocking.

schema.org

• ItemList — the type itself: the definition, the HTML-list distinction, itemListElement/itemListOrder/numberOfItems, and the “More specific Types” liste confirming the subtypes.
• BreadcrumbList — confirms, from the autre direction, que BreadcrumbList is an ItemList.
• ListItem — the entry type que carries position, url, and item.

Quotes from the source

On-the-record statements from Google and schema.org. Où une page exposes the text, the lien is a deep lien que jumps to the quoted passage.

schema.org — ce que ItemList is

• “A list of items of any sort—for example, Top 10 Movies About Weathermen, or Top 100 Party Songs.” — schema.org, ItemList. Jump to quote
• “Not to be confused with HTML lists, which are often used only for formatting.” Jump to quote
• On itemListElement: “For itemListElement values, you can use simple strings (e.g. ‘Peter’, ‘Paul’, ‘Mary’), existing entities, or use ListItem.” Jump to quote

schema.org — BreadcrumbList is an ItemList

• “A BreadcrumbList is an ItemList consisting of a chain of linked Web pages, typically described using at least their URL and their name, and typically ending with the current page.” — schema.org, BreadcrumbList. Jump to quote

Google — the same-type rule

• “All items in the list must be of the same type. For example, if a list is about recipes, only include Recipe items. Don’t mix different types.” — Recherche Google Central, Carousel documentation. Jump to quote

Gary Illyes, Google (Search Central Live APAC 2025, via Moteur de recherche Journal’s write-up)

• Excessive or redundant schema “only adds page bloat and has no additional ranking benefits” — schema helps entity understanding and machine fonctionnalités, but n’est pas partie of the ranking traiter. Lire the coverage

John Mueller, Google (Reddit, reported Jan 2026 by Moteur de recherche Roundtable — explicitly framed as personal opinion, “not official guidance”)

• On où schema genuinely helps: “Pricing, shipping, availability for shopping is basically impossible to read in high fidelity & accurately from a text page, for example.” Lire the coverage

ItemList — cheat sheet

The properties

Classic Carousel vs. Carousels (Beta)

The rules que break validation

• Fewer que the minimum items (2 classic / 3 beta).
• Mixed item types on the classic carousel — tout items doit be the même type là (the beta permet mixing).
• Markup que doesn’t match visible on-page content.
• Item URLs off votre propre domain (host carousels are same-site).
• Manquant requis properties on the companion type.

Fast facts

• ItemList alone is pas a rich result — vous besoin a pris en charge companion type pour a carousel.
• BreadcrumbList is a subtype of ItemList (with HowToSection, HowToStep, OfferCatalog).
• Pas a ranking factor — valeur is eligibility + machine understanding.
• JSON-LD is Google’s recommended format.
• ItemList vs. CollectionPage: ordered liste of items vs. a themed-collection page type.

Do I besoin ItemList — and va it obtenir me a carousel?

Fonctionner bas the questions; chaque réponse points vous to the correct déplacer.

1. Is votre page genuinely a liste of discrete, ranked/ordered items?

• Aucun → ItemList isn’t the correct type. Si lune page is a themed collection, regarder at CollectionPage à la place. Si it’s a breadcrumb trail, that’s BreadcrumbList (a subtype of ItemList, but with its propre requis shape).
• Yes → continuer.

2. Are ceux items un of the carousel-supported types?

• Course liste / Movie / Recipe / Restaurant → you’re eligible pour the classic Carousel (global). Continuer to 3.
• LocalBusiness / Product / Event → vous pouvez seulement obtenir a carousel via the Carousels (Beta) program, qui is limited to the EEA, Turkey, and South Africa and nécessite 3+ entities. Elsewhere, votre ItemList encore helps machine understanding but won’t produce a carousel.
• Anything sinon (blog posts, generic “Top 10”) → plain ItemList is fine pour structure and understanding, but it va pas produce a carousel rich result. Don’t expect un.

3. Do vous have separate detail pages pour chaque item?

• Yes → utiliser the summary-page pattern: chaque ListItem nécessite seulement @type, position, and url; put the complet companion-type markup on chaque detail page.
• Aucun, everything’s on un page → utiliser the all-in-one pattern: chaque ListItem nests the complet item markup.

4. Final eligibility checks avant vous expect a carousel:

• 2+ items (3+ pour the beta)? · Tout the même type (classic seulement — the beta permet mixing)? · Markup matches visible content? · Item URLs on votre propre domain? · Requis companion-type properties présent? · Page pas blocked by robots.txt/noindex?
• Tout yes → you’re eligible. Remember Google encore decides si to en réalité render it — résultats enrichis are jamais guaranteed.

Reality vérifier: none of ce lifts rankings. The upside is a possible carousel (meilleur click-through) and cleaner machine understanding — pas a plus élevé position.

Courant ItemList/carousel problems and Comment corriger les

Symptom-cause-fix lookups pour the situations que en réalité arrêter a carousel from appearing, or que break the BreadcrumbList side of the même mechanism.

The markup validates clean, but aucun carousel ever apparaît

Probable causer: ItemList by itself n’est pas a rich result — a carousel seulement fires quand ItemList is paired with a pris en charge companion type (Course liste, Movie, Recipe, Restaurant pour the classic carousel; LocalBusiness/Product/Event pour the geo-gated beta). Si lune page’s items are a type outside ceux listes (a generic “Top 10 blog posts,” pour instance), the ItemList is doing its job pour machine understanding but was jamais going to produce a carousel. Fix: confirmer the companion type is un of the pris en charge ones pour the program you’re targeting; si it isn’t, don’t expect a carousel — remember que même entièrement eligible markup seulement rend vous eligible, jamais guaranteed, since Google encore decides si to render it.

The liste validates but Google flags a same-type or count error

Probable causer: the two la plupart courant structural échecs — mixing item types on the classic carousel (“Tout items in the liste doit be of the même type… Don’t mix différent types”) or having fewer que the minimum (2+ pour the classic carousel, 3+ pour the beta). Si you’re targeting the beta à la place, mixed types aren’t votre problem — Google’s beta docs explicitly autoriser mixing entity types quand the scenario calls pour it. Fix: pour the classic carousel, vérifier every ListItem in itemListElement is the même schema.org type; pour the beta, skip que vérifier and confirmer the entry count contre the correct minimum pour the program you’re pairing with à la place.

The carousel doesn’t render même though item count and type are correct

Probable causer: visible-content parity — the text visible to the utilisateur doit be similaire to the information in the données structurées, and the item URLs devrait be on votre propre domain pour a host carousel. A liste que marks up items pas genuinely represented on the visible page, or que points at off-domain URLs, fails ce general structured-data policy même quand the ItemList shape itself is technically correct. Fix: vérifier chaque marked-up item is genuinely visible on lune page (or, in the summary-page pattern, que chaque detail page carries the complet companion-type markup) and que URLs resolve on votre propre domain, alors re-validate.

Breadcrumbs (or un autre ItemList subtype) échouer the même façon

Probable causer: parce que BreadcrumbList is formally a subtype of ItemList sharing the même itemListElement/position mechanics, the même structural mistakes — aussi few items, mismatched visible content — break breadcrumb eligibility aussi. Fix: appliquer the même checks (minimum items, visible-content match) to the BreadcrumbList markup as vous voudrait to a carousel ItemList; si you’ve debugged un, vous déjà know how to debug the autre.

Worked exemples: the two ItemList patterns

The article ci-dessus describes summary-page and all-in-one patterns in prose seulement — here’s ce que chaque en réalité semble comme as JSON-LD, plus how BreadcrumbList reuses the exact même shape.

Pattern 1 — summary page + separate detail pages

Chaque ListItem carries seulement @type, position, and url; the complet Recipe/Movie/etc. markup lives on the lié detail page, pas ici.

{
  "@context": "https://schema.org",
  "@type": "ItemList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "url": "https://example.com/recipes/lemon-bars"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "url": "https://example.com/recipes/banana-bread"
    }
  ]
}

• position is 1-fondé, pas 0-fondé.
• url is l’URL canonique of que item’s propre detail page — the Recipe object itself is marked up over là, pas nested ici.
• Ce shape nécessite 2+ entries pour the classic carousel (3+ pour the beta), and every entry doit be the même companion type on the far fin.

Pattern 2 — all-in-one page (aucun separate detail pages)

Everything lives on un page, so chaque ListItem nests the complet item object à la place of simplement a url.

{
  "@context": "https://schema.org",
  "@type": "ItemList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "item": {
        "@type": "Recipe",
        "name": "Lemon Bars",
        "url": "https://example.com/recipes#lemon-bars"
      }
    },
    {
      "@type": "ListItem",
      "position": 2,
      "item": {
        "@type": "Recipe",
        "name": "Banana Bread",
        "url": "https://example.com/recipes#banana-bread"
      }
    }
  ]
}

• Utiliser ce quand there’s aucun dedicated detail page per item — the whole companion-type object (Recipe ici) nests sous item.
• Les deux items are Recipe — mixing in a Product or Movie ici voudrait break the same-type rule and disqualify the whole liste from carousel eligibility.

How BreadcrumbList reuses the même mechanism

BreadcrumbList is formally a subtype of ItemList — même itemListElement/position shape, simplement a différent outer @type and semantic objectif:

{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Recipes",
      "item": "https://example.com/recipes/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Lemon Bars"
    }
  ]
}

• Google exige au moins two ListItems pour a breadcrumb trail — the même “2+ items” mechanic as the classic carousel, simplement applied to page hierarchy à la place of content items.
• The final crumb (the current page) typically omits item, since it has aucun plus loin lien target.

Outils pour checking ItemList and carousel eligibility

• Rich-Result Eligibility Checker — paste votre JSON-LD, an HTML page, or récupérer a live URL and voir, per type, qui of Google’s résultats enrichis it qualifies pour, notamment the Breadcrumb fonctionnalité ce article establishes as a subtype of ItemList — it flags the exact manquant requis field plutôt que simplement a generic réussir/échouer, qui is the fastest façon to voir si a BreadcrumbList (or a carousel companion type) is en réalité eligible.
• Balisage de données structurées Validator — paste or récupérer votre JSON-LD and run it via severity-tiered structured-data validation: schema.org vocabulary checks, Google’s rich-result requirements, and cross-block @id graph checks, with a corrected copy-pasteable JSON-LD block back. Utile pour catching the same-type mismatches and missing-property errors que are the la plupart courant causer of ItemList/carousel validation échecs.
• Google’s Résultats enrichis Tester — Google’s propre eligibility checker; a bon second opinion une fois the two outils ci-dessus come back clean, since it reflects Google’s live parsing plutôt que a third-party interpretation of the spec.

Confirming an ItemList/carousel modifier en réalité took effect

The checks ci-dessous prove a spécifique ItemList or BreadcrumbList modifier fonctionne, in the order to run les, with the signal que signifie “undo this.”

Confirmer the JSON-LD parses and hits the correct eligibility bar

Tester to run: paste the mis à jour JSON-LD into the Rich-Result Eligibility Checker or the Balisage de données structurées Validator. Attendu result: the companion type (Recipe, Movie, Course liste, Restaurant, or the beta’s LocalBusiness/Product/Event) montre as eligible, with aucun missing-required-property errors and aucun same-type mismatches flagged. Échec interpretation: a flagged manquant property signifie the companion type’s propre requis fields aren’t présent yet; a same-type warning signifie the itemListElement array mixes types, qui disqualifies the whole liste. Monitoring window: immediate — ce is a point-in-time parse vérifier, re-run correct après quelconque markup edit. Rollback trigger: si the checker reports nouveau eligibility errors que weren’t là avant the modifier, revert to the dernier known-passing JSON-LD pendant que vous investigate.

Confirmer the item and minimum-count rules hold

Tester to run: count the ListItem entries in itemListElement and vérifier chaque one’s @type (on the nested item, or on the lié detail page pour the summary-page pattern) contre the same-type rule. Attendu result: 2 or plus entries pour the classic carousel (3 or plus pour the beta), and every entry resolving to the identical companion type. Échec interpretation: fewer entries que the minimum, or a mixed-type liste, signifie the ItemList is structurally valid JSON-LD but encore won’t qualify pour a carousel. Monitoring window: immediate — ce is a static structural vérifier contre the current markup. Rollback trigger: si a content modifier drops the liste ci-dessous the minimum count, treat que as a regression and restore the supprimé items or pull the carousel-targeting markup jusqu’à the count is back up.

Confirmer Google en réalité renders the fonctionnalité (pas simplement eligibility)

Tester to run: run the live page via Google’s Résultats enrichis Tester, alors watch Search Console’s Enhancements report pour the relevant carousel or breadcrumb fonctionnalité over the suivant weeks. Attendu result: Résultats enrichis Tester confirms the fonctionnalité is detected with aucun errors, and the Enhancements report montre valid items with aucun nouveau warnings. Échec interpretation: eligibility passing in a third-party outil but Google’s propre tester or Search Console showing errors usually signifie a policy problème (visible-content mismatch, blocked page) plutôt que a markup syntax problem. Monitoring window: a carousel’s réel appearance in search results is jamais guaranteed même quand eligible, so treat 2–4 weeks of Search Console données as the point où vous pouvez judge si the fonctionnalité is being picked up at tout. Rollback trigger: si Search Console starts reporting a rising error count pour ce item type après the modifier, revert the markup to the dernier version que showed zero errors.

Ressources utiles

My connexe writing

• Données structurées: Ce que c’est and Comment utiliser It — my Ahrefs guide to schema types, implementation méthodes, validation outils, and the sameAs entity angle; the broader context ItemList sits à l’intérieur.
• The Beginner’s Guide to SEO technique — où données structurées (and listes comme ce) fit in the bigger picture.

My speaking

• How Search Fonctionne (SlideShare) — my walkthrough of exploration, rendering, indexation, and ranking, pour the context of où markup comme ItemList fait and doesn’t déplacer the needle. (My standing disclaimer s’applique: “This is my understanding of systems… not going to be 100% complete or accurate.”)

Official

• Google — Carousel (ItemList) Données structurées and Carousels (Beta) — the two carousel programs, leur pris en charge types, and requirements.
• Google — Données structurées General Guidelines — the policies every rich-result type (ItemList inclus) has to satisfy.
• schema.org — ItemList and BreadcrumbList — the type definitions, and the subtype relationship confirmed from les deux directions.

From autour the industry

• Recherche Google Central APAC 2025: Everything From Day 2 (Moteur de recherche Journal) — Gary Illyes on schema, ranking, and “page bloat.”
• John Mueller (Personally) On Si Schema Helps With LLMs & Google (Moteur de recherche Roundtable, Jan 2026) — Mueller’s personal, non-official prendre on où données structurées genuinely helps.
• Ce que Is ItemList Schema? A Complet Guide (Greadme) — a solid third-party walkthrough of carousel eligibility conditions and the two implementation patterns.
• ItemList Schema (Rank Math KB) — plugin-oriented référence que separates “ItemList” from “Carousel” and covers les deux use-case patterns.

Testez vos connaissances: ItemList Schema

Five rapide questions on ce que ItemList is — and isn’t. Pick an réponse pour chaque, alors vérifier.

Journal des modifications