# Coursera Courses Scraper - Course Catalog Data (`fascinating_lentil/coursera-courses-scraper`) Actor

Scrape Coursera course catalog search results with titles, partners, ratings, skills, difficulty, duration, product type, URLs, and images.

- **URL**: https://apify.com/fascinating\_lentil/coursera-courses-scraper.md
- **Developed by:** [Md Jakaria Mirza](https://apify.com/fascinating_lentil) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 course scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Coursera Courses Scraper - Course Catalog Data

Scrape Coursera search results into clean course catalog records for market research, education lead generation, training catalog analysis, and competitive course tracking. The actor searches Coursera by one or more keywords and saves structured records with course title, URL, product type, university or company partners, difficulty, duration, skills, rating, review count, image URL, and Coursera Plus/free flags when present.

This build follows a probe-first workflow. Coursera exposes enough public page data for reliable catalog extraction without a login or paid key. Udemy is intentionally not included in this actor: public Udemy course endpoints returned Cloudflare blocks during probing, and Udemy states that access to its Affiliate API was discontinued from January 1, 2025. The actor therefore ships as a Coursera-only scraper instead of publishing fragile or misleading Udemy support.

### Use Cases

- Build course directories and training catalogs.
- Research competing online courses by keyword.
- Track university and company partner offerings.
- Collect B2B education leads for learning platforms.
- Analyze skills, difficulty levels, ratings, and review volume.

### Input

```json
{
  "queries": ["python", "data science"],
  "maxResults": 100,
  "productTypes": ["COURSE"],
  "difficulties": ["BEGINNER"],
  "includeSkills": true
}
````

### Output

```json
{
  "source": "coursera",
  "query": "python",
  "courseId": "course~ejOz7RDUEei99hK0xs-tsg",
  "title": "Python for Data Science, AI & Development",
  "courseUrl": "https://www.coursera.org/learn/python-for-applied-data-science-ai",
  "courseSlug": "learn/python-for-applied-data-science-ai",
  "productType": "COURSE",
  "productTypeLabel": "Course",
  "partners": ["IBM"],
  "partnerNames": "IBM",
  "difficulty": "BEGINNER",
  "difficultyLabel": "Beginner",
  "duration": "ONE_TO_THREE_MONTHS",
  "durationLabel": "1-3 months",
  "skills": ["Python Programming", "NumPy", "Data Analysis"],
  "skillNames": "Python Programming, NumPy, Data Analysis",
  "rating": 4.620138506696019,
  "ratingRounded": 4.62,
  "reviewCount": 43608,
  "isFree": false,
  "isPartOfCourseraPlus": true,
  "imageUrl": "https://s3.amazonaws.com/coursera-course-photos/c6/fcdecba59c48ad9f64b9cf73964466/BC-5768_VisMerch-Phase-3-Assets_IBM_PythonforDataScience.png",
  "resultPage": 1,
  "scrapedAt": "2026-06-12T00:00:00.000Z"
}
```

### How to Scrape Coursera Courses

1. Enter one or more course search keywords.
2. Set the maximum number of results to collect.
3. Optionally filter by product type or difficulty.
4. Run the actor.
5. Download the dataset as JSON, CSV, Excel, or via API.

### Pricing

| Event | When charged | Price |
| --- | --- | --- |
| `course-scraped` | Each unique Coursera course record saved | `$0.002` |

Charges are made only after a real record is saved to the Apify Dataset.

### Data Fields

| Field | Description |
| --- | --- |
| `source` | Source platform, currently `coursera`. |
| `query` | Search keyword that found the course. |
| `courseId` | Coursera product identifier. |
| `title` | Course or program title. |
| `courseUrl` | Full Coursera URL. |
| `productType` | Course, specialization, professional certificate, and similar product type. |
| `productTypeLabel` | Human-friendly product type for table views. |
| `partners` | University, company, or institution partners. |
| `difficulty` | Coursera difficulty label when available. |
| `difficultyLabel` | Human-friendly difficulty label for table views. |
| `duration` | Coursera duration bucket when available. |
| `durationLabel` | Human-friendly duration label for table views. |
| `skills` | Public skill tags when available. |
| `rating` | Average rating. |
| `ratingRounded` | Rounded rating for compact table views. |
| `reviewCount` | Number of ratings or reviews exposed in search data. |
| `isFree` | Coursera free flag when present. |
| `isPartOfCourseraPlus` | Coursera Plus flag when present. |
| `imageUrl` | Course image URL. |
| `scrapedAt` | ISO timestamp for the scrape. |

### Notes and Limits

- Pagination is supported up to 500 unique records per run.
- Results are deduplicated by Coursera product ID.
- Coursera may change its public page payloads, which can require parser updates.
- Udemy is parked until an official, accessible, and compliant data source becomes available.

# Actor input Schema

## `queries` (type: `array`):

One or more Coursera search queries.

## `maxResults` (type: `integer`):

Maximum number of unique courses to save across all queries.

## `productTypes` (type: `array`):

Optional product type filter.

## `difficulties` (type: `array`):

Optional difficulty filter.

## `includeSkills` (type: `boolean`):

Include Coursera skill tags when present.

## `proxyConfiguration` (type: `object`):

Optional Apify proxy settings.

## Actor input object example

```json
{
  "queries": [
    "python",
    "data science"
  ],
  "maxResults": 100,
  "includeSkills": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "queries": [
        "python",
        "data science"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fascinating_lentil/coursera-courses-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 = { "queries": [
        "python",
        "data science",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fascinating_lentil/coursera-courses-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 '{
  "queries": [
    "python",
    "data science"
  ]
}' |
apify call fascinating_lentil/coursera-courses-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Coursera Courses Scraper - Course Catalog Data",
        "description": "Scrape Coursera course catalog search results with titles, partners, ratings, skills, difficulty, duration, product type, URLs, and images.",
        "version": "1.0",
        "x-build-id": "BeUV6Nb3iJqJf4C3X"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fascinating_lentil~coursera-courses-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fascinating_lentil-coursera-courses-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/fascinating_lentil~coursera-courses-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fascinating_lentil-coursera-courses-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/fascinating_lentil~coursera-courses-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fascinating_lentil-coursera-courses-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",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "One or more Coursera search queries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of unique courses to save across all queries.",
                        "default": 100
                    },
                    "productTypes": {
                        "title": "Product types",
                        "type": "array",
                        "description": "Optional product type filter.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "COURSE",
                                "SPECIALIZATION",
                                "PROFESSIONAL_CERTIFICATE",
                                "GUIDED_PROJECT",
                                "PROJECT",
                                "DEGREE",
                                "MASTERTRACK"
                            ],
                            "enumTitles": [
                                "Course",
                                "Specialization",
                                "Professional Certificate",
                                "Guided Project",
                                "Project",
                                "Degree",
                                "MasterTrack"
                            ]
                        }
                    },
                    "difficulties": {
                        "title": "Difficulty levels",
                        "type": "array",
                        "description": "Optional difficulty filter.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "BEGINNER",
                                "INTERMEDIATE",
                                "ADVANCED",
                                "MIXED"
                            ],
                            "enumTitles": [
                                "Beginner",
                                "Intermediate",
                                "Advanced",
                                "Mixed"
                            ]
                        }
                    },
                    "includeSkills": {
                        "title": "Include skills",
                        "type": "boolean",
                        "description": "Include Coursera skill tags when present.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
