RateMyProfessors APIratemyprofessors.com ↗
Access professor ratings, reviews, difficulty scores, and student tags from RateMyProfessors.com. Search by name, filter by school, and fetch full profiles.
What is the RateMyProfessors API?
This API exposes professor data from RateMyProfessors.com across 3 endpoints, covering aggregate scores, individual student reviews, course lists, and tag summaries. The search_professors endpoint lets you query by professor name and optionally narrow results to a specific school, while get_professor_details returns the full profile including recent comments, difficulty ratings, and top student-generated tags.
curl -X GET 'https://api.parse.bot/scraper/32ad44ea-e63f-4810-a4fe-10e409452bae/search_professors?limit=5&query=Smith' \ -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 ratemyprofessors-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: RateMyProfessors SDK — search, drill-down, lookup by name, typed errors."""
from parse_apis.ratemyprofessors_api import RateMyProfessors, ProfessorNotFound
client = RateMyProfessors()
# Search professors by name — limit= caps total items fetched.
for prof in client.professorsummaries.search(query="Smith", limit=3):
print(prof.full_name, prof.school_name, prof.avg_rating)
# Drill-down: take one result, then fetch full details via .details()
summary = client.professorsummaries.search(query="Johnson", limit=1).first()
if summary:
detail = summary.details()
print(detail.full_name, detail.department, detail.school_name)
print(detail.aggregate_ratings.overall_avg_rating, detail.aggregate_ratings.avg_difficulty_rating)
for review in detail.recent_reviews[:2]:
print(review.course_name, review.quality_rating, review.comment[:80])
# Lookup professor by name directly (convenience — searches then fetches best match)
prof = client.professors.lookup_by_name(name="John Smith")
print(prof.full_name, prof.department, prof.aggregate_ratings.total_num_ratings)
# Direct fetch by known ID
prof = client.professors.get(professor_id="VGVhY2hlci0xNjA4NzAw")
print(prof.full_name, prof.aggregate_ratings.total_num_ratings)
for course in prof.courses_taught[:3]:
print(course.course_code, course.num_ratings)
# Typed error handling for a non-existent professor
try:
client.professors.get(professor_id="9999999")
except ProfessorNotFound as exc:
print(f"Not found: {exc}")
print("exercised: professorsummaries.search / summary.details / professors.lookup_by_name / professors.get / ProfessorNotFound")
Search for professors by name and optionally filter by school. Returns a list of matching professors with basic rating info. The total field reports the server-side match count (capped at 10000); use limit to control how many results are returned per call.
| Param | Type | Description |
|---|---|---|
| limit | integer | Maximum number of results to return (up to 250) |
| queryrequired | string | Professor name to search for |
| school_id | string | Optional school ID (base64-encoded) to filter results by a specific school |
{
"type": "object",
"fields": {
"total": "integer total number of matching professors (server capped at 10000)",
"professors": "array of professor summary objects with professor_id, full_name, legacy_id, department, school_name, avg_rating, num_ratings"
},
"sample": {
"data": {
"total": 10000,
"professors": [
{
"full_name": "Wayne Smith",
"legacy_id": 858279,
"avg_rating": 2.9,
"department": "Business",
"num_ratings": 301,
"school_name": "California State University - Northridge",
"professor_id": "VGVhY2hlci04NTgyNzk="
}
]
},
"status": "success"
}
}About the RateMyProfessors API
What the API Returns
The three endpoints cover the core professor data on RateMyProfessors.com. search_professors accepts a required query string and an optional school_id (base64-encoded), returning up to 250 matches per call. Each result includes professor_id, full_name, department, school_name, avg_rating, and num_ratings — enough to identify and compare professors before fetching a full profile.
Professor Profiles
get_professor_details accepts either a base64-encoded professor ID or a legacy numeric ID (auto-converted internally) and returns the complete profile. The aggregate_ratings object contains overall_avg_rating, total_num_ratings, would_take_again_percent, and avg_difficulty_rating. The courses_taught array lists each course code alongside how many ratings it has, and top_rating_tags shows student-generated labels with their occurrence counts.
Reviews and Convenience Lookup
The recent_reviews array on both detail endpoints includes per-review fields: comment, date, course_name, quality_rating, clarity_rating, difficulty_rating, would_take_again, and grad (indicating graduate-level). The third endpoint, get_professor_by_name, combines a search and a profile fetch into a single call — useful when you have a name but not an ID. It returns the full profile of the best match, or a stale_input signal when no match is found.
The RateMyProfessors API is a managed, monitored endpoint for ratemyprofessors.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when ratemyprofessors.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 ratemyprofessors.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 course-selection tool that surfaces a professor's
avg_difficulty_ratingandwould_take_again_percentalongside the syllabus. - Aggregate
top_rating_tagsacross a department to identify teaching patterns or common student concerns. - Track how a professor's
overall_avg_ratingandtotal_num_ratingschange over academic terms. - Filter
recent_reviewsbycourse_nameto show students reviews specific to the class they are considering. - Identify which courses in
courses_taughthave the most review volume for deeper per-course analysis. - Cross-reference
school_idfiltering insearch_professorsto build a school-specific professor directory with ratings. - Export
commenttext fromrecent_reviewsfor sentiment analysis on teaching quality by department.
| 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 RateMyProfessors.com have an official public developer API?+
What does `get_professor_details` return that `search_professors` does not?+
search_professors returns summary-level fields: professor_id, full_name, department, school_name, avg_rating, and num_ratings. get_professor_details adds the full aggregate_ratings object, the courses_taught array with per-course review counts, top_rating_tags, and the recent_reviews array with individual student comments and per-review scores.How does school filtering work in the search endpoint?+
school_id parameter in search_professors and get_professor_by_name is a base64-encoded school identifier. When supplied, results are scoped to that institution. If omitted, the search runs across all schools in the RateMyProfessors database.