# Coursera Scraper · Courses, Specializations, Partners & Ratings (`reapx/coursera-scraper`) Actor

Scrape Coursera courses, specializations, skills, universities, partners, workloads, languages, ratings, and course details. HTTP only, fast, structured JSON output.

- **URL**: https://apify.com/reapx/coursera-scraper.md
- **Developed by:** [Tarek Etman](https://apify.com/reapx) (community)
- **Categories:** Developer tools, Business, Other
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.30 / 1,000 coursera course returneds

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 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

![reapX — public sources in, addressable records out](https://reapx.dev/reapx.gif)

## Coursera Scraper · Courses, Specializations, Partners & Ratings

Coursera Scraper allows you to extract structured course data, specializations, university partners, instructors, difficulty levels, workloads, and primary languages from Coursera. Scrape public course listings and catalog details without requiring login credentials or API keys.

> Maintained by **reapX**. Every row cites the Apify run that produced it — nothing is inferred, modelled or filled in, and a field absent from the source is absent from the row. The extracted archive for this source is browsable at [reapx.dev/data/coursera-scraper/](https://reapx.dev/data/coursera-scraper/) and mirrored as an open dataset on [Hugging Face](https://huggingface.co/datasets/reapxdev/coursera-scraper) and [Kaggle](https://www.kaggle.com/datasets/reapxdev/coursera-scraper). Questions: reapxdev@proton.me

***

### Overview & Key Features

Coursera is one of the world's leading online learning platforms, offering thousands of courses, specializations, and professional certificates from top universities like Stanford, Yale, Duke, and University of Michigan, as well as industry leaders like Google, IBM, Meta, and AWS.

This actor connects directly to Coursera's public catalog API endpoint over plain HTTP. It operates at high speed without needing a headless browser, extracting comprehensive structured records for courses across all domains.

- **Complete Metadata Extraction**: Scrape course titles, permanent slugs, internal IDs, descriptions, workloads, difficulty levels, and primary language codes.
- **Partner & Instructor Mapping**: Automatically link partner institutions (universities and companies) and course instructors directly into each course record.
- **Domain & Subject Categorization**: Extract domain and subdomain classifications (e.g. Data Science, Computer Science, Machine Learning, Business).
- **Flexible Filtering**: Filter output by subject domain, difficulty level (`BEGINNER`, `INTERMEDIATE`, `ADVANCED`), primary language (`en`, `es`, `fr`, `pt`, etc.), or partner name (`Google`, `Stanford`, `IBM`).
- **Pay-Per-Event Pricing**: Charged strictly per course record returned. Empty runs or rate-limited responses bill zero.

***

### ⬇️ Input

The input for Coursera Scraper is configured using simple JSON options or through the Apify Console user interface.

#### Input Parameters

| Field | Type | Required | Default / Prefill | Description |
| :--- | :--- | :--- | :--- | :--- |
| `maxCourses` | Integer | Yes | `100` | Maximum number of Coursera courses to extract in this run. Higher limits take longer and consume more events. |
| `subject` | String | No | `""` | Filter courses by subject area or domain identifier (e.g. `data-science`, `computer-science`, `business`, `information-technology`, `health`). Leave empty to include all subjects. |
| `level` | String | No | `""` | Filter courses by difficulty level (`BEGINNER`, `INTERMEDIATE`, or `ADVANCED`). Leave empty for all levels. |
| `language` | String | No | `""` | Filter courses by primary language ISO code (e.g. `en` for English, `es` for Spanish, `fr` for French). Leave empty for all languages. |
| `partnerQuery` | String | No | `""` | Filter courses offered by specific university or corporate partners matching this string (e.g. `Google`, `Stanford`, `IBM`). Leave empty for all partners. |

#### Worked Input Examples

##### Example 1: Extract Top 100 Data Science Courses

```json
{
  "maxCourses": 100,
  "subject": "data-science",
  "level": "",
  "language": "",
  "partnerQuery": ""
}
```

##### Example 2: Extract Beginner Courses Offered by Google

```json
{
  "maxCourses": 50,
  "subject": "",
  "level": "BEGINNER",
  "language": "en",
  "partnerQuery": "Google"
}
```

##### Example 3: Extract Spanish Language Courses in Business

```json
{
  "maxCourses": 50,
  "subject": "business",
  "level": "",
  "language": "es",
  "partnerQuery": ""
}
```

***

### ⬆️ Output

Every scraped course is pushed directly to the run's default dataset in real time. Each record represents a single Coursera course with addressable identifier (`slug`).

#### Dataset Schema Fields

| Field Name | Type | Title | Description & Example |
| :--- | :--- | :--- | :--- |
| `slug` | String | Course Slug | Permanent addressable URL slug. Example: `"googlecloud-getting-started-with-the-vertex-ai-gemini-1-5-pro-model-i43mr"` |
| `name` | String | Course Title | Full title of the course. Example: `"Getting started with the Vertex AI Gemini 1.5 Pro Model"` |
| `courseId` | String | Course ID | Coursera internal course ID (never named `id`). Example: `"l31la3mKEe-zFg7heHyXOQ"` |
| `courseType` | String | Course Type | Format of course delivery. Example: `"v2.ondemand"` |
| `description` | String | Description | Summary of course content and learning goals. |
| `workload` | String | Estimated Workload | Estimated duration or weekly workload. Example: `"1 hour 30 minutes"` |
| `level` | String | Difficulty Level | Target audience level. Example: `"BEGINNER"` |
| `primaryLanguages` | Array\[String] | Primary Languages | Primary course language ISO codes. Example: `["en"]` |
| `partners` | Array\[String] | Partner Names | Names of offering universities or partners. Example: `["Google Cloud"]` |
| `partnerIds` | Array\[String] | Partner IDs | Coursera partner IDs. Example: `["443"]` |
| `partnerLogo` | String | Partner Logo URL | URL of the primary partner's logo image. |
| `instructors` | Array\[String] | Instructor Names | Names of course instructors. Example: `["Google Cloud Training"]` |
| `instructorIds` | Array\[String] | Instructor IDs | Internal IDs of course instructors. Example: `["22997770"]` |
| `domainTypes` | Array\[Object] | Domain Categories | List of domain and subdomain classifications. |
| `photoUrl` | String | Cover Image URL | URL of course thumbnail/banner image. |
| `certificates` | Array\[String] | Certificates Offered | Certificate types available upon completion. Example: `["VerifiedCert"]` |
| `s12nIds` | Array\[String] | Specialization IDs | IDs of associated specializations. |

#### Sample Output Record

```json
{
  "slug": "googlecloud-getting-started-with-the-vertex-ai-gemini-1-5-pro-model-i43mr",
  "name": "Getting started with the Vertex AI Gemini 1.5 Pro Model",
  "courseId": "l31la3mKEe-zFg7heHyXOQ",
  "courseType": "v2.ondemand",
  "description": "This is a self-paced lab that takes place in the Google Cloud console. This lab will provide an introductory, hands-on experience with Generative AI on Google Cloud.",
  "workload": "1 hour 30 minutes",
  "level": "BEGINNER",
  "primaryLanguages": [
    "en"
  ],
  "partners": [
    "Google Cloud"
  ],
  "partnerIds": [
    "443"
  ],
  "partnerLogo": "http://coursera-university-assets.s3.amazonaws.com/7f/db40d0f4a711e6bc06c3b39ee3e5b0/cloud_logo_400x96.png",
  "instructors": [
    "Google Cloud Training"
  ],
  "instructorIds": [
    "22997770"
  ],
  "domainTypes": [
    {
      "domainId": "information-technology",
      "subdomainId": "cloud-computing"
    },
    {
      "domainId": "data-science",
      "subdomainId": "machine-learning"
    }
  ],
  "photoUrl": "https://d3njjcbhbojbot.cloudfront.net/api/utilities/v1/imageproxy/https://coursera-course-photos.s3.amazonaws.com/c5/e1dc34a146454fad3d65ce2304cb2b/Logo-Image_GC-Projects.png",
  "certificates": [
    "VerifiedCert"
  ],
  "s12nIds": []
}
```

***

### How it works

1. **HTTP Direct API Connection**: The scraper calls `https://api.coursera.org/api/courses.v1` directly over plain HTTP. It bypasses heavy browser automation, enabling maximum speed and low resource consumption (256 MB memory footprint).
2. **Linked Entity Resolution**: Coursera's catalog API returns separate entity maps for universities (`partners.v1`) and instructors (`instructors.v1`). The scraper automatically resolves and joins these entities onto every course record before outputting.
3. **Identifier Normalization**: Every course carries a stable `slug` field which acts as the entity addressable key for index pages. The course ID is preserved as `courseId` (never `id`).
4. **Streaming & Backoff**: Data is pushed item-by-item to Apify's default dataset. Automatic exponential backoff handles rate-limits (`429`) or server errors (`5xx`).

***

### ❓ FAQ

#### 1. How is this actor priced?

This actor uses **Pay-Per-Event (PPE)** pricing. You pay only per course record returned ($0.002 per event on the Free tier, with tiered volume discounts down to $0.0008 on Diamond). Empty runs or failed requests cost $0.00.

#### 2. Do I need a Coursera account or API key?

No. The scraper accesses Coursera's public catalog endpoints without requiring authentication, login tokens, or API keys.

#### 3. How fast is the scraper?

Because it runs purely over lightweight HTTP calls without browser rendering, it can fetch 100 courses per second. A run of 1,000 courses typically finishes in under 15 seconds.

#### 4. What filters can I apply?

You can filter by subject domain (e.g. `data-science`, `computer-science`), difficulty level (`BEGINNER`, `INTERMEDIATE`, `ADVANCED`), primary language ISO code (e.g. `en`, `es`, `fr`), and partner institution name (e.g. `Google`, `Stanford`, `IBM`).

#### 5. What format can I export data in?

Results are stored in standard Apify dataset storages and can be exported as JSON, CSV, Excel, XML, or HTML table via Apify Console or API.

#### 6. Can I run this scraper on a schedule?

Yes. You can schedule regular runs using Apify Schedules to monitor new course additions or updates from specific universities.

***

### 💬 Your feedback

We actively maintain this scraper to ensure high accuracy and reliability. If you encounter any issue, have a feature request, or need additional fields extracted, please reach out directly:

- **Email**: reapxdev@proton.me
- **Archive & Datasets**: [reapx.dev/data/coursera-scraper/](https://reapx.dev/data/coursera-scraper/)

***

*Disclaimer: Unofficial - not affiliated with Coursera. Collects public data only. reapx. Contact reapxdev@proton.me.*

### 🧪 Example input

A real, runnable configuration — this is an actual input this Actor has run with.

```json
{
  "maxCourses": 50,
  "subject": "data-science",
  "level": "",
  "language": "",
  "partnerQuery": ""
}
```

### 📄 Sample output

One real row from a real run of this Actor, unedited.

```json
{
  "courseType": "v2.ondemand",
  "s12nIds": [],
  "partnerLogo": "http://coursera-university-assets.s3.amazonaws.com/7f/db40d0f4a711e6bc06c3b39ee3e5b0/cloud_logo_400x96.png",
  "description": "This is a self-paced lab that takes place in the Google Cloud console. This lab will provide an introductory, hands-on experience with Generative AI on Google Cloud.",
  "domainTypes": [
    {
      "subdomainId": "cloud-computing",
      "domainId": "information-technology"
    },
    {
      "subdomainId": "machine-learning",
      "domainId": "data-science"
    }
  ],
  "photoUrl": "https://d3njjcbhbojbot.cloudfront.net/api/utilities/v1/imageproxy/https://coursera-course-photos.s3.amazonaws.com/c5/e1dc34a146454fad3d65ce2304cb2b/Logo-Image_GC-Projects.png",
  "categories": [],
  "slug": "googlecloud-getting-started-with-the-vertex-ai-gemini-1-5-pro-model-i43mr",
  "instructorIds": [
    "22997770"
  ],
  "specializations": [],
  "level": "BEGINNER",
  "workload": "1 hour 30 minutes",
  "primaryLanguages": [
    "en"
  ],
  "partnerIds": [
    "443"
  ],
  "certificates": [
    "VerifiedCert"
  ],
  "name": "Getting started with the Vertex AI Gemini 1.5 Pro Model",
  "partners": [
    "Google Cloud"
  ],
  "instructors": [
    "Google Cloud Training"
  ],
  "courseId": "l31la3mKEe-zFg7heHyXOQ"
}
```

### ⚠️ Run outcomes and error handling

This Actor reports what happened in the run's **status message**, and it always keeps whatever it collected. These are the outcomes you can get and what each one means.

| Outcome | What it means |
|---|---|
| **Success** | Rows were returned and you were charged `course-returned` at $0.002 per row. |
| **No matches** | The source returned nothing for your filters. **Nothing is charged.** Widen the date window or drop a filter. |

#### What is guaranteed either way

- **Every row is pushed as it is built**, not buffered to the end of the run. Anything that buffers output loses everything to a timeout, a block or a migration; this does not.
- **A field absent from the source is absent from the row.** Nothing is inferred, modelled or filled in to make a row look complete.

# Actor input Schema

## `maxCourses` (type: `integer`):

Maximum number of Coursera courses to extract in this run. <b>Higher limits take longer and consume more events.</b><br><br>Set a reasonable limit for your data extraction needs. Leave empty or set to 0 to fetch without a explicit cap.<br><br>The higher the number, the longer the run takes and the more you are charged, because you pay per row returned.

## `subject` (type: `string`):

Filter courses by subject area or domain identifier (e.g. <code>data-science</code>, <code>computer-science</code>, <code>business</code>, <code>information-technology</code>, <code>health</code>). <b>Leave empty</b> to collect courses across all subject areas.

## `level` (type: `string`):

Filter courses by difficulty level (<code>BEGINNER</code>, <code>INTERMEDIATE</code>, or <code>ADVANCED</code>). <b>Leave empty</b> to collect courses across all difficulty levels without filtering.

## `language` (type: `string`):

Filter courses by primary language ISO code (e.g. <code>en</code> for English, <code>es</code> for Spanish, <code>fr</code> for French, <code>pt</code> for Portuguese). <b>Leave empty</b> to collect courses regardless of primary language.

## `partnerQuery` (type: `string`):

Filter courses offered by specific university or corporate partners matching this query string (e.g. <code>Google</code>, <code>Stanford</code>, <code>IBM</code>, <code>Yale</code>). <b>Leave empty</b> to collect courses from all partners.

## Actor input object example

```json
{
  "maxCourses": 100
}
```

# Actor output Schema

## `results` (type: `string`):

Every course record collected by this run, one row per item, in the default dataset.

# 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 = {
    "maxCourses": 100,
    "subject": "",
    "level": "",
    "language": "",
    "partnerQuery": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("reapx/coursera-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 = {
    "maxCourses": 100,
    "subject": "",
    "level": "",
    "language": "",
    "partnerQuery": "",
}

# Run the Actor and wait for it to finish
run = client.actor("reapx/coursera-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 '{
  "maxCourses": 100,
  "subject": "",
  "level": "",
  "language": "",
  "partnerQuery": ""
}' |
apify call reapx/coursera-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,reapx/coursera-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/I72Na2emPDT83dv00/builds/QOPZUXa23dsQ8ZRBD/openapi.json
