# Coursera Course Scraper 🎓⚡ - Fast & cheap (`scrapestorm/coursera-course-scraper---fast-cheap`)

Unlock the potential of the Google Scholar scraper tool! 📚✨ Easily collect courses from Coursera based on your chosen keyword or research topic 🔍. Get essential details like the title 📝, rating 🖋️, duration ⏰, difficulty 🌐, and direct links to full texts 🔗 ideal for researchers ! 🚀

- **URL**: https://beta-securitybyobscurity.apify.com/scrapestorm/coursera-course-scraper---fast-cheap.md
- **Developed by:** [Storm\_Scraper](https://beta-securitybyobscurity.apify.com/scrapestorm) (community)
- **Categories:** Automation, E-commerce, Social media
- **Stats:** 7 total users, 3 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

$9.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.
You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

# README

### Advanced Coursera Course Scraper 📚✨

This Coursera Course Scraper allows you to retrieve courses based on your search query 🔍, with customizable filters such as the maximum number of items to extract 🔢 and sorting options like "Best match" 🏆.

This tool helps you discover the latest or most relevant courses on specific topics, keywords, or skills 🌍. You can also extract key details such as the course name 📝, average rating ⭐, difficulty level 🏆, and direct course link 🔗.

Simply specify your search query—whether it’s a topic 🧠 or keyword 🔑—and get the best Coursera courses related to your interests 🚀.

### Description 💯🎓

The Coursera Course Scraper is your go-to tool for discovering relevant and up-to-date courses. Just input a topic, keyword, or skill, and get tailored results with adjustable filters 🛠️. You can specify the maximum number of results to extract 🔢, choose your preferred sorting options, and explore courses in your preferred domain.

Retrieve detailed information about each course, including course title 📝, ratings ⭐, difficulty level 🏆, skills taught 📚, and direct course link 🔗. Whether you’re looking to enhance your learning or analyze course trends, this scraper provides an easy and efficient way to stay informed!

### How many results can you extract using this Google Scholar scraper? 🔍

There is no limit to the number of results you can extract 📊.

You can extract as many academic articles as needed, depending on your query and filters 🔍.

### Key Features ✨

- Unlimited Results 🔢: Extract as many courses as needed, depending on your query and filters.

- Customizable Sorting Options 🔍: Choose how to sort your results, such as by “Best match” or by ratings.

- Detailed Course Info 📝: Extract key details such as course name, ratings, skills, difficulty level, and direct links.

- Search Flexibility 🔍: Specify any topic, keyword, or skill to find courses related to your query.

### 💸 Pricing

This scraper operates on a monthly subscription basis, priced at $9.99/month.

### How to Use? 📲

Using this Coursera Course Scraper is simple and intuitive! It’s designed for users of all skill levels. Follow these easy steps to get started:

```
Enter your search query — for example, a keyword like "artificial intelligence" 🔑.
Customize your filters: Choose the maximum number of courses to extract (e.g., 100 courses) and the sorting preference (e.g., Best match) 🔍.
Click the "Start" button to begin the scraping process 🚀.
Once completed, download the extracted data in your preferred format:
    JSON 📄
    CSV 📊
    XML 📑
    Excel 📈
    HTML 🌐
```

And that’s it! You’ll have all the courses ready to explore.

### Applications 🌟

```
Exploring online learning opportunities and enhancing skills 📚
Building learning paths for researchers, students, and professionals 🧑‍🏫
Analyzing course trends and learner preferences 📊
Evaluating course ratings, reviews, and duration 🏆
```

### Input Example for Coursera Course Scraper 👌

The scraper accepts various parameters to customize the scraping process. Here’s how to structure your input JSON:

```
{
    "keyword": "Artificial Intelligence",
    "maxitems": 100,
    "sort_by": "Best match"
}


```

### Output Example from Coursera Course Scraper 👌

Once the extraction is finished, the data will be stored in a dataset. You can download this data in various formats (JSON, CSV, XML, RSS, HTML Table).

Here is an example of the JSON output for a course:

```
{
  "id": "course~daG-a-O1EeijKBISCWxf6g",
  "name": "AI For Everyone",
  "avg_rating": 4.792651715611851,
  "num_ratings": 46106,
  "difficulty_level": "BEGINNER",
  "duration": "ONE_TO_FOUR_WEEKS",
  "is_free": "Paid",
  "partners": [
      "DeepLearning.AI"
  ],
  "skills": [
      "Data Ethics",
      "Market Opportunities",
      "Artificial Intelligence and Machine Learning (AI/ML)",
      "Artificial Intelligence",
      "Team Building",
      "Machine Learning",
      "Strategic Thinking",
      "Generative AI",
      "Data Science",
      "Deep Learning",
      "Business Ethics",
      "Artificial Neural Networks",
      "Business Transformation"
  ],
  "image_url": "https://s3.amazonaws.com/coursera-course-photos/41/763803169e4d31a5e7611bc928124b/Course-Logo.png",
  "course_url": "https://www.coursera.org/learn/ai-for-everyone"
}

```

### Related Actors ⭐

If you're interested in other Google, social media scraper or real estate Actors:

- [Udemy Course Reviews Scraper 📖💬](https://apify.com/scrapestorm/udemy-course-reviews-scraper)
- [Google Scholar Scraper: Fast & Affordable (Rental) 📚⚡](https://apify.com/scrapestorm/google-scholar-scraper-fast-affordable-rental)
- [Google Scholar Scraper: Fast & Affordable (Pay Per Result) 📚⚡](https://apify.com/scrapestorm/google-scholar-scraper-fast-affordable-pay-per-result)
- [Google News Scraper Fast & Real-Time (Pay per results) 📰⚡](https://apify.com/scrapestorm/google-news-scraper-fast-real-time-pay-per-results)
- [Facebook Likes Scraper (Fast & Cheap) 👍 🌟](https://apify.com/scrapestorm/facebook-likes-scraper-fast-cheap)
- [Facebook Shares Scraper (Exclusive & Affordable) 🚀💡](https://apify.com/scrapestorm/facebook-shares-scraper-exclusive-affordable)
- [Facebook Followers & Following Scraper 📊👥](https://apify.com/scrapestorm/facebook-followers-following-scraper)
- [Facebook Comments Scraper (All-in-One) 💬](https://apify.com/scrapestorm/facebook-comments-scraper-all-in-one)
- [YouTube Scraper (By Keyword) - ⭐⭐⭐⭐⭐ Fast & cheap](https://apify.com/scrapestorm/youtube)
- [Youtube Channel Scraper](https://apify.com/scrapestorm/youtube-channel-scraper)
- [Youtube Shorts Scraper 📺 (Rental) - Fast & cheap](https://apify.com/scrapestorm/youtube-shorts-scraper-rental---fast-cheap)
- [Zillow (Find a Home Improvement Agent) 🛠️)](https://apify.com/scrapestorm/zillow-find-a-home-improvement-agent)
- [YouTube Transcript Video Scraper 📝 (⚡ Fast & 💸 Cheap)](https://apify.com/scrapestorm/youtube-transcript-videos)
- [Youtube Playlist Scraper 🎵 - Rental (Fast & cheap)](https://apify.com/scrapestorm/youtube-playlist-scraper---rental-fast-cheap)

***

### Can I use this Coursera Course API in Python? 🎓

Yes, you can use the Apify API with Python.

To access the Coursera Course Scraper via Python, use the apify-client PyPI package. You can find more details about the client in our Python Client documentation.

### 📫 Support

😊 Leave us a ⭐⭐⭐⭐⭐ if you are satisfied with the product!
🌍 For any questions, specific needs or issues, please reach out through Apify's platform or via email - [Storm\_Scraper 🌪️🌩️](https://apify.com/scrapestorm)

# Actor input Schema

## `keyword` (type: `string`):

The keyword or subject you wish to search courses for on Coursera 🔍🎓

## `maxitems` (type: `integer`):

Maximum number of results you want to scrape 📊

## `sort_by` (type: `string`):

Select a Sort type 🌍

## Actor input object example

```json
{
  "keyword": "artificial intelligence",
  "maxitems": 40,
  "sort_by": "Best match"
}
```

# 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 = {
    "keyword": "artificial intelligence",
    "maxitems": 40,
    "sort_by": "Best match"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapestorm/coursera-course-scraper---fast-cheap").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 = {
    "keyword": "artificial intelligence",
    "maxitems": 40,
    "sort_by": "Best match",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapestorm/coursera-course-scraper---fast-cheap").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 '{
  "keyword": "artificial intelligence",
  "maxitems": 40,
  "sort_by": "Best match"
}' |
apify call scrapestorm/coursera-course-scraper---fast-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Coursera Course Scraper 🎓⚡ - Fast & cheap",
        "description": "Unlock the potential of the Google Scholar scraper tool! 📚✨ Easily collect courses from Coursera based on your chosen keyword or research topic 🔍. Get essential details like the title 📝, rating 🖋️, duration ⏰, difficulty 🌐, and direct links to full texts 🔗 ideal for researchers ! 🚀",
        "version": "0.0",
        "x-build-id": "nzFHgLkYMxLbBxb35"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapestorm~coursera-course-scraper---fast-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapestorm-coursera-course-scraper---fast-cheap",
                "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/scrapestorm~coursera-course-scraper---fast-cheap/runs": {
            "post": {
                "operationId": "runs-sync-scrapestorm-coursera-course-scraper---fast-cheap",
                "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/scrapestorm~coursera-course-scraper---fast-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-scrapestorm-coursera-course-scraper---fast-cheap",
                "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": [
                    "keyword"
                ],
                "properties": {
                    "keyword": {
                        "title": "The keyword or subject you wish to search courses for on Coursera 🔍🎓",
                        "type": "string",
                        "description": "The keyword or subject you wish to search courses for on Coursera 🔍🎓",
                        "default": "artificial intelligence"
                    },
                    "maxitems": {
                        "title": "Maximum number of results you want to scrape 📊",
                        "type": "integer",
                        "description": "Maximum number of results you want to scrape 📊",
                        "default": 40
                    },
                    "sort_by": {
                        "title": "Select a Sort type 🌍",
                        "enum": [
                            "Best match",
                            "Newest"
                        ],
                        "type": "string",
                        "description": "Select a Sort type 🌍",
                        "default": "Best match"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
