Cousera Reviews Scraper

Coursera Reviews Scraper

Coursera Reviews Scraper helps you collect public learner reviews, ratings, review counts, and course-level summary information from Coursera in a clean, structured format. Instead of copying reviews manually, you can run this actor on Apify and export the data through the dataset, API, scheduled runs, webhooks, and integrations.

This actor is useful when you want to understand how learners feel about a course, compare different courses, monitor new feedback over time, or send Coursera review data into spreadsheets, BI tools, or internal dashboards. It also extracts the top-level course or specialization summary so you can see the headline stats without manually opening each Coursera page.

If you are new to Apify, the simplest way to try it is:

1. Open the actor.
2. Paste a Coursera course or specialization URL into the Input tab.
3. Run the actor.
4. Open the Output tab and download the results.

Why use Coursera Reviews Scraper?

This actor is designed for people who want Coursera review data in a repeatable and easy-to-use format.

Common use cases:

• Course research: understand learner satisfaction before choosing, promoting, or benchmarking a course.
• Market analysis: compare review quality, volume, and sentiment across multiple courses or specializations.
• Trend monitoring: run the actor on a schedule to watch how ratings and feedback change over time.
• Content strategy: find common praise, complaints, and expectations from real learners.
• Reporting and automation: send results to Google Sheets, Make, Zapier, APIs, or internal reporting tools.

Because it runs on Apify, you also get:

• API access for automated workflows
• scheduling for recurring runs
• monitoring and run history
• integration support
• optional proxy handling when needed

How to use Coursera Reviews Scraper

Quick start

1. Open the actor in Apify Console.
2. Go to the Input tab.
3. Enter one Coursera URL with courseUrl, or provide multiple URLs with startUrls.
4. Set the maximum number of reviews you want.
5. Optionally filter by stars, change the sort order, or add delays.
6. Click Start.
7. After the run finishes, open the Output tab to view or download the data.

What URLs work best?

This actor works best with public Coursera pages such as:

• https://www.coursera.org/learn/some-course
• https://www.coursera.org/learn/some-course/reviews
• https://www.coursera.org/specializations/some-specialization

If you provide a course URL, the actor will use its reviews page automatically.

One URL or multiple URLs?

Use courseUrl when you want to scrape one course or specialization.

Use startUrls when you want to scrape multiple Coursera pages in one run.

If both are provided, you should treat startUrls as your main multi-URL input.

Input

Set everything in the actor's Input tab. You do not need any coding knowledge to use it.

Main input fields

Field	Required	What it does
courseUrl	No	A single public Coursera course or specialization URL
startUrls	No	A list of public Coursera URLs if you want to scrape multiple pages in one run
maxReviews	No	Maximum number of reviews to collect per source URL
maxConcurrency	No	Number of requests processed in parallel
startPage	No	Page number where review scraping should begin
filterByStars	No	Only keep reviews with selected star ratings
sortBy	No	Sort output reviews by helpfulness, date, or rating
minDelayMs	No	Minimum delay between paginated review requests
maxDelayMs	No	Maximum delay between paginated review requests
includeStats	No	Save a summary record with course-level information
proxyConfiguration	No	Optional Apify proxy settings

Recommended defaults

If you are not sure what to use:

• set maxReviews to 100
• keep startPage at 1
• leave filterByStars empty to collect all reviews
• use sortBy as mostHelpful
• keep includeStats as true

Example input for one course

{
  "courseUrl": "https://www.coursera.org/learn/learn-typescript/reviews",
  "maxReviews": 100,
  "startPage": 1,
  "sortBy": "mostHelpful",
  "minDelayMs": 1000,
  "maxDelayMs": 3000,
  "includeStats": true
}

Example input for multiple URLs

{
  "startUrls": [
    { "url": "https://www.coursera.org/learn/learn-typescript" },
    { "url": "https://www.coursera.org/learn/python" },
    { "url": "https://www.coursera.org/specializations/prompt-engineering" }
  ],
  "maxReviews": 50,
  "filterByStars": ["4", "5"],
  "sortBy": "newest",
  "includeStats": true
}

How to choose the right settings

• Use maxReviews to control how much data you collect and how long the run takes.
• Use filterByStars if you only want positive reviews, critical reviews, or a specific rating range.
• Use startPage when you want to start deeper in the review list.
• Use sortBy when you want the exported review order to fit your workflow.
• Use includeStats when you want a course-level summary in addition to individual reviews.
• Use delays if you want more conservative request pacing.

Output

The actor produces two main kinds of useful output:

1. Course summary records when includeStats is enabled
2. Individual review records in the dataset

When includeStats is enabled, the actor writes the final COURSE_STATS record first in the dataset for each source URL, followed by the matching REVIEW rows. This makes it easier to read the dataset top-down and immediately see the headline numbers before the raw reviews.

The summary record is built from the Coursera course or specialization page and from the scraped reviews themselves. That means the output can include:

• overall rating shown by Coursera
• total ratings and total reviews shown on Coursera
• enrolled count when visible
• course count for specializations when visible
• calculated review stats from the reviews collected in the current run

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

Review record example

{
  "type": "REVIEW",
  "sourceUrl": "https://www.coursera.org/learn/learn-typescript/reviews",
  "reviewsUrl": "https://www.coursera.org/learn/learn-typescript/reviews",
  "courseName": "Learn TypeScript",
  "reviewerName": "Jane Doe",
  "rating": 5,
  "reviewText": "Excellent course with very clear explanations.",
  "reviewedAt": "2024-04-12",
  "helpfulVotes": 7,
  "productCompleted": null
}

Course summary example

{
  "type": "COURSE_STATS",
  "courseName": "Foundations: Data, Data, Everywhere by Google",
  "averageRating": 4.8,
  "totalRatings": 121854,
  "totalReviews": 10000,
  "scrapedAt": "2026-04-09T00:18:29.118Z",
  "sourceUrl": "https://www.coursera.org/learn/foundations-data",
  "courseUrl": "https://www.coursera.org/learn/foundations-data/reviews",
  "scrapedReviewStats": {
    "totalReviews": 100,
    "averageRating": 4.29,
    "ratingDistribution": {
      "1": 12,
      "2": 4,
      "3": 5,
      "4": 1,
      "5": 78
    },
    "reviewsWithText": 100,
    "completedCourse": 0,
    "dateRange": {
      "newest": "2025-09-01",
      "oldest": "2021-03-11"
    }
  },
  "totalEnrolled": 83914577,
  "courseCount": null,
  "metadata": {
    "url": "https://www.coursera.org/learn/foundations-data",
    "title": "Foundations: Data, Data, Everywhere",
    "provider": "Google",
    "instructor": "Google Career Certificates",
    "level": "Beginner level",
    "duration": null,
    "weeklyHours": "at 10 hours a week",
    "ratingFromPage": null,
    "reviewCountFromPage": null,
    "enrolledCount": 83914577,
    "courseCount": null
  }
}

What each output type means

• REVIEW: one learner review entry
• COURSE_STATS: one summary record for the course or specialization you scraped
• MISSING_REVIEW_SECTION: a notice that the provided page did not expose a review section the actor could scrape

Where to find summary data

• In the dataset: the COURSE_STATS item is written before the review items for that source URL
• In the key-value store: the actor also saves summary records under COURSE_STATS
• In metadata: page-level course information such as title, provider, instructor, level, and enrollment details when available

Data table

Review fields

Field	Description
type	Record type, usually REVIEW for learner reviews
sourceUrl	The original URL you asked the actor to scrape
reviewsUrl	The Coursera reviews page used for review extraction
courseName	Course title when available
reviewerName	Name shown on the review
rating	Star rating from 1 to 5
reviewText	Full review text when available
reviewedAt	Review date, usually in YYYY-MM-DD format when parseable
helpfulVotes	Helpful count shown on the review
productCompleted	Completion indicator if visible on the page

Summary fields

Field	Description
averageRating	Overall rating shown by Coursera
totalRatings	Total ratings shown on the page
totalReviews	Total reviews shown on the page
totalEnrolled	Enrolled learner count when available
courseCount	Number of courses in a specialization when available
scrapedReviewStats.totalReviews	Number of reviews actually collected in this run
scrapedReviewStats.averageRating	Average rating calculated from collected reviews
scrapedReviewStats.ratingDistribution	Count of 1-star to 5-star reviews collected
scrapedReviewStats.reviewsWithText	How many collected reviews included text
scrapedReviewStats.dateRange	Oldest and newest review dates found in this run
metadata.url	The course or specialization page used for metadata extraction
metadata.provider	Provider shown on the Coursera page when available
metadata.instructor	Instructor or issuing organization shown on the page when available
metadata.level	Level label such as Beginner, Intermediate, or Advanced when available
metadata.enrolledCount	Enrollment count shown on the page when available

Pricing / Cost estimation

How much does it cost to scrape Coursera reviews? This actor is designed to be priced by review records collected.

The intended charging model is:

• charge for the Review event for each review collected
• keep the small apify-actor-start charge enabled
• do not rely on charging COURSE_STATS summary rows as billable review units

Your cost mainly depends on:

• how many URLs you scrape
• how many review pages each URL has
• the maxReviews limit you choose
• whether you run it once or on a schedule
• whether you use proxies

To keep costs lower:

• scrape only the URLs you need
• reduce maxReviews
• avoid unnecessary repeated runs
• keep includeStats on only if you need the summary output

If you are testing the actor for the first time, start with one course and a small maxReviews limit such as 20 or 50.

If you publish this actor with pay-per-event monetization, configure the pricing around the custom Review event so the billing matches the number of reviews collected.

Tips or Advanced options

• Use filterByStars to create separate runs for positive and negative reviews.
• Use startUrls when comparing multiple courses in one run.
• Use scheduled runs if you want to monitor rating changes over time.
• Use COURSE_STATS output if your workflow needs a quick summary rather than every review.
• Read the first dataset item first if you want the top summary before processing review rows.
• Use the dataset export if you want to open the results directly in Excel or Google Sheets.
• Start with a direct course URL if a specialization page gives broader results than you want.

FAQ, disclaimers, and support

Does this actor scrape private data?

No. It is intended for publicly accessible Coursera review pages only.

What if I do not get any reviews?

Possible reasons include:

• the page has no visible review section
• the URL is not a supported Coursera course or specialization page
• Coursera changed the page layout

If no review section is found, the actor may return a MISSING_REVIEW_SECTION notice.

Can I use this for many courses?

Yes. Use startUrls to pass multiple Coursera URLs in one run.

Is it legal to scrape Coursera?

You are responsible for making sure your use complies with Coursera's terms and all applicable laws, regulations, and internal policies.

Where do I ask for help?

Use the Issues tab on Apify Store for support or feedback. If you need a custom export, different workflow, or broader education-data solution, this actor can also be extended for that use case.