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.
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.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/77533f4c-6adf-417b-baef-20019e5d3422/get_all_paths' \ -H 'X-API-Key: $PARSE_API_KEY'
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")
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.
No input parameters required.
{
"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.
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.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a curriculum browser that lists all Odin Project paths and courses using
get_all_pathsandget_path. - Generate a structured syllabus document for any course using the
sectionsandlessonsarrays fromget_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_checkquestions fromget_lesson. - Track lesson freshness by polling
get_lesson_changelogto detect recent GitHub commits on lesson files. - Enumerate all projects in a specific course using
get_projectsfiltered bypath_slugandcourse_slug. - Power a lesson search feature in a learning tool using
search_lessonswith a user-enteredquery.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 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.
Does The Odin Project have an official developer API?+
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?+
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?+
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.