Udemy Course Reviews Scraper: Course Stats & Rating

Udemy Course Reviews Scraper — Reviews, Ratings & Course Stats

Collect Udemy course reviews at scale and get the full course record with every one of them. Give it a course URL, slug, or numeric ID and it returns every review as structured JSON — reviewer name, rating, review text, timestamps — plus the course's own stats (rating, students, price, level, instructor) repeated on each row, and a per-star rating breakdown with derived analytics (rating recency, review-to-enrollment ratio, course age) that Udemy's own review feed never shows. Every response is structured JSON, ready to pass directly to an LLM, index into a vector store, or feed a monitoring pipeline. Point it at one course or a hundred, and pull reviews and course intelligence in a single run.

What is Udemy Course Reviews Scraper: Course Stats & Rating?

Udemy Course Reviews Scraper: Course Stats & Rating queries Udemy's course-review data by course URL, slug, or numeric ID and returns two row types in one dataset: individual review rows and, optionally, one course summary row per target carrying the full course record, rating breakdown and derived analytics. No Udemy account or login is required — the Actor calls Udemy's public course and review endpoints directly.

What sets it apart from just reading the review feed on udemy.com is that every review row already carries course context (title, rating, students, price, category, instructor) and every course gets computed metrics — rating recency delta, review-to-enrollment ratio, course age, days since last update, and an honest sample-coverage percentage — that Udemy does not expose anywhere on the site itself.

Key capabilities:

• 📝 Review rows — reviewer name, rating, review text, creation/modification timestamps, and a compact user block (display name, avatar, initials)
• 📊 Course summary row — the full course record (rating, students, price, level, category, instructor, badges, dates) in one row per target
• ⭐ Per-star rating breakdown — exact counts and percentages for 1–5 stars, plus the reconciliation gap against Udemy's own published total
• 📈 Derived analytics — rating recency delta, review-to-enrollment ratio, course age in days, days since last update, and sample-coverage percentage
• 🎯 Configurable review depth — collect anywhere from 1 review up to Udemy's own per-course serving limit
• 🔢 Batch targets — scrape any number of courses in a single run by adding more entries to the target list

What data can you get with Udemy Course Reviews Scraper: Course Stats & Rating?

The Actor returns four kinds of data, all flattened into rows in the same dataset: review content, course stats, rating breakdown, and derived analytics.

Result Type	Extracted Fields	Primary Use Case
Review	id, content, rating, created, modified, user_modified, reviewerName, user (display name, avatar, initials, tracking ID), created_formatted_with_time_since, courseUrl	Sentiment mining, spotting recurring complaints, review-quality datasets
Course record	courseId, courseTitle, courseRating, courseTotalReviews, courseSubscribers, coursePrice, courseCurrency, courseLevel, courseCategory, courseSubcategory, instructorName, courseBadges, coursePublishedAt, courseLastUpdatedAt	Course due-diligence, catalogue benchmarking, instructor portfolio tracking
Rating breakdown	ratingDistribution, ratingDistributionPct, ratingCount1–ratingCount5, ratingPct1–ratingPct5, ratingDistributionTotal, ratingDistributionDelta	Quality-signal modeling, spotting a gap between Udemy's published total and its own per-star split
Derived analytics	ratingRecencyDelta, reviewToEnrollmentRatio, courseAgeDays, daysSinceLastUpdate, reviewsCollected, apiReviewCap, sampleCoveragePct	Trend detection, freshness scoring, honest sample-size disclosure for downstream reporting

Course Stats & Rating Analytics

This is the capability the rest of the Actor's name is built around. Toggle includeRatingBreakdown and includeDerivedMetrics on (both default to true) and every review row — and the optional course summary row — carries a full analytics block: the exact 1-through-5-star counts and percentages, the gap between that breakdown's total and Udemy's own published review count (ratingDistributionDelta, reported as-is, never rounded away), how the recent average rating compares to the lifetime average (ratingRecencyDelta), how reviews compare to enrollment (reviewToEnrollmentRatio), and how old and how recently updated the course is. None of this ships in Udemy's own review widget — you'd otherwise have to page through raw reviews and compute it yourself.

{
  "ratingDistribution": { "1": 5990, "2": 8890, "3": 25011, "4": 90112, "5": 350210 },
  "ratingDistributionPct": { "1": 1.25, "2": 1.85, "3": 5.21, "4": 18.77, "5": 72.94 },
  "ratingDistributionTotal": 480213,
  "ratingDistributionDelta": 0,
  "ratingRecencyDelta": 0.021909,
  "reviewToEnrollmentRatio": 0.331,
  "courseAgeDays": 2135,
  "daysSinceLastUpdate": 150,
  "sampleCoveragePct": 20.826
}

Review rows with full course context

Every review is returned as its own row, and by default (courseFieldSet: "full") that row already carries the complete course record — title, price, level, category, instructor, badges, publish and update dates — so you can filter, group, or chart reviews by course attributes without joining two datasets. Set courseFieldSet to "essential" to keep only the 7 core course columns (courseId, courseTitle, courseRating, courseTotalReviews, courseSubscribers, courseLevel, instructorName) on each review row when you don't need the rest repeated thousands of times.

How does Udemy Course Reviews Scraper: Course Stats & Rating differ from the official Udemy API?

Udemy publishes an official Instructor API (https://www.udemy.com/developers/instructor/), which includes a course-reviews endpoint — but per its own documentation summary (checked via publicapi.dev, 2026-08-15), that API is scoped to courses the authenticated instructor account owns or manages, and it requires an instructor API key. It is not a general-purpose way to pull reviews for any course on Udemy.

Feature	Udemy Instructor API	Udemy Course Reviews Scraper: Course Stats & Rating
Course scope	Only courses the authenticated instructor owns/manages	Any public course, by URL, slug, or numeric ID
Authentication	Requires an instructor API key	None — no Udemy account or API key
Review pagination	course_reviews() endpoint on your own courses	Automatic paging up to reviewsPerCourse, capped at Udemy's own 10,000-per-course limit
Rating analytics	Not part of the raw endpoint response	Per-star breakdown, recency delta, review-to-enrollment ratio computed and attached to every row
Output shape	Raw API response, joins needed client-side	Flattened rows combining review + course + analytics in one record
Setup	Apply for instructor API credentials	Run the Actor with a course URL

If you are an instructor auditing only your own courses and already have API credentials, the Instructor API is a legitimate direct route. If you need reviews and stats for courses you don't own — competitor courses, category research, a course you're considering buying — the Instructor API's scope doesn't reach that data, which is what this Actor is built for.

How to scrape Udemy with Udemy Course Reviews Scraper: Course Stats & Rating?

1. Open Udemy Course Reviews Scraper: Course Stats & Rating on the Apify Store and click Try for free.
2. Enter one or more courses in courseTargets — a full course URL, a course slug, or a numeric course ID.
3. Set reviewsPerCourse to how many reviews you want per course, and leave includeCourseRow, includeRatingBreakdown, and includeDerivedMetrics at their defaults (all true) to get the full analytics set.
4. Click Start to run the Actor.
5. Open the Dataset tab and download the results as JSON, CSV, Excel, or any other format Apify supports.

{
  "courseTargets": ["https://www.udemy.com/course/100-days-of-code/"],
  "reviewsPerCourse": 200
}

How to run multiple courses in one job

courseTargets accepts an array, so add as many course URLs, slugs, or numeric IDs as you need — each one is treated as an independent target, and results for all of them land in the same dataset. There is no separate batch-upload step: a longer array is the batch.

⬇️ Input

Configure the run with these parameters. None are required — the Actor will simply have nothing to do (and logs a warning) if both courseTargets and urls are left empty.

Parameter	Required	Type	Constraints	Description
courseTargets	No	array	editor: stringList	One entry per course. Accepts a full course URL, a course slug, or a numeric course ID. Examples: https://www.udemy.com/course/100-days-of-code/, 100-days-of-code, 2776760.
urls	No	array	editor: stringList	Legacy key, kept so existing runs and saved input files keep working. Entries here are merged with courseTargets. New runs can leave this empty.
reviewsPerCourse	No	integer	minimum 1	How many reviews to collect for each course. Udemy serves a maximum of 10,000 reviews per course, so any value above that is capped. Example: 100 returns up to 100 reviews per course. Default is 10.
maxItems	No	integer	default 10, minimum 1	Legacy key, kept so existing runs and saved input files keep working. Used only when reviewsPerCourse is left empty. Default is 10.
includeCourseRow	No	boolean	default true	Adds one extra row per course (type: "course") holding the complete course record, the rating breakdown, the derived analytics, and the coverage figures. The row is written after that course's reviews so its coverage numbers are final. It is also mirrored to a separate per-run course dataset.
courseFieldSet	No	string	enum: "essential", "full"; default "full"	How much course context to repeat on every review row. essential = course ID, title, rating, review total, students, level, and instructor name (7 columns). full = all of the above plus headline, price and currency, locale and language, content hours, lecture count, certificate flag, badges, published and last-updated dates, category, subcategory, status, image, and the full instructor block.
includeRatingBreakdown	No	boolean	default true	Adds ratingDistribution and ratingDistributionPct plus flat ratingCount1–ratingCount5 and ratingPct1–ratingPct5 columns, the distribution total, and the exact gap between that total and the course's published review count (reported as-is, never rounded away).
includeDerivedMetrics	No	boolean	default true	Adds ratingRecencyDelta (recent average minus lifetime average), reviewToEnrollmentRatio, courseAgeDays, and daysSinceLastUpdate. On the course summary row it also adds reviewsCollected, apiReviewCap, and sampleCoveragePct.
proxyConfiguration	No	object	editor: proxy; prefill { "useApifyProxy": false }	Optional. Leave off for normal runs; enable it for large batches or restricted networks.

Example input:

{
  "courseTargets": [
    "https://www.udemy.com/course/100-days-of-code/",
    "the-complete-javascript-course",
    "2776760"
  ],
  "reviewsPerCourse": 200,
  "includeCourseRow": true,
  "courseFieldSet": "full",
  "includeRatingBreakdown": true,
  "includeDerivedMetrics": true,
  "proxyConfiguration": { "useApifyProxy": false }
}

⚠️ proxyConfiguration defaults to { "useApifyProxy": false }. With that default, the Actor still starts every run with direct requests, but its built-in retry ladder cannot escalate to an actual Apify Proxy route on repeated failures — it needs useApifyProxy: true (or a full proxy group config) supplied here to get real alternate routes when a target is being rate-limited or blocked. For large batches or courses that keep failing, turn proxy on rather than leaving the prefill as-is.

Common pitfall: reviewsPerCourse left empty falls back to maxItems (default 10) — set reviewsPerCourse explicitly if you want more than the default 10 reviews per course. Also, review order is fixed to Udemy's own ranking (course_review_score__rank, then newest first) — there is no input to change it, so a low reviewsPerCourse value returns Udemy's highest-ranked reviews first, not necessarily the most recent ones.

⬆️ Output

Results are typed, normalized JSON with a consistent schema across runs, exportable from the Dataset tab as JSON, CSV, Excel, XML, RSS, or HTML table. Each pushed row — review or course — is billed as one row_result event; a course target that can't be resolved or isn't found on Udemy produces no row at all and is not charged.

Scraped results

[
  {
    "type": "review",
    "isChild": true,
    "courseUrl": "https://www.udemy.com/course/100-days-of-code/",
    "class": "course_review",
    "id": 123456789,
    "content": "Fantastic course, the projects made everything click.",
    "rating": 5,
    "created": "2026-06-02T14:22:10Z",
    "modified": "2026-06-02T14:22:10Z",
    "user_modified": "2026-06-02T14:22:10Z",
    "user": {
      "_class": "user",
      "title": "",
      "name": "",
      "display_name": "Jordan P.",
      "image_50x50": "https://img-c.udemycdn.com/user/50x50/1234567_abcd.jpg",
      "initials": "JP",
      "tracking_id": "abc123|xyz789",
      "public_display_name": "Jordan P."
    },
    "created_formatted_with_time_since": "2 months ago",
    "reviewerName": "Jordan P.",
    "courseId": 2776760,
    "courseTitle": "100 Days of Code: The Complete Python Pro Bootcamp",
    "courseHeadline": "Master Python by building 100 projects in 100 days.",
    "courseRating": 4.7,
    "courseTotalReviews": 480213,
    "courseRecentReviews": 512,
    "courseSubscribers": 1450213,
    "coursePrice": 84.99,
    "courseCurrency": "USD",
    "coursePriceText": "$84.99",
    "courseIsPaid": true,
    "courseLevel": "All Levels",
    "courseLocale": "en_US",
    "courseLanguage": "English",
    "courseContentHours": 57.0,
    "courseVideoHours": 56.8,
    "courseLectureCount": 704,
    "courseCurriculumItemCount": 720,
    "courseHasCertificate": true,
    "courseBadges": "Bestseller",
    "coursePublishedAt": "2020-05-11T10:00:00Z",
    "courseLastUpdatedAt": "2026-03-18T00:00:00Z",
    "courseCreatedAt": "2020-04-02T00:00:00Z",
    "courseCategory": "Development",
    "courseSubcategory": "Programming Languages",
    "courseStatus": null,
    "courseImageUrl": "https://img-c.udemycdn.com/course/480x270/course-image.jpg",
    "instructorId": 12345,
    "instructorName": "Dr. Angela Yu",
    "instructorJobTitle": "Developer and Lead Instructor",
    "instructorProfileUrl": "https://www.udemy.com/user/angela-yu-2/",
    "ratingDistribution": { "1": 5990, "2": 8890, "3": 25011, "4": 90112, "5": 350210 },
    "ratingDistributionPct": { "1": 1.25, "2": 1.85, "3": 5.21, "4": 18.77, "5": 72.94 },
    "ratingDistributionTotal": 480213,
    "ratingDistributionDelta": 0,
    "ratingCount1": 5990,
    "ratingCount2": 8890,
    "ratingCount3": 25011,
    "ratingCount4": 90112,
    "ratingCount5": 350210,
    "ratingPct1": 1.25,
    "ratingPct2": 1.85,
    "ratingPct3": 5.21,
    "ratingPct4": 18.77,
    "ratingPct5": 72.94,
    "courseAvgRating": 4.679213,
    "courseAvgRatingRecent": 4.701122,
    "ratingRecencyDelta": 0.021909,
    "reviewToEnrollmentRatio": 0.331,
    "courseAgeDays": 2135,
    "daysSinceLastUpdate": 150,
    "scrapedAt": "2026-08-15T09:12:44Z"
  },
  {
    "type": "review",
    "isChild": true,
    "courseUrl": "https://www.udemy.com/course/100-days-of-code/",
    "class": "course_review",
    "id": 123456790,
    "content": "Good pacing, though a couple of sections felt outdated.",
    "rating": 4,
    "created": "2026-05-28T09:04:02Z",
    "modified": "2026-05-28T09:04:02Z",
    "user_modified": "2026-05-28T09:04:02Z",
    "user": {
      "_class": "user",
      "title": "",
      "name": "",
      "display_name": "Priya S.",
      "image_50x50": "https://img-c.udemycdn.com/user/50x50/2345678_bcde.jpg",
      "initials": "PS",
      "tracking_id": "def456|uvw012",
      "public_display_name": "Priya S."
    },
    "created_formatted_with_time_since": "2 months ago",
    "reviewerName": "Priya S.",
    "courseId": 2776760,
    "courseTitle": "100 Days of Code: The Complete Python Pro Bootcamp",
    "courseRating": 4.7,
    "courseTotalReviews": 480213,
    "courseSubscribers": 1450213,
    "coursePrice": 84.99,
    "courseCurrency": "USD",
    "courseLevel": "All Levels",
    "instructorName": "Dr. Angela Yu",
    "ratingDistributionTotal": 480213,
    "ratingRecencyDelta": 0.021909,
    "reviewToEnrollmentRatio": 0.331,
    "courseAgeDays": 2135,
    "daysSinceLastUpdate": 150,
    "scrapedAt": "2026-08-15T09:12:45Z"
  },
  {
    "type": "review",
    "isChild": true,
    "courseUrl": "https://www.udemy.com/course/100-days-of-code/",
    "class": "course_review",
    "id": 123456791,
    "content": "Best coding course I've taken, worth every hour.",
    "rating": 5,
    "created": "2026-05-14T18:47:31Z",
    "modified": "2026-05-14T18:47:31Z",
    "user_modified": "2026-05-14T18:47:31Z",
    "user": {
      "_class": "user",
      "title": "",
      "name": "",
      "display_name": "Marco D.",
      "image_50x50": "https://img-c.udemycdn.com/user/50x50/3456789_cdef.jpg",
      "initials": "MD",
      "tracking_id": "ghi789|rst345",
      "public_display_name": "Marco D."
    },
    "created_formatted_with_time_since": "3 months ago",
    "reviewerName": "Marco D.",
    "courseId": 2776760,
    "courseTitle": "100 Days of Code: The Complete Python Pro Bootcamp",
    "courseRating": 4.7,
    "courseTotalReviews": 480213,
    "courseSubscribers": 1450213,
    "coursePrice": 84.99,
    "courseCurrency": "USD",
    "courseLevel": "All Levels",
    "instructorName": "Dr. Angela Yu",
    "ratingDistributionTotal": 480213,
    "ratingRecencyDelta": 0.021909,
    "reviewToEnrollmentRatio": 0.331,
    "courseAgeDays": 2135,
    "daysSinceLastUpdate": 150,
    "scrapedAt": "2026-08-15T09:12:46Z"
  },
  {
    "type": "course",
    "isChild": false,
    "courseUrl": "https://www.udemy.com/course/100-days-of-code/",
    "courseId": 2776760,
    "courseTitle": "100 Days of Code: The Complete Python Pro Bootcamp",
    "courseHeadline": "Master Python by building 100 projects in 100 days.",
    "courseRating": 4.7,
    "courseTotalReviews": 480213,
    "courseRecentReviews": 512,
    "courseSubscribers": 1450213,
    "coursePrice": 84.99,
    "courseCurrency": "USD",
    "coursePriceText": "$84.99",
    "courseIsPaid": true,
    "courseLevel": "All Levels",
    "courseLocale": "en_US",
    "courseLanguage": "English",
    "courseContentHours": 57.0,
    "courseVideoHours": 56.8,
    "courseLectureCount": 704,
    "courseCurriculumItemCount": 720,
    "courseHasCertificate": true,
    "courseBadges": "Bestseller",
    "coursePublishedAt": "2020-05-11T10:00:00Z",
    "courseLastUpdatedAt": "2026-03-18T00:00:00Z",
    "courseCreatedAt": "2020-04-02T00:00:00Z",
    "courseCategory": "Development",
    "courseSubcategory": "Programming Languages",
    "courseStatus": null,
    "courseImageUrl": "https://img-c.udemycdn.com/course/480x270/course-image.jpg",
    "instructorId": 12345,
    "instructorName": "Dr. Angela Yu",
    "instructorJobTitle": "Developer and Lead Instructor",
    "instructorProfileUrl": "https://www.udemy.com/user/angela-yu-2/",
    "ratingDistribution": { "1": 5990, "2": 8890, "3": 25011, "4": 90112, "5": 350210 },
    "ratingDistributionPct": { "1": 1.25, "2": 1.85, "3": 5.21, "4": 18.77, "5": 72.94 },
    "ratingDistributionTotal": 480213,
    "ratingDistributionDelta": 0,
    "ratingCount1": 5990,
    "ratingCount2": 8890,
    "ratingCount3": 25011,
    "ratingCount4": 90112,
    "ratingCount5": 350210,
    "ratingPct1": 1.25,
    "ratingPct2": 1.85,
    "ratingPct3": 5.21,
    "ratingPct4": 18.77,
    "ratingPct5": 72.94,
    "courseAvgRating": 4.679213,
    "courseAvgRatingRecent": 4.701122,
    "ratingRecencyDelta": 0.021909,
    "reviewToEnrollmentRatio": 0.331,
    "courseAgeDays": 2135,
    "daysSinceLastUpdate": 150,
    "reviewsCollected": 200,
    "apiReviewCap": 10000,
    "sampleCoveragePct": 0.041638,
    "collectionOutcome": "limit_reached",
    "scrapedAt": "2026-08-15T09:13:02Z"
  }
]

Review rows use courseFieldSet: "full" inconsistently above only to show the complete key set once (first row) versus the trimmed repeat you'll actually see on every row after it — in a real run every review row for a course carries the same course-context keys, decided once by courseFieldSet. The course row (type: "course") always carries the full course record regardless of courseFieldSet, since that field only controls what's repeated on review rows.

How can I use the data extracted with Udemy Course Reviews Scraper: Course Stats & Rating?

• 🎓 Course creators and instructors: track your own course's courseRating, ratingRecencyDelta, and per-star breakdown over time to see whether a recent update improved or hurt perception, and mine content for recurring complaints.
• 🤖 AI engineers and LLM developers: have an agent query a course, receive structured review and rating JSON, and pass it to the model as grounding context for a course-recommendation or due-diligence assistant.
• 📊 Market researchers: compare courseRating, courseSubscribers, and reviewToEnrollmentRatio across many courses in the same category to map competitive positioning.
• 🏗️ E-learning product teams: mine review content across a course category for feature gaps and unmet demand before building a competing course or curriculum.

How do you monitor course ratings and analytics over time?

Rating monitoring means re-running the same courseTargets list on a schedule and comparing the derived and breakdown fields between runs, rather than reading a single snapshot. Each run recomputes courseRating, ratingDistribution, ratingRecencyDelta, reviewToEnrollmentRatio, and — on the course row — sampleCoveragePct, so diffing two runs shows exactly what moved: a rating drop after a content update, a spike in 1-star reviews, or enrollment growing faster than the review count.

The fields worth diffing between runs: courseRating and courseTotalReviews for the headline trend, ratingCount1–ratingCount5 for where the shift happened, ratingRecencyDelta for whether recent sentiment is diverging from the lifetime average, and courseLastUpdatedAt / daysSinceLastUpdate to correlate a rating change with a course update.

A typical workflow: schedule a run across your tracked course list every few days using Apify's built-in Scheduler, store each run's dataset, and compare the latest courseRating and ratingDistribution against the previous run — alert when the rating drops by a meaningful margin or 1-star review volume spikes. There is no built-in diffing inside the Actor itself; comparison happens between the datasets your scheduled runs produce.

Integrate Udemy Course Reviews Scraper: Course Stats & Rating and automate your workflow

Udemy Course Reviews Scraper: Course Stats & Rating works with any language or tool that can call the Apify API.

REST API with Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

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

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["type"] == "review":
        print(row["rating"], row["reviewerName"], row["content"][:80])

Scheduled monitoring and delivery

Use Apify's built-in Schedules to trigger runs on a cron interval against the same courseTargets list, and pull each run's dataset via the Apify API or apify_client afterward. There is no Actor-specific webhook payload; use Apify's platform-level webhooks to get notified when a scheduled run finishes, then fetch the dataset for comparison.

⚖️ Is it legal to scrape Udemy results?

Yes — scraping publicly accessible Udemy pages is generally legal in most jurisdictions. Udemy Course Reviews Scraper: Course Stats & Rating returns only what any visitor to a course page can already see: the course record and its public reviews.

Because reviews include reviewer-supplied personal data — display name, avatar image, and initials — GDPR (EU/EEA) and CCPA (California) can apply if you collect, store, or process reviewer data tied to an identifiable person, particularly at scale or for profiling. Course and pricing fields (rating, price, category, curriculum stats) are business/catalogue data and are governed separately by Udemy's Terms of Service rather than data-protection law. Scraping for one-off research carries a different risk profile than bulk collection for AI training or resale — review Udemy's Terms of Service before either. Consult your legal team for commercial use cases involving bulk data storage.

❓ Frequently asked questions

How many reviews does the Actor collect per course, and can I get more than the default?

By default it collects 10 reviews per course (reviewsPerCourse default). Raise reviewsPerCourse to collect more — up to Udemy's own hard limit of 10,000 reviews per course, which the platform enforces regardless of how many reviews actually exist. Requesting more than 10,000 has no additional effect; the value is capped.

Does the Actor return course prices and reviews in my local currency or language?

No. Every request is sent with fixed headers requesting the US, English-language storefront view (x-udemy-cache-marketplace-country: US, x-udemy-cache-language: en), so coursePrice, courseCurrency, and course text always reflect Udemy's US/English presentation, regardless of the course's own audience locale. There is no input parameter to change this.

Can I control the order reviews are returned in — newest first, highest rated first?

No, there's no input for it. Reviews are always requested in Udemy's own default order (highest-ranked first, then newest), which is fixed in the Actor and not exposed as a configurable parameter.

How does the Actor handle Udemy's rate limiting and blocking?

Every request starts unproxied. On a 401, 403, 429, or 503 response — or a malformed response — the Actor retries with a jittered delay and automatically escalates the route: first to Apify Proxy's datacenter pool, then to the residential pool, staying on whichever route last worked for the rest of the run. Automatic escalation only reaches real alternate IPs when proxyConfiguration has Apify Proxy enabled; see the input warning above.

Does the Actor extract rating and course analytics, not just review text?

Yes — with includeRatingBreakdown and includeDerivedMetrics left at their default true, every row carries ratingDistribution, ratingCount1–ratingCount5, ratingRecencyDelta, reviewToEnrollmentRatio, courseAgeDays, and daysSinceLastUpdate. These are omitted if you turn the corresponding toggle off, and the rating breakdown is empty if Udemy's course document doesn't include a rating_distribution for that course.

What happens if a course URL, slug, or ID doesn't exist on Udemy?

That target is skipped: the Actor logs a warning, pushes no rows for it, and moves on to the next target. Nothing is charged for a target that resolves to nothing.

How do I monitor a course's rating over time?

Schedule repeated runs against the same courseTargets list using Apify's Scheduler, and diff courseRating, ratingDistribution, and ratingRecencyDelta between the latest and previous run's datasets. See "How do you monitor course ratings and analytics over time?" above for the full workflow.

Does the Actor work with Claude, ChatGPT, and AI agent frameworks?

It isn't published as an MCP server, but it's callable as a standard HTTP endpoint through the Apify API or apify_client from any agent framework — an agent can call it, receive structured review and rating JSON, and use that as grounding context before generating an answer.

Can I use the Actor without managing proxies or a Udemy account?

Yes for the account side — no Udemy login or credentials are needed at any point. Proxies are optional too: the Actor runs direct by default and only benefits from Apify Proxy's automatic route-switching if you enable useApifyProxy in proxyConfiguration, which is worth doing for large batches or courses that keep failing.

What's the difference between the essential and full course field sets?

courseFieldSet: "essential" repeats only 7 core columns on every review row — courseId, courseTitle, courseRating, courseTotalReviews, courseSubscribers, courseLevel, instructorName. courseFieldSet: "full" (the default) repeats the complete course record instead, including price, currency, locale, content hours, lecture count, certificate flag, badges, dates, category, subcategory, status, image, and the full instructor block. This only affects review rows — the course summary row (type: "course") always carries the full record either way.

💬 Your feedback

Found a bug or a field that doesn't match what's on Udemy? Let us know through the Actor's Issues tab on Apify or the Scrapier support channel — reports like these are what keep this Actor accurate as Udemy's site changes.