BlogFindings
ItemList schema: 17 of 605 home pages declared one, and 525 of 766 items carried no name
An answer engine asked for the best five of something has to find five things, and ItemList is the one schema.org construct built to say a page holds a list of named things in a stated order. Lantad requested the home page of all 1,419 hostnames in this repository's committed corpus on 1 October 2026 and parsed every JSON-LD block. 605 pages carried markup that parsed. 17 of those declared an ItemList, 58 nodes between them, and 525 of the 766 items inside those nodes carried no name at all.
So this run counted them. Lantad requested the home page of all 1,419 hostnames in this repository's two committed corpus seed files on 1 October 2026, read the raw bytes with no JavaScript executed, parsed every JSON-LD block on every page that answered, and walked every object inside it. 605 of the home pages carried at least one block that parsed as JSON. 17 of those 605 declared an ItemList. The interesting part is not the adoption figure, which is simply low. It is what the 17 put inside the lists, because on most of them the list describes how the page is laid out rather than what the page is about.
In short
- ItemList schema is the markup that tells a machine a page holds a list of named things in a stated order, and on 1 October 2026 Lantad found it on 17 of the 605 corpus home pages whose JSON-LD parsed, against 131 of the same pages carrying its BreadcrumbList subtype.
- Of the 766 items inside those 58 ItemList nodes, 525 carried no name property anywhere and were identified only by a URL, so a consumer reading the markup alone learns that a list exists and not what is in it.
- 29 of the 58 ItemList nodes held fewer than the two ListItem elements Google's carousel documentation requires, and 28 of those 29 sat on theglobeandmail.com, whose home page declared 38 separate lists named after layout components such as story-card-f0f7KNPsBvX81tO.
- Neither stratum where a list of things is most expected used the markup at all: 0 of 37 reachable ecommerce home pages and 0 of 28 government home pages declared an ItemList on 1 October 2026, while 5 of 54 news home pages did.
- nationalgeographic.com declared an ItemList with numberOfItems set to 0, an empty itemListElement array and the name 2.mods.0.edgs.0.heading, which is a template path rather than a heading, and a second fetch the same day returned the same thing.
| Stage | Sites | What happened |
|---|---|---|
| Hostnames asked | 1,419 | The committed corpus, an editorial frame rather than a random draw |
| Never returned a status | 32 | 20 failed DNS resolution, 10 aborted on the 20 second timeout, 2 failed in the client |
| Refused this crawler | 221 | Answered HTTP 403 to LantadBot |
| Answered some other status | 106 | 57 of 503, 29 of 429, 7 of 202, 4 of 404, and 9 others |
| Answered 200 with HTML | 1,059 | The reachable set |
| Answered 200 without HTML | 1 | A single page served a non-HTML content type and was not parsed |
| Carried at least one JSON-LD block | 612 | 1,137 blocks between them, of which 16 did not parse |
| Carried at least one block that parsed | 605 | The denominator for every figure below |
| Declared an ItemList | 17 | 58 nodes, 766 items |
What is ItemList schema, and what counts as declaring one?
The definition is short and the properties are few. itemListElement holds the members, and schema.org says it accepts a simple string, an existing entity, or a ListItem. itemListOrder takes a value from the ItemListOrderType enumeration, whose three members are ItemListOrderAscending, ItemListOrderDescending and ItemListUnordered, or plain text. numberOfItems takes an integer, with a note that a paginated listing may describe fewer items than the number given. That is the whole vocabulary, and it is enough to tell a machine that a page holds eight ranked things and where each one lives.
Counting it requires one decision first, and it changes the answer by an order of magnitude. ItemList has four more specific types in the vocabulary at release 30.1, dated 2026-09-16: BreadcrumbList, OfferCatalog, HowToSection and HowToStep. A BreadcrumbList is an ItemList by inheritance, so a page carrying a breadcrumb trail has technically declared a list. It has not, however, declared a list of the things the page is about, which is the only version of the question worth asking here. So every figure in this post counts nodes typed ItemList and not typed any of those four subtypes, and the subtypes are reported separately.
The separation matters because the subtype is where almost all the usage is. 131 of the 605 pages carried a BreadcrumbList, and for 122 of them that was the only list markup on the page. This blog has already measured those trails on their own terms and found that 201 of 936 interior pages declared one, 35 of them holding a single item. 15 pages carried an OfferCatalog, the subtype for a set of offerings, across 18 nodes. HowToStep appeared on exactly one, wix.com, and HowToSection on none. Strip the inheritance away and the bare ItemList sits at 17 of 605, which is in the same range as the rarest types this blog has counted: 8 of 1,114 pages declared speakable and 21 of the 270 showing a video declared one.
| Type | Sites | Nodes | Relationship to ItemList |
|---|---|---|---|
| BreadcrumbList | 131 | 131 | Subtype. A navigation trail, not a list of the page's subjects |
| ItemList | 17 | 58 | The type itself, counted with subtypes excluded |
| OfferCatalog | 15 | 18 | Subtype. A set of offerings |
| HowToStep | 1 | 6 | Subtype. Found on wix.com only |
| HowToSection | 0 | 0 | Subtype. Not found |
17 of 605 home pages declared a list of anything
The two strata where a page most obviously holds a list of things are the two that used the markup least, and both used it zero times. 0 of the 37 reachable ecommerce home pages carrying parseable JSON-LD declared an ItemList, which is notable because a storefront home page is very often a row of featured products and nothing else, and because this blog has separately found that 38 Shopify stores served 1,112 products as open JSON to anyone who asked. The data to populate a list is there. The statement that it is a list is not. 0 of the 28 government home pages declared one either.
News is where the markup actually appears, at 5 of 54, and the explanation is probably that news home pages are generated by a layout system that emits structured data per component. SaaS came to 3 of 89, education and healthcare and finance to 2 each, travel to 1, and two more sites arrived through the platform strata rather than the industry ones: one Webflow site and one single page application startup. That is 17 sites in total and it is worth being plain that 17 is a small number to reason from. The denominator is honest and the finding it supports is narrow: on this corpus, declaring an ordered list of your own content is rare, and rarer still than declaring who you are, since 103 of 385 pages with JSON-LD named no organization and that is a far more common type.
Why it matters for AI visibility rather than for a rich result is the part worth separating. Google documents ItemList for carousels and ties it to four content types, so for most sites in this corpus there is no search appearance to win. The argument for the markup is different: a model answering a question that asks for several things has to decide what the several things are, and a list it can read is a shorter path to that than inferring the set from layout. This is an argument, not a measurement, and nothing in this run tested whether any engine behaves that way. What has been measured on this blog is that structured data came third in a 1,100 URL citation audit, behind factors that had nothing to do with markup.
Most of the 58 lists described the layout, not the content
38 of the 58 nodes were on one site. theglobeandmail.com emits an ItemList per front page module, and the name on each one is the module's own identifier: story-card-f0fgDNdYwtF51wb, podcast-f0fWLGWvspHJmp, horizontal-span-f0fmDLp5tpHJVh, vertical-list-f0fvEiDYspHJ2K. 28 of those 38 lists hold exactly one item, which is a list in the same sense that a single card is a row. Three of the 20 distinct names are used more than once, on nine nodes, seven nodes and five nodes, so 21 of the 38 share a name with another list on the same page. Nothing here is broken and the markup parses, but what a consumer receives is a description of the page's grid rather than of the journalism in it, and that is a different thing from what the type was defined to carry.
The clearest single case is nationalgeographic.com, and it was re-fetched to be sure. Its one ItemList declares numberOfItems as 0, carries an empty itemListElement array, and takes as its name the string 2.mods.0.edgs.0.heading. That is a path into a template's data structure which was never resolved to the heading it points at, so the page publishes a list of nothing called by the name of a variable. The same bytes came back on a second request the same day. postman.com is the honest version of the same pattern: its list is named Postman Footer Navigation, so the markup says plainly that it describes navigation. This blog has measured that distinction at scale before and found that 80,761 of 104,474 list items were navigation, and separately that 1,395 of 2,729 text blocks were navigation rather than main content, so a crawler meeting a list of links has no reason to assume it has met the page's subject matter.
Set against those, nine sites used the type the way the definition reads. yo.directory declares a 24 item list called Discover Tools with a name and a URL on every member. trustmrr.com declares three, among them Top startups by verified revenue. france24.com declares a 98 item list of named articles. meininger-hotels.com declares 39 named properties, citi.com three named account types, and intercom.com a three item list called Products in the Intercom Platform. These are lists of the things the page is for, which is what makes the rest of the count readable as a problem rather than as a style difference.
-
theglobeandmail.comLayout 38 nodes named after front page modules, 28 of them holding exactly one item, and three names reused across 21 of the 38. No member carried a name. -
nationalgeographic.comEmpty numberOfItems 0, an empty itemListElement array, and the name 2.mods.0.edgs.0.heading, an unresolved template path. -
postman.comNavigation, stated One node named Postman Footer Navigation with five named members. The markup says what it is, and it is not the page's subject. -
theregister.comContent, unnamed A single 250 item list declared as the page's mainEntity. Every member carries a position and a nested item, and none carries a name. -
yo.directory and 8 othersContent Named lists of the things the page is for, with a name on every member. yo.directory, trustmrr.com, france24.com, unacademy.com, mdanderson.org, meininger-hotels.com, citi.com, hdfcbank.com, intercom.com.
525 of 766 items carried no name a consumer could read
Across the 58 nodes there were 766 members. 241 carried a name, either directly or on a nested item object. 525 carried none, and were identified by a URL alone. That is the figure that decides whether the markup is worth anything to something reading the page once: a list of 250 URLs with positions tells a consumer the page ranks 250 things and nothing about what any of them is, so the only way to learn is to fetch all 250. theregister.com is exactly that case, with a 250 item list and not one name on it, and edx.org is the same shape at 176 items. Both lists are otherwise well formed.
The structural fields are in better order than the naming. 729 of the 766 members were typed ListItem, which is the shape schema.org offers for a positioned member, and 37 were plain objects of some other type. 751 of the 766 carried a position. 46 of the 58 nodes declared numberOfItems and 45 of those 46 matched the number of members actually present, the single exception being abc.net.au, which declared 20 and carried 19. itemListOrder appeared on only 5 nodes, and three of those five do not resolve against the enumeration: unacademy.com and nationalgeographic.com both write the ItemListOrderAscending identifier with an http scheme rather than https, and intercom.com writes the bare word Ordered, which is permitted because the property also accepts text but matches no enumeration member, so a consumer checking against the three defined values finds nothing.
Google's carousel documentation, carrying Last updated 2026-09-08 UTC when it was opened on 1 October 2026, states the requirement plainly: to specify a list, define an ItemList containing at least two ListItem elements, each with a position and the canonical URL of the item's detail page. 29 of the 58 nodes measured here hold fewer than two members, 28 of them on theglobeandmail.com and one on nationalgeographic.com, so half the nodes in this corpus fall below the minimum Google publishes for the one appearance the type is documented for. On the other required field the picture is better but split: 440 members carried both a position and a direct url property, while 311 carried a position and reached their target through a nested item object instead. Whether a given consumer follows that nesting is not something this run tested, and the honest statement is only what the bytes contain. The same discipline applies to the rest of the markup on these pages, where 117 of 612 home pages with JSON-LD carried a defect a validator can name.
| Property of the member | Members | Of 766 |
|---|---|---|
| Carried a name, directly or on a nested item | 241 | 31.5 percent |
| Carried no name, identified by URL only | 525 | 68.5 percent |
| Typed ListItem | 729 | 95.2 percent |
| Carried a position | 751 | 98.0 percent |
| Carried both a position and a direct url | 440 | 57.4 percent |
| Carried a position but reached the target through a nested item | 311 | 40.6 percent |
How this was measured, and what it does not say
One request per hostname, sent as LantadBot/1.0 with redirects followed and a 20 second timeout, no JavaScript executed and no stylesheet fetched, from a single network location. Every JSON-LD block was extracted from the raw bytes, parsed with JSON.parse, and every object inside it walked to a depth of 40, so a list nested inside a WebPage or inside an @graph is found rather than missed. A node counted only if its @type included ItemList and did not include BreadcrumbList, OfferCatalog, HowToSection or HowToStep. All 17 sites were then fetched a second time the same day and the whole analysis re-run against the new bytes: every node count, member count, name count, the one numberOfItems mismatch and the three unresolvable itemListOrder values came back identical. The conduct of the crawler is set out at the bot policy and the reading rules at methodology.
Four things this does not say. It does not say any answer engine reads ItemList, or weights it, or would answer differently without it: nothing here touched an engine, and the claim that an ordered list helps a model assemble a set remains an argument from the shape of the data. It does not describe the web, because the corpus is an editorial frame of 1,419 hostnames rather than a random sample, and the 221 sites that refused this crawler with a 403 are missing from every figure, which is its own finding and one this blog has measured directly at 103 of 1,089 sites serving an unknown bot and refusing GPTBot. It does not cover interior pages, where a category listing or a ranked article is far likelier to carry a list than a home page is, so 17 of 605 is a floor for this corpus and not an estimate for these sites. And it does not account for markup that a browser would add after the fact: 27 of 404 pages with no JSON-LD in the HTML gained some when a browser ran the page, so some of the 588 pages with no list here may build one in the client.
What a reader can check on their own site takes a minute and needs no tool. Open the page source, find the application/ld+json blocks, and ask whether any node is typed ItemList rather than only BreadcrumbList. If one is, read the name and ask whether it is the name of a thing a person would ask for or the name of a component in your template. Then read the members and ask whether each carries a name as well as a URL, because that is the difference between publishing a list and publishing a set of links. What GPTBot sees shows the same bytes this run read, and the crawler directory lists the tokens that do the asking. Where the page turns out to carry no schema at all, which is the common case on this corpus at 141 of 382 home pages, a list is not the place to start.
Flow: GET / on 1,419 hostnames to 1,059 answered 200 with HTML; 1,059 answered 200 with HTML to 605 held a block that parsed; 605 held a block that parsed to Walk every node to depth 40; Walk every node to depth 40 to Typed ItemList, no subtype; Typed ItemList, no subtype to 17 sites, 58 nodes, 766 items; 17 sites, 58 nodes, 766 items to Re-fetch all 17, figures identical.
Lantad
Published .
An answer engine asked for the best five of something has to find five things, and the markup built for exactly that job is ItemList. schema.org defines it as a list of items of any sort, giving as its own examples Top 10 Movies About Weathermen and Top 100 Party Songs, and it carries three properties: the items, the order they are in, and how many there are. A page that declares one is saying, with no reading of prose required, that it holds a set of named things in a stated sequence. Nothing else in structured data does that job.
Common questions
What is ItemList schema?
It is the schema.org type for a list of items of any sort. It carries three properties: itemListElement for the members, itemListOrder for how they are ordered, and numberOfItems for how many there are. schema.org gives Top 10 Movies About Weathermen as its own example. A page that declares one is stating that it holds a set of named things in a sequence, without a consumer having to infer that from the layout.
Does a breadcrumb trail count as an ItemList?
By inheritance yes, and that is why this post counts them separately. BreadcrumbList is one of four more specific types of ItemList in the vocabulary at release 30.1, alongside OfferCatalog, HowToSection and HowToStep. 131 of the 605 corpus home pages with parseable JSON-LD carried a BreadcrumbList and for 122 of them it was the only list markup present, against 17 carrying a bare ItemList. A trail describes where the page sits, not what it is about.
How many items does an ItemList need?
Google's carousel documentation, Last updated 2026-09-08 UTC, says to define an ItemList containing at least two ListItem elements, each carrying a position and the canonical URL of its detail page. 29 of the 58 nodes Lantad measured on 1 October 2026 held fewer than two members. schema.org itself sets no minimum, so a one item list is valid markup that does not meet the documented requirement for the appearance the type is used for.
Will adding an ItemList get my site cited by AI?
Nothing in this measurement shows that. Lantad read markup on 1 October 2026 and did not ask any answer engine anything, so the case for the type rests on the shape of the data rather than on observed behaviour. The measured evidence this blog has on the question points the other way: structured data came third in a 1,100 URL citation audit, behind factors unrelated to markup. A list whose members carry no names is the weakest version regardless.
See what AI can read on your site
Run a free scan and get a graded report of exactly what AI crawlers can and cannot read, with ranked fixes.
Structured data for AI (schema markup)
Structured data is schema.org markup, usually written as JSON-LD, that labels a page's facts in a machine-readable format so AI systems can extract and attribute them without having to interpret the surrounding prose.
AI crawler
An AI crawler is an automated bot, such as GPTBot, ClaudeBot, or PerplexityBot, that fetches web pages so an AI system can read, train on, or cite what those pages contain.
Breadcrumb schema: 201 of 936 interior pages declared a trail, and 35 of those held one item
Lantad asked all 1,419 hostnames in this repository's committed corpus for robots.txt on 22 September 2026, then followed each home page's own first link one level deeper and read the interior page with no JavaScript executed. 936 answered HTTP 200. 201 of them declared a BreadcrumbList in JSON-LD, 35 of the 202 trails those pages carried held a single item, and 165 of the 202 named no level between the site root and the page.
Schema markup validator: 117 of 612 home pages with JSON-LD carried a defect, and on 7 not one block parsed
Lantad requested the home page of all 1,419 hostnames in this repository's committed corpus on 21 September 2026 and read the raw bytes with no JavaScript executed. 1,072 answered HTTP 200 with HTML, and 612 of those carried at least one JSON-LD block, 1,143 blocks between them. 117 of the 612 carried a defect, 16 blocks never parsed as JSON, and on 7 sites not one block on the page did.
Structured data: 313 of 615 home pages gave no schema node an @id, and 14 reused one for two things
Lantad asked all 1,419 hostnames in this repository's committed corpus for robots.txt on 26 September 2026, then read the home page of every host that allowed it with no JavaScript executed. 1,081 answered HTTP 200 with HTML and 615 of them carried at least one JSON-LD block that parsed. 313 of those 615 put an @id on no node at all, 545 described more than one typed thing, and 193 of the 545 joined two of those things with an @id reference that resolved on the page.
