Course Schema in 2026: What Still Works After Deprecation

If you run online courses, a university catalog, a bootcamp, or professional training, Course schema is one of the most valuable types of structured data you can implement, but there's important recent news you need to get right first, because a lot of guides out there are now out of date.

Here's the honest, current picture: in June 2025, Google deprecated the Course Info rich result, the detailed search card that showed price, start date, instructor, and ratings. If you're following a guide that promises that detailed course card, it's describing a feature that no longer exists. But, and this is the encouraging part, the Course List carousel is still very much alive, the underlying Course schema vocabulary remains completely valid, and Course schema has become genuinely essential for a fast-growing channel: AI course search. When someone asks ChatGPT or Google's AI for the best course on a topic, structured course data is how yours gets understood and surfaced.

This guide gives you the accurate 2026 picture: what changed, what still works, exactly what to implement, and why Course schema matters more for AI discovery than the rich result it lost. Let's get your courses found.

What changed in 2025 (and what didn't)

Getting this straight is the foundation for every decision below, so let's be precise.

The Course Info rich result was deprecated in June 2025. This was the detailed course card, a carousel showing rich per-course details like pricing, educational level, ratings, instructor, and length, introduced back in late 2023. Google retired it in June 2025, and by September 2025 it was also removed from Search Console reporting and the Rich Results Test. So if you implement the full Course Info markup expecting that detailed card, you won't get it, the feature is gone.

The Course List carousel is still supported. This is a separate, older feature: a scrollable row of course cards from a single site. It survived the deprecation and remains an active visual feature in Google Search. It's built from ItemList markup, and it's the surviving visual course result you can still earn.

The Course schema vocabulary remains completely valid. The schema.org Course, CourseInstance, and related types are unaffected, they're valid, unpenalized, and actively used both by the surviving Course List carousel and, increasingly, by AI search systems. The deprecation removed a Google display feature, not the vocabulary.

This pattern, a rich result retired while the underlying markup stays valid and useful, is exactly the broader trend in structured data, which we track in our structured data changelog. The takeaway for courses: don't chase the deprecated detailed card, do implement Course schema for the carousel that survives and the AI discovery that's growing.

What you can still get from Course schema

With the picture clear, here's the genuine value available to you in 2026:

The Course List carousel, the scrollable row of your courses in Google Search, earned through ItemList markup with at least three courses. This is the surviving visual feature and a real visibility win for course providers.

AI course discovery, the fast-growing reason, and arguably now the bigger one. When a learner asks "what are the best online Python courses?" or "find me a beginner data science bootcamp" in ChatGPT Search, Perplexity, or Google's AI, these systems parse structured data to identify courses, their providers, levels, and pricing. A well-implemented Course schema makes your course a structured, machine-readable entity, significantly more likely to be understood and surfaced than a page with only prose.

Knowledge Graph grounding, marking up your institution as an EducationalOrganization or CollegeOrUniversity helps ground it as a recognized entity, strengthening the trust signals that help across both search and AI.

None of this depends on the deprecated card. All of it is available now, and most course providers haven't implemented it well.

The Course List carousel: requirements

To earn the surviving carousel, you build an ItemList of your courses. The requirements are specific:

• At least three courses. The carousel needs a minimum of three ListItem entries, fewer won't trigger it.
• Sequential positions. Each ListItem needs a position (1, 2, 3...) defining its order.
• A unique URL per course. Each course must have its own unique url pointing to its individual detail page. Duplicate URLs cause errors, if the same course exists at multiple URLs, canonicalize first and mark up only the canonical.
• Each course needs a name and a provider. The provider is strongly recommended, needing a name and optionally a sameAs link to the organization's homepage.

The structure is a summary or catalog page carrying the ItemList, with each ListItem pointing to an individual course page. Those individual pages then carry their own detailed Course markup, covered next.

A complete Course List example

Here's the carousel structure, an ItemList referencing individual courses:

{
  "@context": "https://schema.org",
  "@type": "ItemList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "item": {
        "@type": "Course",
        "name": "Python for Beginners",
        "url": "https://example.com/courses/python-beginners",
        "description": "A hands-on introduction to Python programming for complete beginners.",
        "provider": {
          "@type": "Organization",
          "name": "Bright Academy",
          "sameAs": "https://example.com"
        }
      }
    },
    {
      "@type": "ListItem",
      "position": 2,
      "item": {
        "@type": "Course",
        "name": "Intermediate Python",
        "url": "https://example.com/courses/intermediate-python",
        "provider": { "@type": "Organization", "name": "Bright Academy", "sameAs": "https://example.com" }
      }
    },
    {
      "@type": "ListItem",
      "position": 3,
      "item": {
        "@type": "Course",
        "name": "Data Science with Python",
        "url": "https://example.com/courses/data-science-python",
        "provider": { "@type": "Organization", "name": "Bright Academy", "sameAs": "https://example.com" }
      }
    }
  ]
}

Three courses, sequential positions, unique URLs, each with a provider. That's the minimum for the carousel. Now let's enrich the individual course pages.

The Course entity: full properties

On each individual course page, a complete Course entity gives Google and AI a rich, machine-readable picture. Beyond name, description, and provider, the valuable properties are:

• hasCourseInstance, specific offerings of the course (dates, mode, instructor), covered in detail next; at least one is expected for a complete course entity
• about, the skills or knowledge learners gain
• educationalLevel, beginner, intermediate, advanced
• coursePrerequisites, required prior knowledge, as text or links to prerequisite courses
• offers, pricing, with a numeric price and priceCurrency (or marked as free)
• availableLanguage, the languages offered, as ISO 639-1 codes
• aggregateRating, average rating from genuine learner reviews, if you have them
• datePublished, when the course was first published
• courseCode, your internal course identifier
• timeRequired or totalHistoricalEnrollment, duration and popularity signals

Even though the detailed rich card is gone, filling these in is far from wasted effort, this is precisely the structured detail AI systems parse when matching courses to learner queries. A course marked up with its level, prerequisites, skills, price, and language is a course an AI can confidently recommend for the right query. Rich course entities are an AI-discovery asset, not a rich-result one.

CourseInstance: specific offerings

hasCourseInstance describes actual offerings of a course, the specific cohorts, terms, or sessions people can enroll in. This is where scheduling and delivery detail live:

"hasCourseInstance": {
  "@type": "CourseInstance",
  "courseMode": "Online",
  "startDate": "2026-09-14",
  "endDate": "2026-11-23",
  "instructor": {
    "@type": "Person",
    "name": "Dr. Maria Santos"
  }
}

Key properties:

• courseMode, how it's delivered: Online, Onsite, or Blended. This matters enormously for matching, since learners search specifically for online or in-person courses.
• startDate and endDate, when the instance runs, in ISO 8601 format.
• instructor, who teaches it, as a Person entity (more on this below).
• location, for onsite instances, a Place; for online, you can use a VirtualLocation.

For a course that runs multiple times a year, you can provide multiple CourseInstance entries, each a specific cohort. This tells machines exactly when and how learners can take your course, which is precisely what an AI needs to answer "what data science courses start this autumn?"

Provider and institution: grounding your entity

The provider connects each course to the organization offering it, and this is where Course schema ties into the broader entity picture that matters so much for AI search.

Mark up your institution properly as an EducationalOrganization, or the more specific CollegeOrUniversity or School where accurate. This grounds your institution as a recognized entity, helping it appear correctly in the Knowledge Graph and strengthening the trust signals that carry across search and AI. When your courses connect to a well-defined institutional entity, which connects to its identity and reputation, you're building the kind of connected entity graph that AI systems rely on to trust and surface educational content.

This is the same entity thinking behind a strong brand entity profile, your courses are offerings of your institutional entity, and connecting them properly makes the whole stronger. A recognized educational institution offering clearly-structured courses is far more citable, in both search and AI, than a set of disconnected course pages.

Instructors as Person entities

Your instructors are a real asset, and modeling them as proper Person entities strengthens both your courses and your institution's authority.

An instructor with a defined identity, credentials, a role, links to their professional profiles, lends genuine expertise signal to the course they teach. This is the same author-and-expert entity work that establishes E-E-A-T across your content, applied to teaching: an instructor marked up as a credentialed Person, connected to your institution, tells machines a real expert stands behind the course. For education especially, where the instructor's expertise is central to a course's value, this is worth doing well. Our Person and author schema guide covers building strong person entities in depth, the same principles apply directly to your instructors.

Course schema and AI course search

This is the reason Course schema matters more in 2026 than it did when the detailed card existed, so it's worth dwelling on.

Learners increasingly begin their search for courses with AI. They ask ChatGPT, Perplexity, or Google's AI open questions, "what's the best online course for learning SQL?", "beginner-friendly UX design bootcamps", "affordable data science courses I can do part-time", and these systems answer by parsing structured data to identify courses, their providers, levels, modes, schedules, and prices. Clean, complete Course schema is what makes your course a structured entity these systems can understand and recommend accurately, rather than prose they have to interpret and might get wrong.

So the strategic shift is this: the value of Course schema has migrated from earning a Google display card to being understood by AI course search. That's a more durable and arguably more valuable place for it to be, the detailed card was one Google feature that could be, and was, retired, while machine-readability for AI discovery is a growing, cross-platform requirement no one can remove. Marking up your courses richly and accurately positions them exactly where course discovery is heading. It's the same principle as getting cited by AI systems generally: the clearer and more structured your information, the more accurately AI can understand and surface it.

What you should NOT mark up as a Course

A quick but important accuracy point, because marking up ineligible content causes errors: Course schema is for specific educational courses, not for everything education-adjacent.

Don't apply Course markup to degree program overview pages that aren't a specific course, general "our programs" landing pages, or broad topic pages. These aren't courses in the schema sense, and marking them up as such generates errors and misrepresents your content. Reserve Course for pages describing an actual, specific course someone can take. For your institution overall, use EducationalOrganization; for events like open days, use Event; for a genuine course, use Course.

Common mistakes to avoid

Implementing the deprecated Course Info card. The big current one, following an old guide that promises the detailed course card retired in June 2025. Implement for the surviving carousel and AI discovery instead.

Duplicate course URLs. Each course in an ItemList needs a unique URL. Same course at multiple URLs causes errors, canonicalize first.

Fewer than three courses. The Course List carousel needs at least three. With fewer, focus on rich individual Course markup for AI discovery rather than expecting the carousel.

Missing provider. Provider is strongly recommended and central to how courses are attributed. Include it, connected to your institution entity.

Marking up non-courses. Degree overviews and program landing pages aren't courses. Reserve Course markup for specific courses.

Thin course entities. Just name and description leaves most of the AI-discovery value unclaimed. Add level, prerequisites, mode, schedule, price, and instructor.

Markup that doesn't match the page. As always, your course schema must reflect what's genuinely on the page, real courses, real prices, real schedules.

Implementing it on WordPress

Course providers on WordPress usually run an LMS, LearnDash, LifterLMS, Tutor LMS, Sensei, and your approach should fit it.

Check what your LMS or SEO plugin outputs, view source on a course page and see whether it produces Course markup, whether it includes the valuable properties (mode, instances, provider, level), and whether it correctly avoids the deprecated Course Info expectations. Many produce thin or outdated course markup.

The challenge is richness and accuracy at scale, a complete Course entity per course, with instances, provider connection, and instructor entities, kept accurate as schedules and prices change across a catalog. Hand-maintaining that is impractical for anything beyond a handful of courses.

Generating from your course content is what scales. AI Schema Gen reads your course pages and generates complete, current Course schema, with instances, provider connections to your institution entity, and instructor entities, and because it generates from your live content, your schedules, prices, and details stay accurate as they change. It also connects your courses, institution, and instructors into a coherent entity graph, which is exactly what AI course search rewards, and it builds for the surviving carousel and AI discovery rather than the deprecated card. Whatever route you take, the tests are: rich Course entities with instances and providers; a valid ItemList for the carousel; instructors as real entities; and accuracy as your catalog changes.

Validating your course schema

The Schema Markup Validator at validator.schema.org is your primary tool, since it checks the full Course vocabulary, important now that the Rich Results Test no longer covers the deprecated Course Info.

Google's Rich Results Test still validates the Course List carousel eligibility, test your catalog page with its ItemList. Note it will no longer show the deprecated detailed course card, and that's expected.

Check your ItemList has at least three courses with unique URLs and sequential positions, and that each connects to a provider.

Confirm accuracy, that prices, schedules, modes, and instructors in your markup match your actual course offerings, and update them as your catalog changes.

Running courses on WordPress? AI Schema Gen generates complete, current Course schema from your course pages, instances, providers, and instructor entities, connected into your institution's entity graph and built for the surviving carousel and AI course discovery. Start free at aischemagen.com.