Free Course Instance Schema Generator

Fill in the facts visible on your page, copy the Course Instance JSON-LD, and validate it before you publish. The guide, examples, and FAQs are below the tool. Generate this schema with AI

Type to filter 121 supported schema types.

Schema workflow

Use only facts a visitor can verify on the page, then validate the JSON-LD before publishing.

Required

  • Visible Course Instance content
  • Canonical page URL
  • Clear page owner/publisher
  • Fields that match the visible page

Recommended

  • A representative image when the schema supports it
  • SameAs or related links when visible
  • Validation before publishing

Avoid

  • Adding properties that are not visible
  • Copying example URLs into production
  • Skipping Google and Schema.org validation

Schema stacks

Use Course Instance schema in a stack

Complete JSON-LD bundles that combine Course Instance with the other types a real page needs. Browse all stacks

  • Education Schema Stack

    Course pages with scheduled CourseInstances, FAQs, and breadcrumb context for education programs.

  • Course Marketplace Stack

    Course catalog/category pages with ItemList of courses and instances, FAQs, and breadcrumb context.

  • Language School Stack

    Language program pages with EducationalOrganization + Course + CourseInstance, FAQs, and breadcrumbs.

  • Campus / Education Stack

    Campus or department pages with educational org, courses, instances, FAQs, and breadcrumb context.

  • Course Pathway / Track Stack

    Learning tracks listing multiple courses and instances with FAQs and breadcrumb navigation.

Next step

Validate, repair, and publish clean structured data.

Check the generated JSON-LD against the visible page, then run both SwiftSchema and external validators before publishing.

Course Instance Schema Generator — Publish Scheduled Runs

Generate clean CourseInstance JSON‑LD for a specific session. Clarify dates, instructors, and attendance mode, nested under its parent Course.

Try the CourseInstance Generator

Why many course run pages underperform

  • Dates lack timezones or clarity between start/end.
  • Attendance mode (online/in‑person) and location details are ambiguous.
  • The session is not linked to a canonical Course object.
  • Instructor details are missing or not structured.

How SwiftSchema helps

The CourseInstance generator focuses on the essentials for a scheduled run: startDate (and endDate when known), attendance mode via courseMode, and a proper location (Place or VirtualLocation).

It embeds or references the parent Course with a name (and URL) and supports adding one or more instructors with names and optional URLs.

How it works

  1. 01

    Choose CourseInstance in the generator below.

  2. 02

    Provide startDate (and endDate) with clear formats; set courseMode and attendance expectations.

  3. 03

    Add a location: Place (with a name) for in‑person or VirtualLocation with a registration/join URL.

  4. 04

    Reference or embed the parent Course with name (and URL) and add instructors.

  5. 05

    Copy JSON or Script, paste on the session page, and validate in the Schema Markup Validator.

Ready to build the markup?

Paste once per session. Validate. Ship.

Generate CourseInstance JSON‑LD

What is CourseInstance structured data?

CourseInstance captures the details of a specific run or cohort of a Course—start/end dates, attendance mode, location, instructors, and the parent Course reference. It’s ideal for scheduled bootcamps, university terms, webinars, and live training sessions. While the Course object explains what learners will cover, CourseInstance tells search engines “this cohort starts on X date, lasts Y weeks, and happens in Z format.” Linking each instance back to the parent Course helps Google consolidate catalog entries and improves visibility in education-focused surfaces.

Required and high-impact properties

  1. startDate — ISO 8601 with timezone (2026-01-10T18:00:00-05:00).
  2. endDate — optional but recommended, especially for multi-week cohorts.
  3. courseMode — online, onSite, blended, asynchronous, etc. Combine terms (e.g., “online synchronous”) if helpful.
  4. location — Place (with name + PostalAddress) for in-person or VirtualLocation (with url) for remote sessions.
  5. Parent course — CourseInstance has no property that points to its course. Publish the Course (name, url, description) and nest each session under its hasCourseInstance.
  6. instructor — Person or Organization with name and optional url, sameAs.
  7. offers — price, currency, availability, and registration URL when the session is paid.
  8. maximumAttendeeCapacity / remainingAttendeeCapacity — optional fields to communicate seat limits.
  9. performer / organizer — optional, usually the same as instructor or the parent Organization.

Content prep checklist

  • Publish clear session details: start/end dates (with time zones), meeting cadence, and delivery format.
  • Introduce instructors or facilitators with bios and links to their profiles.
  • Identify prerequisites, required materials, and outcomes (certificates, credits).
  • Provide venue info for on-site sessions: address, building, room, accessibility notes.
  • Include tuition/pricing, payment plan options, and refund/cancellation policies if publicly available.
  • Add prominent registration CTAs, deadlines, and waitlist links. Note if seats are limited.

Implementation workflow

  1. Update the landing page with the content above, ensuring the parent Course exists (either on the same page or separate).
  2. Generate CourseInstance JSON‑LD with start/end dates, courseMode, location, and instructors, nested under the Course with hasCourseInstance.
  3. Reference the parent Course either inline or via @id. Make sure the Course object includes name, description, provider, and url.
  4. Include Offers for paid cohorts. Use multiple Offers for tiered pricing (early bird vs standard) and set availabilityStarts/Ends.
  5. Embed the schema once per session. If the page lists multiple sessions, include multiple CourseInstance objects with unique identifiers.
  6. Validate in the Schema Markup Validator; fix warnings about missing Course data or invalid timestamps.
  7. Monitor Search Console for structured data coverage and track conversions via analytics.

Handling recurring and dynamic schedules

  • For self-paced courses, stick with Course schema. Use CourseInstance only when there’s a specific start date.
  • For rolling admissions, update startDate and endDate to reflect the next available cohort, and archive past cohorts (schema.org has no completed status, so label them as past on the page).
  • If sessions repeat (monthly webinars), consider Event/EventSeries for simpler models; use CourseInstance when the content is clearly tied to a Course curriculum.
  • When you load schedules dynamically (React components, calendar widgets), ensure the JSON‑LD reflects the same data on first paint to avoid mismatches.

Attendance modes and locations

  • Set courseMode to describe the delivery format (“online asynchronous,” “onSite in-person,” “hybrid”).
  • Use location: VirtualLocation for remote, Place + PostalAddress for on-site. For hybrid, you can include both or note the flexibility in courseMode.
  • Provide a url within VirtualLocation pointing to the registration or webinar platform login page.
  • For travel-heavy trainings, mention multi-city itineraries in the content and consider modeling separate CourseInstances per city if they have unique schedules.

Offers and enrollment

  • Use Offer with price, priceCurrency, url, availability, validFrom, validThrough.
  • Include eligibleQuantity or remainingAttendeeCapacity to highlight limited seats.
  • Mark free cohorts with price: 0 but still include availability.
  • Update Offers when price changes or the cohort closes; keeping stale prices can trigger policy issues.
  • Mention scholarships or employer-sponsored pricing in the visible copy, and keep schema focused on publicly advertised prices to avoid compliance issues.
  • For invite-only cohorts, set availability to LimitedAvailability and describe the application process.

Troubleshooting checklist

  • Missing parent Course: publish the Course with its name and url, and nest each session under its hasCourseInstance.
  • Ambiguous attendance: specify courseMode (“online”, “onSite”, “blended”) and provide proper location.
  • No timezone: include offsets in ISO timestamps (2026-03-02T14:00:00+01:00).
  • Stale data: update the schema for every new cohort; don’t keep last season’s dates live.
  • Duplicate identifiers: if listing multiple sessions on one page, give each CourseInstance a unique @id.

Maintenance and QA tips

  • Maintain a scheduling spreadsheet with fields for URL, start/end dates, instructors, and status (planned/live/completed). Use it to drive both content and schema updates.
  • After launching a new cohort, request indexing in Search Console to help search engines pick up the new dates quickly.
  • If a cohort is canceled or postponed, update eventStatus (EventCancelled, EventPostponed) and adjust copy so registrants aren’t confused.
  • Set automated reminders to audit CourseInstance pages quarterly, ensuring instructors, venues, and pricing remain accurate.
  • Build integration tests that compare on-page dates to JSON‑LD values to catch drift between CMS content and schema.

Common Errors & Fixes

  • Missing parent Course: link to the canonical Course with name and url.
  • Ambiguous attendance: specify courseMode and provide concrete location objects.
  • No timezone: use ISO 8601 timestamps with offsets.
  • Instructors omitted: add instructor entries with names/links to build trust.
  • Offers lacking detail: include price, currency, and URL for paid sessions.

Required properties

  • startDate

Recommended properties

  • endDate
  • courseMode
  • instructor.name
  • location.name
Minimal JSON-LD
Validate
{
  "@context": "https://schema.org",
  "@type": "Course",
  "name": "Intro to Python",
  "hasCourseInstance": {
    "@type": "CourseInstance",
    "courseMode": "online",
    "startDate": "2026-01-10"
  }
}

FAQs

Do I need a Course too?Show

Yes. CourseInstance has no property that points back to its course, so publish the Course and list each session under its hasCourseInstance property.

Online classes?Show

Set location as VirtualLocation and provide a registration URL on the page.

Related types

Browse all schema types

References