Udemy Course Reviews Scraper By Rating, Keyword & Date

Udemy Reviews Scraper — Extract Reviews, Feedback Tags & Summaries

This scraper collects Udemy course reviews filtered by star rating, by a keyword in the review text, and by a posting-date window, then sorted by relevance, newest or oldest. Every review can carry Udemy's own six structured student-feedback tags — valuable info, clear explanations, engaging delivery, helpful practice, knowledgeable instructor, accurate description — plus a per-course summary row with the honest tag-coverage percentage. Every response is typed, normalized JSON, no HTML or selectors. Point it at a course URL, slug or ID and start pulling structured review data in minutes.

---

🎓 What is Udemy Course Reviews Scraper?

Udemy Course Reviews Scraper By Rating, Keyword & Date is an Apify Actor that reads Udemy's own review API for any public course and returns every review that matches your filters as structured JSON — not the raw course page. It targets one platform, Udemy, and returns three related things from it: individual reviews, Udemy's six structured feedback-survey tags attached to each review, and a per-course roll-up summary. No Udemy account or login is required — every request goes out as an anonymous, logged-out visitor. Because it runs as a normal Apify Actor reachable over the Apify API, it is also callable directly from any agent framework that can send an HTTP request.

• 🔍 Scrape reviews filtered by star rating, keyword, exclude-terms and posting date
• 🏷️ Capture Udemy's six structured student-feedback tags per review
• 📊 Add a per-course feedback-summary row with tag-coverage and review-stage stats
• 📦 Export as JSON, CSV or any other Apify dataset format
• 🚫 No Udemy login, no proxy setup required by default

---

📊 What data does Udemy Course Reviews Scraper collect?

Every run returns review-level data, the six structured feedback tags attached to each review, and (optionally) a per-course summary row that aggregates both.

Data Type	Key Fields	JSON Field Names
Reviews	star rating, review text, reviewer name, posted date, review length	rating, content, reviewerName, created, reviewLength
Feedback Tags	six yes / no / not-sure answers to Udemy's student-feedback survey	aspectValuableInfo, aspectClearExplanations, aspectEngagingDelivery, aspectHelpfulPractice, aspectKnowledgeableInstructor, aspectAccurateDescription
Review Stage	where in the course the student was when they wrote the review	reviewStage, reviewStageRaw
Course Summary	per-course roll-up: tag-coverage share, yes-rate per tag, review-stage mix	aspectCoveragePct, aspectValuableInfoYesPct, stageStartOfCoursePct

---

🔌 How does Udemy Course Reviews Scraper differ from the official Udemy API?

Udemy's Instructor API lets an approved instructor manage their own courses over REST; Udemy Course Reviews Scraper reads review data for any public Udemy course without an instructor account.

Feature	Udemy Instructor API	Udemy Course Reviews Scraper
Access	Requires an approved/premium instructor account and an API key	✅ No Udemy account or login needed
Course scope	Instructor's own courses only	✅ Any public course by URL, slug or numeric ID
Reviews endpoint	Not documented in the public reference as of 2026-08-15	✅ Dedicated review collection with rating, keyword and date filters
Structured feedback tags	Not documented	✅ Native — Udemy's six survey tags per review
Development status	In maintenance mode with no new features planned, per Udemy's own docs (checked 2026-08-15)	Actively maintained; output schema kept stable
Setup time	Apply for instructor status and an API key	Paste a course URL and run

Sources: Udemy Instructor API v1.0 Reference, checked 2026-08-15.

If you already hold instructor access to the exact courses you need and only want your own course data, the Instructor API is the direct route. For reviews on courses you don't own, or for rating/keyword/date filtering and structured feedback tags, use Udemy Course Reviews Scraper.

---

🎯 Why do developers and teams scrape Udemy reviews?

For AI engineers and agent builders

Course reviews are a compact, labeled sentiment dataset: star rating, free text, and Udemy's own six-dimension feedback survey (aspectValuableInfo, aspectClearExplanations, aspectEngagingDelivery, aspectHelpfulPractice, aspectKnowledgeableInstructor, aspectAccurateDescription) arrive as typed yes/no/not-sure fields, not raw HTML to parse. That combination is directly usable as retrieval content for a RAG agent that answers "is this course worth it?" from real student language instead of marketing copy, or as labeled data for a course-quality classifier. The reviewStage field adds a credibility signal an agent can weight — a review written in the first minutes of a course carries a different reliability than one written after completion.

For instructors and course teams

An instructor with several published courses, or an ed-tech team tracking a catalogue, can pull every review that mentions a specific word — refund, outdated, subtitles, support — across one or many courses in a single run, using the containsText filter. Combined with postedAfter, this becomes a recurring check for new complaints since the last course update, without reading through pages the course dashboard doesn't filter. The per-course courseFeedbackSummary row gives an at-a-glance yes-rate for each of the six feedback dimensions, so a team can see whether "engaging delivery" or "helpful practice" is the actual weak point before touching the course content.

For researchers and analysts

Udemy's six-question student-feedback survey is a structured, platform-native opinion signal that online-learning researchers can aggregate across courses without building a survey instrument of their own. Because the scraper reports aspectCoveragePct alongside the tag percentages, a researcher knows exactly what share of the sample actually answered each question — a figure the course page itself doesn't surface. Sorting by oldest with a date window also isolates reviews from a course's early cohort versus its current one, useful for tracking how perceived quality shifts as a course ages or gets revised. Only publicly visible reviews are ever returned.

For developers building data products

A course-comparison site, a browser extension that surfaces "real" ratings next to Udemy's star average, or an internal dashboard tracking competitor courses can all be built on this Actor's JSON output without writing a Udemy parser. reviewLimit, starRating and sortBy give direct control over how much data a scheduled run pulls per course, and stable field names mean a downstream product doesn't need to change its schema when Udemy adjusts its page layout — only this Actor's collection logic would need to change.

---

🚀 How to scrape Udemy course reviews (step by step)

1. Open Udemy Course Reviews Scraper By Rating, Keyword & Date on its Apify Console store listing — no separate Udemy account needed.
2. Add one or more course targets in courses — a full course URL, a slug or a numeric course ID (courseIdsOrSlugs also accepts these).
3. Set your filters — starRating, containsText, excludeText, postedAfter / postedBefore and sortBy — to narrow the run to exactly the reviews you need.
4. Click Start and let the run collect reviews (and, if emitCourseSummary is on, one summary row per course).
5. Download the results as JSON, CSV or any other format the Apify dataset export offers, or read them through the Apify API.

What to do when Udemy changes its structure

This Actor is maintained against Udemy's own review API, and its output field names and types are kept stable across updates — an integration built on courseId, rating, content and the six aspect fields keeps working even if the collection logic behind them changes. No specific turnaround time is promised for any given fix.

---

⬇️ Input

All fields are optional — at least one course target (courses, urls or courseIdsOrSlugs) is required for the run to collect anything.

Parameter	Required	Type	Description	Example Value
courses	No	array (stringList)	One or more Udemy course URLs, slugs or numeric IDs.	["https://www.udemy.com/course/100-days-of-code/"]
urls	No	array (stringList)	Legacy field, kept for backward compatibility. Merged into courses.	[]
courseIdsOrSlugs	No	array (stringList)	Optional second way to name a course without the full URL.	["100-days-of-code"]
reviewLimit	No	integer, min 0	Max matching reviews to collect per course. 0 collects everything this source makes public (up to 10,000 per course). Applies after filters.	50
maxItems	No	integer, min 1, default 10	Legacy field. Used only when reviewLimit is left empty.	10
starRating	No	string enum: any (Any Rating), 5 (5 Stars only (5.0)), 4 (4 Stars only (4.0–4.5)), 3 (3 Stars only (3.0–3.5)), 2 (2 Stars only (2.0–2.5)), 1 (1 Star only (1.0–1.5)); default any	Keep only reviews with the chosen star bucket (each bucket includes its half-star reviews).	"any"
containsText	No	string (textfield)	Keep only reviews whose text contains this word or phrase.	"refund"
excludeText	No	array (stringList)	Drop any review whose text contains one of these words/phrases (case-insensitive).	["good", "nice course"]
sortBy	No	string enum: relevance (Relevance (course page order)), newest (Newest first), oldest (Oldest first); default relevance	Order reviews are collected in — decides which reviews you get when a limit is set.	"newest"
postedAfter	No	string (datepicker, absolute or relative)	Keep only reviews posted on or after this date. Absolute (2026-01-01) or relative (3 months).	"3 months"
postedBefore	No	string (datepicker, absolute or relative)	Keep only reviews posted on or before this date.	"2024-12-31"
includeRatingOnlyReviews	No	boolean, default false	Include silent star-only ratings (empty content, isRatingOnly: true).	false
minReviewLength	No	integer, min 0, default 0	Skip reviews shorter than this many characters.	0
includeAspectTags	No	boolean, default true	Add the six structured feedback columns to every review.	true
includeReviewStage	No	boolean, default true	Add reviewStage, where in the course the review was written.	true
emitCourseSummary	No	boolean, default true	Append one courseFeedbackSummary roll-up row per course.	true
requestDelay	No	integer, min 0, max 30, default 1	Seconds to pause between requests while collecting a course.	1
concurrency	No	integer, min 1, max 10, default 5	How many courses to process in parallel.	5
proxyConfiguration	No	object (proxy editor), default {"useApifyProxy": false}	Optional proxy settings. No proxy by default — the run switches route automatically if it needs to.	{"useApifyProxy": false}

Example JSON input:

{
  "courses": ["https://www.udemy.com/course/100-days-of-code/"],
  "urls": [],
  "courseIdsOrSlugs": ["2776760"],
  "reviewLimit": 50,
  "maxItems": 10,
  "starRating": "any",
  "containsText": "refund",
  "excludeText": ["good", "nice course"],
  "sortBy": "newest",
  "postedAfter": "3 months",
  "postedBefore": "",
  "includeRatingOnlyReviews": false,
  "minReviewLength": 0,
  "includeAspectTags": true,
  "includeReviewStage": true,
  "emitCourseSummary": true,
  "requestDelay": 1,
  "concurrency": 5,
  "proxyConfiguration": { "useApifyProxy": false }
}

⚠️ Common pitfall: leaving reviewLimit empty does not mean "collect everything." It falls back to the legacy maxItems field, which defaults to 10. Set reviewLimit to 0 explicitly if you want every review this source makes public for a course.

---

⬆️ Output

Every run pushes typed, normalized JSON rows to the default dataset, exportable as JSON, CSV or any other format the Apify dataset offers. A type field distinguishes two row shapes: review rows (one per collected review) and courseFeedbackSummary rows (one per course, only when emitCourseSummary is on and at least one of includeAspectTags / includeReviewStage is on).

Scraped review

{
  "courseUrl": "https://www.udemy.com/course/100-days-of-code/",
  "class": "course_review",
  "id": 123456789,
  "content": "Excellent course for beginners. The instructor explains everything clearly and the projects are genuinely useful.",
  "rating": 5,
  "created": "2026-06-14T09:22:31Z",
  "modified": "2026-06-14T09:22:31Z",
  "user_modified": "2026-06-14T09:22:31Z",
  "user": {
    "_class": "user",
    "title": "Jordan M.",
    "name": "Jordan",
    "display_name": "Jordan M.",
    "image_50x50": "https://img-c.udemycdn.com/user/50x50/12345678_abcdef.jpg",
    "initials": "JM",
    "tracking_id": "12345678-abcd-4321-a1b2-c3d4e5f60789",
    "public_display_name": "Jordan M."
  },
  "created_formatted_with_time_since": "2 months ago",
  "type": "review",
  "isChild": false,
  "courseId": "2776760",
  "reviewerName": "Jordan M.",
  "reviewLength": 118,
  "isRatingOnly": false,
  "scrapedAt": "2026-08-15T10:04:02Z",
  "aspectValuableInfo": "yes",
  "aspectClearExplanations": "yes",
  "aspectEngagingDelivery": "not-sure",
  "aspectHelpfulPractice": "yes",
  "aspectKnowledgeableInstructor": "yes",
  "aspectAccurateDescription": "yes",
  "aspectAnswerCount": 6,
  "hasAspectFeedback": true,
  "reviewStageRaw": "course_taking__initial",
  "reviewStage": "start_of_course"
}

aspectAnswerCount and hasAspectFeedback are only present when includeAspectTags is on; reviewStageRaw and reviewStage only when includeReviewStage is on. If a reviewer left no answer for one of the six aspect questions, that field stays null rather than being guessed at.

Course feedback summary

{
  "type": "courseFeedbackSummary",
  "isChild": true,
  "courseId": "2776760",
  "courseUrl": "https://www.udemy.com/course/100-days-of-code/",
  "reviewsCollected": 50,
  "reviewsScanned": 63,
  "resultsIncomplete": false,
  "filterMatchedTotal": 48213,
  "filterMatchedTotalIsCapped": false,
  "appliedStarRating": "any",
  "appliedContainsText": null,
  "appliedSortBy": "newest",
  "appliedPostedAfter": "2026-05-15",
  "appliedPostedBefore": null,
  "includedRatingOnlyReviews": false,
  "scrapedAt": "2026-08-15T10:07:44Z",
  "aspectCoveragePct": 71.43,
  "aspectReviewsWithFeedback": 34,
  "aspectValuableInfoYesPct": 91.18,
  "aspectClearExplanationsYesPct": 88.24,
  "aspectEngagingDeliveryYesPct": 76.47,
  "aspectHelpfulPracticeYesPct": 82.35,
  "aspectKnowledgeableInstructorYesPct": 94.12,
  "aspectAccurateDescriptionYesPct": 85.29,
  "stageStartOfCoursePct": 58.0,
  "stageEndOfIntroPct": 4.0,
  "stageMidCoursePct": 22.0,
  "stageMyCoursesPagePct": 10.0,
  "stageDashboardPct": 6.0,
  "stageOtherPct": 0.0
}

aspectCoveragePct through aspectAccurateDescriptionYesPct and aspectReviewsWithFeedback are only present when includeAspectTags was on for the run; the stage*Pct fields only when includeReviewStage was on. Each *YesPct is the share of "yes" answers among reviews that actually answered that specific question — not among all collected reviews, since some students skip individual questions.

---

🆚 How does Udemy Course Reviews Scraper compare to other Udemy review scrapers?

Feature	Udemy Course Reviews Scraper	Generic Udemy scraper
Output format	Typed, normalized JSON with stable field names	❌ Often raw HTML or ad hoc fields tied to page layout
Entity coverage	Reviews + six structured feedback tags + per-course summary row	❌ Usually review text and star rating only
Server-side filtering	Rating, keyword and rating-only inclusion applied at Udemy's own API, so unwanted pages are never fetched	❌ Typically filtered client-side after a full page-by-page scrape
Sort control	Relevance, newest or oldest, honored at the source	❌ Often fixed to whatever order the page returns
Anti-bot handling	Automatic three-step route escalation (direct → datacenter proxy → residential proxy) on blocked requests	Varies; frequently requires manual proxy configuration

If you're building an AI agent or RAG pipeline, the output format row is the decision-maker — parsing HTML inside an agent loop is a reliability failure mode, not a feature.

---

🔢 How many reviews can you scrape with Udemy Course Reviews Scraper?

Set reviewLimit to 0 to collect every review this source makes public for a course. Udemy's own review collection is capped at 10,000 reviews per course (100 rows per page, up to 100 pages), and the Actor reports filterMatchedTotalIsCapped: true on a course's summary row when the matching total hits that ceiling. Leaving reviewLimit empty does not mean unlimited — it falls back to the legacy maxItems field, which defaults to 10. Pagination is handled automatically per course: the Actor pages through Udemy's review endpoint until reviewLimit is reached, the date window is exited (when sorted newest or oldest), or Udemy returns no further pages. Multiple courses run in parallel, up to the concurrency setting (max 10).

---

🔗 Integrate Udemy Course Reviews Scraper and automate your workflow

Udemy Course Reviews Scraper works with any language or tool that can send an HTTP request.

REST API integration

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run = client.actor("YOUR_USERNAME/udemy-course-reviews-scraper-by-rating-keyword-date").call(
    run_input={
        "courses": ["https://www.udemy.com/course/100-days-of-code/"],
        "reviewLimit": 50,
        "starRating": "any",
        "sortBy": "newest",
    }
)

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

Works in Python, Node.js, Go, Ruby, cURL.

Automation platforms (n8n, Make, LangChain)

n8n — the official @apify/n8n-nodes-apify node's Run Actor operation can start this Actor with your input as JSON, then a Get Dataset Items step reads the review and summary rows into the rest of the workflow (verified via n8n.io/integrations/apify and github.com/apify/n8n-nodes-apify, 2026-08-15). Make — Apify's official Make app runs an Actor and retrieves its dataset items as a module inside a larger scenario. LangChain / agent frameworks — since every result is typed JSON reachable over the standard Apify API, it can be wrapped as a tool in any framework that can call an HTTP endpoint and parse JSON, with no custom Udemy parser required.

---

⚖️ Is it legal to scrape Udemy reviews?

Scraping Udemy's publicly visible review pages is generally lawful; how you store and use the data afterward is where the rules apply. Udemy Course Reviews Scraper only returns reviews that are publicly visible on a course's review page — it never logs in, and it cannot see private, unlisted or login-gated content. Because a review carries a reviewer's public display name and, for the underlying user, a profile-image URL and initials, the collected data qualifies as personal data under most privacy frameworks. If you collect this at scale for commercial use, GDPR and CCPA (or their regional equivalents) govern how you may store and use it, alongside Udemy's own Terms of Service. Consult legal counsel for commercial use cases involving bulk personal data.

---

❓ Frequently asked questions

Does Udemy Course Reviews Scraper work without a Udemy account?

Yes. Every request is sent as an anonymous, logged-out request to Udemy's public review API — no login, cookie or Udemy account is used or required.

How often is the review data updated?

Every run fetches reviews live from Udemy at request time; nothing is served from a cache. Running the Actor again returns whatever Udemy's review API returns at that moment, including any reviews posted since the last run.

What happens if a course doesn't exist or has no reviews matching my filters?

If a course URL, slug or ID can't be resolved (deleted, mistyped, or Udemy returns a 404), the Actor logs it as not found and moves on to the next course without pushing any row for it — the run still succeeds if at least one other course resolves. If a course resolves but no review matches your filters, that course simply contributes zero review rows (or, if emitCourseSummary is on, one summary row with reviewsCollected: 0).

Can I scrape reviews from private or login-gated Udemy courses?

No. The Actor never logs in, so it can only see the review data Udemy serves to a logged-out visitor of a public course page. Login-gated or unlisted course content is not reachable.

Do the legacy urls and maxItems fields still work?

Yes. urls is merged into courses, and maxItems is used only as the review-limit fallback when reviewLimit is left empty — both exist purely for backward compatibility with the original input format.

Does Udemy Course Reviews Scraper work for AI agent workflows and LLM pipelines?

Yes. It's callable as a standard Apify API HTTP endpoint by any agent framework that can send a request and parse JSON. Every response is typed JSON with stable field names — no HTML, no selectors, no parsing step before passing a review or summary row into an LLM.

How does Udemy Course Reviews Scraper handle Udemy's anti-bot defenses?

Requests start on a direct connection and automatically escalate through an Apify datacenter proxy and then a residential-proxy route if Udemy responds with a blocking or rate-limit status (401, 403, 429, 500, 502, 503 or 504), with a jittered delay between attempts. Once a route proves reliable the run sticks to it rather than re-testing on every subsequent request.

How does Udemy Course Reviews Scraper compare to other Udemy review scrapers?

It extracts Udemy's own six-dimension structured feedback survey and a per-course summary row alongside the review text. A generic Udemy scraper typically returns review text and star rating only, with no structured tag support and no per-course roll-up.

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

Yes. Typed, normalized JSON with stable field names — no HTML, no selectors, no parsing. Pass a row directly into an LLM's context window, index it into a vector store, or route it through an agent tool.

Can I use Udemy Course Reviews Scraper without managing proxies?

Yes. By default no proxy is configured (useApifyProxy: false). If Udemy responds with a blocking status, the Actor automatically requests an Apify Proxy datacenter or residential route for you — you only need to supply your own proxyConfiguration if you want a specific proxy group.

What happens when Udemy changes its structure or blocks the scraper?

The Actor is maintained against Udemy's review API, and the output schema — field names and types — stays stable on your end even when the collection logic behind it has to change. No specific turnaround time is promised.

---

💬 Your feedback

Found a bug, or need a field this Actor doesn't collect yet? We want to know. Open an issue through this Actor's page on the Apify Console — it goes straight to the team that maintains it.