GregMat APIgregmat.com ↗
Access GregMat GRE prep data via API: study plans, video courses, recorded classes, and practice problems with filters for difficulty and question type.
What is the GregMat API?
The GregMat API exposes 5 endpoints covering GRE preparation content from gregmat.com, including structured study plans, video courses, recorded class sessions, and a filterable practice problem bank. The list_problems endpoint alone surfaces per-problem metadata such as acceptance rate, difficulty, question type, and whether a solution video exists, making it straightforward to build custom study tools or problem-set generators on top of GregMat's content library.
curl -X GET 'https://api.parse.bot/scraper/2b9de531-27a7-4cc7-a610-3dcaae141af4/list_study_plans?limit=5&offset=0' \ -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 gregmat-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.
from parse_apis.gregmat_gre_prep_api import GregMat, StudyPlanSummary, Category, Difficulty
client = GregMat()
# List study plans and get details for the first one
for plan_summary in client.studyplans.list(limit=3):
print(plan_summary.title, plan_summary.slug, plan_summary.plus_only)
# Fetch full detail of a study plan
plan = client.studyplans.get(slug="week-1-of-the-one-month-study-plan")
for unit in plan.units:
print(unit.id, unit.title, unit.plus_only)
# Navigate from summary to detail
summary = client.studyplansummary(slug="week-1-of-the-one-month-study-plan")
full_plan = summary.details()
print(full_plan.title, full_plan.description)
# Get a video course
course = client.courses.get(slug="must-see-videos")
print(course.title, course.ongoing)
for group in course.classgroups:
print(group.title, group.order)
for cls in group.classes:
print(cls.title, cls.class_type, cls.plus_only)
# List recent classes
for recent in client.recentclasses.list(limit=5):
print(recent.title, recent.class_type, recent.starts_at)
# Search problems with filters
for problem in client.problems.list(category=Category.QUANT, difficulty=Difficulty.HARD, limit=5):
print(problem.title, problem.acceptance, problem.has_solution_video, problem.first_tlc)
List all available GRE study plans with pagination. Returns plan titles, slugs, and whether they require a Plus subscription. Each plan can be fetched in detail via get_study_plan.
| Param | Type | Description |
|---|---|---|
| limit | integer | Maximum number of study plans to return per page. |
| offset | integer | Number of results to skip for pagination. |
{
"type": "object",
"fields": {
"count": "integer total of available study plans",
"results": "array of study plan summaries"
},
"sample": {
"data": {
"count": 37,
"results": [
{
"img": null,
"slug": "week-1-of-the-one-month-study-plan",
"title": "Week 1 of the One-Month Study Plan",
"plus_only": false
}
]
},
"status": "success"
}
}About the GregMat API
Study Plans and Course Structure
The list_study_plans endpoint returns paginated summaries of all available GRE study plans, each including a title, slug, and a plus_only boolean indicating whether a GregMat Plus subscription is required. Fetching a specific plan via get_study_plan (using its slug) returns the full unit list, where each unit carries an id, title, HTML description with embedded links to videos and problems, and its own plus_only flag — units can be gated independently of the parent plan.
Video Courses and Recorded Classes
get_course retrieves a full course by slug (for example, must-see-videos) and returns a nested structure of classgroups, each containing an array of individual class entries with title, slug, description, image, and type. The ongoing boolean field signals whether the course is still receiving new content. For recent live sessions, list_recent_classes provides paginated results ordered newest-first, with each record including starts_at, ends_at, class_type, associated courses, and a video reference.
Practice Problem Bank
list_problems is the most filter-rich endpoint. It accepts category, difficulty, question_type (such as Quantitative Comparison, Multiple Choice, or Numeric Entry), a numeric tag ID (e.g., 1 for Triangles, 2 for Fractions), and a free-text query. Each result in the paginated response includes id, title, slug, type, difficulty, dynamic_difficulty, acceptance rate, has_solution_video, and likes. Pagination across all list endpoints uses standard limit and offset parameters, and each list response includes a top-level count of total matching records.
The GregMat API is a managed, monitored endpoint for gregmat.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when gregmat.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 gregmat.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 custom GRE study scheduler by pulling unit sequences from
get_study_planand tracking progress against Plus-gated content - Generate adaptive practice sets filtered by
difficultyandquestion_typeusinglist_problemsacceptance-rate data - Surface problems by math topic using the
tagfilter (e.g., triangles, fractions) to build topic-specific drill tools - Create a course browser that shows which GregMat courses are still actively updated via the
ongoingfield fromget_course - Build a recent-classes feed using
list_recent_classeswithstarts_atandends_attimestamps for scheduling or review reminders - Flag problems with available solution videos using
has_solution_videoto guide learners toward explained worked examples - Identify which study plan units require Plus access via the per-unit
plus_onlyfield before surfacing content to free-tier users
| 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 GregMat have an official developer API?+
What does `list_problems` return, and how can I filter it?+
list_problems returns a paginated array of GRE practice problems. Each object includes id, title, slug, difficulty, dynamic_difficulty, acceptance rate, has_solution_video, and likes. You can filter by category, difficulty, question_type (e.g., 'Quantitative Comparison', 'Multiple Choice', 'Numeric Entry'), a numeric tag ID for math topics, or a free-text query against problem titles.Can I retrieve the full text or answer choices for individual practice problems?+
list_problems returns listing-level metadata — title, difficulty, acceptance rate, question type, and whether a solution video exists — but not the full problem body or answer options. You can fork this API on Parse and revise it to add an endpoint that fetches individual problem detail pages.How does Plus-gating appear in study plan responses?+
get_study_plan returns a top-level plus_only boolean for the plan itself, but individual units within the units array each carry their own plus_only flag. A plan that is not Plus-gated overall may still contain individual units that are, so checking both levels is necessary to accurately represent access requirements.