# RateMyProfessors Scraper (`solidcode/ratemyprofessors-scraper`) Actor

\[💰 $0.8 / 1K] Extract RateMyProfessors professor profiles and student ratings. Search by school or professor name, or paste profile URLs. Get rating, difficulty, would-take-again %, top tags, and every student review. Ideal for education research and EdTech.

- **URL**: https://apify.com/solidcode/ratemyprofessors-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 professor profiles

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## RateMyProfessors Scraper

Pull professor profiles and the individual student ratings behind them from RateMyProfessors — average quality, difficulty, would-take-again %, top tags, and every comment with its course, grade, and post date. Search a whole school, look up professors by name, or paste profile URLs, and get back clean, linked records. Built for education researchers, EdTech product teams, and academic-advising tools that need professor sentiment at scale without copy-pasting profiles one page at a time.

### Why This Scraper?

- **Two linked record types in one run** — every job returns `professor` profile rows plus individual `rating` rows, joined by `professorId` and `professorLegacyId`, so you can pivot from a professor's 4.3 average straight to the hundreds of comments behind it.
- **The three headline metrics, pre-parsed** — a 0–5 average quality rating, a 0–5 average difficulty score, and the would-take-again percentage on every professor, alongside the total rating count.
- **Full per-rating breakdown** — each student rating carries the course code, a 1–5 quality score, a 1–5 difficulty score, the free-text comment, the reported letter grade, and the post date in clean ISO 8601.
- **Grade, textbook, credit, online, and attendance signals** — each rating exposes whether a textbook was used, whether the class was for credit, whether it was online, and the attendance-mandatory flag — context you can filter and segment on.
- **Top-tags aggregation** — up to 5 most-used tags per professor (e.g. "Tough grader", "Gives good feedback", "Get ready to read"), ranked by frequency across their reviews.
- **Community helpfulness on every review** — thumbs-up and thumbs-down counts per rating, so you can weight comments by peer agreement instead of treating every review equally.
- **Three ways to target data** — scrape a whole school (by name or numeric RateMyProfessors ID), search professors by name (optionally narrowed to one school), or paste `/professor/` and `/school/` URLs directly, all mixable in a single run.
- **Independent, predictable caps** — `maxProfessors` and `maxRatingsPerProfessor` are separate controls, so a 50-professor / 100-ratings run stays predictable instead of hiding behind one blurry combined limit.
- **Pipeline-ready IDs** — every professor ships both the stable RateMyProfessors ID and the numeric `legacyId`, plus a ready-to-open `profileUrl`, so downstream re-lookups and follow-up runs chain cleanly.

### Use Cases

**Academic Research**
- Study grade-inflation and student-sentiment trends across departments or entire schools.
- Compare would-take-again rates and difficulty scores between institutions.
- Build longitudinal datasets from rating post dates spanning multiple academic years.

**EdTech & Product**
- Seed course-planning and professor-matching apps with structured ratings.
- Enrich scheduling tools with quality and difficulty scores plus top tags.
- Power "best professor for this course" recommendation features.

**Student Advising & Course Planning**
- Flag high-difficulty, low-would-take-again sections before registration.
- Surface a professor's most-used tags so students know what to expect.
- Aggregate course-level feedback by class code across a department.

**Reputation & Sentiment Analysis**
- Track how a department's ratings evolve over time.
- Mine free-text comments for recurring themes with your own NLP.
- Weight consensus using thumbs-up counts on individual reviews.

**Lead Generation (Tutoring & Services)**
- Identify high-difficulty courses where tutoring demand is strongest.
- Target schools and departments by average difficulty.
- Build outreach lists segmented by school and department.

### Getting Started

#### Scrape one school (summaries only)

```json
{
  "schools": ["Arizona State University"],
  "maxProfessors": 25,
  "includeRatings": false
}
````

#### Find a professor by name, narrowed to a school, with ratings

```json
{
  "schools": ["University of California Los Angeles"],
  "professorNames": ["Andrew Ng"],
  "maxProfessors": 20,
  "includeRatings": true,
  "maxRatingsPerProfessor": 50
}
```

#### Paste URLs directly and pull deep ratings

```json
{
  "startUrls": [
    "https://www.ratemyprofessors.com/professor/1936365",
    "https://www.ratemyprofessors.com/school/1234"
  ],
  "maxProfessors": 100,
  "includeRatings": true,
  "maxRatingsPerProfessor": 200
}
```

### Input Reference

#### What to Scrape

Fill in any combination — everything you populate runs in one job.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `schools` | array | `["Arizona State University"]` | School names (e.g. `Arizona State University`) or numeric RateMyProfessors school IDs (e.g. `15723`). Pulls every professor at each school. Also narrows the professor-name search below. |
| `professorNames` | array | `[]` | Professor names to search for (e.g. `John Smith`). Returns matching profiles. Add a school above to narrow the search to that campus. |
| `startUrls` | array | `[]` | RateMyProfessors professor URLs (`/professor/<id>` → that professor) or school URLs (`/school/<id>` → all its professors). Type is detected automatically. |

#### Results

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxProfessors` | integer | `50` | Maximum professors to collect per school or per name search. Set to `0` for as many as available. Ignored for direct professor URLs (those return one professor each). |

#### Ratings

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeRatings` | boolean | `true` | Also collect each professor's individual student ratings (comment, course, quality and difficulty scores, grade, tags, and more), added as separate linked rows. Turn off for professor summaries only. |
| `maxRatingsPerProfessor` | integer | `100` | Maximum ratings to collect per professor when ratings are enabled. Set to `0` for all available. Popular professors can have hundreds to over a thousand ratings. |

### Output

Every run writes to one **Overview** tab with all records, plus clean **Professors** and **Ratings** tabs that are type-filtered subsets. Each row carries a `recordType` field so you can split them anywhere.

#### Professor record

```json
{
  "recordType": "professor",
  "professorId": "VGVhY2hlci0xOTM2MzY1",
  "legacyId": 1936365,
  "firstName": "Jane",
  "lastName": "Doe",
  "fullName": "Jane Doe",
  "department": "Computer Science",
  "schoolId": "U2Nob29sLTE1NzIz",
  "schoolLegacyId": 15723,
  "schoolName": "Arizona State University",
  "avgRating": 4.3,
  "avgDifficulty": 3.1,
  "numRatings": 214,
  "wouldTakeAgainPercent": 88,
  "topTags": ["Gives good feedback", "Caring", "Respected", "Clear grading criteria", "Inspirational"],
  "profileUrl": "https://www.ratemyprofessors.com/professor/1936365"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"professor"` |
| `professorId` | string | Stable RateMyProfessors professor ID (use for joins) |
| `legacyId` | integer | Numeric professor ID used in the profile URL |
| `firstName` | string | Professor's first name |
| `lastName` | string | Professor's last name |
| `fullName` | string | Combined first and last name |
| `department` | string | Department the professor teaches in |
| `schoolId` | string | Stable RateMyProfessors school ID |
| `schoolLegacyId` | integer | Numeric school ID |
| `schoolName` | string | School name |
| `avgRating` | number | Average overall quality rating (0–5) |
| `avgDifficulty` | number | Average difficulty (0–5) |
| `numRatings` | integer | Total number of student ratings on the profile |
| `wouldTakeAgainPercent` | number | Percent of students who would take the professor again (null when unrated) |
| `topTags` | array | Up to 5 most-used rating tags, ranked by frequency |
| `profileUrl` | string | Direct link to the professor's RateMyProfessors page |

#### Rating record

Present only when **Include Student Ratings** is enabled. One row per student rating, linked back to its professor.

```json
{
  "recordType": "rating",
  "ratingId": "UmF0aW5nLTM4MjE0NTk=",
  "professorId": "VGVhY2hlci0xOTM2MzY1",
  "professorLegacyId": 1936365,
  "professorName": "Jane Doe",
  "schoolName": "Arizona State University",
  "class": "CSE110",
  "qualityRating": 5,
  "difficultyRating": 3,
  "comment": "Clear lectures and fair exams. Attend every class and you'll do well.",
  "date": "2026-03-10T18:02:47Z",
  "grade": "A",
  "wouldTakeAgain": true,
  "attendanceMandatory": "mandatory",
  "textbookUse": true,
  "isForCredit": true,
  "isForOnlineClass": false,
  "tags": ["Clear grading criteria", "Gives good feedback"],
  "thumbsUp": 12,
  "thumbsDown": 1
}
```

**Rating & review**

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"rating"` |
| `ratingId` | string | Unique rating ID |
| `professorId` | string | Parent professor ID (join key back to the professor row) |
| `professorLegacyId` | integer | Parent professor numeric ID (join key) |
| `professorName` | string | Parent professor's full name (standalone context) |
| `schoolName` | string | School name (standalone context) |
| `class` | string | Course code the rating is for (e.g. `CSE110`) |
| `qualityRating` | number | Student's quality score (1–5) |
| `difficultyRating` | number | Student's difficulty score (1–5) |
| `comment` | string | Free-text review comment |
| `date` | string | Post date in ISO 8601 UTC (e.g. `2026-03-10T18:02:47Z`) |

**Course context & feedback**

| Field | Type | Description |
|-------|------|-------------|
| `grade` | string | Letter grade the student reported receiving |
| `wouldTakeAgain` | boolean | Whether the student would take the professor again |
| `attendanceMandatory` | string | Attendance flag (`mandatory` / `non mandatory` / null) |
| `textbookUse` | boolean | Whether a textbook was used |
| `isForCredit` | boolean | Whether the class was taken for credit |
| `isForOnlineClass` | boolean | Whether it was an online class |
| `tags` | array | Tags the student applied to this rating |
| `thumbsUp` | integer | Helpful (thumbs-up) count from the community |
| `thumbsDown` | integer | Not-helpful (thumbs-down) count |

### Tips for Best Results

- **Skip search with direct URLs** — paste `/professor/<id>` or `/school/<id>` links to jump straight to exactly the professors or schools you want, with no name matching in the way.
- **Use a numeric school ID for exact targeting** — school names go through a fuzzy match, but the numeric ID (the number in a `/school/<id>` URL) always resolves to the exact campus.
- **Turn off ratings for a fast, cheap professor census** — you still get every average rating, difficulty, would-take-again %, and top tags, without the per-professor rating pull.
- **Cap `maxRatingsPerProfessor` for predictable costs** — popular professors can have 1,000+ ratings; a cap of 50–100 keeps runs fast. Set it to `0` only when you truly need the full history.
- **Add a school to narrow a professor-name search** — putting a school in the Schools field limits "John Smith" to that campus instead of every John Smith across North America.
- **Keep ratings on if tags matter** — RateMyProfessors often leaves the profile-level tag list empty, so top tags are rebuilt from the individual ratings; they populate best when ratings are enabled.
- **Start small, then scale** — run 10–25 professors first to confirm the school and fields look right, then raise `maxProfessors`.

### Pricing

**From $0.80 per 1,000 professors + $0.20 per 1,000 ratings.** You're charged per professor profile plus per student rating collected — a dual model that keeps summary-only runs cheap and only adds rating cost when you ask for ratings. No compute or time-based charges; you pay per professor and per rating collected, plus a small fixed per-run start fee.

Bronze, Silver, and Gold discount tiers apply automatically based on your Apify subscription plan — the higher your tier, the less you pay per result.

**Per 1,000 professors collected**

| Volume | No discount | Bronze | Silver | Gold |
|--------|-------------|--------|--------|------|
| 100 professors | $0.095 | $0.090 | $0.085 | $0.080 |
| 1,000 professors | $0.95 | $0.90 | $0.85 | $0.80 |
| 10,000 professors | $9.50 | $9.00 | $8.50 | $8.00 |
| 100,000 professors | $95.00 | $90.00 | $85.00 | $80.00 |

**Per 1,000 student ratings collected**

| Volume | No discount | Bronze | Silver | Gold |
|--------|-------------|--------|--------|------|
| 100 ratings | $0.024 | $0.022 | $0.021 | $0.020 |
| 1,000 ratings | $0.24 | $0.22 | $0.21 | $0.20 |
| 10,000 ratings | $2.40 | $2.20 | $2.10 | $2.00 |
| 100,000 ratings | $24.00 | $22.00 | $21.00 | $20.00 |

**Example totals at Gold pricing**

| Run | Professors | Ratings | Professor cost | Rating cost | Total |
|-----|------------|---------|----------------|-------------|-------|
| 100 professors × 20 ratings each | 100 | 2,000 | $0.08 | $0.40 | $0.48 |
| 500 professors × 40 ratings each | 500 | 20,000 | $0.40 | $4.00 | $4.40 |

A "result" is one professor profile or one student rating. Turn off **Include Student Ratings** to pay for professors only. Platform usage fees are additional.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This scraper collects publicly available information from RateMyProfessors. Use the data responsibly and in compliance with RateMyProfessors' terms of service and all applicable laws, including data-protection regulations such as GDPR and CCPA. Student ratings are user-generated opinions — treat them as subjective commentary, not statements of fact, and do not use the data to harass, defame, or make automated decisions about individuals. You are responsible for how you use the data you collect.

# Actor input Schema

## `schools` (type: `array`):

School names (e.g. `Arizona State University`) or numeric RateMyProfessors school IDs (e.g. `15723`). The scraper finds all professors at each school. Add a school here to also narrow the professor-name search below.

## `professorNames` (type: `array`):

Professor names to search for (e.g. `John Smith`). Returns matching professor profiles. If you also add a school above, the search is narrowed to that school.

## `startUrls` (type: `array`):

Paste RateMyProfessors professor or school page URLs. A professor URL (e.g. `https://www.ratemyprofessors.com/professor/12345`) returns that professor; a school URL (e.g. `https://www.ratemyprofessors.com/school/1234`) returns all its professors. The type is detected automatically.

## `maxProfessors` (type: `integer`):

Maximum number of professors to collect per school or per name search. Set to 0 for as many as available. Note: RateMyProfessors returns at most ~10,000 professors per school or search, so a single school or search tops out around that number even at 0. Tip: start with 10-50 to test, then increase. Ignored for direct professor URLs (those return one professor each).

## `includeRatings` (type: `boolean`):

For each professor, also collect individual student ratings (comment, course, quality and difficulty scores, grade, tags, and more). Ratings are added as separate rows linked to the professor. This adds work per professor, so it is slower and costs more. Turn off for professor summaries only.

## `maxRatingsPerProfessor` (type: `integer`):

Maximum number of ratings to collect per professor when ratings are enabled. Set to 0 for all available. Note: popular professors can have hundreds to over a thousand ratings, so a low cap keeps runs fast and predictable.

## Actor input object example

```json
{
  "schools": [
    "Arizona State University"
  ],
  "professorNames": [],
  "startUrls": [],
  "maxProfessors": 50,
  "includeRatings": true,
  "maxRatingsPerProfessor": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Every record from the run in one place — professors and student ratings — distinguished by `recordType`.

## `professors` (type: `string`):

Professors only, with name, school, department, average rating, difficulty, would-take-again %, rating count, top tags, and profile URL.

## `ratings` (type: `string`):

Individual student ratings only, each linked to its professor — quality, difficulty, course, grade, comment, tags, and date. Present only when 'Include Student Ratings' is enabled.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "schools": [
        "Arizona State University"
    ],
    "professorNames": [],
    "startUrls": [],
    "maxProfessors": 50,
    "includeRatings": true,
    "maxRatingsPerProfessor": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/ratemyprofessors-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "schools": ["Arizona State University"],
    "professorNames": [],
    "startUrls": [],
    "maxProfessors": 50,
    "includeRatings": True,
    "maxRatingsPerProfessor": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/ratemyprofessors-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "schools": [
    "Arizona State University"
  ],
  "professorNames": [],
  "startUrls": [],
  "maxProfessors": 50,
  "includeRatings": true,
  "maxRatingsPerProfessor": 100
}' |
apify call solidcode/ratemyprofessors-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidcode/ratemyprofessors-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RateMyProfessors Scraper",
        "description": "[💰 $0.8 / 1K] Extract RateMyProfessors professor profiles and student ratings. Search by school or professor name, or paste profile URLs. Get rating, difficulty, would-take-again %, top tags, and every student review. Ideal for education research and EdTech.",
        "version": "1.0",
        "x-build-id": "apX0To0Cm6O5jcQya"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~ratemyprofessors-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-ratemyprofessors-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~ratemyprofessors-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-ratemyprofessors-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~ratemyprofessors-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-ratemyprofessors-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "schools": {
                        "title": "Schools",
                        "type": "array",
                        "description": "School names (e.g. `Arizona State University`) or numeric RateMyProfessors school IDs (e.g. `15723`). The scraper finds all professors at each school. Add a school here to also narrow the professor-name search below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "professorNames": {
                        "title": "Professor Names",
                        "type": "array",
                        "description": "Professor names to search for (e.g. `John Smith`). Returns matching professor profiles. If you also add a school above, the search is narrowed to that school.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "RateMyProfessors URLs",
                        "type": "array",
                        "description": "Paste RateMyProfessors professor or school page URLs. A professor URL (e.g. `https://www.ratemyprofessors.com/professor/12345`) returns that professor; a school URL (e.g. `https://www.ratemyprofessors.com/school/1234`) returns all its professors. The type is detected automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProfessors": {
                        "title": "Max Professors per School / Search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of professors to collect per school or per name search. Set to 0 for as many as available. Note: RateMyProfessors returns at most ~10,000 professors per school or search, so a single school or search tops out around that number even at 0. Tip: start with 10-50 to test, then increase. Ignored for direct professor URLs (those return one professor each).",
                        "default": 50
                    },
                    "includeRatings": {
                        "title": "Include Student Ratings",
                        "type": "boolean",
                        "description": "For each professor, also collect individual student ratings (comment, course, quality and difficulty scores, grade, tags, and more). Ratings are added as separate rows linked to the professor. This adds work per professor, so it is slower and costs more. Turn off for professor summaries only.",
                        "default": true
                    },
                    "maxRatingsPerProfessor": {
                        "title": "Max Ratings per Professor",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of ratings to collect per professor when ratings are enabled. Set to 0 for all available. Note: popular professors can have hundreds to over a thousand ratings, so a low cap keeps runs fast and predictable.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```