Free Carousel Schema Generator

Why many collection pages underperform

How SwiftSchema helps

How it works

What is ItemList structured data?

ItemList is the Schema.org type behind most navigational collections—think “Top 5 articles,” “Recipes in this guide,” “Products in this category.” Search engines read ItemLists to understand how list pages relate to their children. When Google chooses to show a carousel in search, it typically relies on consistent ItemList markup pointing to crawlable pages that already have their own entity schema. Marking up ItemLists doesn’t guarantee a carousel, but it does make your collections machine-readable and easier to monitor.

Essential elements for a valid ItemList

1. @type: ItemList — identifies the wrapper object.
2. itemListElement — array of ListItems representing each entry.
3. ListItem fields:
   • @type: ListItem
   • position — 1-based integer reflecting the order you want search engines to use.
   • name — optional but recommended label (match the visible link text).
   • url or item — absolute canonical URL of the target page.
4. name — descriptive label for the list (“2025 Product Schema Guides”).
5. numberOfItems — optional; helpful for long lists or paginated sets.
6. itemListOrder — specify ItemListOrderAscending, ItemListOrderDescending, or ItemListUnordered when order matters.

Preparing your content

• Ensure the collection page clearly explains what the list covers (topic, timeframe, selection criteria).
• Provide unique, human-readable link text that matches the name in each ListItem.
• Confirm each linked page contains the correct entity schema (Article, Recipe, Product, FAQ, etc.). The ItemList alone isn’t enough.
• Use canonical URLs for each item. Avoid linking to search facets or filtered URLs unless they’re indexable.
• Decide whether the list is curated (fixed order) or dynamic (auto-generated). Curated lists should have stable positions; dynamic lists might need automation.

Implementation checklist

1. Source data from your CMS or component—create a structured array with label, URL, and order.
2. Normalize URLs to absolute form (https://domain/...).
3. Assign positions starting at 1 and incrementing sequentially. Do not skip numbers, even when paginating.
4. Generate JSON‑LD using the form below; include name, optional description, itemListOrder, and numberOfItems.
5. Embed the JSON‑LD on the collection page. If your collection spans multiple pages, include an ItemList per page (with accurate positions) and provide pagination markup (rel=prev/next).
6. Validate via Rich Results Test or Schema Markup Validator.
7. Monitor Search Console for manual actions and log when Google surfaces carousels for your queries.

Linking ItemList to detail schema

• Every URL in the ItemList should point to a page with entity-specific JSON‑LD (Product, Recipe, Article, Video, etc.).
• Cross-reference using mainEntityOfPage on the detail page. For example, an Article detail page can mention the ItemList via isPartOf.
• If list items represent fragments within a page (e.g., a recipe index), consider using ListItem with item: {"@id": "#recipe-1"} referencing anchors, but only if those anchors correspond to structured data entries.
• For eCommerce, pair ItemList with BreadcrumbList to help search engines trace category depth.

Large-scale or automated lists

• Programmatic SEO: when generating thousands of list pages, create a shared utility that produces both the UI component and the ItemList JSON‑LD from the same data to avoid drift.
• Pagination: maintain consistent numbering across pages (page 2 should continue positions 11,12,...). Include numberOfItems to indicate total size.
• Dynamic ranking: if you reorder items frequently (e.g., trending posts), consider caching the ItemList and invalidating it when order changes to keep schema fresh.
• Localization: translate list names and item labels per locale; ensure URLs point to localized pages when available.

Analytics and QA tips

• Track clicks from SERPs that include list/collection queries (e.g., “best product schema guides”). If you notice Google showing carousels, note which queries triggered them.
• Use crawlers (Screaming Frog, Sitebulb) to extract ItemList data and compare against your sitemap or CMS exports.
• Add unit tests or integration tests in your codebase that confirm itemListElement.length matches the number of visible list items.
• Monitor Search Console coverage for errors like “Invalid URL in field ‘itemListElement’” or manual actions for spammy lists.

Maintenance practices

• Whenever you add/remove list items, update both the visible content and the JSON‑LD simultaneously.
• Keep track of expired or unpublished items. Remove them from the list to avoid 404s in schema.
• If you migrate URLs, update the ItemList entries and ensure 301 redirects are in place. Schema should reference the final canonical URL, not rely on redirects.
• Document list ownership (e.g., blog team vs product team) so someone is responsible for keeping the schema accurate.

Common Errors & Fixes

• Missing positions: always provide 1-based positions without gaps.
• Broken links: ensure each URL resolves to a live, crawlable page with relevant schema.
• Relative URLs: convert to absolute canonical URLs to avoid ambiguity.
• Expectation mismatch: remember ItemList does not force a carousel; focus on relevance and quality.
• Duplicate entries: avoid listing the same URL multiple times unless there’s a meaningful reason (different anchors/sections).