Course Catalog Page Schema

One page that describes every course a business teaches: an ItemList with a Course per course on the page, each with a real title and a short description, taught by the Organization from the homepage.

When To Use It

Use on a page that describes three or more real courses: a series of lessons with a stated outcome and an instructor. A single talk, a one-off workshop or a tutorial video is not a course; an in-store workshop belongs on an event page.

This is the pattern for a page where every course is described in full under its own heading. Each Course in the list links to that heading. Where every course has a page of its own, use the collection page pattern instead: a list of links, with the Course on each course page.

How The Pieces Connect

Every node has a stable @id. A node is written out once, where it belongs, and everywhere else it is referenced by that @id alone. This is the map for this page, generated from the output below.

Nodes and the @id links between them
@idDefined onTypeReferenced by
/courses/#webpageThis pageCollectionPageTop-level node
/courses/#breadcrumbThis pageBreadcrumbListCollectionPage.breadcrumb
/courses/#coursesThis pageItemListCollectionPage.mainEntity
/courses/#map-and-compassThis pageCourseNested in ItemList.itemListElement.item
/courses/#wilderness-first-aidThis pageCourseNested in ItemList.itemListElement.item
/courses/#winter-campingThis pageCourseNested in ItemList.itemListElement.item
/courses/#backcountry-cookingThis pageCourseNested in ItemList.itemListElement.item
/#organizationHomepageOnlineStoreCourse.provider
/#websiteHomepageWebSiteCollectionPage.isPartOf

The Builder

One function turns the page's data into the whole graph. It drops anything Google would reject instead of shipping it half built. A list is all or nothing, because it has to hold every item the page shows: one item that fails and the whole list is left out. The input below is a list that passes.

// Course catalog page schema: one page that describes several courses, each
// under its own heading. A CollectionPage with its BreadcrumbList and an
// ItemList that holds a Course per course on the page, taught by the
// Organization from the homepage.
//
// Google shows a course list for three or more courses. Each needs a real
// title and a description, and its url is this page plus the anchor of the
// course's heading. A catalog that falls short has no list at all: the list
// must hold every course the page shows.

const clean = (v) => (typeof v === 'string' ? v.trim() : v);
const isUrl = (v) => typeof v === 'string' && /^https:\/\/[^\s]+$/.test(v);
const compact = (obj) => {
  if (Array.isArray(obj)) {
    const out = obj.map(compact).filter((v) => v !== undefined);
    return out.length ? out : undefined;
  }
  if (obj && typeof obj === 'object') {
    const out = {};
    for (const [k, v] of Object.entries(obj)) {
      const c = compact(v);
      if (c !== undefined) out[k] = c;
    }
    return Object.keys(out).length ? out : undefined;
  }
  return obj === null || obj === '' ? undefined : obj;
};

function breadcrumb(trail, id) {
  const items = (trail || []).filter((c) => c.name && isUrl(c.url));
  if (items.length < 2) return undefined;
  return {
    '@type': 'BreadcrumbList',
    '@id': id,
    itemListElement: items.map((c, i) => ({ '@type': 'ListItem', position: i + 1, name: clean(c.name), item: c.url })),
  };
}

// A real course title: no prices, discounts or sales phrases.
const PROMO = /[$€£]\s?\d|\d+\s?%\s?off|\b(sale|discount|deal|cheap|free|best|top|only|make money)\b/i;
const ANCHOR = /^[A-Za-z][\w-]*$/;

// Google shows about 60 characters of a description, so a short summary is
// used when the full text is longer and a summary exists.
function describe(course) {
  const full = clean(course.description) || '';
  const short = clean(course.summary) || '';
  if (full.length > 60 && short && short.length <= 60) return short;
  return full || short || undefined;
}

// Every course on the page, in page order, or nothing.
function courseItems(courses, pageUrl, providerId) {
  if (courses.length < 3) return undefined;
  const anchors = courses.map((c) => c.anchor);
  if (!anchors.every((a) => ANCHOR.test(a || ''))) return undefined;
  if (new Set(anchors).size !== anchors.length) return undefined;
  const items = [];
  for (const [i, c] of courses.entries()) {
    const name = clean(c.name);
    const description = describe(c);
    if (!name || PROMO.test(name) || !description) return undefined;
    const url = `${pageUrl}#${c.anchor}`;
    items.push({
      '@type': 'ListItem',
      position: i + 1,
      item: { '@type': 'Course', '@id': url, name, description, url, provider: { '@id': providerId } },
    });
  }
  return items;
}

function buildCourseCatalogPageSchema(source) {
  const site = source.site || {};
  const page = source.page || {};
  const catalog = source.catalog || {};
  if (!isUrl(site.url) || !isUrl(page.url) || !catalog.name) return null;

  const root = site.url.replace(/\/+$/, '');
  const pageUrl = page.url;
  const listId = `${pageUrl}#courses`;

  const elements = courseItems(catalog.courses || [], pageUrl, `${root}/#organization`);
  const itemList = elements
    ? { '@type': 'ItemList', '@id': listId, name: clean(catalog.name), itemListElement: elements }
    : undefined;

  const crumbs = breadcrumb(page.breadcrumbs, `${pageUrl}#breadcrumb`);
  const webpage = compact({
    '@type': 'CollectionPage',
    '@id': `${pageUrl}#webpage`,
    url: pageUrl,
    name: clean(page.title) || clean(catalog.name),
    description: clean(catalog.description),
    isPartOf: { '@id': `${root}/#website` },
    breadcrumb: crumbs ? { '@id': crumbs['@id'] } : undefined,
    mainEntity: itemList ? { '@id': listId } : undefined,
  });

  return { '@context': 'https://schema.org', '@graph': [webpage, crumbs, itemList].filter(Boolean) };
}

The Logic As A Flowchart

The same logic as the builder above, drawn for readers who do not write code. Every Yes moves down. A No that runs out to the line on the right stops everything, and no schema is output. Where the path splits, exactly one branch is taken. Each step was run against the builder itself before this page was published: 30 test cases, all passing.

  1. A page that describes several courses
  2. 1Site has an https URL?the home page addressNo: no schema
    Yes
  3. 2Page has an https URL?the address of this pageNo: no schema
    Yes
  4. 3Catalog has a name?the title of the course listNo: no schema
    Yes
  5. Three or more courses, each with a real title, a description and its own anchor?no prices or sales phrases in a title, and no two courses on one anchor
    Yes
    An ItemList holds a Course for every course on the page, each pointing at the homepage Organization as its provider
    No
    No ItemList. The page and its breadcrumb are still output
  6. Two or more breadcrumbs with a name and an https link?the trail shown on the page
    Yes
    A BreadcrumbList is added and linked from the page
    No
    No BreadcrumbList
  7. Build the linked nodesCollectionPage and the course list. Anything optional that is missing or invalid is left out
  8. Output CollectionPage
    No schema

Validation

The output above was run through the SchemaCDN validator, which checks every rule in Google's documentation for each feature. It was validated together with the homepage graph, so the @id links resolve. Result: no errors, and eligible for:

Breadcrumb Carousel Course list

Left Out On Purpose

  • Schedules, instances and prices. Google retired the course info result that used them on Sep 9, 2025, so they no longer earn anything.
  • Ratings on the courses. The course list does not show them.
  • A full Organization inside every course. Each one points at the homepage Organization by @id.

Implementation Checklist

  • Mark up three or more courses, and every course the page shows.
  • Use the course title as people would search for it: no prices, discounts or sales phrases.
  • Keep a summary of 60 characters or fewer for each course. Google shows about that much.
  • Give every course a heading with its own id on the page, so its url lands on it.
  • Run the catalog through the Rich Results Test after adding or removing a course.

Other Page Types