If you sell products, publish blog posts, or list services online, there is a good chance you have pages that group things together. A category page with 40 products. A blog archive with your latest articles. A "Top 10" recommendations post. These are all lists, and AI search engines like ChatGPT, Perplexity, and Gemini struggle to understand them without a little help.
That help comes in the form of ItemList schema. It is one of the more underused schema types in e-commerce and content marketing, yet it has a direct impact on how AI systems read, interpret, and cite your pages. This post walks through exactly what ItemList schema is, how to implement it correctly, and what it can do for your AI search visibility.
What ItemList Schema Actually Does
ItemList schema is a structured data type defined by Schema.org that tells machines: "This page contains an ordered or unordered collection of items." Rather than leaving an AI crawler to infer relationships between pieces of content on a page, you spell it out explicitly in JSON-LD.
Think about what happens when an AI model is trained on or crawls your category page. Without schema, it sees a wall of product names, prices, images, and links. It might figure out that they are all products. It might not. It certainly cannot tell you with confidence which item is first, which is most important, or how they relate to each other.
With ItemList schema, you provide a structured list where each entry has a name, a URL, a position, and optionally an image or description. The AI now knows the page is a curated collection. That is the kind of clear, structured signal that makes a page far more likely to be cited or surfaced in a list-style AI answer.
The difference between ItemList and other list-like schemas
You might be wondering how ItemList differs from something like BreadcrumbList or a collection of Product schema. The distinction matters.
BreadcrumbList describes navigation hierarchy, not content collections. Product schema describes individual products but does not group them. ItemList is specifically for signalling that a page presents a curated set of things, whether those are products, articles, FAQs, recipes, or anything else. It wraps the collection itself, not just the individual items within it.
The JSON-LD Structure You Need
Let us get practical. Here is what a basic ItemList implementation looks like in JSON-LD for a product category page:
{
"@context": "https://schema.org",
"@type": "ItemList",
"name": "Women's Running Shoes",
"description": "Our full range of women's running shoes, from lightweight racers to stability trainers.",
"url": "https://www.example.com/womens-running-shoes",
"numberOfItems": 12,
"itemListElement": [
{
"@type": "ListItem",
"position": 1,
"name": "FlinnRun Pro 3",
"url": "https://www.example.com/womens-running-shoes/flinnrun-pro-3",
"image": "https://www.example.com/images/flinnrun-pro-3.jpg",
"description": "Lightweight carbon-plated racer for PB chasers."
},
{
"@type": "ListItem",
"position": 2,
"name": "FlinnStride Stability",
"url": "https://www.example.com/womens-running-shoes/flinnstride-stability",
"image": "https://www.example.com/images/flinnstride-stability.jpg",
"description": "Maximum support for overpronators."
}
]
}
A few things to note here. The position property is important. It tells AI systems the order of the list, which matters when a model is trying to decide which items to surface in a ranked or sequential answer. Always start at 1, not 0. Each ListItem should have at minimum a name, a url, and a position. Adding image and description gives AI systems more context to work with.
Should you use "item" or just "name" and "url"?
Schema.org allows you to nest a full typed entity inside the item property of a ListItem. For example, you could nest a full Product object, a full Article object, or a full LocalBusiness object. This is worth doing when you have rich data available and the items are complex entities.
For simpler use cases, particularly blog post lists or category pages with dozens of items, keeping it lean with just name, url, and position is perfectly acceptable and much easier to maintain. Do not add complexity you cannot sustain.
Where ItemList Schema Delivers the Biggest Wins
E-commerce category pages
This is the highest-value placement for most online retailers. When someone asks ChatGPT or Perplexity "what are the best trail running shoes under £150?", the AI looks for pages that present curated lists of products with clear structure. A category page with ItemList schema is far better positioned to be cited than a page that just renders products as a grid with no machine-readable structure.
The goal is to make it obvious to the AI that this page is an authoritative, structured answer to a collection-style query. ItemList schema does exactly that.
Blog roundups and "best of" posts
If you publish any form of roundup content, "Top 5 protein powders for beginners" or "Best Shopify apps for subscriptions", ItemList schema is non-negotiable. These posts are inherently list-shaped, and the schema confirms that to AI crawlers. It also helps AI systems pull out individual list items to reference in their answers, giving your content item-level visibility, not just page-level visibility.
FAQ pages structured as lists
While FAQ schema handles question-and-answer pairs specifically, some sites structure their FAQ pages as a list of topics rather than Q&A pairs. ItemList works well here to signal the collection of topics, alongside or separately from FAQ schema on your pages.
Service listing pages
If you offer multiple services and have a page that lists them all, ItemList schema gives that page structure. Each service becomes a ListItem with a name, URL to the service page, and a brief description. AI systems can then surface individual services in response to specific queries, rather than just citing your homepage.
Common Implementation Mistakes to Avoid
Listing items that do not appear on the page
Every item in your ItemList schema must correspond to something actually visible on the page. If you list 20 products in the schema but only 6 are visible above the fold and the rest load lazily via JavaScript, you may run into issues. AI crawlers do not always execute JavaScript the way a browser does. Make sure the items you declare in schema are genuinely present in the HTML that the crawler receives.
This is worth checking as part of any free AI visibility audit, because JavaScript rendering issues are one of the most common reasons schema appears valid but fails to deliver results.
Skipping the position property
Some implementations omit position entirely. Do not do this. Position is what turns a bag of items into an ordered list. Even if your list is not truly ranked, assign sequential positions starting from 1. It gives AI systems a clear reading order and makes your schema more complete according to Schema.org guidelines.
Using the same schema on every page without customisation
This is a real problem with templated implementations. A Shopify store might auto-generate ItemList schema for every collection page using the same boilerplate, with no actual product data populated. The result is an ItemList with an empty itemListElement array or placeholder values. Check your rendered schema output, not just your template code, to make sure real data is being injected.
Ignoring the numberOfItems property
This is optional but useful. Declaring numberOfItems tells AI systems how many items the list contains. If your page lists 24 products, say so. It adds a layer of specificity that can help when AI systems are deciding whether your page is a broad catalogue or a tightly curated shortlist.
Combining ItemList with Other Schema Types
ItemList works well alongside other schema types and you should not think of it as a standalone addition. On a product category page, you might have:
- ItemList to describe the collection as a whole
- Individual Product schema on each product's own page (not necessarily on the category page itself)
- BreadcrumbList to describe where the category sits in your site hierarchy
- Organisation schema on the same page to reinforce brand identity
None of these conflict. They each answer a different question for the AI: what is this collection, what is each item, where does this page sit, and who runs this site. Together they create a much richer picture than any single schema type alone.
If you are unsure how many schema types to use on one page, the general principle is: use what is genuinely accurate and useful for that page type. Do not add schema for the sake of it.
How AI Systems Use ItemList Data
Understanding the mechanism helps you make better decisions about implementation. When an AI model like Perplexity or Gemini crawls a page with ItemList schema, it extracts the structured data and uses it to build an internal representation of what that page contains. This representation feeds into how the AI answers future queries.
If someone asks "what running shoes does [your brand] sell?", and your category page has clean ItemList schema with product names, URLs, and descriptions, the AI has a ready-made answer it can synthesise from your structured data. Without the schema, it has to guess from the page content, which introduces errors and reduces the chance of your page being cited.
There is also a confidence dimension. AI systems prefer sources they can clearly understand. A page with structured, well-formed schema signals that the site owner understands how machines read content. That kind of clarity correlates with citation frequency in AI-generated answers.
At FlinnSchema, we see this play out regularly with clients. Category pages that previously had zero mentions in AI search answers start appearing in Perplexity citations and ChatGPT responses within weeks of implementing proper ItemList schema, particularly when combined with other structural improvements.
Validating Your ItemList Schema
Once you have implemented ItemList schema, validation is not optional. The two main tools to use are Google's Rich Results Test and the Schema.org Validator. Neither will tell you definitively whether AI systems will cite your page, but they will tell you whether your schema is syntactically correct and logically structured.
Pay particular attention to warnings, not just errors. A warning about a missing recommended property like image or description on a ListItem is worth addressing. It means your schema is technically valid but not as informative as it could be.
For a deeper look at the validation process, including what to do when errors appear, see our post on how to validate your schema markup before publishing.
Frequently Asked Questions
Does ItemList schema help with Google search as well as AI search?
Yes, though Google's use of ItemList is more limited than some other schema types. Google primarily uses ItemList for carousel-style rich results, particularly for recipe, article, and product list pages in certain contexts. The bigger opportunity right now is in AI search visibility, where structured list data directly informs how AI systems read and cite your pages.
How many items should I include in my ItemList schema?
There is no hard limit, but be practical. If your category page shows 100 products, you do not necessarily need all 100 in the schema. Including the top 20 to 30 most relevant items is often more useful than an exhaustive list that is harder to maintain accurately. Focus on quality and accuracy over completeness for completeness's sake.
Can I use ItemList schema on a blog archive page?
Absolutely. A blog archive or category page listing your articles is a perfect use case. Each article becomes a ListItem with its title, URL, and optionally a description and publication date. This helps AI systems understand that your blog covers a topic area in depth, making it more likely to be cited when AI answers are related to that topic.
Does the order of items in my ItemList schema matter to AI systems?
It can. Some AI systems treat the position property as a signal of relevance or editorial ranking. If your category page sorts products by bestseller, putting your bestsellers first in the schema reinforces that signal. If the order is arbitrary, use a consistent logic (price, alphabetical, date) and stick to it. Inconsistency between the page display order and the schema order can confuse crawlers.