# Coursera Course Review Scraper (`shahidirfan/coursera-course-review-scraper`) Actor

Extract Coursera course reviews, ratings, learner feedback, course details, reviewer insights, and review data at scale. Perfect for course research, sentiment analysis, e-learning analytics, market research, and education datasets. Fast, reliable, and structured.

- **URL**: https://apify.com/shahidirfan/coursera-course-review-scraper.md
- **Developed by:** [Shahid Irfan](https://apify.com/shahidirfan) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

### What does Coursera Course Review Scraper do?

Coursera Course Review Scraper collects public learner reviews from one or more Coursera course or program URLs. Provide a course, specialization, Professional Certificate, or review-tab URL and receive structured records containing the review text, star rating, author, date, completion status, helpful votes, course URL, and collection context.

Use the dataset for course research, learner sentiment analysis, education-market monitoring, recommendation systems, review archives, and AI or RAG workflows.

### Why use Coursera Course Review Scraper?

- **Review-focused data** - Collect individual learner reviews instead of only course-card summaries.
- **Useful review context** - Keep rating, review date, completion status, helpful votes, course identity, and result rank together.
- **Flexible collection** - Process one course or multiple course URLs in a single run.
- **Controlled results** - Set a per-course result limit and page cap for predictable datasets.
- **Filtering and ordering** - Collect all ratings or one star rating, optionally require course completion, and sort by recent or most helpful reviews.
- **Automation-ready exports** - Download JSON, CSV, Excel, or XML, or connect the dataset to downstream services through Apify.

### What data can you extract from Coursera?

| Field                    | Description                                              |
| ------------------------ | -------------------------------------------------------- |
| `reviewId`               | Unique Coursera review identifier                        |
| `courseId`               | Coursera course identifier                               |
| `courseSlug`             | Course slug from the supplied URL                        |
| `courseUrl`              | Course page URL                                          |
| `authorName`             | Public review author name when available                 |
| `rating`                 | Star rating from 1 to 5                                  |
| `reviewText`             | Clean learner review text                                |
| `reviewedAt`             | Review date in ISO 8601 format                           |
| `productCompleted`       | Whether the learner marked the course completed          |
| `mostHelpfulVoteCount`   | Helpful votes recorded for the review                    |
| `isMarkedHelpful`        | Helpful status returned for the current request          |
| `sortBy`                 | Ordering used for the request: `recent` or `helpful`     |
| `ratingFilter`           | Star filter used, when one was selected                  |
| `productCompletedFilter` | Completion filter used, when selected                    |
| `reviewRank`             | Position in the collected reviews for that course        |
| `page`                   | Page number used to collect the review                   |
| `totalReviews`           | Total matching reviews reported for the selected filters |

Empty and null values are left out of individual records.

### How to scrape Coursera reviews

1. Open the Actor in Apify Console.
2. Add one or more public Coursera course URLs.
3. Choose the review ordering and optional filters.
4. Set the number of reviews and maximum pages per course.
5. Run the Actor and review the dataset preview.
6. Export the results or connect the dataset to your workflow.

Course pages such as `https://www.coursera.org/learn/course-slug`, specializations such as `https://www.coursera.org/specializations/program-slug`, Professional Certificates such as `https://www.coursera.org/professional-certificates/program-slug`, and their review-tab variants with `/reviews` or `#reviews` are accepted. Query strings, fragments, trailing slashes, and Coursera subdomains are also supported.

### Input Parameters

| Parameter           | Type             | Required | Default                | Description                                                                                                                                 |
| ------------------- | ---------------- | -------- | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `startUrls`         | Array of strings | Yes      | One working course URL | Coursera course or program URLs to process. Course, specialization, Professional Certificate, `/reviews`, and `#reviews` URLs are accepted. |
| `sort_by`           | String           | No       | `recent`               | Use `recent` or `helpful`.                                                                                                                  |
| `rating_filter`     | String           | No       | `all`                  | Use `all`, `1`, `2`, `3`, `4`, or `5`.                                                                                                      |
| `product_completed` | Boolean          | No       | -                      | If true, keep only reviews marked as completed.                                                                                             |
| `results_wanted`    | Integer          | No       | `20`                   | Maximum reviews per supplied URL; program URLs distribute this limit across constituent courses.                                            |
| `max_pages`         | Integer          | No       | `10`                   | Maximum review pages to request per course. Each page contains up to 50 reviews.                                                            |

### Output Data

Each dataset item is one learner review. Reviews from duplicate URLs are deduplicated by review identifier.

| Field                  | Type    | Description                                |
| ---------------------- | ------- | ------------------------------------------ |
| `reviewId`             | String  | Unique review identifier                   |
| `courseSlug`           | String  | Course slug                                |
| `courseUrl`            | String  | URL of the course page                     |
| `programSlug`          | String  | Program slug when input is a program       |
| `programUrl`           | String  | Original program URL when applicable       |
| `authorName`           | String  | Public author name                         |
| `rating`               | Integer | Rating from 1 to 5                         |
| `reviewText`           | String  | Review content without presentation markup |
| `reviewedAt`           | String  | ISO 8601 review timestamp                  |
| `productCompleted`     | Boolean | Learner completion state                   |
| `mostHelpfulVoteCount` | Integer | Helpful vote count when available          |
| `reviewRank`           | Integer | Collected order for the course             |
| `page`                 | Integer | Collection page                            |
| `totalReviews`         | Integer | Matching review count                      |

### Usage Examples

#### Basic Extraction

Collect 20 recent reviews from one course page:

```json
{
    "startUrls": ["https://www.coursera.org/learn/python-for-applied-data-science-ai"],
    "results_wanted": 20
}
```

#### Multiple Course URLs

Collect the same number of reviews from several courses:

```json
{
    "startUrls": [
        "https://www.coursera.org/learn/python-for-applied-data-science-ai",
        "https://www.coursera.org/learn/machine-learning"
    ],
    "sort_by": "recent",
    "results_wanted": 50,
    "max_pages": 4
}
```

#### Program Reviews

Collect 20 reviews across all courses in a specialization or Professional Certificate. The limit is per supplied URL and is distributed across its constituent courses:

```json
{
    "startUrls": [
        "https://www.coursera.org/specializations/ai-healthcare#reviews",
        "https://www.coursera.org/professional-certificates/google-it-support"
    ],
    "results_wanted": 20,
    "max_pages": 10
}
```

#### Filtered Helpful Reviews

Collect the most helpful five-star reviews that indicate course completion:

```json
{
    "startUrls": ["https://www.coursera.org/learn/python-for-applied-data-science-ai/reviews"],
    "sort_by": "helpful",
    "rating_filter": "5",
    "product_completed": true,
    "results_wanted": 100,
    "max_pages": 5
}
```

### Sample Output

```json
{
    "reviewId": "216543659~COURSE!~ejOz7RDUEei99hK0xs-tsg",
    "courseId": "COURSE~ejOz7RDUEei99hK0xs-tsg",
    "courseSlug": "python-for-applied-data-science-ai",
    "courseUrl": "https://www.coursera.org/learn/python-for-applied-data-science-ai",
    "authorName": "Example Learner",
    "rating": 5,
    "reviewText": "The practical exercises made the concepts easier to understand.",
    "reviewedAt": "2026-08-25T10:30:00.000Z",
    "productCompleted": true,
    "mostHelpfulVoteCount": 12,
    "isMarkedHelpful": false,
    "sortBy": "recent",
    "reviewRank": 1,
    "page": 1,
    "totalReviews": 43772
}
```

### Tips for Best Results

- Use the canonical Coursera course URL, with or without the `/reviews` suffix.
- Start with `results_wanted: 20` to confirm the output before larger collections.
- Use `helpful` sorting for frequently endorsed feedback and `recent` sorting for current learner sentiment.
- Combine `rating_filter` and `product_completed` for focused analysis.
- Use `max_pages` with larger result limits to control run duration.
- Review the dataset preview because course review totals and ordering can change over time.

### Integrations and Export Formats

| Option         | Useful for                                          |
| -------------- | --------------------------------------------------- |
| JSON           | Data pipelines, AI agents, and RAG preparation      |
| CSV            | Spreadsheet analysis and sentiment review           |
| Excel          | Reports and course comparisons                      |
| Google Sheets  | Collaborative review analysis                       |
| Airtable       | Searchable course-feedback catalogs                 |
| Webhooks       | Triggering downstream jobs after a run              |
| Make or Zapier | No-code workflows                                   |
| Apify API      | Starting runs and reading datasets programmatically |

### Frequently Asked Questions

#### Can I use a Coursera `/reviews` URL?

Yes. Course URLs and their `/reviews` variants are accepted. Tracking parameters and trailing slashes do not affect course identification.

#### Can I collect only five-star reviews?

Yes. Set `rating_filter` to `5`. Values from `1` through `5` are supported, as well as `all`.

#### Can I collect completed-course reviews?

Yes. Set `product_completed` to `true` to request reviews marked as completed by the learner.

#### Can I export Coursera reviews to CSV or Excel?

Yes. Apify datasets can be downloaded in CSV, Excel, JSON, XML, and other supported formats.

#### Can I schedule recurring review monitoring?

Yes. Create an Apify schedule to repeat a run daily, weekly, or at another interval and compare the resulting datasets.

#### Is it legal to collect Coursera reviews?

Public-data collection rules vary by jurisdiction and use case. Review Coursera's terms, privacy requirements, and applicable laws before collecting or redistributing review data.

### Related Actors

- [edX Course Scraper](https://apify.com/shahidirfan/edx-course-scraper) - Collect course data from edX.
- [Udacity Course Scraper](https://apify.com/shahidirfan/udacity-course-scraper) - Build comparable datasets from Udacity courses.
- [Skillshare Courses Scraper](https://apify.com/shahidirfan/skillshare-courses-scraper) - Collect course information from Skillshare.

### Support

For issues or feature requests, use the Issues tab on the Actor page. Include the input JSON, course URL, and a small output example.

### Legal Notice

This Actor is intended for lawful collection and analysis of publicly available Coursera review data. Users are responsible for complying with Coursera's terms, applicable privacy requirements, intellectual property rules, and all other laws that apply to their collection and use of the data.

# Actor input Schema

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

One or more Coursera URLs. Course, specialization, Professional Certificate, /reviews, and #reviews URLs are accepted.

## `sort_by` (type: `string`):

Choose recent reviews or reviews with the most helpful votes.

## `rating_filter` (type: `string`):

Only collect reviews with this star rating, or use all ratings.

## `product_completed` (type: `boolean`):

When enabled, collect only reviews from learners who completed the course.

## `results_wanted` (type: `integer`):

Maximum number of reviews to collect for each supplied URL. Program URLs distribute this limit across their constituent courses.

## `max_pages` (type: `integer`):

Maximum number of API pages to request for each course.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.coursera.org/learn/python-for-applied-data-science-ai"
  ],
  "sort_by": "recent",
  "rating_filter": "all",
  "product_completed": false,
  "results_wanted": 20,
  "max_pages": 10
}
```

# Actor output Schema

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

No description

# 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 = {
    "startUrls": [
        "https://www.coursera.org/learn/python-for-applied-data-science-ai"
    ],
    "sort_by": "recent",
    "rating_filter": "all",
    "product_completed": false,
    "results_wanted": 20,
    "max_pages": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("shahidirfan/coursera-course-review-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 = {
    "startUrls": ["https://www.coursera.org/learn/python-for-applied-data-science-ai"],
    "sort_by": "recent",
    "rating_filter": "all",
    "product_completed": False,
    "results_wanted": 20,
    "max_pages": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("shahidirfan/coursera-course-review-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.coursera.org/learn/python-for-applied-data-science-ai"
  ],
  "sort_by": "recent",
  "rating_filter": "all",
  "product_completed": false,
  "results_wanted": 20,
  "max_pages": 10
}' |
apify call shahidirfan/coursera-course-review-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,shahidirfan/coursera-course-review-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/YXL4bsCqfvisO5wKm/builds/q1MXDBHG1PSqPEHZi/openapi.json
