MIT APImit.edu ↗
Access MIT tuition costs, financial aid, degree programs, and course listings via API. 5 endpoints covering ~97 programs and department course data.
What is the MIT API?
The MIT Course Catalog API provides structured access to 5 endpoints covering tuition fee tables, financial aid sections, degree program listings, program requirements, and department course data from mit.edu. The list_programs endpoint returns approximately 97 programs across all MIT schools, each with a slug you can pass directly to get_program_details to retrieve GIR and departmental requirements with course numbers and unit counts.
curl -X GET 'https://api.parse.bot/scraper/3fd7ddaa-7f2f-4350-b7ab-bcd948332da5/get_tuition_costs?level=undergraduate' \ -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 mit-edu-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: MIT Course Catalog SDK — tuition, financial aid, programs, and courses."""
from parse_apis.mit_edu_api import MITCatalog, Level, ProgramNotFound
client = MITCatalog()
# Get undergraduate tuition costs
tuition = client.tuitions.get(level=Level.UNDERGRADUATE)
print(f"Level: {tuition.level}")
for table in tuition.fee_tables[:1]:
for row in table[:3]:
print(f" {row}")
# Get financial aid info for undergraduates
aid = client.financial_aids.get(level=Level.UNDERGRADUATE)
for section in aid.sections[:3]:
print(f"Aid section: {section.heading}")
# List all degree programs and drill into the first one
program_summary = client.program_summaries.list(limit=3).first()
if program_summary:
print(f"Program: {program_summary.name} (slug={program_summary.slug})")
detail = program_summary.details()
print(f" Title: {detail.title}, Department: {detail.department}")
print(f" Requirement tables: {len(detail.requirements)}")
# Typed error: attempt to get a non-existent program
try:
client.programs.get(slug="nonexistent-program-xyz")
except ProgramNotFound as exc:
print(f"Expected error: {exc}")
# List courses in a department via constructible Department
dept = client.department(code="6")
for course in dept.courses.list(limit=5):
print(f" {course.course_number}: {course.title} ({course.units})")
print("exercised: tuitions.get / financial_aids.get / program_summaries.list / programs.get / department.courses.list")
Retrieves tuition and cost information from the MIT Course Catalog for either undergraduate or graduate level. Returns fee tables with itemized costs, extracted dollar amounts, and full descriptive content about attendance costs, visiting student fees, and withdrawal policies.
| Param | Type | Description |
|---|---|---|
| level | string | Education level to retrieve costs for. |
{
"type": "object",
"fields": {
"level": "string",
"content": "string",
"fee_tables": "array of fee tables, each containing rows of fee name and cost",
"cost_figures": "array of unique dollar amounts found in the content"
},
"sample": {
"data": {
"level": "undergraduate",
"content": "Costs\nAttendance Costs...",
"fee_tables": [
[
[
"Fee",
"Cost"
],
[
"Full regular tuition, per term, fall and spring*",
"$32,155"
]
]
],
"cost_figures": [
"$32,155",
"$85,960",
"$995"
]
},
"status": "success"
}
}About the MIT API
Tuition and Financial Aid
The get_tuition_costs endpoint accepts an optional level parameter (undergraduate or graduate) and returns itemized fee_tables — each row containing a fee name and cost — plus an array of cost_figures with every unique dollar amount found in the content. The get_financial_aid endpoint returns structured sections, each with a heading and content field, covering application requirements, eligibility criteria, and aid types for the specified education level.
Degree Programs and Requirements
list_programs returns the full catalog of MIT degree programs as an array of objects with name, slug, and url fields. Pass a slug to get_program_details to retrieve the program's title, department, and requirements — structured tables that include course numbers and unit counts for both GIR (General Institute Requirements) and departmental requirements. Program slugs follow a consistent naming pattern, for example computer-science-engineering-course-6-3.
Course Listings by Department
list_courses requires a department code matching MIT's numbering system — 6 for Electrical Engineering and Computer Science, 18 for Mathematics, 2 for Mechanical Engineering, and so on. Each returned course object includes course_number, title, prerequisites, terms offered, units, and a description. The endpoint returns all courses offered by that department in a single response with a total count.
Coverage Notes
Data reflects the MIT Course Catalog at mit.edu and covers the degree programs and courses listed there. The API does not expose enrollment figures, faculty profiles, research group data, or real-time class availability — only the catalog content itself.
The MIT API is a managed, monitored endpoint for mit.edu — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when mit.edu 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 mit.edu 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 cost comparison tool using
get_tuition_costsfee tables for undergraduate vs. graduate levels - Aggregate financial aid section data to summarize scholarship eligibility criteria across education levels
- Enumerate all ~97 MIT degree programs via
list_programsto populate a program search interface - Extract GIR and departmental requirements from
get_program_detailsto map prerequisite chains - Pull all courses for a department code via
list_coursesto display prerequisites and unit loads - Cross-reference program slugs with course department codes to model full degree plans
- Monitor catalog changes over time by periodically calling
list_programsand diffing program counts
| 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 MIT have an official developer API for its course catalog?+
What does `get_program_details` return, and how do I find the right slug?+
title, department, full content text, and a requirements array of structured tables. Each table row includes a course number and unit count. To find valid slugs, call list_programs first — every program object includes a slug field ready to pass as the required parameter.Does `list_courses` support filtering by term, unit count, or prerequisite?+
courses array. You can fork the API on Parse and revise it to add a server-side filter endpoint if needed.Does the API cover individual course syllabi, reading lists, or lecture notes?+
Are graduate program requirements as detailed as undergraduate ones in `get_program_details`?+
requirements tables returned reflect what the MIT Course Catalog publishes for each program. Some graduate programs list fewer structured requirement rows than undergraduate programs because the catalog itself presents them that way — thesis requirements and advisor-set coursework are often described in prose within the content field rather than in tabular form.