# Coursera Scraper \[Only $0.5/1K💰] | Course Catalog | Syllabus (`ahmed_jasarevic/coursera-scraper`) Actor

Scrape the Coursera catalogue — courses, specializations, professional certificates and guided projects — with syllabus modules, skills, difficulty, duration, ratings, reviews and pricing flags. HTTP-only, no browser, no API key. $0.0005 per product.

- **URL**: https://apify.com/ahmed_jasarevic/coursera-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 1,000 reviews

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Coursera Scraper

**Extract structured course, specialization, professional-certificate and guided-project data from the Coursera catalogue — including syllabus modules with per-module durations, skills, difficulty, exact duration, ratings, reviews, partners and pricing flags — using pure HTTP requests with no browser, no API key and no anti-bot costs.** At **$0.0005 per product + $0.0002 per review**, this is the cheapest per-product Coursera scraper on the Apify Store.

Built for edtech founders, universities benchmarking peers, course affiliates, L\&D teams and skills-gap researchers.

### Main Use Cases

- **Coursera course catalog database** — one dataset covering courses, specializations, professional certificates and guided projects, each tagged with its `productType`
- **Skills gap analysis data** — pivot on the `skills` array per product to see which offerings cover a capability and which partners dominate it
- **Course syllabus data** — module-by-module breakdown with per-module duration (ISO 8601 + normalised minutes), not just a headline "1–3 months"
- **E-learning market research** — ratings, review counts, total historical enrolment, languages and pricing flags normalised across all partners
- **Edtech competitor analysis / university benchmarking** — filter `partner` to a specific university and compare catalogue, ratings and module counts
- **Course affiliate and L\&D planning** — free vs Coursera Plus flags, `credentialAwarded`, and exact durations for curriculum comparison

### How It Works

![Coursera Scraper workflow: from course searches and product URLs to records with partners, ratings, skills, difficulty, durations, syllabus modules and pricing flags](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-coursera-scraper.webp)

Looking for a **Coursera scraper** or a practical **course-catalogue data alternative**? Add search queries or direct product URLs, set page and product limits, then choose whether to fetch full detail and embedded reviews. Each product row includes title, URL, slug, Coursera ID, product type, partner, skills, difficulty, duration, rating, review count, free and Coursera Plus flags, price category, badges, syllabus modules and durations, instructors, languages, description, image, financial-aid eligibility and credential.

Use the dataset for course-catalogue research, university benchmarking, skills-gap analysis, affiliate planning and L\&D curriculum comparison. Export as JSON, CSV or Excel, or pull results through the Apify API. Pay from $0.50 per 1,000 products plus $0.20 per 1,000 reviews.

### Build an Online Course Database Without the Coursera API

Coursera's official catalogue API supports no free-text search and only ever exposes `id`, `slug`, `name` and `courseType` (`/api/courses.v1` ignores the `fields` parameter), and the search backend (Cohere) is issued server-side with no client-side key. The server-rendered pages are the reachable, free surface — and they carry the **internal product id** in each result card's `data-click-value.objectID` (`course~…` / `s12n~…`), so no catalogue-API scan is needed. A JSON catalogue index exists but costs up to 130 extra requests per run and is not used. The result: the same field depth browser actors sell at $0.012/result, at **$0.0005/product**, with a **second `reviews` dataset** (up to 5 embedded reviews per product) that costs **no extra HTTP requests**.

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `searchQueries` | array | No | `["data science"]` | Catalogue search terms; category-shaped terms auto-redirect to `/browse/...` |
| `startUrls` | array | No | `[]` | Direct product URLs (`/learn/...`, `/specializations/...`, `/professional-certificates/...`), as `{"url": "..."}` objects; merged with `searchQueries` |
| `maxPages` | integer | No | `5` | Result pages per query (12 products each), capped at 50 |
| `maxItems` | integer | No | `100` | Total products to emit, capped at 2000 (free accounts: 10-product preview) |
| `fetchDetails` | boolean | No | `true` | Load each detail page for syllabus modules, exact duration, difficulty, instructors; `false` = listing-only (1 request per 12 products) |
| `scrapeReviews` | boolean | No | `false` | Also collect embedded reviews into a second `reviews` dataset — no extra requests; a sample, not the full list (see FAQ) |
| `maxRequestsPerCrawl` | integer | No | `400` | Hard cap on total HTTP requests |
| `proxy` | object | No | `useApifyProxy: false` | Optional; not needed to get unblocked |

### Output — Coursera Catalogue Records for Market Research

**`default` dataset** (one row per product):

| Field | Description |
|---|---|
| `title`, `url`, `slug`, `courseraId` | Canonical identity + internal product id (always populated, prefix stripped) |
| `productType` | `Course`, `Specialization`, `Professional Certificate`, `Certificate`, `Guided Project` |
| `partner`, `partnerUrl` | University or company offering the product |
| `skills` | Coursera's own skill tags, 6–22 per product |
| `difficulty`, `duration`, `durationHours` | `Beginner`/`Intermediate`/`Advanced`/`Mixed`; exact duration for courses, range (`1 - 3 Months`) for certificates |
| `rating`, `reviewCount` | Averaged and exact counts (not rounded card values) |
| `isFree`, `isCourseraPlus`, `priceCategory` | Pricing flags: `Free`, `Partially Free`, `Paid`, `Subscription`; Plus enrolment where shown |
| `syllabusModules`, `syllabusModuleCount` | Module name + duration (courses); constituent `/learn/` courses (specializations/certificates) |
| `instructors`, `learnersEnrolled`, `languages`, `description`, `image` | From the detail-page JSON-LD |
| `financialAidEligible`, `credentialAwarded`, `badges` | Aid eligibility, credential, listing badges |
| `searchQuery`, `scrapedAt`, `detailFetched` | Provenance + run metadata |

**`reviews` dataset** (when `scrapeReviews: true`): `productUrl`, `productSlug`, `productTitle`, `productType`, `courseraId`, `reviewer`, `rating`, `date`, `text`, `scrapedAt`.

Two views are preconfigured: **Coursera catalogue** (default table) and **Syllabus modules** (one row per module, for curriculum analysis).

### Example Input

```json
{
  "searchQueries": ["machine learning", "artificial intelligence"],
  "maxPages": 3,
  "maxItems": 200,
  "fetchDetails": true
}
```

Direct URLs are merged with search — e.g. add `"startUrls": [{ "url": "https://www.coursera.org/learn/what-is-datascience" }]`.

### Example Output — Product Record (trimmed)

```json
{
  "title": "Introduction to Artificial Intelligence (AI)",
  "url": "https://www.coursera.org/learn/introduction-to-ai",
  "slug": "introduction-to-ai",
  "courseraId": "ejOz7RDUEei99hK0xs-tsg",
  "productType": "Course",
  "partner": "IBM",
  "skills": ["Responsible AI", "Machine Learning Methods", "Generative AI", "AI literacy"],
  "difficulty": "Beginner",
  "duration": "13 hours 26 minutes",
  "durationHours": 13.43,
  "rating": 4.7,
  "reviewCount": 23395,
  "isFree": true,
  "isCourseraPlus": true,
  "priceCategory": "Subscription",
  "syllabusModules": [
    { "name": "Introduction and Applications of AI", "durationIso": "PT3H45M38S", "durationMinutes": 225.63 }
  ],
  "syllabusModuleCount": 4,
  "instructors": [{ "name": "Antonio Cangiano" }],
  "learnersEnrolled": 956714,
  "languages": ["ar", "de", "es", "fr", "pt", "zh"],
  "financialAidEligible": false,
  "credentialAwarded": "Coursera Certificate",
  "searchQuery": "artificial intelligence",
  "scrapedAt": "2026-09-26T09:11:24.438Z"
}
```

### Course Catalogue Data at $0.0005 Per Product

**$0.0005 per product** (`scraped_product`), **$0.0002 per review row** (`scraped_review`), plus Apify's standard **$0.00005 actor start** — and reviews are charged only for rows successfully written. `fetchDetails: true` (default) adds one detail request per product but does **not** change the price per row. A 100-product run at `maxPages: 5` is about 110 requests on the default 512 MB container — a fraction of one compute unit; `fetchDetails: false` drops it to ~5 requests for a broad listing sweep. The closest competitor with syllabus data charges $0.012/result + $0.01 start, so a 1,000-product catalogue here costs **~$0.55 vs ~$13 there**.

### Integrations & Automation

- **API** — run and fetch via the Apify REST API, or call it from AI agents through the Apify MCP server
- **Scheduling** — monthly catalogue refreshes to track new products, price-flag changes and rating drift
- **Webhooks** — push new course matches (by query or partner) to your app, Sheets or Slack
- **Export** — JSON, CSV, Excel, HTML (both datasets)

**Recommended schedule:** weekly for skills-gap research and peer benchmarking; monthly for full-catalogue database refreshes.

### Related Actors

- [Coursera Scraper](https://apify.com/antonionduarte/coursera-scraper) — `antonionduarte/coursera-scraper` — the most-used Coursera actor (247 users, 4.47★); $0.012/result + $0.01 start, no syllabus modules
- [Coursera Scraper 🎓](https://apify.com/shahidirfan/coursera-scraper) — `shahidirfan/coursera-scraper` — $0.00093/result + $0.0005 start, 5.0★
- [Coursera Search Scraper](https://apify.com/piotrv1001/coursera-search-scraper) — `piotrv1001/coursera-search-scraper` — search-surface only, $0.001/course
- [Coursera Scraper | All In One](https://apify.com/fatihtahta/coursera-scraper) — `fatihtahta/coursera-scraper` — $0.001/result, course + review data
- [Coursera Transcript Scraper — Lecture Subtitles (No Login)](https://apify.com/scrapersdelight/coursera-transcript-scraper) — `scrapersdelight/coursera-transcript-scraper` — transcript-specific, $0.001/lecture

This actor is the cheapest per product ($0.0005), the only one with **syllabus modules + per-module durations + product-type tagging**, and the only one with a zero-extra-cost reviews dataset.

### FAQ

#### Why use this actor instead of the official Coursera API?

The public catalogue endpoint (`/api/courses.v1`) has no free-text search, ignores the `fields` parameter, and only ever returns `id`, `slug`, `name` and `courseType`; partner-facing APIs are gated. The actor reads server-rendered pages — the surface every logged-out visitor gets — and never triggers anti-bot protection.

#### What are alternatives to this actor for course catalogue data?

On the Store: [antonionduarte/coursera-scraper](https://apify.com/antonionduarte/coursera-scraper) ($0.012 + $0.01 start), [shahidirfan/coursera-scraper](https://apify.com/shahidirfan/coursera-scraper) ($0.00093 + $0.0005 start), [piotrv1001/coursera-search-scraper](https://apify.com/piotrv1001/coursera-search-scraper) ($0.001/course), [fatihtahta/coursera-scraper](https://apify.com/fatihtahta/coursera-scraper) ($0.001/result). Ours is the cheapest per product and the only one emitting syllabus modules and product-type tags.

#### Does it need a paid anti-bot service or residential proxy?

No. All three endpoints return `200` to a plain HTTP client. The proxy input is optional (IP rotation/geo-targeting only) — this is not a browser actor, so you pay only for compute.

#### How many courses does it return per query?

Search pages return 11–12 products per page with proper `&page=` pagination; category pages (infinite scroll) return the first server-rendered batch (typically 20–70 products). To enumerate the full catalogue (~24,500 products documented), crawl `/browse/...` and feed the URLs in as `startUrls`.

#### Why are the reviews just a sample?

Coursera embeds only ~5 reviews per `/learn/` course in the server-rendered HTML (none on specializations/certificates/guided projects); the full list loads client-side from endpoints that return `API Route Does Not Exist` over plain HTTP. `reviewCount` on each product is the true total; the `reviews` dataset holds the individual texts actually served. Extracting every review would require a headless browser, which this actor deliberately avoids.

#### Why is `isCourseraPlus` null on some products?

It is `null` when the logged-out page does not surface a Plus marker — this is expected, not a bug. `instructors` and `learnersEnrolled` are often empty on specialization and certificate pages because those JSON-LD nodes carry no `teaches`/`totalHistoricalEnrollment`; individual `/learn/` pages populate both.

#### Why is 512 MB the default memory?

The detail pages embed 1–3 MB of SSR JSON each; at 100 products a 256 MB container was OOM-killed (exit 137), and measured peak is 318 MB. HTTP-only keeps it ~10–20x cheaper than a browser actor anyway; raise it for very large runs (capped at 1024 MB).

### For AI Agents & LLM Apps

- **Purpose**: given search queries (or direct product URLs), returns one row per Coursera product — course/specialization/professional certificate/guided project — with syllabus modules, per-module durations, skills, difficulty, exact duration, rating, review count, enrolment, instructors, languages, pricing flags and credential; optionally a second `reviews` dataset.
- **Minimal working input**:

```json
{ "searchQueries": ["data science"], "maxItems": 100, "fetchDetails": true }
```

- **Variant inputs** — listing-only sweep: `{ "searchQueries": ["python"], "fetchDetails": false }`; direct products: `{ "startUrls": [{ "url": "https://www.coursera.org/learn/what-is-datascience" }] }`; with reviews: add `"scrapeReviews": true`; full catalogue: crawl `/browse/...` URLs via `startUrls`.
- **Output fields**: `title, url, slug, courseraId, productType, partner, partnerUrl, skills, difficulty, duration, durationHours, rating, reviewCount, isFree, isCourseraPlus, badges, priceCategory, syllabusModules, syllabusModuleCount, instructors, learnersEnrolled, languages, description, image, financialAidEligible, credentialAwarded, searchQuery, scrapedAt, detailFetched` (+ `reviews` dataset: `productUrl, productSlug, productTitle, productType, courseraId, reviewer, rating, date, text, scrapedAt`).
- **Behaviors an agent should know**: `searchQueries` and `startUrls` run in the same crawl and results are merged. Category-shaped queries (`machine learning`) 301-redirect to `/browse/...` which has no server-side pagination — expect the first batch (20–70 products); free-text queries paginate 12/page. `scrapeReviews` costs no extra requests but returns only the ~5 embedded reviews per course (never the full list — use `reviewCount` for totals). `fetchDetails: false` produces title/partner/skills/rating-only rows 12-per-request and leaves `syllabusModules`, `instructors`, `learnersEnrolled` empty. Free accounts are capped at 10 products. `durationHours` is exact for courses and `null`/range-formatted for certificates. If a run returns `null` detail rows, Coursera may be A/B-testing — a re-run usually fixes it. Billing notes: reviews are charged ($0.0002) only when written; product rows are $0.0005 each; there is no per-page or per-GB fee.
- **Billing**: pay-per-event — $0.0005 per product + $0.0002 per review + standard $0.00005 actor start; no anti-bot or proxy charges unless you enable proxy yourself.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Coursera, Inc.** It requests only publicly available catalogue pages — the same content any logged-out visitor's browser receives — and does not log in, bypass paywalls, access personal data or circumvent access controls; pricing flags such as `isFree`/`isCourseraPlus` describe the public offer, not an entitlement to course content. Users are responsible for their own compliance with [Coursera's Terms of Use](https://www.coursera.org/terms), `robots.txt` and applicable law. The data is intended for legitimate purposes such as market research, curriculum benchmarking and skills-gap analysis.

### SEO Keywords

coursera scraper, coursera course catalog, coursera api alternative, online course data, e-learning market research, skills gap analysis data, coursera skills taxonomy, mooc database, course syllabus data, edtech competitor analysis, coursera ratings and reviews, professional certificate data, coursera guided projects, university course benchmarking, online learning trends, coursera course pricing data, machine learning courses dataset, python courses data, coursera partners data, l\&d curriculum data

# Actor input Schema

## `searchQueries` (type: `array`):

Catalogue search queries, e.g. \["data science", "python", "marketing"].

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

Optional list of direct Coursera product URLs to scrape (/learn/..., /specializations/..., /professional-certificates/...). When set together with searchQueries, results are merged. Each entry must be an object with a "url" key, e.g. \[{"url": "https://www.coursera.org/learn/what-is-datascience"}] - this is what the requestListSources editor requires, and a bare string is rejected as an invalid URL.

## `maxPages` (type: `integer`):

How many SSR result pages to walk per search query. Coursera returns 12 products per page. Capped at 50 by the actor.

## `maxItems` (type: `integer`):

Maximum number of products to output in total. Capped at 2000 by the actor.

## `fetchDetails` (type: `boolean`):

Also load each product's detail page to extract the syllabus modules, exact duration, difficulty and instructor. Disable for a fast listing-only scrape (1 request per 12 products instead of 13).

## `scrapeReviews` (type: `boolean`):

Also collect the reviews Coursera embeds in each product's detail page and write them to a second dataset named "reviews" (one row per review), leaving the main dataset at one row per product. Costs no extra HTTP requests. Note: Coursera only embeds a small SEO sample of up to 5 reviews per product -- the full review list is loaded client-side and is not reachable over plain HTTP -- so this is a sample, while `reviewCount` on each product is the true total.

## `maxRequestsPerCrawl` (type: `integer`):

Hard safety cap on total HTTP requests made by the crawler.

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "searchQueries": [
    "data science"
  ],
  "startUrls": [],
  "maxPages": 5,
  "maxItems": 100,
  "fetchDetails": true,
  "scrapeReviews": false,
  "maxRequestsPerCrawl": 400,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per Coursera product (course, specialization, professional certificate or guided project).

## `reviews` (type: `string`):

Individual reviews, only produced when scrapeReviews is true. Contains the reviews Coursera embeds in each detail page (up to 5 per /learn/ course), not the full review history.

# 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": [],
    "maxPages": 5,
    "maxItems": 100,
    "fetchDetails": true,
    "scrapeReviews": false,
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/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 = {
    "startUrls": [],
    "maxPages": 5,
    "maxItems": 100,
    "fetchDetails": True,
    "scrapeReviews": False,
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/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 '{
  "startUrls": [],
  "maxPages": 5,
  "maxItems": 100,
  "fetchDetails": true,
  "scrapeReviews": false,
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/coursera-scraper --silent --output-dataset

```

## MCP server setup

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