# Skillshare Scraper | Creative Classes and Teachers (`parseforge/skillshare-scraper`) Actor

Pull Skillshare class data including title, teacher, category, level, duration, lessons, reviews, ratings, and full description. Track creative course catalogs across design, photography, business, and more for education analytics, lead generation, and competitive learning research.

- **URL**: https://apify.com/parseforge/skillshare-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Education, For creators, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎨 Skillshare Course Scraper

> 🚀 **Export Skillshare course data to CSV, Excel, JSON, or XML in seconds.** No account needed. No API key required.

> 🕒 **Last updated:** 2026-05-22 · **📊 10 fields** per record · **Up to 1,000,000 courses** · **Global catalog**

Skillshare is one of the largest online learning platforms, hosting tens of thousands of creative and professional courses. This Actor searches the Skillshare catalog by keyword using their internal API, and delivers a structured dataset with course titles, teachers, durations, student counts, ratings, and direct URLs - all without needing a Skillshare subscription.

Data is fetched live from Skillshare's API on every run. Results are sorted by popularity and paginated automatically until your `maxItems` limit is reached.

**Coverage:** The full Skillshare course catalog across all categories - design, photography, illustration, business, marketing, technology, writing, lifestyle, and more. Each record includes the course thumbnail, teacher name and profile link, duration, project count, student count, rating score, category, and course URL.

### 🎯 Target Audience / Use Cases

| Who uses this | What they do with it |
|---|---|
| EdTech researchers | Analyze course catalog trends, pricing, and instructor popularity |
| Content strategists | Research which topics attract the most students on Skillshare |
| Online educators | Benchmark their courses against the competition |
| Market analysts | Track the growth of creative education categories |
| Developers | Build course recommendation engines or educational dashboards |
| Recruiters | Identify top instructors in a specific creative field |

### 📋 What the Skillshare Scraper does

- Searches the full Skillshare catalog by any keyword
- Returns results sorted by popularity (most students first)
- Paginates through all result pages automatically (24 courses per page)
- Fetches teacher name, profile URL, and all course metadata
- Computes a normalized rating score from positive/total review ratio
- Delivers a clean structured dataset: one record per course

> 💡 **Why it matters:** Skillshare has no public search API for external use. Manually collecting course metadata for research or competitive analysis is impractical at scale. This Actor automates the entire process and gives you a download-ready dataset in minutes.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

<table>
  <thead>
    <tr><th>Field</th><th>Type</th><th>Required</th><th>Default</th><th>Description</th></tr>
  </thead>
  <tbody>
    <tr><td><b>query</b></td><td>string</td><td>No</td><td>photography</td><td>Keyword to search (e.g. "python", "watercolor", "logo design")</td></tr>
    <tr><td><b>maxItems</b></td><td>integer</td><td>No</td><td>10</td><td>Max courses to collect. Free: 10. Paid: up to 1,000,000.</td></tr>
  </tbody>
</table>

**Example 1 - Search for photography courses:**
```json
{
  "query": "photography",
  "maxItems": 50
}
````

**Example 2 - Search for Python programming courses:**

```json
{
  "query": "python programming",
  "maxItems": 200
}
```

> ⚠️ **Good to Know:** Results are sorted by popularity (most enrolled students first). This gives you the most relevant courses for any topic. The Actor uses residential proxies to ensure reliable access to the Skillshare API.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼️ imageUrl | string | Course thumbnail URL |
| 📌 title | string | Full course title |
| 👤 teacherName | string | Instructor's full name |
| 🔗 teacherUrl | string | URL to instructor's Skillshare profile |
| ⏱️ duration | string | Course length (e.g. "1h 32m", "45m") |
| 📁 projectCount | number | Number of class projects |
| 👥 studentCount | number | Total number of enrolled students |
| ⭐ rating | number | Normalized rating (0-1 scale, from positive/total reviews) |
| 🗂️ category | string | Course category (e.g. Design, Photography) |
| 🔗 courseUrl | string | Direct URL to the Skillshare course page |
| 🕒 scrapedAt | string | ISO timestamp when this record was collected |

**Sample record:**

```json
{
  "imageUrl": "https://d1z3xf5h3ibjm6.cloudfront.net/courses/abc123/600x338.jpg",
  "title": "Photography Fundamentals: Shoot Like a Pro in 1 Hour",
  "teacherName": "Marc Henriksen",
  "teacherUrl": "https://www.skillshare.com/en/user/marchenriksen",
  "duration": "1h 4m",
  "projectCount": 312,
  "studentCount": 48203,
  "rating": 0.96,
  "category": "Photography",
  "courseUrl": "https://www.skillshare.com/en/classes/photography-fundamentals/abc123",
  "scrapedAt": "2026-05-22T09:15:00.000Z"
}
```

### ✨ Why choose this Actor

- 🔍 **Full catalog search** - any keyword, any category on Skillshare
- 👥 **Student counts included** - see which courses are actually popular
- ⭐ **Computed ratings** - normalized from positive/total review counts
- 👤 **Teacher profiles** - name and direct profile URL for every instructor
- ⏱️ **Duration included** - filter courses by length for your research
- 💾 **Multiple export formats** - CSV, Excel, JSON, XML
- 🌐 **Residential proxy support** - reliable access at scale

### 📈 How it compares to alternatives

| Feature | This Actor | Manual browsing | Other scrapers |
|---|---|---|---|
| Keyword search | Yes | Yes (tedious) | Varies |
| Student counts | Yes | Yes | Rarely |
| Teacher profiles | Yes | Yes | Rarely |
| Duration | Yes | Yes | Rarely |
| Computed ratings | Yes | No | No |
| Export to CSV/Excel | Yes | No | Sometimes |
| Automated pagination | Yes | No | Sometimes |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 credit)
2. Open the Skillshare Course Scraper on Apify Store
3. Enter your search keyword
4. Set `maxItems` (free users get 10 items automatically)
5. Click **Save & Run**
6. Download your dataset as CSV, Excel, JSON, or XML

### 💼 Business use cases

#### Competitive analysis for course creators

Before launching a new course, research what already exists. See how many students top courses have attracted, what duration they run, and what rating they hold. Use the data to position your course effectively.

#### EdTech market research

Track the size and growth of specific learning categories. Monitor which instructors dominate each category. Build datasets for investor research, content strategy, or platform analysis.

#### Instructor discovery

Find the top teachers in a specific niche (photography, UI design, Python, etc.) for partnerships, interviews, or collaboration opportunities.

#### SEO and content strategy

Identify which course topics drive the highest student enrollment. Use that signal to inform blog content, YouTube strategy, or your own platform's topic selection.

### 🔌 Automating Skillshare Scraper

- **Make (formerly Integromat)** - schedule weekly runs and sync results to Google Sheets
- **Zapier** - notify your team when new top courses appear for your tracked keywords
- **Apify Scheduler** - run automatic weekly catalog snapshots
- **REST API** - programmatically trigger runs from your research pipeline
- **Webhooks** - push new data directly to your database or BI tool

### 🌟 Beyond business use cases

#### Academic research

Study the economics of creator-led education, instructor retention patterns, or how course popularity correlates with topic trends.

#### Personal learning discovery

Find the most popular courses in a topic you want to learn. Sort by student count to find what practitioners actually recommend.

#### Non-profit education

Map available free and low-cost learning resources for specific skills to help underserved communities access online education.

#### Journalism and media

Investigate which skills are most in demand based on enrollment volume, or profile the top educators in emerging fields.

### 🤖 Ask an AI assistant about this scraper

You can ask any AI assistant questions like:

- "What fields does the Skillshare Scraper return?"
- "How is the rating score computed?"
- "How do I find the most popular design courses on Skillshare?"
- "Can I get the number of students enrolled in each course?"

### ❓ Frequently Asked Questions

**Q: Do I need a Skillshare account to use this?**
A: No. The Actor accesses Skillshare's public API without any login or subscription.

**Q: How is the rating computed?**
A: The `rating` field is calculated as `positiveReviews / totalReviews`, normalized to a 0-1 scale. A score of 0.96 means 96% positive reviews.

**Q: What does `studentCount` represent?**
A: The total number of students who have enrolled in the course since it was published.

**Q: Are all Skillshare categories available?**
A: Yes. You can search any topic - design, photography, business, technology, writing, lifestyle, and more.

**Q: How many results can I get per search?**
A: Free users get up to 10. Paid users can get up to 1,000,000 (subject to Skillshare's catalog size for that query).

**Q: Is the data real-time?**
A: Yes. Every run fetches live data from Skillshare's API.

**Q: Can I search for courses in a specific language?**
A: The API defaults to English results. The Actor does not currently support language filtering.

**Q: What is the `projectCount` field?**
A: The number of student projects submitted for the course - a good proxy for course engagement.

**Q: How fast does it run?**
A: About 24 courses are fetched per API call. Expect a few hundred courses per minute.

**Q: Can I export to Google Sheets directly?**
A: Yes. Use the Make or Zapier integration, or download as CSV and import manually.

### 🔌 Integrate with any app

Export your Skillshare dataset to:

**Spreadsheets:** Google Sheets, Microsoft Excel, Airtable\
**Databases:** PostgreSQL, MySQL, MongoDB, Snowflake\
**BI tools:** Tableau, Power BI, Looker, Metabase\
**Automation:** Make, Zapier, n8n, Pipedream\
**Storage:** AWS S3, Google Cloud Storage, Azure Blob\
**Notifications:** Slack, Discord, email via webhook

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Wantedly Scraper](https://apify.com/parseforge/wantedly-scraper) | Scrape job and company listings from Wantedly |
| [Jobrapido Scraper](https://apify.com/parseforge/jobrapido-scraper) | Export job listings from Jobrapido across multiple countries |
| [Upwork Scraper](https://apify.com/parseforge/upwork-scraper) | Scrape freelance job postings from Upwork |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 100+ ready-to-use data scrapers across real estate, jobs, travel, finance, and more.

***

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA) and we will get back to you within one business day.

***

> **⚠️ Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or associated with Skillshare. Use of this tool must comply with Skillshare's Terms of Use and applicable laws. The data collected is publicly available. ParseForge is not responsible for how collected data is used.

# Actor input Schema

## `query` (type: `string`):

Search keyword to find courses (e.g. photography, python, design)

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "query": "photography",
  "maxItems": 10
}
```

# Actor output Schema

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

No description

# 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 = {
    "query": "photography",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/skillshare-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 = {
    "query": "photography",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/skillshare-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 '{
  "query": "photography",
  "maxItems": 10
}' |
apify call parseforge/skillshare-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Skillshare Scraper | Creative Classes and Teachers",
        "description": "Pull Skillshare class data including title, teacher, category, level, duration, lessons, reviews, ratings, and full description. Track creative course catalogs across design, photography, business, and more for education analytics, lead generation, and competitive learning research.",
        "version": "0.1",
        "x-build-id": "GLbX0XWJotls8O9Q1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~skillshare-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-skillshare-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/parseforge~skillshare-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-skillshare-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/parseforge~skillshare-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-skillshare-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",
                "properties": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search keyword to find courses (e.g. photography, python, design)"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
