# Frontend Masters Course Scraper (`crawlerbros/frontendmasters-course-scraper`) Actor

Scrape Frontend Masters' full course catalog - web development, JavaScript, React, AI engineering, and more. Get titles, ratings, durations, teachers, and cover images. Enrich individual course URLs with full descriptions, instructor bios, and syllabus breakdowns.

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

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Frontend Masters Course Scraper

Scrape Frontend Masters' full course catalog — web development, JavaScript, React, AI engineering, cloud, and more. Get every course's title, rating, duration, teacher, and cover image in one run, or enrich specific course URLs with full descriptions, instructor bios, publish dates, and syllabus breakdowns.

### What this actor does

- **Five modes:** `list` (the entire course catalog, filterable/sortable), `byTopic` (browse one of Frontend Masters' 74 topic tags, e.g. `javascript`, `react`, `artificial-intelligence`), `byLearningPath` (browse one of Frontend Masters' 24 curated, ordered learning paths, e.g. `beginner`, `fullstack`, `ai`), `byTeacher` (browse every course taught by one of Frontend Masters' 97 instructors, e.g. `kentcdodds`, `scott-moss`), and `byUrls` (fetch full details for specific course URLs)
- **Filters:** keyword (title/description substring), topic, teacher name, minimum rating, exclude unrated courses
- **Sorting:** popularity, rating, duration, or title
- **Rich detail enrichment:** full description, instructor(s), publish date, language, total duration, and a section-by-section syllabus with lesson counts
- **No login, no cookies, no paid proxy** — public catalog and course pages only
- **Empty fields are omitted** — every record only contains fields that have real data

### Output per course

- `title` — course title
- `sourceUrl` — canonical `frontendmasters.com/courses/...` URL
- `courseSlug` — URL slug / course code
- `courseId` — Frontend Masters' internal course ID (mode=`list`, `byTopic`, `byLearningPath`, `byTeacher`)
- `description` — course summary
- `rating` — average rating (0–5); omitted for newly-released, not-yet-rated courses
- `durationSeconds`, `durationText` — total course length
- `lessonCount` — number of lessons in the course (mode=`list`, `byTopic`, `byLearningPath`, `byTeacher`; also present as a syllabus total in mode=`byUrls`)
- `thumbnailUrl` — cover image
- `teacherName` / `teacherNames[]` — instructor name(s) (single field for one instructor, array for multi-instructor courses)
- `teacherUrl` — instructor's Frontend Masters profile
- `teacherCompany` — instructor's employer/tagline as shown on Frontend Masters (e.g. `Netflix`, `Spotify`)
- `publishedDate` — release date (`YYYY-MM-DD`)
- `language` — course language (mode=`byUrls` only)
- `isAccessibleForFree` — whether the course requires a subscription (mode=`byUrls` only)
- `syllabus[]` — section breakdown: `title`, `durationSeconds`, `lessonCount` (mode=`byUrls` only)
- `sectionCount`, `lessonCount` — syllabus totals (mode=`byUrls` only)
- `topics[]` — topic tags shown on the course's own page, e.g. `["Artificial Intelligence", "OpenAI", "TypeScript"]` (mode=`byUrls` only; omitted when the course page doesn't list topics)
- `recordType: "course"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `list` | `list` / `byTopic` / `byLearningPath` / `byTeacher` / `byUrls` |
| `searchKeyword` | string | – | Substring match on title/description (mode=`list`, `byTopic`, `byLearningPath`, `byTeacher`). Leave empty to list the whole catalog/topic/path/teacher. |
| `topic` | select | `javascript` | One of 74 Frontend Masters topic tags (mode=`byTopic`) |
| `learningPath` | select | `beginner` | One of 24 Frontend Masters curated learning paths (mode=`byLearningPath`) |
| `teacherSlug` | select | `kentcdodds` | One of 97 Frontend Masters instructors to browse all courses from (mode=`byTeacher`) |
| `teacherName` | string | – | Substring match on teacher name |
| `minRating` | number | – | Drop courses rated below this (0–5) |
| `excludeUnrated` | boolean | `false` | Skip courses without a rating yet |
| `sortBy` | select | `relevance` | `relevance` / `popularityDesc` / `ratingDesc` / `ratingAsc` / `durationDesc` / `durationAsc` / `titleAsc` |
| `courseUrls` | array | – | Course URLs to fetch (mode=`byUrls`) |
| `maxItems` | int | `50` | Hard cap on emitted records (1–500) |

#### Example: highest-rated JavaScript courses

```json
{
  "mode": "list",
  "searchKeyword": "javascript",
  "sortBy": "ratingDesc",
  "excludeUnrated": true,
  "maxItems": 20
}
```

#### Example: everything by a specific teacher

```json
{
  "mode": "list",
  "searchKeyword": "",
  "teacherName": "Brian Holt",
  "sortBy": "durationDesc"
}
```

#### Example: browse the Artificial Intelligence topic

```json
{
  "mode": "byTopic",
  "topic": "artificial-intelligence",
  "sortBy": "ratingDesc",
  "maxItems": 30
}
```

#### Example: browse the Beginner learning path

```json
{
  "mode": "byLearningPath",
  "learningPath": "beginner",
  "sortBy": "relevance",
  "maxItems": 30
}
```

#### Example: everything taught by Kent C. Dodds

```json
{
  "mode": "byTeacher",
  "teacherSlug": "kentcdodds",
  "sortBy": "durationDesc"
}
```

#### Example: enrich specific course URLs with full syllabus

```json
{
  "mode": "byUrls",
  "courseUrls": [
    "https://frontendmasters.com/courses/typescript-ai/",
    "https://frontendmasters.com/courses/aws-v3/"
  ]
}
```

### Use cases

- **Edtech competitive analysis** — track Frontend Masters' catalog breadth and release cadence
- **Curriculum design** — discover highest-rated courses for a given technology
- **Content gap analysis** — compare course coverage against your own learning platform
- **Instructor research** — pull every course by a specific teacher
- **Learning path planning** — use syllabus section/lesson counts to estimate study time

### FAQ

**Do I need a Frontend Masters account?**  No. This actor only reads publicly rendered course-catalog pages — no login, cookies, or paid proxy required.

**Why do some courses lack a `rating`?**  Frontend Masters doesn't show a rating until a course has accumulated enough reviews; brand-new courses are unrated. Use `excludeUnrated: true` to skip them.

**What's the difference between `list`, `byTopic`, `byLearningPath`, `byTeacher`, and `byUrls`?**  `list` fetches the entire catalog in a single request (fast, includes rating/duration/teacher). `byTopic` narrows that same catalog down to courses tagged with one of Frontend Masters' 74 topics (e.g. `react`, `devops`, `machine-learning`). `byLearningPath` narrows it down to one of Frontend Masters' 24 curated, ordered learning paths (e.g. `beginner`, `fullstack`, `ai`) — these are hand-picked course sequences distinct from topic tags. `byTeacher` narrows it down to every course taught by one of Frontend Masters' 97 instructors. `byUrls` fetches each course's own page for richer detail — full description, publish date, language, topic tags, and a section-by-section syllabus — at the cost of one request per course.

**How is `durationText` formatted?**  Parsed from Frontend Masters' own course length (e.g. `4h 28m`).

**How fresh is the data?**  Real-time — every run reads Frontend Masters' live public course-catalog API (the same one the site's own catalog page uses for its pagination), so it reflects the full, current catalog rather than just the page's initial render.

**Why is there a `teacherCompany` field?**  Frontend Masters shows each instructor's current employer/tagline (e.g. "Netflix", "Staff Software Engineer") alongside their name; it's included whenever available.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `searchKeyword` (type: `string`):

Case-insensitive substring match against course title and description. Leave empty to list the entire catalog (or the entire topic, in mode=byTopic).

## `topic` (type: `string`):

Frontend Masters topic/tag to browse, e.g. `javascript`, `react`, `artificial-intelligence`.

## `learningPath` (type: `string`):

Frontend Masters curated, ordered learning path to browse, e.g. `beginner`, `react`, `ai`.

## `teacherSlug` (type: `string`):

Frontend Masters instructor to browse all courses from.

## `teacherName` (type: `string`):

Case-insensitive substring match against the teacher's name.

## `minRating` (type: `number`):

Drop courses rated below this value (0-5).

## `excludeUnrated` (type: `boolean`):

Skip newly-released courses that don't have a rating yet (rating = 0).

## `sortBy` (type: `string`):

Result ordering.

## `courseUrls` (type: `array`):

Full Frontend Masters course URLs to fetch, e.g. `https://frontendmasters.com/courses/typescript-ai/`.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "list",
  "searchKeyword": "",
  "topic": "javascript",
  "learningPath": "beginner",
  "teacherSlug": "kentcdodds",
  "excludeUnrated": false,
  "sortBy": "relevance",
  "courseUrls": [
    "https://frontendmasters.com/courses/typescript-ai/"
  ],
  "maxItems": 50
}
```

# Actor output Schema

## `courses` (type: `string`):

Dataset containing all scraped Frontend Masters courses.

# 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 = {
    "mode": "list",
    "searchKeyword": "",
    "topic": "javascript",
    "learningPath": "beginner",
    "teacherSlug": "kentcdodds",
    "excludeUnrated": false,
    "sortBy": "relevance",
    "courseUrls": [
        "https://frontendmasters.com/courses/typescript-ai/"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/frontendmasters-course-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 = {
    "mode": "list",
    "searchKeyword": "",
    "topic": "javascript",
    "learningPath": "beginner",
    "teacherSlug": "kentcdodds",
    "excludeUnrated": False,
    "sortBy": "relevance",
    "courseUrls": ["https://frontendmasters.com/courses/typescript-ai/"],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/frontendmasters-course-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 '{
  "mode": "list",
  "searchKeyword": "",
  "topic": "javascript",
  "learningPath": "beginner",
  "teacherSlug": "kentcdodds",
  "excludeUnrated": false,
  "sortBy": "relevance",
  "courseUrls": [
    "https://frontendmasters.com/courses/typescript-ai/"
  ],
  "maxItems": 50
}' |
apify call crawlerbros/frontendmasters-course-scraper --silent --output-dataset

```

## MCP server setup

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