S SCHEMA.BIZ
Other Extends: WebPage

Collection Page Schema (CollectionPage)

Collection page schema marks a page whose job is to list other things: a shop category, a blog tag archive, a recipe index, a gallery. CollectionPage is a WebPage subtype, so it describes the page itself, while an ItemList in its mainEntity holds the items in the order the page shows them. Google has no rich result for the type; the breadcrumb and list inside it can still count.

Last updated:

Does Google show Collection Page schema?

No Google has no search feature for CollectionPage markup. It's still valid schema.org that describes the page to search engines and other consumers.

Google doesn't document CollectionPage for any feature. The BreadcrumbList in its breadcrumb can still show as a breadcrumb trail (desktop results only since January 2025), and an ItemList of courses, movies, recipes or restaurants on the page can feed a carousel under that feature's own rules.

Last checked against Google's documentation: .

What we found on the top 10,000 sites

  • 5.4% of the 5,687 top sites we could analyze use CollectionPage markup (305 sites).
  • 0.7% of those sites have a property schema.org doesn't define on their CollectionPage markup, the most common problem we found.

From the home page of each of the Tranco top 10,000 sites and, where we found one, a page it links to, crawled in November 2026. Methodology and every chart: State of Schema 2026.

When to Use CollectionPage

Shop category and subcategory pages Blog category and tag archives Recipe and course index pages Photo and video galleries Directory listing pages

CollectionPage properties

The properties that matter most in practice, of the 139 schema.org defines for CollectionPage. Status is our advice for a complete description; Google's own requirements are covered in the box above.

Property Type Status Description
name Text recommended The listing's title as the page shows it, such as "Women's Trail Running Shoes".
url URL recommended The canonical URL of the listing, without sort or filter parameters.
description Text recommended The category's intro text, if the page has one.
mainEntity ItemList recommended The list the page exists to show, with a ListItem per item in display order.
hasPart CreativeWork optional Articles, videos or other works the page contains, when you'd rather not wrap them in a list.
breadcrumb BreadcrumbList recommended The page's place in the site's category tree. Google reads this for breadcrumb trails.
isPartOf WebSite optional The site the listing belongs to, usually an @id reference to the home page's WebSite node.
about Thing optional The topic the collection covers, when it's an entity in its own right (a brand, a cuisine, a place).
inLanguage Text optional The page's language as a BCP 47 code, such as en-US.
dateModified Date or DateTime optional When the listing last changed, such as when items were added.
significantLink URL optional Links the page treats as most important, such as subcategories.
primaryImageOfPage ImageObject optional The category's banner or hero image.

JSON-LD Examples

Minimal:A category page named and located

The type, a name and the canonical URL. It tells consumers the page is a listing rather than an article or a product, which is all a bare CollectionPage can say.

{
  "@context": "https://schema.org",
  "@type": "CollectionPage",
  "name": "Women's Trail Running Shoes",
  "url": "https://www.example.com/shoes/womens/trail-running/"
}

Complete:Shop category with its product list and breadcrumb

A category page with its breadcrumb trail and the products in display order as an ItemList. Each ListItem gives the product page's URL and name, not a full Product, because product details belong on the product pages.

{
  "@context": "https://schema.org",
  "@type": "CollectionPage",
  "@id": "https://www.example.com/shoes/womens/trail-running/#webpage",
  "name": "Women's Trail Running Shoes",
  "description": "Trail shoes for women, from light racers to cushioned shoes for long mountain days.",
  "url": "https://www.example.com/shoes/womens/trail-running/",
  "inLanguage": "en-US",
  "dateModified": "2026-10-28T09:15:00-06:00",
  "isPartOf": {
    "@id": "https://www.example.com/#website"
  },
  "breadcrumb": {
    "@type": "BreadcrumbList",
    "itemListElement": [
      {
        "@type": "ListItem",
        "position": 1,
        "name": "Shoes",
        "item": "https://www.example.com/shoes/"
      },
      {
        "@type": "ListItem",
        "position": 2,
        "name": "Women",
        "item": "https://www.example.com/shoes/womens/"
      },
      {
        "@type": "ListItem",
        "position": 3,
        "name": "Trail Running"
      }
    ]
  },
  "mainEntity": {
    "@type": "ItemList",
    "numberOfItems": 3,
    "itemListOrder": "https://schema.org/ItemListUnordered",
    "itemListElement": [
      {
        "@type": "ListItem",
        "position": 1,
        "name": "Ridgeline 4 Trail Shoe",
        "url": "https://www.example.com/products/ridgeline-4-womens/"
      },
      {
        "@type": "ListItem",
        "position": 2,
        "name": "Scree Runner GTX",
        "url": "https://www.example.com/products/scree-runner-gtx-womens/"
      },
      {
        "@type": "ListItem",
        "position": 3,
        "name": "Talus Lite",
        "url": "https://www.example.com/products/talus-lite-womens/"
      }
    ]
  }
}

Real-world, nested:Recipe index in an @graph with the site, breadcrumb and list

A recipe category page whose nodes link by @id: the WebSite, the CollectionPage, its BreadcrumbList and the ItemList of recipe URLs. Because each linked page carries Recipe markup, this list has the shape of the summary page in Google's carousel documentation.

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "WebSite",
      "@id": "https://www.example.org/#website",
      "name": "Pantry Notes",
      "url": "https://www.example.org/"
    },
    {
      "@type": "CollectionPage",
      "@id": "https://www.example.org/recipes/weeknight-pasta/#webpage",
      "name": "Weeknight Pasta Recipes",
      "description": "Pasta dinners that take 30 minutes or less, tested in a home kitchen in Portland.",
      "url": "https://www.example.org/recipes/weeknight-pasta/",
      "inLanguage": "en-US",
      "isPartOf": {
        "@id": "https://www.example.org/#website"
      },
      "breadcrumb": {
        "@id": "https://www.example.org/recipes/weeknight-pasta/#breadcrumb"
      },
      "mainEntity": {
        "@id": "https://www.example.org/recipes/weeknight-pasta/#list"
      }
    },
    {
      "@type": "BreadcrumbList",
      "@id": "https://www.example.org/recipes/weeknight-pasta/#breadcrumb",
      "itemListElement": [
        {
          "@type": "ListItem",
          "position": 1,
          "name": "Recipes",
          "item": "https://www.example.org/recipes/"
        },
        {
          "@type": "ListItem",
          "position": 2,
          "name": "Weeknight Pasta",
          "item": "https://www.example.org/recipes/weeknight-pasta/"
        }
      ]
    },
    {
      "@type": "ItemList",
      "@id": "https://www.example.org/recipes/weeknight-pasta/#list",
      "name": "Weeknight Pasta Recipes",
      "itemListElement": [
        {
          "@type": "ListItem",
          "position": 1,
          "url": "https://www.example.org/recipes/lemon-ricotta-spaghetti/"
        },
        {
          "@type": "ListItem",
          "position": 2,
          "url": "https://www.example.org/recipes/sausage-kale-orecchiette/"
        },
        {
          "@type": "ListItem",
          "position": 3,
          "url": "https://www.example.org/recipes/one-pan-tomato-orzo/"
        },
        {
          "@type": "ListItem",
          "position": 4,
          "url": "https://www.example.org/recipes/brown-butter-sage-gnocchi/"
        }
      ]
    }
  ]
}

Common Collection Page schema mistakes

Putting itemListElement straight on the CollectionPage

PROP_NOT_ON_TYPE: This schema.org property isn't defined for the object's type, so search engines may ignore it.

A CollectionPage isn't a list. The ListItems belong to an ItemList, which the page carries as its mainEntity.

Wrong

{
  "@context": "https://schema.org",
  "@type": "CollectionPage",
  "name": "Trail Running Shoes",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "url": "https://www.example.com/products/ridgeline-4/"
    }
  ]
}

Right

{
  "@context": "https://schema.org",
  "@type": "CollectionPage",
  "name": "Trail Running Shoes",
  "mainEntity": {
    "@type": "ItemList",
    "itemListElement": [
      {
        "@type": "ListItem",
        "position": 1,
        "url": "https://www.example.com/products/ridgeline-4/"
      }
    ]
  }
}

List entries generated without "@type": "ListItem"

TYPE_MISSING_NESTED: Nested objects should say what they are too. Without an @type, search engines have to guess, and Google's features may not recognise the object.

Template loops often build each entry from the item's fields and forget the wrapper's own type.

Wrong

{
  "@context": "https://schema.org",
  "@type": "CollectionPage",
  "name": "Trail Running Shoes",
  "mainEntity": {
    "@type": "ItemList",
    "itemListElement": [
      {
        "position": 1,
        "url": "https://www.example.com/products/ridgeline-4/"
      }
    ]
  }
}

Right

{
  "@context": "https://schema.org",
  "@type": "CollectionPage",
  "name": "Trail Running Shoes",
  "mainEntity": {
    "@type": "ItemList",
    "itemListElement": [
      {
        "@type": "ListItem",
        "position": 1,
        "url": "https://www.example.com/products/ridgeline-4/"
      }
    ]
  }
}

Relative item URLs copied from the template's links

VALUE_URL: This property expects an absolute URL, including https://. Relative paths can't be resolved reliably.

An href can be relative because the browser resolves it; a URL in JSON-LD should be the full canonical address of the item's page.

Wrong

{
  "@context": "https://schema.org",
  "@type": "CollectionPage",
  "name": "Trail Running Shoes",
  "mainEntity": {
    "@type": "ItemList",
    "itemListElement": [
      {
        "@type": "ListItem",
        "position": 1,
        "url": "/products/ridgeline-4/"
      }
    ]
  }
}

Right

{
  "@context": "https://schema.org",
  "@type": "CollectionPage",
  "name": "Trail Running Shoes",
  "mainEntity": {
    "@type": "ItemList",
    "itemListElement": [
      {
        "@type": "ListItem",
        "position": 1,
        "url": "https://www.example.com/products/ridgeline-4/"
      }
    ]
  }
}

Breadcrumb levels with names but no URLs

BC_ITEM_MISSING: Every breadcrumb except the last needs an item: the URL (or WebPage with @id) of that level.

The last level, the current category, may leave out item; every level above it needs the URL of that category page.

Wrong

{
  "@context": "https://schema.org",
  "@type": "CollectionPage",
  "name": "Trail Running Shoes",
  "breadcrumb": {
    "@type": "BreadcrumbList",
    "itemListElement": [
      {
        "@type": "ListItem",
        "position": 1,
        "name": "Shoes"
      },
      {
        "@type": "ListItem",
        "position": 2,
        "name": "Trail Running"
      }
    ]
  }
}

Right

{
  "@context": "https://schema.org",
  "@type": "CollectionPage",
  "name": "Trail Running Shoes",
  "breadcrumb": {
    "@type": "BreadcrumbList",
    "itemListElement": [
      {
        "@type": "ListItem",
        "position": 1,
        "name": "Shoes",
        "item": "https://www.example.com/shoes/"
      },
      {
        "@type": "ListItem",
        "position": 2,
        "name": "Trail Running"
      }
    ]
  }
}

Also watch for

  • Marking every listed product as a full Product with offers and ratings on the category page. Google's product documentation asks for markup about a specific product, so keep the details on each product page and list only names and URLs here.

  • Listing items in the markup that the page doesn't show, such as the whole category on page 1 of a paginated listing. The list should match what a visitor sees on that URL.

  • Using CollectionPage for a site search results page. schema.org has SearchResultsPage for that, and most sites keep internal search results out of the index anyway.

  • Giving filtered and sorted variants of a category their own CollectionPage url. Use the canonical category URL, the same one the page's canonical link points to.

CollectionPage, ItemList or SearchResultsPage

These three get confused because they all involve lists. CollectionPage describes a page: it has a URL, a title, a breadcrumb, a language. ItemList describes a list: ordered entries, each a ListItem with a position. A category page has both, so the usual pattern is a CollectionPage whose mainEntity is the ItemList. The page is the container; the list is what it's about.

SearchResultsPage is a sibling of CollectionPage under WebPage, meant for pages generated from a visitor's query. A tag archive or a curated category is a collection; /search?q=boots is a search results page. If your platform builds category pages from saved filters, they're still collections: what matters is that the page is a stable, linkable listing, not an answer to one person's query.

CollectionPage also has subtypes for media: ImageGallery and VideoGallery (both under MediaGallery). Use those for a photo gallery or a video hub; the same mainEntity and hasPart patterns apply.

A page that ranks things editorially, "The 10 best trail shoes of 2026", is usually an article with a list in it. Mark it up as an Article and, if you want, add an ItemList of the products it reviews. Calling it a CollectionPage loses the author, dates and headline that make an article an article.

mainEntity, hasPart, and how much to say about each item

There are two ways to tie items to the page. mainEntity with an ItemList keeps the order and suits listings where position matters to the visitor: product grids, recipe indexes, ranked lists. hasPart takes CreativeWork values directly and suits archive pages where the items are articles or videos and order is simply newest first. Pick one per page; doing both duplicates every item.

For each item, decide between a summary and a full description. A summary ListItem has position and url, and optionally name. A full one puts the thing itself in item: a Course, a Recipe, a BlogPosting. Summaries are the safer default for category pages. The item's own page is where its complete markup lives, and repeating it on every category that lists the item multiplies the places that can go stale when a price or title changes.

Full items make sense when the listing page is the only place the items are described, such as a single page with several short courses, or when you're building one of Google's all-in-one carousels, where each ListItem's item must have at least a name and a URL.

On paginated listings, each page lists its own items, with position counting from where that page starts (page 2 of a 24-per-page grid starts at 25) and its own url. numberOfItems can state the size of the whole category if you know it.

Generating the markup from category templates

On most sites every category, tag and archive page is built from one or two templates, so the markup should come from the same query that renders the grid. Loop over the items the template is about to print, and emit a ListItem for each with the counter as position and the item's permalink as url. If the page shows 24 items, the list has 24 entries; if a filter hides some, the markup hides them too.

Give the page node a stable @id, such as the canonical URL plus #webpage, and reference the site's WebSite node in isPartOf by its @id rather than describing the site again on every page. Build the breadcrumb from the category tree the template already knows (parent categories up to the shop root). In WordPress, Shopify and similar platforms the category object usually exposes its ancestors, so the breadcrumb is a second loop.

Use the canonical URL everywhere: in url, in the @id, and in breadcrumb items. Sort and filter parameters (?sort=price, ?color=blue) shouldn't leak into the markup, and the URLs in the list should be the item pages' canonical URLs, not tracking or variant links.

If an SEO plugin already outputs a WebPage node for the page, change its type to CollectionPage instead of adding a second page node; two page nodes for one URL leave consumers to work out which is real.

When the list can feed a Google carousel

Google's carousel feature reads ItemList markup for four content types only: courses, movies, recipes and restaurants. If your collection lists one of those, the same ItemList that serves as the mainEntity can also qualify. On a summary page each ListItem needs a url pointing to a page on your site with that item's own markup; on an all-in-one page each ListItem holds the item in item, with name and url. For a course list, Google needs at least three Course items and a unique url per ListItem, and the feature is English only.

A collection of anything else, such as products, articles, events or software, is valid markup, but Google won't show it as a carousel. That's no reason to leave it out; it's a reason not to expect a visible change in results.

To check a template, paste a rendered category page's markup into the Validator at /markup/validator/: it flags missing @types on list entries, relative URLs and breadcrumb levels without an item. Then run one category URL through Google's Rich Results Test, which shows whether Google sees a breadcrumb or, for the four supported types, a carousel. Test a paginated page and an empty category too; those are where templates break.

Complete Guide to Collection Page Schema

A collection page is any page whose main content is a set of links to other pages: the women's trail shoe category of a shop, the "vegetarian" tag on a food blog, an index of all the courses a school offers. schema.org's CollectionPage gives that page a type, which separates it from the articles and product pages it links to. Search engines can usually tell a listing from its layout, but the type, together with the ItemList in mainEntity, states it outright and puts the items in order.

The properties that matter are inherited from WebPage and CreativeWork. name, url and description describe the listing; breadcrumb places it in the site's hierarchy; mainEntity or hasPart connects the items; isPartOf ties the page to the site. CollectionPage adds no properties of its own, so the property table above is a selection of the WebPage properties that make sense on a listing.

Of everything in a collection page's markup, the breadcrumb is the part Google most reliably uses. A BreadcrumbList with at least two levels, each but the last with an item URL, can replace the URL line in desktop results with a trail such as Shoes › Women › Trail Running. The ItemList can feed a carousel only for the four content types Google supports.

Keep the listing honest: the same items, in the same order, as the visible page, with absolute canonical URLs. A collection page that matches its HTML is easy to maintain because it's generated from the same data, and it gives other consumers of structured data, from other search engines to site-search tools that crawl JSON-LD, an accurate map of how your site is organized.

Where CollectionPage sits in schema.org

"Web page type: Collection page."

Path from Thing: Thing CreativeWork WebPage CollectionPage

Parent type
WebPage
More specific types
MediaGallery

Related Types

Check Your CollectionPage Markup

The generator doesn't have a CollectionPage form yet. Paste your markup into the validator to check its types, properties and values, and what Google needs from it.

Open Validator