# Domestika Course Catalog Scraper (`automation-lab/domestika-course-catalog-scraper`) Actor

Extract public Domestika course catalogs and profiles with prices, ratings, students, instructors, languages, workload, topics, and FAQs. Export structured data, use the API, or schedule catalog monitoring.

- **URL**: https://apify.com/automation-lab/domestika-course-catalog-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Education
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.06 / 1,000 course extracteds

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?

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

## Domestika Course Catalog Scraper

Extract structured **Domestika course catalog data** from public category, search, ranked, and individual course pages.
Collect prices, instructors, ratings, student counts, languages, workload, learning topics, and FAQs without a login or API key.
The Actor uses lightweight HTTP requests rather than a browser, so scheduled catalog snapshots stay fast and economical.

- 🎓 Turn Domestika pages into clean JSON, CSV, Excel, XML, or RSS exports.
- 📈 Compare prices, popularity, ratings, and availability across creative courses.
- 👩‍🏫 Research instructors with public biographies, locations, and social links.
- 🔁 Schedule recurring runs to monitor catalog changes over time.

### What does Domestika Course Catalog Scraper do?

[Domestika](https://www.domestika.org/) publishes creative-course catalogs and detailed public course pages.
This scraper converts those pages into analysis-ready records.
Give it one or more catalog or course URLs, choose a limit, and receive one dataset row per unique course.

It supports:

- public category pages such as Illustration;
- public search result pages;
- ranked catalog URLs such as highest rated;
- direct course URLs;
- optional course-detail enrichment;
- optional Apify Proxy configuration;
- global deduplication by Domestika course ID.

The Actor does **not** log in, buy courses, or access paid lessons.

### Who is Domestika Course Catalog Scraper for?

**Edtech catalog teams**

- Build a structured creative-learning catalog.
- Normalize course prices, languages, workload, and availability.
- Feed course records into internal search or recommendation systems.

**Market and competitive intelligence analysts**

- Compare creative-course categories and instructors.
- Track price, rating, and popularity changes.
- Create recurring category snapshots for trend analysis.

**Instructor and creator researchers**

- Discover teachers in a creative discipline.
- Collect public biographies, locations, topics, and social links.
- Rank instructors using course and student signals.

**Data engineers and automation teams**

- Export records through the Apify API.
- Schedule updates and deliver them through webhooks.
- Connect datasets to warehouses, spreadsheets, or dashboards.

### Why use this Domestika scraper?

- ✅ **No login or API key:** it reads public course metadata.
- ✅ **Rich detail data:** combines SSR catalog cards and structured JSON-LD.
- ✅ **Low overhead:** HTTP/Cheerio extraction runs at 256 MB.
- ✅ **Stable identity:** numeric course IDs support reliable deduplication.
- ✅ **Flexible sources:** mix direct course and catalog URLs in one run.
- ✅ **Typed output:** numeric prices, counts, and ratings remain numbers.
- ✅ **Apify-native:** use schedules, webhooks, API clients, and 5,000+ integrations.
- ✅ **Scope-safe:** only domestika.org course URLs are accepted.

### What Domestika course data can you extract?

| Data group | Fields |
|---|---|
| Course identity | Course ID, canonical URL, source URL, catalog rank |
| Catalog copy | Title, description, category, badges, cover image |
| Commercial data | Price, currency, availability |
| Social proof | Positive rating percentage, rating count, student count |
| Learning format | Workload, lesson count, resource count, level |
| Localization | Course/audio languages and subtitle languages |
| Instructor | Name, role, portrait, biography, location, social URLs |
| Discovery | Learning topics and public course FAQs |
| Provenance | Extraction timestamp and originating source URL |

Optional fields are omitted when Domestika does not publish them for a course.
This avoids misleading placeholder values.

### How much does it cost to scrape Domestika courses?

The Actor uses pay-per-event pricing.
A run has a **$0.005 start charge** plus a charge for every course saved.
The current Starter/BRONZE price is **$0.00010374 per course**; higher plans receive volume discounts.

| Plan tier | Per course |
|---|---:|
| Free | $0.0001193 |
| Starter / BRONZE | $0.00010374 |
| Scale / SILVER | $0.000080914 |
| Business / GOLD | $0.000062242 |
| Platinum | $0.000041494 |
| Diamond | $0.000029046 |

Example Starter-plan totals:

| Workflow | Courses | Estimated Actor charge |
|---|---:|---:|
| One direct course | 1 | $0.00510 |
| Small category snapshot | 20 | $0.00707 |
| Multi-source research run | 100 | $0.01537 |

Apify platform usage is handled according to the active Actor pricing shown in the Store.
Start with a small limit before scheduling a larger workflow.

### How to scrape Domestika courses

1. Open **Domestika Course Catalog Scraper** on Apify.
2. Add a public Domestika category, search, ranked, or direct course URL.
3. Set **Maximum courses** to the number of unique records you need.
4. Keep **Enrich course details** enabled for price, language, instructor, and FAQ data.
5. Click **Start**.
6. Preview the dataset and export it as JSON, CSV, Excel, XML, or RSS.
7. Save the task or add a schedule when you need recurring snapshots.

A minimal direct-course input:

```json
{
  "startUrls": [
    {
      "url": "https://www.domestika.org/en/courses/2432-atmospheric-scenes-in-procreate-paint-with-color-and-light"
    }
  ],
  "maxItems": 1,
  "includeDetails": true
}
```

A ranked-category input:

```json
{
  "startUrls": [
    {
      "url": "https://www.domestika.org/en/courses/category/11-illustration/highest_rated"
    }
  ],
  "maxItems": 20,
  "includeDetails": true,
  "maxConcurrency": 4
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | required | Public domestika.org category, search, ranked, or direct course URLs |
| `maxItems` | integer | `20` | Maximum unique courses saved across every source URL |
| `includeDetails` | boolean | `true` | Open course pages for complete detail enrichment |
| `maxConcurrency` | integer | `4` | Simultaneous detail requests, from 1 to 10 |
| `proxyConfiguration` | object | direct access | Optional Apify Proxy settings |

The input editor prefill uses one real direct course and a low three-course limit.
Only URLs on `domestika.org` whose path includes `/courses` are accepted.

### Output example

```json
{
  "courseId": 2432,
  "url": "https://www.domestika.org/en/courses/2432-atmospheric-scenes-in-procreate-paint-with-color-and-light",
  "sourceUrl": "https://www.domestika.org/en/courses/category/11-illustration/highest_rated",
  "rank": 1,
  "title": "Atmospheric Scenes in Procreate: Paint with Color and Light",
  "description": "Learn to create digital paintings filled with magic and emotion by exploring illustration techniques",
  "category": "Illustration",
  "badges": ["Best seller"],
  "instructor": "Ramona Wultschner",
  "instructorLocation": "Neuss, Germany",
  "price": 29.99,
  "currency": "USD",
  "availability": "InStock",
  "ratingPercentage": 100,
  "ratingCount": 893,
  "studentCount": 33452,
  "workload": "PT2H47M1S",
  "courseLanguages": ["English", "French", "Italian", "Portuguese", "Turkish"],
  "learningTopics": ["Digital Illustration"],
  "scrapedAt": "2026-07-23T00:00:00.000Z"
}
```

Prices and counts reflect the public page at run time and can change.
The exact optional fields vary by course.

### Catalog-only versus enriched output

Keep `includeDetails` enabled when you need the full product.
Each discovered course receives one additional public HTTP request.
This adds price, availability, category, workload, learning format, languages, instructor profile, topics, and FAQs.

Disable detail enrichment when you only need a fast catalog index.
Catalog cards still provide:

- course ID and URL;
- title and short description;
- instructor name;
- badge and cover image;
- student count;
- positive rating percentage and rating count.

Both modes return the same course entity and dataset schema.

### Tips for best results

- 🎯 Start with `maxItems: 5` while validating a new source URL.
- 📚 Add several category or search URLs to build a combined catalog.
- 🔍 Use direct course URLs for deterministic one-course monitoring.
- ⚡ Disable detail enrichment only when catalog-card fields are enough.
- 🧭 Keep concurrency at 4 unless you have a specific reason to change it.
- 🌍 Use English `/en/courses` pages for the most consistent labels.
- 🔁 Schedule snapshots at a cadence appropriate for your analysis.
- 🆔 Join historical datasets by `courseId`, not by title.

### Monitor Domestika catalog changes

Create an Apify task with a stable category or search URL.
Run it daily or weekly and store each dataset ID in your data warehouse.
Compare snapshots using `courseId` as the key.

Useful changes to detect include:

- price or currency changes;
- availability changes;
- new and removed courses;
- rating and student-count growth;
- changes in workload or language coverage;
- instructor profile updates.

Use a webhook to trigger your comparison pipeline when each run succeeds.

### Integrations

**Domestika → Google Sheets**

Export course rows to a sheet used by catalog or content teams.
Create formulas for category, price, rating, and popularity comparisons.

**Domestika → Slack or Discord**

Schedule a run and send an alert when a tracked price or availability field changes.
Keep the detailed dataset linked from the notification.

**Domestika → Make or Zapier**

Trigger downstream workflows from a completed Actor run.
Upsert courses into Airtable, Notion, a CMS, or a CRM using `courseId`.

**Domestika → data warehouse**

Load JSON or CSV snapshots into BigQuery, Snowflake, or PostgreSQL.
Build time-series dashboards for price and demand signals.

**Domestika → webhook API**

Send the dataset URL to your own endpoint as soon as extraction completes.
This works well for internal catalog-refresh pipelines.

### Use the Apify API with Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/domestika-course-catalog-scraper').call({
    startUrls: [{
        url: 'https://www.domestika.org/en/courses/category/11-illustration/highest_rated',
    }],
    maxItems: 20,
    includeDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Install the client with `npm install apify-client`.
Keep your Apify token in an environment variable.

### Use the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/domestika-course-catalog-scraper').call(run_input={
    'startUrls': [{
        'url': 'https://www.domestika.org/en/courses/2432-atmospheric-scenes-in-procreate-paint-with-color-and-light'
    }],
    'maxItems': 1,
    'includeDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Install the client with `pip install apify-client`.
The returned dataset supports pagination for larger exports.

### Use the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~domestika-course-catalog-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{
      "url": "https://www.domestika.org/en/courses/search/illustration"
    }],
    "maxItems": 10,
    "includeDetails": true
  }'
```

The run response includes the dataset and key-value-store identifiers.
Poll the run endpoint or use a webhook to wait for completion.

### Use with AI agents via MCP

Domestika Course Catalog Scraper can be used by AI assistants through the [Model Context Protocol](https://docs.apify.com/platform/integrations/mcp).

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/domestika-course-catalog-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/domestika-course-catalog-scraper"
    }
  }
}
```

Authenticate with your Apify account when prompted.

**Example prompts**

Then try prompts such as:

- “Use `automation-lab/domestika-course-catalog-scraper` to compare the top-rated illustration courses by price and student count.”
- “Extract this Domestika course and summarize the teacher background, workload, languages, and learning topics.”
- “Create a weekly Domestika category snapshot and flag courses whose price or availability changed.”

### Is it legal to scrape Domestika?

This Actor extracts information visible on public Domestika course and catalog pages.
It does not authenticate, circumvent paid access, or retrieve lesson media.
Web scraping laws and website terms vary by jurisdiction and use case.

You are responsible for ensuring that your collection and use of data comply with applicable laws, Domestika terms, privacy obligations, and intellectual-property rights.
Collect only what you need, use reasonable request volume, and avoid republishing protected course content.
Do not use the Actor to access purchased or private material.

### Limitations

- The first server-rendered result surface of each supplied catalog/search URL is extracted; Domestika currently does not expose working `?page=` pagination on the tested ranked page.
- Add multiple source URLs when your workflow needs several catalog slices.
- Detail fields depend on what Domestika publishes for the selected locale and course.
- Price and availability may vary by locale, campaign, or time.
- The Actor does not download course videos, lessons, or other paid assets.
- Domestika HTML can change; extraction errors are surfaced rather than silently returning an empty successful dataset.

### Troubleshooting

**Why did my run reject a URL?**

Use a public `https://www.domestika.org/.../courses...` URL.
The Actor intentionally rejects other hosts and non-course pages so unrelated inputs cannot bypass product scope.

**Why is an optional field missing?**

Domestika does not publish every field on every course or locale.
Keep detail enrichment enabled and try the English page before treating the field as unavailable.

**Why did I receive fewer courses than `maxItems`?**

`maxItems` is a ceiling, not a promise.
The source surface may contain fewer unique course cards, and duplicates across source URLs are removed by course ID.

**What should I do after an extraction failure?**

Inspect the Actor log and verify that the source URL still opens publicly.
If direct access is restricted in your region, enable Apify Proxy in the advanced input section.

### Frequently asked questions

**How fast is the Domestika scraper?**

A direct course usually finishes in seconds.
Catalog runs depend on course count and detail enrichment; up to four detail pages are requested concurrently by default.

**Do I need a Domestika account?**

No.
The supported product uses only anonymous public course metadata.

**Can I scrape paid lessons?**

No.
Paid lessons, downloads, and authenticated learning content are outside scope.

**Does it support category and search pages?**

Yes.
Supply public category, ranked, search, or direct course URLs in `startUrls`.

**How are duplicate courses handled?**

The Actor deduplicates every discovered record by Domestika’s numeric course ID across all source URLs.

**Can I schedule it as a monitor?**

Yes.
Save the input as an Apify task, add a schedule, and compare datasets using `courseId`.

### Other research and catalog scrapers

Combine this Actor with other Automation Lab tools:

- [Google Search Scraper](https://apify.com/automation-lab/google-search-scraper) for broader course and instructor discovery.
- [Google Scholar Scraper](https://apify.com/automation-lab/google-scholar-scraper) for education and learning-market research.
- [YouTube Scraper](https://apify.com/automation-lab/youtube-scraper) for public tutorial and creator analysis.
- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper) for creative-skill demand research.
- [Reddit Scraper](https://apify.com/automation-lab/reddit-scraper) for public learner discussions and course-demand signals.

Each linked Actor has its own input, output, pricing, and data-use requirements.
Use stable identifiers when joining results across sources.

# Actor input Schema

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

Add Domestika category, search, ranked catalog, or direct course URLs.

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

Stop after saving this many unique course records across all source URLs.

## `includeDetails` (type: `boolean`):

Open each course page to collect price, workload, languages, instructor profile, topics, and FAQs.

## `maxConcurrency` (type: `integer`):

Set the maximum number of simultaneous course-detail requests.

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

Optionally route requests through Apify Proxy. Direct access works for normal public pages.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.domestika.org/en/courses/2432-atmospheric-scenes-in-procreate-paint-with-color-and-light"
    }
  ],
  "maxItems": 3,
  "includeDetails": true,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Open the default dataset table containing one row per unique Domestika course.

# 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": [
        {
            "url": "https://www.domestika.org/en/courses/2432-atmospheric-scenes-in-procreate-paint-with-color-and-light"
        }
    ],
    "maxItems": 3,
    "includeDetails": true,
    "maxConcurrency": 2,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/domestika-course-catalog-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": [{ "url": "https://www.domestika.org/en/courses/2432-atmospheric-scenes-in-procreate-paint-with-color-and-light" }],
    "maxItems": 3,
    "includeDetails": True,
    "maxConcurrency": 2,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/domestika-course-catalog-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": [
    {
      "url": "https://www.domestika.org/en/courses/2432-atmospheric-scenes-in-procreate-paint-with-color-and-light"
    }
  ],
  "maxItems": 3,
  "includeDetails": true,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/domestika-course-catalog-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/domestika-course-catalog-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/k4dNTHJzmWmBOG8em/builds/Dtarhg8gU6EqL1BGU/openapi.json