Carousel Rich Results (Schema)

TL;DR — A carousel rich resultA carousel rich result (Google calls it a \"host carousel\") is a horizontally scrollable row of cards, all from one site, built by wrapping two or more same-type items in an ItemList with position values. Only a short, shifting list of schema.org types qualifies — and a second, geographically limited beta carousel system now runs alongside the original. is that swipeable row of cards you sometimes see in Google, all coming from one website. You build it by wrapping several items of the same kind — say, several recipes — in a bit of code called an ItemList, giving each one a number (position) so they show up in order. The catch: only a short, specific list of content types can become a carousel, and a valid ItemList on its own does not guarantee you’ll get one.

What a carousel rich result is

When you search Google and see a row of cards you can scroll sideways through — a strip of recipes, a strip of movies — that’s a carousel rich result. Google’s own name for it is a host carousel, because every card comes from the same host (the same website). Google describes it as “a list-like rich result that people can swipe through on mobile devices.”

You create one with a piece of structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. called an ItemList — think of it as a container that holds a list. Inside it you put each item as a ListItem, and each ListItem gets a position number (1, 2, 3…) that tells Google what order to show them in. If you’ve read the structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. basics, this is just one specific rich result you can earn with that markup.

The one thing to get right first

Here’s the trap: an ItemList by itself doesn’t make a carousel. You can’t just list any old pages and get a swipeable strip. The ItemList has to be paired with a content type that Google actually supports for carousels. For the main, everyday carousel feature, that’s a short list: Course listsCourse schema (schema.org/Course) marks up educational courses for Google's 'Course list' carousel — which requires at least three courses marked up together, not a single-course card. A richer single-course 'Course Info' feature existed but was deprecated in June 2025., Movies, Recipes, and Restaurants. Wrap anything else — a bunch of blog posts, generic products — and you’ll get a valid ItemList, but no carousel.

A few plain rules

• Use the same type in one list. A recipe carousel should contain only recipes. Don’t mix recipes and courses in the same list.
• You need at least two items for the classic carousel (the newer “beta” one needs three — more on that in the Advanced tab).
• position sets the order. Number your items and Google shows them in that order.
• Not every scrollable row is yours to control. Some carousel-like strips in Google (like “Top Stories”) pull from many sites and you can’t trigger those with your markup at all.

And the honest caveat that applies to every rich result: even with perfect markup, Google decides whether to actually show it. Valid markup makes you eligible, not guaranteed.

Want the full picture — the two different carousel systems, exactly which types qualify for each, the geography catch, and the required properties? Switch to the Advanced tab.

TL;DR — A carousel rich resultA carousel rich result (Google calls it a \"host carousel\") is a horizontally scrollable row of cards, all from one site, built by wrapping two or more same-type items in an ItemList with position values. Only a short, shifting list of schema.org types qualifies — and a second, geographically limited beta carousel system now runs alongside the original. (“host carousel”) is an ItemList wrapping two or more same-type ListItems, each with a 1-based position that fixes display order. The accuracy spine: valid ItemList ≠ visible carousel — ItemList is only carousel-eligible when combined with a supported type. There are two separate carousel systems live right now: the mature, generally available Carousel (ItemList) feature (Course listCourse schema (schema.org/Course) marks up educational courses for Google's 'Course list' carousel — which requires at least three courses marked up together, not a single-course card. A richer single-course 'Course Info' feature existed but was deprecated in June 2025., Movie, Recipe, Restaurant — Restaurant is limited-access, sign-up-gated) and the newer Structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. carousels (beta) / host carousel (LocalBusiness subtypes, Product, Event), available only in the EEA, Turkey, and South Africa. They differ on minimum items (2 vs 3), same-type- only vs mixed-types-allowed, and page-structure options (classic supports summary

• detail or all-in-one; beta supports summary + detail only). It’s a display format, not a ranking guarantee; other search engines document their own features separately.

What a carousel rich result actually is

Google’s definition is exact: “A carousel is a list-like rich result that people can swipe through on mobile devices. It displays multiple cards from the same site (also known as a host carousel).” The mechanism underneath is always the same — an ItemList container holding multiple ListItem entries, each pointing at an item of a supported type, each carrying a position. Google is explicit that order follows position: “The item’s position in the carousel. This is a 1-based number,” and items “will be shown in the order specified by the position property.”

The generic mechanics of ItemList — its properties, the summary-page pattern, how position and url work — are a topic in their own right; the sibling ItemList schema deep dive owns those. This page is about the specific thing ItemList unlocks: the carousel rich result. And the first rule of that is a myth-buster.

Valid ItemList is not a visible carousel

This is the accuracy spine. An ItemList on its own — or an ItemList wrapping an unsupported type like generic Article or BlogPosting — is not carousel- eligible. Google’s requirement is that you “add ItemList structured data in combination with one of the… supported structured data features.” The ItemList is necessary but nowhere near sufficient. This is where most guides go wrong, and it’s also why the creative works schema\"Creative Works schema\" is a practitioner label for the schema.org CreativeWork subtypes used to mark up authored content — Article, AudioObject, Book, Course, Dataset, Movie, Recipe, and VideoObject. hub keeps hammering “valid is not visible” — the same principle, applied here.

There are two carousel systems right now

Almost no competing guide separates these cleanly, and that’s the single biggest source of confusion in this space. As of mid-2026 there are two differently-scoped carousel systems live in Google Search:

1. The classic Carousel (ItemList) — generally available

The mature feature, documented on the Carousel (ItemList) page (last updated 2025-12-10 UTC). Google’s supported-type rule: “To be eligible for a host carousel rich result for your site, add ItemList structured data in combination with one of the following supported structured data features: Course list / Movie / Recipe / Restaurant.” Minimum items: “Check that itemListElement contains two or more ListItem elements.” Same type only: “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.”

2. Structured data carousels (beta) — EEA, Turkey, South Africa only

A newer, separate system documented on the Carousels (beta) page (last updated 2026-01-21 UTC — the more actively iterated of the two). Google: “a new carousel rich result that’s in beta, which is a list-like rich result that people can scroll horizontally to see more entities from a given site.” Its type set is completely different: ItemList combined with LocalBusiness and its subtypes (Restaurant, Hotel, VacationRental), Product, or Event. Its minimum is three, not two: “To specify a list, define an ItemList that contains at least three itemListElement.item elements.” And the constraint that matters more than any on-page detail: “This feature is also only available in European Economic Area (EEA) countries, Turkey, and South Africa, on both desktop and mobile devices.” Sites also have to apply via an interest form, not just implement markup, and coverage differs by country. Google flags it as provisional: “This feature is in beta and you may see changes in requirements or guidelines, as we develop this feature.”

Side-by-side

Which types are eligible for the classic carousel (2026)

I re-checked Google’s docs on 2026-07-02, and the master Search Gallery page (last updated 2026-06-15 UTC) corroborates the same four-type rule: “This feature must be combined with one of the following features: Recipe, Course list, Restaurant, Movie.” But there’s an asterisk on that list:

• Recipe, Course list, and Movie are open to any qualifying site. (For the individual-type detail — Course being a 3+-course carousel only since the June 2025 single-card deprecation, and Movie’s carousel being mobile-only — see the creative works schema\"Creative Works schema\" is a practitioner label for the schema.org CreativeWork subtypes used to mark up authored content — Article, AudioObject, Book, Course, Dataset, Movie, Recipe, and VideoObject. hub, which documents each type’s rich result at the property level.)
• Restaurant is listed but gated. The Local Business doc spells it out: “The Restaurant carousel is currently limited to a small set of restaurant providers. If you would like to participate, register your interest in our form.” So treating Restaurant as a fourth open-door type — as several third-party guides now do, having copied the updated type list without checking the gating — is a real, checkable inaccuracy. It’s supported on paper, sign-up-only in practice.

And the type that is not on the list: Article. At least one top-ranking guide lists Article as carousel-eligible. It isn’t — Article appears on neither the Carousel doc nor the master gallery. That’s almost certainly confusion with the unrelated, Google-controlled Top Stories feature, which you can’t trigger with your own markup.

Which types are eligible for the beta host carousel

Completely different set, per the beta doc: LocalBusiness and its subtypes (the doc names Restaurant, Hotel, VacationRental), Product, and Event. The beta also explicitly permits mixing — a genuine structural difference from the classic carousel: “You can mix and match different types of entities (for example, hotels, restaurants), if needed for your scenario.” Think a “Things to do in Switzerland” page listing both local events and local businesses in one carousel.

Availability is the gotcha, and it’s more granular than “EEA + Turkey + South Africa” — which query types are covered varies by country, per the 2026-01-21 doc: the EEA has the widest coverage (hotels, vacation rentals, ground transportation, flights, local businesses, things to do, shopping); Turkey covers only hotels, vacation rentals, and local businesses; South Africa covers hotels, vacation rentals, things to do, flights, shopping, food delivery, car hire, and bus booking. Because this is a beta, treat every one of those per-country lists as dated, not permanent — Google explicitly flags the feature as subject to change. If your audience is outside those three regions entirely, the beta carousel simply won’t appear no matter how clean your markup is.

How position builds the display order

In both systems, the display-order mechanism is the same: each ListItem carries a 1-based position, and Google promises order-in-markup equals order-on-screen. Two page-structure patterns exist for the classic carousel:

• Summary page + detail pages. The summary page’s ItemList holds minimal ListItems (@type, position, url), and each linked detail page carries the full type-specific markup (e.g., complete Recipe schema). Google’s constraint: “all URLs in the list must point to different pages on the same domain.”
• Single all-in-one page. One page contains the full ItemList with each item’s properties embedded, and each ListItem.url points to an anchor on that same page.

The beta only supports the summary + detail pattern — no all-in-one option. And a useful clarification Google added after early ambiguity: for the beta, “the markup must be on the summary page, and you don’t need to add markup to the detail pages in order to be eligible for this feature.”

Eligibility requirements and the honest caveats

• Content parity. Google’s standard anti-cloaking rule applies: “The text visible to the user must be similar to the information contained in the structured data on the page.”
• Same type (classic) vs mixed (beta) — covered above; it’s structural, not cosmetic.
• Eligibility, not entitlement. Passing the Rich Results Test confirms syntax, not display. Google never guarantees a rich result will render, and it checks content/guideline compliance separately from syntax. If your markup validates but no carousel shows, that’s expected behavior, not a bug.
• Not a ranking factor. This is a display format, not a ranking signal — consistent with Google’s general position that structured data doesn’t affect ranking. I won’t claim it lifts click-through either: that’s a common assumption in the SEO community, but Google doesn’t publish CTR data for carousel placements and I don’t have measured data of my own to back it, so treat any “carousels boost CTR” line (including in earlier versions of this article) as an unverified assumption, not a documented effect.
• No Bing equivalent. Bing reads ItemList as generic structured data but has no documented host-carousel SERP featureSERP features are any element on a search results page beyond the classic ten blue links — featured snippets, People Also Ask, knowledge panels, sitelinks, image and video packs, AI Overviews, and structured-data-driven rich results. Google documents that losing rich-result eligibility doesn't affect ranking; their SEO relevance is CTR (they redistribute clicks). Some are unlocked by markup; most are purely algorithmic.. Don’t imply cross-engine parity.

Where this sits

Carousel rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. are one specific payoff of structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding., inside the broader on-page SEO cluster. The generic ItemList mechanics (its properties, the summary-page pattern in full) live in the sibling ItemList schemaItemList is a schema.org type — a generic container for an ordered or unordered list of items ('a list of items of any sort'). Two properties do most of the work: itemListElement (the array of entries, usually ListItem objects) and position (a 1-based rank on each item). It's the underlying mechanism Google's Carousel rich result is built on, and BreadcrumbList is formally a subtype of it — but ItemList by itself is not a rich result and doesn't affect rankings. deep dive; the per-type rich-result detail for Course, Movie, Recipe, and Restaurant lives in creative works schema\"Creative Works schema\" is a practitioner label for the schema.org CreativeWork subtypes used to mark up authored content — Article, AudioObject, Book, Course, Dataset, Movie, Recipe, and VideoObject. and the local-business docs. This page owns the carousel mechanism — the two systems, the eligible-type lists, and the “valid ItemList is not a visible carousel” rule.

AI summary

A condensed take on the Advanced version:

• What it is: a carousel rich resultA carousel rich result (Google calls it a \"host carousel\") is a horizontally scrollable row of cards, all from one site, built by wrapping two or more same-type items in an ItemList with position values. Only a short, shifting list of schema.org types qualifies — and a second, geographically limited beta carousel system now runs alongside the original. (“host carousel”) is an ItemList wrapping two or more ListItems of a supported type, each with a 1-based position that fixes display order. Order in markup = order on screen.
• Accuracy spine: valid ItemList ≠ visible carousel. ItemList is only carousel-eligible when combined with a supported type. Wrapping generic Article or BlogPosting produces valid markup and no carousel.
• Two separate systems:
  • Classic Carousel (ItemList) — generally available; types = Course listCourse schema (schema.org/Course) marks up educational courses for Google's 'Course list' carousel — which requires at least three courses marked up together, not a single-course card. A richer single-course 'Course Info' feature existed but was deprecated in June 2025., Movie, Recipe, Restaurant; 2+ items; same type only; summary+detail or all-in-one page.
  • Structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. carousels (beta) — EEA, Turkey, South Africa only; types = LocalBusiness subtypes, Product, Event; 3+ items; mixed types allowed; summary+detail only; must apply via a form.
• Restaurant is gated: listed as a classic type but limited-access, sign-up- only — not equally open like Recipe/Course/Movie.
• Article is NOT a carousel type — a common myth, likely confused with Google’s own uncontrollable Top Stories feature.
• Caveats: eligibility ≠ entitlement (Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test checks syntax, not display); not a ranking factor (a display format — any CTR lift is an unverified assumption, not something Google documents or confirms); Bing has no equivalent.
• Where it sits: the generic ItemList mechanics live in the sibling ItemList deep dive; per-type detail (Course 3+-carousel-only since June 2025, Movie mobile- only) lives in the creative works hub. This page owns the carousel mechanism.

Official documentation

Primary-source documentation from Google.

Google — the two carousel systems

• Carousel (ItemList) structured data — the classic, generally available feature: the four-type combination rule, the 2-item minimum, same-type rule, position, and the two page-structure patterns. (Last updated 2025-12-10 UTC.)
• Structured data carousels (beta) — the newer host carousel: LocalBusiness/Product/Event types, the 3-item minimum, mixed-types allowance, EEA/Turkey/South Africa restriction, and the interest forms. (Last updated 2026-01-21 UTC.)

Google — supporting docs

• Local business (LocalBusiness) structured data — where the “Restaurant carousel (limited access)” gating actually lives.
• Structured Data Markup that Google Search Supports (Search Gallery) — the master list corroborating the four classic-carousel types. (Last updated 2026-06-15 UTC.)
• Course list structured data and Movie structured data — the individual-type docs for two of the classic carousel members.
• Rich Results Test — validates carousel markup syntax (not display).

Bing / Microsoft

• Marking Up Your Site with Structured Data — Bing Webmaster Help — Bing supports ItemList as general structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding.; there is no Bing carousel-specific rich result.

Quotes from the source

On-the-record statements from Google. Each link is a deep link that jumps to the quoted passage on the source page.

Google — what a carousel is, and how position works

• “A carousel is a list-like rich result that people can swipe through on mobile devices. It displays multiple cards from the same site (also known as a host carousel).” — Google Search Central, Carousel (ItemList) docs. Jump to quote
• “The item’s position in the carousel. This is a 1-based number.” Jump to quote

Google — the classic type list and minimums

• “Check that itemListElement contains two or more ListItem elements.” Jump to quote
• “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.” Jump to quote
• Master gallery, on the four eligible types: “This feature must be combined with one of the following features: Recipe, Course listCourse schema (schema.org/Course) marks up educational courses for Google's 'Course list' carousel — which requires at least three courses marked up together, not a single-course card. A richer single-course 'Course Info' feature existed but was deprecated in June 2025., Restaurant, Movie.” Jump to quote

Google — Restaurant is gated (from the Local Business doc)

• “The Restaurant carousel is currently limited to a small set of restaurant providers. If you would like to participate, register your interest in our form.” Jump to quote

Google — the beta carousel (different system)

• “a new carousel rich resultA carousel rich result (Google calls it a \"host carousel\") is a horizontally scrollable row of cards, all from one site, built by wrapping two or more same-type items in an ItemList with position values. Only a short, shifting list of schema.org types qualifies — and a second, geographically limited beta carousel system now runs alongside the original. that’s in beta, which is a list-like rich result that people can scroll horizontally to see more entities from a given site (also known as a host carousel).” Jump to quote
• “This feature is also only available in European Economic Area (EEA) countries, Turkey, and South Africa, on both desktop and mobile devices.” Jump to quote
• “To specify a list, define an ItemList that contains at least three itemListElement.item elements.” Jump to quote

Which carousel — if any — can I get?

Carousel eligibility is genuinely a “which path am I on?” question, because the two systems don’t overlap. Walk it once for your content and region.

Carousel rich results — cheat sheet

The two systems at a glance

Fast facts

• ItemList alone ≠ carousel. Must be combined with a supported type.
• position is 1-based and sets display order in both systems.
• Restaurant is gated — “limited to a small set of restaurant providers”; register interest.
• Article is NOT a carousel type. That myth is confusion with Top Stories (Google-controlled, un-triggerable).
• Recipe / Course / Movie are open; per-type quirks: Course = 3+-course carousel only (since June 2025), Movie = mobile-only carousel.
• Eligibility, not entitlement — Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test checks syntax, not display.
• Not a ranking factor — a display format, not a ranking signal; treat any CTR-lift claim as unverified, since Google doesn’t publish carousel CTR data.
• Bing: no equivalent carousel rich resultA carousel rich result (Google calls it a \"host carousel\") is a horizontally scrollable row of cards, all from one site, built by wrapping two or more same-type items in an ItemList with position values. Only a short, shifting list of schema.org types qualifies — and a second, geographically limited beta carousel system now runs alongside the original..

Common myths, corrected

Tools for validating carousel markup

• Schema Markup Validator — paste the JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. or full HTML to catch malformed JSON, invalid schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. properties, missing references, and structural problems in the ItemList before testing Google’s feature-specific requirements.
• Rich-Result Eligibility Checker — check whether the nested item types carry the Google-required fields for the rich result they target. A clean result confirms eligibility rules, not that Google will display a carousel.
• Google Rich Results Test — run the deployed URL through Google’s renderer. Use it to confirm Google can see the supported item markup and required fields in the rendered page.

Broken vs. clean classic-carousel markup

Broken: mixed types, duplicate positions, and only one eligible item

This list parses as JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal., but it fails the classic carousel rules. It mixes a Recipe and a Course, gives both entries position 1, and therefore has only one item of either supported type.

{
  "@context": "https://schema.org",
  "@type": "ItemList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "item": { "@type": "Recipe", "name": "Tomato Soup" }
    },
    {
      "@type": "ListItem",
      "position": 1,
      "item": { "@type": "Course", "name": "Knife Skills" }
    }
  ]
}

Clean: two same-type items with 1-based positions

The corrected list keeps one supported type, supplies two items, and numbers them in the order Google should display them. Each item would still need the properties required by its own rich-result documentation.

{
  "@context": "https://schema.org",
  "@type": "ItemList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "item": { "@type": "Recipe", "name": "Tomato Soup" }
    },
    {
      "@type": "ListItem",
      "position": 2,
      "item": { "@type": "Recipe", "name": "Mushroom Soup" }
    }
  ]
}

For the beta host carousel, the equivalent clean list needs at least three items and must follow the beta’s summary-page and regional requirements.

Prove a carousel implementation is eligible

Test 1 — The deployed ItemList satisfies the correct carousel system

• Test to run — Fetch the live URL with the Rich-Result Eligibility Checker and inspect the ItemList, nested item types, and positions.
• Expected result — A classic carousel has at least two same-type supported items with consecutive 1-based positions. A beta carousel has at least three supported items and follows the beta summary-page pattern.
• Failure interpretation — Fewer items, a classic list that mixes types, duplicate or missing positions, or an unsupported nested type means the page does not meet that carousel system’s eligibility rules.
• Monitoring window — Immediate after deployment and cache clearance.
• Rollback trigger — Remove or disable the new carousel block if it replaced previously valid structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. with invalid or misleading markup; otherwise correct the list before requesting a recrawlCrawl frequency is how often a search engine comes back to re-fetch a page it already knows about. Popular pages that change often get refreshed many times a day; stable pages can go weeks or months between crawls — and you influence it indirectly, not by setting a dial..

Test 2 — Google can render the eligible item markup

• Test to run — Test the deployed URL in Google’s Rich Results Test, then inspect the detected item types and errors.
• Expected result — Google detects the supported nested types without critical errors, and the rendered HTML contains the same ItemList sent to users.
• Failure interpretation — A missing type points to renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. or deployment; a required-field error belongs to the nested Recipe, Course, Movie, Restaurant, Product, Event, or LocalBusiness markup rather than to ItemList alone.
• Monitoring window — Immediate in the test; Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. can lag until the next crawl.
• Rollback trigger — Abort the carousel launch if Google cannot render the markup or if fixing it would require claiming content that is not visible on the page. Passing the test still does not guarantee a carousel will be shown.

Test yourself: carousel rich results

Five quick questions on how Google’s carousel rich resultA carousel rich result (Google calls it a \"host carousel\") is a horizontally scrollable row of cards, all from one site, built by wrapping two or more same-type items in an ItemList with position values. Only a short, shifting list of schema.org types qualifies — and a second, geographically limited beta carousel system now runs alongside the original. actually works. Pick an answer for each, then check.

Resources worth your time

My related writing

• Structured Data: What It Is and How to Use It — my Ahrefs guide to schema typesSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor., implementation methods, and validation tools; the foundation carousel markup sits on.
• The Beginner’s Guide to Technical SEO — where structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. and rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. fit into the bigger picture.

My speaking

• How Search Works (SlideShare) — my walkthrough of crawlingCrawling is how search engines use automated bots (like Googlebot and Bingbot) to discover URLs and download pages. A page has to be crawlable to be indexed, but crawling on its own isn't a ranking factor., renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM., indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed., and how features like rich resultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. are generated. (My standing disclaimer applies: “This is my understanding of systems… not going to be 100% complete or accurate.”)

Official

• Google’s Carousel (ItemList) structured data — the classic feature’s canonical reference (four types, 2-item minimum, position, page patterns).
• Google’s Structured data carousels (beta) — the beta host carousel (LocalBusiness/Product/Event, 3-item minimum, EEA/Turkey/South Africa).
• Google’s Local business structured data — where the “Restaurant carousel (limited access)” gating lives.
• Google’s Search Gallery — the master supported-types list.

From around the industry

• New Google structured data carousels (beta) (Search Engine Land) — coverage of the beta’s launch: horizontal scrolling through multiple entities from a single site.
• Google structured data carousels (beta) clarified for summary pages (Search Engine Land) — the doc clarification that markup goes on the summary page, not the detail pages.
• Google Expands Feature Availability For Structured Data Carousels (beta) (Search Engine Roundtable, Barry Schwartz) — the geographic-expansion pattern (starting narrow, adding Turkey and South Africa).
• Google Announces New Structured Data Carousels (beta) Rich Result (Search Engine Journal) — the announcement write-up.
• Google Updates Carousels (Beta) Structured Data Documentation (Search Engine Journal) — coverage of a later beta-doc revision.
• Carousel Search Results (Rank Math KB) — plugin-workflow-focused explainer of the classic four types (note: doesn’t cover the beta system or the Restaurant gating).

Quotes worth keeping

The lines I come back to when explaining carousels. (For the verbatim Google statements with deep links, see the Quotes from the Source tab — this is the more opinionated, practitioner-facing set.)

On the core mechanism

• A carousel is “a list-like rich result that people can swipe through on mobile devices… multiple cards from the same site (also known as a host carousel).” — Google. The mechanism underneath is always an ItemList of same-type ListItems, each with a 1-based position.

On the myth that trips everyone up

• Valid ItemList is not a visible carousel. Google requires you to “add ItemList structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. in combination with one of the… supported structured data features.” Wrap an unsupported type and you get valid markup and no carousel — the same “valid is not visible” trap I keep flagging across the structured-data cluster.

On the two-systems confusion

• There are two carousels, not one: the generally available classic Carousel (ItemList) for Course/Movie/Recipe/Restaurant, and a separate beta host carousel for LocalBusiness/Product/Event that’s “only available in European Economic Area (EEA) countries, Turkey, and South Africa.” Almost every guide covers one and forgets the other.

On the Restaurant asterisk

• Restaurant is listed but gated: “The Restaurant carousel is currently limited to a small set of restaurant providers.” Supported on paper, sign-up-only in practice.

carousel rich result

A carousel rich result (Google calls it a "host carousel") is a horizontally scrollable row of cards, all from one site, built by wrapping two or more same-type items in an ItemList with position values. Only a short, shifting list of schema.org types qualifies — and a second, geographically limited beta carousel system now runs alongside the original.

Related: Structured Data, Creative Works Schema, ItemList Schema

carousel rich result

A carousel rich result (Google’s own term is a “host carousel”) is a horizontally scrollable row of cards in Google Search, all sourced from the same site, built from ItemList structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. that wraps two or more ListItem entries of an eligible type. Each ListItem carries a 1-based position that fixes the display order. Google’s definition: “A carousel is a list-like rich result that people can swipe through on mobile devices. It displays multiple cards from the same site (also known as a host carousel).”

The single most important thing to understand: a valid ItemList is not a carousel by itself. ItemList only becomes carousel-eligible when it’s combined with one of a short, specific list of supported types. For the mature, generally available “Carousel (ItemList)” feature that’s Course listCourse schema (schema.org/Course) marks up educational courses for Google's 'Course list' carousel — which requires at least three courses marked up together, not a single-course card. A richer single-course 'Course Info' feature existed but was deprecated in June 2025., Movie, Recipe, or Restaurant (with Restaurant gated behind a limited-access interest form). Alongside it, a separate “Structured data carousels (beta)” / host-carousel system runs for LocalBusiness subtypes, Product, and Event — but only in the European Economic Area, Turkey, and South Africa. Conflating the two systems — or assuming any ItemList produces a visible carousel — is the biggest source of confusion here. Like every rich result, eligibility is not entitlement: passing the Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test confirms syntax, not display.

Related: Structured Data, Creative Works Schema, ItemList Schema

Changelog