Udemy Course Reviews Scraper

Udemy Course Reviews Scraper — Ratings, Text and Reviewer Data

Udemy Course Reviews Scraper collects every publicly visible written review for one or more Udemy courses and returns each one as a structured JSON row — review text, star rating, post and edit timestamps, and reviewer display details. Add a course URL, slug, or numeric course ID, set how many reviews you want, and reviews land in the dataset the moment they're fetched, ready to export as JSON or CSV. Paste in a course list and run it now.

What is Udemy Course Reviews Scraper?

Udemy Course Reviews Scraper is an Apify Actor that pulls the written reviews published on any public Udemy course page and returns them as clean, typed JSON — no HTML to parse. It talks to Udemy's own public course pages; no Udemy account, login, or course purchase is needed to run it. It's built for course-quality researchers, e-learning marketers, and developers feeding review text into sentiment-analysis or LLM pipelines.

What Udemy course review data is publicly available to scrape?

Anyone visiting a public Udemy course page can read its written reviews, star ratings, and reviewer display names without logging in — that is exactly what this scraper collects.

Data Category	Public (no login)	Restricted
Review text & star rating	✅	—
Reviewer display name, initials & avatar	✅	—
Review post & edit timestamps	✅	—
Course's total published review count	✅	—
Star-only ratings with no written text	✅ shown on the page	❌ not returned by this scraper (text reviews only)
Reviewer email address or account profile	❌ never published by Udemy	—
Course Q&A / instructor discussion threads	❌	🔒 enrollment required
Full lecture video playback	❌ full videos	🔒 purchase required (previews only are public)

Udemy Course Reviews Scraper only returns publicly visible data — what any visitor sees. Nothing behind a login wall.

What data can I extract with Udemy Course Reviews Scraper?

Udemy Course Reviews Scraper returns review content, star ratings, timestamps, reviewer identity, and per-course coverage metrics for every review it collects.

📝 Review content and reviewer identity

Field Name	Description
id	Unique Udemy review ID
type	Row type label, always review
courseUrl	Canonical course URL this review belongs to
content	Review text, plain text — null when the reviewer left no text
created_formatted_with_time_since	Human-readable age, e.g. "a week ago"
user.name	Reviewer's first name as shown on the review
user.display_name	Reviewer's full display name
user.public_display_name	Shortened public form, e.g. "Aralyn Violet S."
user.initials	Reviewer's initials
user.image_50x50	URL of the reviewer's 50×50 avatar image
user.tracking_id	Udemy's opaque reviewer identifier

⭐ Ratings, timestamps and coverage metrics

Field Name	Description
rating	Star rating, 1.0–5.0 in half-point steps
created	ISO 8601 timestamp with UTC offset — when the review was posted
modified	ISO 8601 timestamp — when the review record was last modified
user_modified	ISO 8601 timestamp — last edit made by the reviewer
reviewsCollected	Running count of reviews collected so far for this course; the last row for a course carries the final total
apiReviewCap	10000 — the maximum number of reviews Udemy publishes per course, repeated on every row
sampleCoveragePct	reviewsCollected as a percentage of the course's real published review total; null if that total is unavailable
scrapedAt	UTC timestamp of when this row was collected

Why not build this yourself?

Udemy doesn't publish a general-purpose, no-approval API for pulling review data from any public course you don't teach or own. Building and maintaining your own collector means solving the same problems this Actor already solves: the request has to hit Udemy's internal course-review endpoint with a request-header shape that has to be verified and kept in sync — adding ordinary browser-style identity headers to the request is enough to make it fail. Paging through up to 10,000 reviews per course means handling retryable status codes (401, 403, 408, 425, 429, 500, 502, 503, 504) without either giving up too early or hammering the endpoint. And once Udemy rate-limits or blocks a request pattern, you need a fallback connection route — this Actor escalates from a direct connection to a datacenter proxy to a residential proxy, and remembers whichever route last worked. Reproducing that routing, retry, and header logic yourself, then keeping it working as Udemy's front end changes, is the ongoing cost this Actor removes.

How to use Udemy Course Reviews Scraper

No coding is required to run it — everything happens from the Apify Console.

1. Open Udemy Course Reviews Scraper on its Apify Store listing and click Try for free / Start.
2. Provide at least one course target: add course URLs to urls, course slugs or numeric IDs to courseIdsOrSlugs, or both.
3. Set maxItems if you want to cap how many reviews are collected per course — leave it empty to collect everything Udemy publishes, up to its 10,000-review ceiling.
4. Turn on proxyConfiguration if you want to pin a specific proxy setup, or when running very large batches. It's off by default.
5. Click Start, then download or stream results as JSON or CSV once the run finishes (or while it's still running — rows are pushed live).

How to scale to bulk review extraction

urls and courseIdsOrSlugs both accept arrays — paste in as many course URLs, slugs, or numeric IDs as you need in a single run. The two lists are merged and de-duplicated, so naming the same course twice (say once by URL and once by numeric ID) collects it once, not twice. Up to five courses are processed concurrently within one run, so a large course list doesn't have to be split into separate runs.

What can you do with Udemy course review data?

• 🎓 A course-quality analyst comparing courses in a category uses rating and content to rank courses by real feedback and pull the exact complaint phrases behind low scores before recommending one.
• 📊 A competitive researcher tracking e-learning competitors uses courseUrl and sampleCoveragePct to compare how much of each competing course's review history they actually captured.
• ✍️ An instructor improving their own course uses content and created to find recent complaints and see whether a course update changed the tone of new reviews.
• 🤖 An AI engineer building a course-recommendation agent feeds content and rating into a RAG index, using user.public_display_name and created_formatted_with_time_since as citation context in the agent's responses.
• 📈 A market researcher tracking a course category re-runs the scraper on a schedule and uses reviewsCollected and scrapedAt to trend review volume over time.

How does Udemy Course Reviews Scraper handle rate limits and blocking?

Every request is sent through a routing ladder: direct connection first, then an Apify datacenter proxy, then an Apify residential proxy, escalating only when a request comes back with a retryable status (401, 403, 408, 425, 429, 500, 502, 503, 504) or fails outright. Once a route succeeds, it becomes the preferred route for the rest of the run — later requests try it first instead of starting over from direct. Each connection tier gets up to 3 attempts, spaced with a short randomized delay, before the run escalates to the next tier. If every tier fails for a given page, that course is marked incomplete in the run's status message, but any reviews already collected and pushed for it are kept — a failed fetch never deletes data already saved.

⬇️ Input

Parameter	Required	Type	Description	Example Value
urls	No	array	One or more Udemy course URLs. Add several to cover many courses in a single run.	["https://www.udemy.com/course/100-days-of-code/"]
courseIdsOrSlugs	No	array	Optional second way to name a course when you don't have the full URL. Accepts a course slug (100-days-of-code) or a numeric course id (2776760). Combined with anything listed under urls.	["2776760"]
maxItems	No	integer (min 1, default 10)	How many reviews to collect for each course. Leave empty to collect everything Udemy publishes for the course, up to its 10,000-review ceiling. Lower values finish faster. With a small limit you get Udemy's own top-of-page ordering, which favours prominent reviews rather than the very newest ones.	100
proxyConfiguration	No	object	Optional. Leave it off to start without a proxy — the run still switches to an alternate connection route on its own if a request doesn't go through. Turn it on to pin a specific setup, or when running very large batches.	{ "useApifyProxy": false }

Example input

{
  "urls": [
    "https://www.udemy.com/course/100-days-of-code/",
    "https://www.udemy.com/course/the-complete-javascript-course/"
  ],
  "courseIdsOrSlugs": ["2776760"],
  "maxItems": 100,
  "proxyConfiguration": { "useApifyProxy": false }
}

⬆️ Output

Every collected review is pushed to the dataset as one typed JSON row, in a consistent shape across runs. Export the dataset as JSON, CSV, Excel, XML, or RSS from the Apify Console, or pull it with the Apify API or apify-client.

Example output

{
  "id": 12345678,
  "type": "review",
  "courseUrl": "https://www.udemy.com/course/100-days-of-code/",
  "rating": 5.0,
  "content": "I really enjoyed the course, it laid a solid foundation and already set me on building my own projects.",
  "created": "2026-07-31T02:11:44-07:00",
  "modified": "2026-07-31T02:11:44-07:00",
  "user_modified": "2026-07-31T02:11:44-07:00",
  "created_formatted_with_time_since": "a week ago",
  "user": {
    "name": "Aralyn Violet",
    "display_name": "Aralyn Violet Sassenberg",
    "public_display_name": "Aralyn Violet S.",
    "initials": "AS",
    "image_50x50": "https://img-c.udemycdn.com/user/50x50/anonymous_3.png",
    "tracking_id": "ULJIYFkwR22D5dVDaF4sVQ"
  },
  "reviewsCollected": 42,
  "apiReviewCap": 10000,
  "sampleCoveragePct": 0.0097,
  "scrapedAt": "2026-08-15T12:34:56Z"
}

Every pushed row is a review, and every row is billed under the row_result charged event — there's no separate uncharged accounting or error row mixed into the dataset that you'd need to filter out.

How does it work?

Udemy Course Reviews Scraper first resolves each target — a URL, slug, or numeric ID — to a real Udemy course ID and its published review total, then pages through that course's review listing using the same internal endpoint Udemy's own course page calls. Requests go out directly by default and only fall back to an Apify datacenter or residential proxy if a request is blocked or fails, so most runs never need a proxy at all. Each review is normalized into the same field set the moment it's collected and pushed to the dataset immediately, rather than being held until the whole course finishes. Only reviews that are publicly visible on the course page are returned, and the output schema stays the same regardless of how Udemy's own page layout changes.

Integrations

Udemy Course Reviews Scraper runs on the Apify platform, so it works with anything that can call the Apify API — no dedicated SDK required.

Calling Udemy Course Reviews Scraper programmatically

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run = client.actor("udemy-course-reviews-scraper").call(run_input={
    "urls": ["https://www.udemy.com/course/100-days-of-code/"],
    "maxItems": 100,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["content"], item["rating"])

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request.

No-code tools (n8n, Make, LangChain)

In n8n, use the HTTP Request node (or the Apify node) pointed at the Actor's run endpoint, passing your input as the request body and polling the run for its dataset. In Make, use the Apify app's "Run Actor and get dataset items" module with your Apify API token connected as a credential. In LangChain or any custom agent framework, wrap the same apify-client call shown above as a tool function so an agent can trigger a run and read the results back as structured data.

Is it legal to scrape Udemy course reviews?

Scraping publicly available data, such as course reviews that are visible to any visitor without logging in, is generally lawful. Udemy Course Reviews Scraper returns only what any visitor can already see on a public course page — no private, unlisted, or login-gated content. Because reviews carry reviewer-identifying details (display name, initials, avatar), this counts as personal data under GDPR and CCPA, and you are responsible for having a lawful basis for storing and using it — for example, legitimate interest in aggregated, non-identifying analysis rather than building individual reviewer profiles. Consult legal counsel if your use case involves bulk storage of personal data.

Frequently asked questions

What Udemy course review fields does Udemy Course Reviews Scraper return?

The core fields are content (review text), rating (star rating), courseUrl, user.public_display_name, and created (post timestamp). See What data can I extract above for the full field list.

Does Udemy Course Reviews Scraper require a Udemy account or login?

No. Requests are sent as an anonymous, logged-out visitor — the same reviews any visitor can read on the course page. No Udemy account, password, or course purchase is needed to run it.

How many Udemy reviews can I scrape per course?

Up to 10,000 per course — that's Udemy's own published ceiling for how many reviews it serves for any single course, not a limit set by this scraper. apiReviewCap and sampleCoveragePct on every row tell you the ceiling and what share of the course's real review total you actually received. Use maxItems to collect fewer, faster.

What happens if a course URL, slug, or ID doesn't match a real course?

That target is reported as not found and skipped — the run continues normally with the remaining targets. The run's final status message reports how many targets were not found versus successfully collected.

Can I scrape multiple Udemy courses at once?

Yes. Add as many entries as you need to urls and courseIdsOrSlugs — both are arrays, and up to five courses are processed concurrently in a single run. Every review is tagged with its courseUrl so results from different courses can be told apart in the same dataset.

Does the review order match Udemy's newest-first list?

Not exactly. Reviews are requested in Udemy's own default course-page ordering, which ranks by relevance score first and recency second. A run capped with a small maxItems returns Udemy's most prominent reviews for that ordering, not strictly the newest ones — remove the cap to collect the course's full review history instead.

Does Udemy Course Reviews Scraper work with Claude, ChatGPT, and other AI agent tools?

Yes, as an HTTP-callable Actor. Any agent framework that can call the Apify API — directly or through apify-client — can trigger a run and read back the dataset, as shown in the Python example above.

Does Udemy Course Reviews Scraper return data in a format LLMs can use directly?

Yes. Output is typed, normalized JSON with consistent field names across every run — no HTML to parse and no CSS selectors to write. Pass content straight to an LLM prompt, index it into a vector store, or feed the whole row to an agent tool.

What happens when Udemy changes its layout or anti-bot system?

The Actor is maintained against Udemy's actual endpoint and request-header requirements, and the output schema stays stable regardless of front-end changes on Udemy's side. No specific turnaround time for fixes is published or guaranteed.

Can I use Udemy Course Reviews Scraper without managing proxies or browser infrastructure?

Yes. Requests run directly by default, and the Actor automatically escalates to an Apify datacenter or residential proxy on its own if a request is blocked — you don't have to configure or monitor proxies yourself. proxyConfiguration is there only if you want to pin a specific setup.

Which Udemy review fields work best for AI training data and RAG indexing?

For RAG, index content — the high-information free text — alongside rating and courseUrl as retrievable metadata. For training data, rating, reviewsCollected, and sampleCoveragePct are consistently structured numeric fields across every row, and created gives you a reliable time axis. All fields return as typed primitives, not strings that need re-parsing.

Related scrapers

Scraper Name	What it extracts
Facebook Reviews Scraper	Public review and recommendation posts from Facebook pages
Airbnb Review Scraper	Guest reviews for Airbnb listings
Walmart Reviews Scraper	Product reviews from Walmart listings
Google Play Scraper	Google Play app details, search results, similar apps, and user reviews

Your feedback

Found a bug or a review field that's missing? Let us know through the Issues tab on this Actor's Apify Console page, or reach out via the Apify Console's support option — reports like these are what keep the field list accurate as Udemy changes its pages.