Rate My Professors Data API: Extract Structured JSON in 2026

This guide covers extracting publicly accessible data. Always review a site's robots.txt and Terms of Service before scraping.

TL;DR

Use AlterLab's Extract API with a JSON schema to turn Rate My Professors review pages into typed JSON. Define the fields you need (professor name, rating, review count, etc.), POST the URL and schema, and receive validated data — no HTML parsing or regex required.

Why use Rate My Professors data?

• AI training: Collect labeled examples of sentiment and teaching effectiveness for fine‑tuning LLMs.
• Analytics: Track rating trends over time to identify emerging instructional practices.
• Competitive intelligence: Compare department‑level performance across institutions for academic program reviews.

What data can you extract?

Rate My Professors displays publicly available review cards that include:

• product_name: The professor’s name as shown on the page.
• rating: Overall quality score (usually 1‑5).
• review_count: Number of submitted reviews.
• category: Department or school affiliation.
• verified_purchase: Indicator if the reviewer confirmed enrollment (when present).

These fields are visible in the HTML; AlterLab’s AI‑powered extractor can map them directly into a JSON object you define.

The extraction approach

Raw HTTP requests followed by HTML parsing with libraries like BeautifulSoup break when the site updates its layout, adds anti‑bot measures, or lazy‑loads content. Maintaining selectors is fragile and time‑consuming. A data API handles:

• Automatic retries and rotating proxies.
• JavaScript rendering for content loaded after the initial HTML.
• Structured output that conforms to a user‑provided schema, eliminating post‑processing.

Quick start with AlterLab Extract API

See the Extract API docs for full reference. Below are minimal examples in Python and cURL.

import alterlab

client = alterlab.Client("YOUR_API_KEY")

schema = {
  "type": "object",
  "properties": {
    "product_name": {
      "type": "string",
      "description": "Professor name as displayed"
    },
    "rating": {
      "type": "string",
      "description": "Overall quality rating"
    },
    "review_count": {
      "type": "string",
      "description": "Total number of reviews"
    },
    "category": {
      "type": "string",
      "description": "Academic department or school"
    },
    "verified_purchase": {
      "type": "string",
      "description": "Verified enrollment indicator"
    }
  }
}

result = client.extract(
    url="https://ratemyprofessors.com/ShowRatings.jsp?tid=1234567",
    schema=schema,
)
print(result.data)

curl -X POST https://api.alterlab.io/v1/extract \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://ratemyprofessors.com/ShowRatings.jsp?tid=1234567",
    "schema": {
      "properties": {
        "product_name": {"type": "string"},
        "rating": {"type": "string"},
        "review_count": {"type": "string"},
        "category": {"type": "string"},
        "verified_purchase": {"type": "string"}
      }
    }
  }'

Both calls return a JSON object where each field matches the type you declared, ready for downstream consumption.

Define your schema

Passing a JSON schema to the Extract API does two things:

1. Guidance: The model knows which elements to look for on the page.
2. Validation: The returned object is checked against the schema; missing or mistyped fields trigger an error instead of silent garbage.

Example output for the schema above:

{
  "product_name": "Dr. Ada Lovelace",
  "rating": "4.3",
  "review_count": "87",
  "category": "Computer Science",
  "verified_purchase": "Yes"
}

Because the API enforces the schema, you can safely cast review_count to an integer or rating to a float in your pipeline without extra validation.

Handle pagination and scale

Rate My Professors lists professors per school or department across multiple pages. To scrape at scale:

• Batching: Collect a list of target URLs (e.g., school‑specific professor lists) and send them concurrently.
• Rate limiting: AlterLab respects a default limit; you can adjust concurrency based on your subscription.
• Async jobs: For >10k pages, use the /v1/extract/job endpoint to submit a batch and poll for completion.

import alterlab
import asyncio

client = alterlab.Client("YOUR_API_KEY")
schema = {
  "type": "object",
  "properties": {
    "product_name": {"type": "string"},
    "rating": {"type": "string"},
    "review_count": {"type": "string"}
  }
}

async def extract_one(url):
    return await client.extract_async(url=url, schema=schema)

urls = [
    f"https://ratemyprofessors.com/ShowRatings.jsp?tid={i}"
    for i in range(1000100, 1000200)  # example ID range
]

# Run 10 requests at a time
results = []
for i in range(0, len(urls), 10):
    batch = urls[i:i+10]
    batch_results = asyncio.run(asyncio.gather(*[extract_one(u) for u in batch]))
    results.extend(batch_results)

print(f"Fetched {len(results)} records")

See the pricing page for cost estimates at different volumes; the platform caps each extraction at $0.50, making large runs predictable.

Key takeaways

• Use a schema‑driven Extract API to turn Rate My Professors pages into reliable JSON.
• Focus on publicly visible fields; respect robots.txt and the site’s Terms of Service.
• Leverage automatic retries, JavaScript rendering, and built‑in validation to reduce maintenance.
• Scale with batching or async jobs while monitoring cost via the pricing calculator.