Discover/The Odin Project API
live

The Odin Project APItheodinproject.com

Access The Odin Project's full curriculum via API: learning paths, courses, lessons, projects, resources, and changelogs. 10 endpoints, structured JSON.

Endpoint health
verified 4d ago
get_lesson_changelog
get_all_paths
get_path_curriculum_outline
get_projects
get_all_lessons_for_course
10/10 passing latest checkself-healing
Endpoints
10
Updated
26d ago

What is the The Odin Project API?

This API exposes 10 endpoints covering The Odin Project's entire open-source curriculum, from top-level learning paths down to individual lesson content. Call get_lesson to retrieve a lesson's HTML sections, assignment links, and knowledge-check questions by slug, or use get_path_curriculum_outline to pull a complete hierarchical view of every course and section in a single path.

Try it

No input parameters required.

api.parse.bot/scraper/77533f4c-6adf-417b-baef-20019e5d3422/<endpoint>
Ready to send
Fill in the parameters and hit sign in to send to see live response data here.
Call it over HTTPgrab a free API key at signup
curl -X GET 'https://api.parse.bot/scraper/77533f4c-6adf-417b-baef-20019e5d3422/get_all_paths' \
  -H 'X-API-Key: $PARSE_API_KEY'
Python SDK · recommended

Typed, relational, agent-ready

A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.

  • Fully typed · autocompletes
  • Objects link to objects
  • Typed errors & pagination

Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:

uv add parse-sdk
uv run parse init
uv run parse add --marketplace theodinproject-com-api

uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.

"""Walkthrough: The Odin Project SDK — bounded, re-runnable; every call capped."""
from parse_apis.the_odin_project_api import OdinProject, PathSlug, ResourceNotFound

client = OdinProject()

# List all available learning paths
for path in client.paths.list(limit=5):
    print(path.title, path.slug, path.course_count)

# Get a specific path by slug enum, then list its courses
foundations = client.paths.get(slug=PathSlug.FOUNDATIONS)
first_course = foundations.courses.list(limit=1).first()

# Drill into the course: get full details with sections
if first_course:
    detail = first_course.details()
    print(detail.title, detail.description[:80])
    for section in detail.sections[:2]:
        print(section.name)
        for lesson in section.lessons[:3]:
            print(lesson.title, lesson.type, lesson.slug)

    # List all lessons for the course
    for ls in first_course.lessons.list(limit=5):
        print(ls.title, ls.type, ls.section)

    # List projects in the course
    for proj in first_course.projects.list(limit=3):
        print(proj.title, proj.slug, proj.type)

# Search lessons by keyword
for match in client.paths.search_lessons(query="html", limit=3):
    print(match.title, match.slug, match.path, match.course)

# Get full lesson content and sub-operations
lesson = client.lessons.get(slug="introduction-to-html-and-css")
print(lesson.title, lesson.course, lesson.github_edit_url)
for q in lesson.knowledge_check[:2]:
    print(q)

# Get lesson resources
res = lesson.resources()
for link in res.all_links[:3]:
    print(link.title, link.url, link.section)

# Get lesson changelog
cl = lesson.changelog()
print(cl.lesson_title, cl.changelog_url)

# Typed error handling
try:
    client.lessons.get(slug="nonexistent-lesson-slug-xyz")
except ResourceNotFound as exc:
    print(f"not found: {exc}")

print("exercised: paths.list / paths.get / courses.list / details / lessons.list / projects.list / search_lessons / lessons.get / resources / changelog")
All endpoints · 10 totalmissing one? ·

Returns all learning paths available on The Odin Project. Each path contains metadata including title, slug, description, course count, and URL. Use this as the entry point to discover available curricula.

Input

No input parameters required.

Response
{
  "type": "object",
  "fields": {
    "paths": "array of path summary objects"
  },
  "sample": {
    "data": {
      "paths": [
        {
          "url": "https://www.theodinproject.com/paths/foundations",
          "slug": "foundations",
          "title": "Foundations",
          "description": "",
          "course_count": 0
        },
        {
          "url": "https://www.theodinproject.com/paths/full-stack-ruby-on-rails",
          "slug": "full-stack-ruby-on-rails",
          "title": "Full Stack Ruby on Rails",
          "description": "PATH",
          "course_count": 8
        },
        {
          "url": "https://www.theodinproject.com/paths/full-stack-javascript",
          "slug": "full-stack-javascript",
          "title": "Full Stack JavaScript",
          "description": "PATH",
          "course_count": 7
        }
      ]
    },
    "status": "success"
  }
}

About the The Odin Project API

Curriculum Structure

The API models The Odin Project's three-tier hierarchy: paths, courses, and lessons. get_all_paths returns every available learning path with its title, slug, description, and course_count. From there, get_path accepts a slug and returns the path's courses with per-course lesson_count and project_count. get_course goes one level deeper, returning a course's sections array where each section contains an ordered list of lessons and projects, plus a description for the course itself.

Lesson-Level Data

get_lesson is the most field-rich endpoint. Given a lesson slug, it returns the full sections array (each with a name and HTML content), an assignment array of titled external links, a knowledge_check array of question strings, and a github_edit_url pointing to the lesson's source file. get_lesson_resources breaks out all hyperlinks in a lesson into all_links (grouped by source section) and assignment_links — useful when you want to catalog every external reference without parsing HTML yourself.

Filtering and Search

get_all_lessons_for_course takes both path_slug and course_slug and returns a flat ordered list of lessons with title, slug, url, type, and section — the type field distinguishes regular lessons from projects. get_projects shares the same optional filters; omitting both params returns projects across all paths but is noted as slower. search_lessons accepts a query string and matches case-insensitively against lesson titles, currently scoped to the Foundations path. Results include path and course context alongside the lesson slug and type.

Changelog Access

get_lesson_changelog returns a changelog_url — the GitHub commits page for a lesson's source file — alongside the lesson_title. This lets you track when any lesson was last updated directly from the response without navigating GitHub manually.

Reliability & maintenanceVerified

The The Odin Project API is a managed, monitored endpoint for theodinproject.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when theodinproject.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.

This isn't an official theodinproject.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.

Last verified
4d ago
Latest check
10/10 endpoints passing
Maintenance
Monitored & self-healing
Will this API break when the source site changes?+
It's built not to. Every endpoint is health-checked on a schedule with automated test probes. When the source site changes and a check fails, the API is automatically queued for repair and re-verified — that's the self-healing layer. Each API page shows when its endpoints were last verified. And because marketplace APIs are shared, any fix reaches everyone using it.
Is this an official API from the source site?+
No — Parse APIs are independent, managed REST wrappers over publicly available data. That is the point: where a site has no official API (or only a limited one), Parse gives you a maintained, monitored endpoint for that data and keeps it working as the site changes — so you get a stable contract over a source that never promised one.
Can I fix or extend this API myself if I need a new endpoint or field?+
Yes — and you don't have to wait on us. This API was generated by the Parse agent, which stays attached. Describe the change in plain English ("add an endpoint that returns reviews", "fix the price field") in the revise box on the API page or via the revise_api MCP tool, and the agent rebuilds it against the live site in minutes. Contributing the change back to the public API is free.
What happens if I call an endpoint that has an issue?+
Errors are machine-readable: a bad call returns a clean status with the list of available endpoints and a repair hint, so an agent (or you) can recover or trigger a fix instead of failing silently. Confirmed failures feed the automatic repair queue.
Common use cases
  • Build a curriculum browser that lists all Odin Project paths and courses using get_all_paths and get_path.
  • Generate a structured syllabus document for any course using the sections and lessons arrays from get_course.
  • Index all assignment links across lessons for a curated external-resources directory via get_lesson_resources.
  • Populate a quiz or flashcard app with knowledge_check questions from get_lesson.
  • Track lesson freshness by polling get_lesson_changelog to detect recent GitHub commits on lesson files.
  • Enumerate all projects in a specific course using get_projects filtered by path_slug and course_slug.
  • Power a lesson search feature in a learning tool using search_lessons with a user-entered query.
Pricing & limitsSee full pricing →
TierPriceCredits/monthRate limit
Free$0/mo1005 req/min
Hobby$30/mo1,00020 req/min
Developer$100/mo5,000100 req/min

One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.

Frequently asked questions
Does The Odin Project have an official developer API?+
No. The Odin Project does not publish an official public REST or GraphQL API for programmatic curriculum access. This Parse API provides structured JSON access to the same curriculum data.
What does `get_lesson` return beyond the lesson text?+
get_lesson returns a sections array of named HTML content blocks, an assignment array of external links with titles and URLs, a knowledge_check array of question strings, and a github_edit_url. The course field identifies the parent course, though it may be empty for some lessons.
Is `search_lessons` scoped to the entire curriculum?+
No. search_lessons currently matches against lesson titles in the Foundations path only. The response includes a note field that states this scope. It does not search lesson body content, only titles. You can fork this API on Parse and revise it to extend search coverage to additional paths or full-text content.
Does the API expose user progress, accounts, or completion data?+
No. The API covers curriculum structure only: paths, courses, lessons, projects, and associated links. User accounts, progress tracking, and community forum data are not included. You can fork this API on Parse and revise it to add endpoints for any publicly accessible data the site exposes.
What is the difference between `get_course` and `get_all_lessons_for_course`?+
get_course returns the course's sections hierarchy with nested lesson lists and includes the course description. get_all_lessons_for_course flattens that into a single ordered array where each lesson carries a type field (lesson or project) and a section label — useful when you need a linear sequence rather than a nested structure.
Page content last updated . Spec covers 10 endpoints from theodinproject.com.
Related APIs in EducationSee all →
roadmap.sh API
Discover and access structured learning roadmaps, detailed guides, interview questions, and community projects to build your development skills across different technologies and career paths. Search through curated learning content, explore topic breakdowns, and find project ideas tailored to your learning goals.
hyperskill.org API
Explore Hyperskill.org's learning content by browsing tracks, projects, stages, and topics, or retrieve detailed information about any specific course component and educational provider. Search and filter through the platform's complete curriculum to find exactly what you need for your learning journey.
runoob.com API
Access comprehensive programming tutorials and learning materials from Runoob, including browsing categories and directories, retrieving full tutorial content, and searching across thousands of coding lessons. Discover structured learning paths by category, view navigation links, and get detailed metadata to help you find exactly what you need to learn.
cfainstitute.org API
Access the complete CFA Program curriculum across all three levels, including topics, learning modules, and Learning Outcome Statements directly from official CFA Institute materials. Search and retrieve structured exam content to study efficiently, compare learning objectives, or build study tools.
coloso.global API
Discover and browse Coloso's entire course catalog by searching products, filtering by categories, and viewing details on new releases, best sellers, and free classes. Get insights into promotional events, trending keywords, and personalized recommendations to find the perfect creative courses.
voanews.com API
Access VOA Learning English lessons, programs, and vocabulary across all proficiency levels, search for specific content, and retrieve detailed lesson information with transcripts. Browse featured homepage content and explore lessons by category to find the perfect English learning materials for your level.
neetcode.io API
Access curated coding problem collections including Core Skills, Blind 75, NeetCode 150, and NeetCode 250, along with detailed problem solutions and course content organized by chapters and lessons. Perfect for preparing for technical interviews and mastering data structures and algorithms through structured learning paths.
overthewire.org API
Access structured data from the OverTheWire wargames platform, including the full list of wargames, per-level goals and instructions, SSH connection details, community rules, and the recommended progression order. Supports lookups by wargame name or level number across all available challenges.