Udemy Course Reviews Scraper: Instructor Course Catalog

Udemy Course Reviews Scraper — Ratings and Instructor Catalogs

Give this Actor one Udemy course link and it returns every review on that course — content, rating, timestamps, and (optionally) the reviewer's name, profile link and ID — then automatically finds the instructor behind the course and pulls reviews for every other course that instructor has published. Each run also emits an instructor portfolio row: courses published, total students, a review-weighted average rating, and the highest- and lowest-rated course in the catalog. It's built for course creators, e-learning marketing agencies, and researchers who need instructor-level review data, not just a single course's. No Udemy login or API key required — only an Apify account to start the run.

What is Udemy Course Reviews Scraper: Instructor Course Catalog?

It's an Apify Actor that turns a single Udemy course URL, slug, numeric course ID, or instructor reference into a full set of review and catalog data for that instructor's entire published portfolio. It reads Udemy's own course, catalog, and review endpoints directly — no browser automation — and writes typed JSON rows to an Apify dataset that you can export as CSV, Excel, JSON, or query through the API. No Udemy account or login is required to run it.

Key features:

• 🎯 Flexible targeting — accepts a course URL, a bare course slug, a numeric course ID, or an explicit instructor:<id> reference
• 👨‍🏫 Automatic instructor expansion — every target resolves to its instructor, and that instructor's whole published catalog is added to the run (can be turned off)
• 📝 Full review text and ratings — content, rating, created/modified timestamps, and Udemy's own "time since" string, per review
• 🙋 Optional reviewer identity — name, profile URL, numeric ID, and avatar, added as separate columns
• 📊 Instructor portfolio rollup — one row per instructor with catalog size, total students, weighted average rating, and highest/lowest-rated course
• 🥇 Catalog ranking and quality filters — sort the instructor's catalog by most reviews, highest rated, most students, or newest, and drop courses below a minimum review count
• 📦 Standard Apify export — every row lands in the run's dataset, downloadable as JSON, CSV, Excel, or accessed via the Apify API

What data can I extract with Udemy Course Reviews Scraper?

The Actor returns two row types in the same dataset — review rows (type: "review") and instructor summary rows (type: "instructor") — plus a nested catalog list inside every instructor row.

Field	Example value	Use case
type	"review"	Distinguish review rows from instructor rollup rows
isChild	true	Filter to per-review detail rows vs. summary rows
id	35123456	Unique review ID
courseId	2776760	Join reviews back to a specific course
courseTitle	"100 Days of Code: The Complete Python Pro Bootcamp"	Human-readable course label
courseUrl	"https://www.udemy.com/course/100-days-of-code/"	Link to the course page
discoveredVia	"instructorCatalog"	Was this course the seed target or found via catalog expansion
catalogRank	4	Position in the sorted catalog when discovered via expansion (null for seed courses)
instructorId	31334738	Join to the instructor summary row
instructorName	"Dr. Angela Yu"	Instructor display name
instructorProfileUrl	"https://www.udemy.com/user/4573e5a3-.../"	Link to the instructor's Udemy profile
class	"course_review"	Udemy's own object type label
content	"Great course, very clear explanations."	The review text itself
rating	5	Star rating (1–5)
created	"2024-11-02T10:15:00Z"	When the review was posted
modified	"2024-11-03T08:00:00Z"	Last edit timestamp
user_modified	"2024-11-03T08:00:00Z"	Last edit timestamp as reported on the user record
created_formatted_with_time_since	"2 years ago"	Udemy's own relative-time string
reviewerName	"Jordan K."	Present only when Add Reviewer Identity Columns is on
reviewerProfileUrl	"https://www.udemy.com/user/jordan-k/"	Reviewer's public profile
reviewerId	48213099	Numeric reviewer ID
reviewerAvatarUrl	"https://.../100x100.jpg"	Reviewer's avatar image
scrapedAt	"2026-08-15T09:00:00Z"	When this row was collected

Nested user object (always present on review rows): _class, title, name, display_name, image_50x50, initials, tracking_id, public_display_name — Udemy's raw review-author record, kept alongside the flattened reviewerName/reviewerProfileUrl/reviewerId/reviewerAvatarUrl columns.

⭐ Ratings and review data

Every review row carries the star rating, the full text, and both a created and a last-modified timestamp, plus Udemy's own relative-time string ("2 years ago"). Use content and rating for sentiment or trend analysis across an instructor's whole catalog — group by courseId to compare how individual courses are received, or by instructorId to see whether recent reviews trend up or down against created.

🧭 Targeting and catalog data

Instructor rows carry the fields you filter and segment on: coursesPublished, coursesSelected, totalReviewsAcrossCatalog, totalStudents, weightedAvgRating, arithmeticAvgRating, and the highest/lowest rated course (id, title, rating, URL). Each instructor row also nests a full catalogCourses array — one object per course with courseId, courseTitle, courseUrl, rating, numReviews, numSubscribers, price, priceAmount, priceCurrency, instructionalLevel, contentInfo, headline, badges, publishedAt, lastUpdatedAt, and locale.

Why not build this yourself?

Udemy's own Affiliate API (v2.0) — the only public, documented API that ever exposed course and review data to outside developers — was discontinued as of January 1, 2025, per Udemy's developer documentation (checked 2026-08-15). Udemy's separate Instructor API is scoped to a logged-in instructor's own courses and analytics; it does not expose another instructor's catalog or public review text, so it doesn't cover bulk collection either. That leaves the internal endpoints this Actor talks to as the only route to this data, and they carry no pagination guarantees, no stable auth model for third parties, and active anti-bot defenses.

Building this yourself means reverse-engineering those undocumented endpoints, writing the course → instructor → catalog resolution chain from scratch, handling pagination across both the catalog and every course's review list, and maintaining proxy rotation and retry logic as blocking patterns change. This Actor already does all of that: it resolves each target to its instructor, walks the full catalog with pagination, retries failed reads, and automatically escalates from a direct connection to Apify Proxy datacenter and residential IPs when a request is blocked.

If you need official, rate-plan-backed access to your own courses' data as an instructor, Udemy's Instructor API is the right tool. If you need review and catalog data across courses and instructors you don't own — for competitive research, market analysis, or content curation — this Actor covers that gap.

How to use data extracted from Udemy?

🎓 Course creators and education marketers

Pull every review for a competing course, then expand to that instructor's whole catalog to see how ratings and review volume vary across their portfolio. Filter on rating and content to find recurring complaints (pacing, outdated content, audio quality) before positioning a new course against them, and use weightedAvgRating from the instructor row to benchmark a whole catalog at once rather than one course at a time.

🏢 E-learning marketing agencies

Run this on a client's competitor set on a schedule, comparing totalStudents, totalReviewsAcrossCatalog, and weightedAvgRating across instructors to build a recurring competitive-landscape report. Because catalogRank and discoveredVia mark which courses came from catalog expansion, you can separate "the course we were asked about" from "everything else this instructor sells."

📊 Market research and pricing analysts

Use priceRangeMin, priceRangeMax, and priceCurrency on instructor rows alongside numSubscribers and rating on individual catalog courses to map pricing against demand and satisfaction across a category — for example, comparing coding-bootcamp instructors by price band and review volume to see where the market clusters.

🤖 AI agents and automated pipelines

Feed content and rating into a review-summarization or sentiment pipeline, or use the instructor rollup row as structured context for a course-recommendation agent. Because output is typed JSON with a stable type field distinguishing review from instructor rows, downstream pipelines can filter and route without custom parsing.

⬇️ Input sample

Parameter	Required	Type	Description	Example value
targets	No	array	Udemy course URLs, course slugs, numeric course IDs, or an instructor reference written as instructor:31334738. Each course target is matched to its instructor, and the instructor's whole published catalog is added to the run.	["https://www.udemy.com/course/100-days-of-code/"]
urls	No	array	Legacy field kept for backward compatibility with the original input format. Anything listed here is merged into targets. Leave empty if you use targets.	[]
keywords	No	array	Legacy field kept for backward compatibility. Accepts a course slug (100-days-of-code) or a numeric course ID (2776760), merged into targets. It is not a search box.	[]
reviewsPerCourse	No	integer, minimum 0	How many reviews to collect for each course, including every course discovered from the instructor's catalog. This budget is per course — discovered courses never consume the seed course's budget. Set 0 to take as many as the source returns. Default 10.	10
maxItems	No	integer, minimum 1	Legacy field, kept for backward compatibility. Used only when reviewsPerCourse is left empty.	—
expandInstructorCatalog	No	boolean, default true	On: every target is matched to its instructor and every other course that instructor publishes is added to the run. Off: only the courses you listed are collected.	true
maxCoursesPerInstructor	No	integer, minimum 0, default 10	Caps how many courses are taken from the instructor's catalog, per instructor. The course you supplied is always collected and is not counted against this cap. Set 0 for the whole catalog.	10
catalogSortBy	No	string, default "most_reviews"	Ranking applied to the instructor's catalog before the cap above is applied. Enum: most_reviews (Most reviewed courses first), highest_rated (Highest rated courses first), most_students (Most students first), newest (Newest courses first).	"most_reviews"
minCourseReviews	No	integer, minimum 0, default 0	Drops small or brand-new courses from the instructor's catalog before ranking. Set 0 to keep everything.	0
emitInstructorSummary	No	boolean, default true	Adds one row per instructor (type: "instructor") with courses published, total reviews and students across the catalog, a review-count-weighted average rating, highest/lowest rated course, and price range. Also written to a separate per-run instructor dataset.	true
includeReviewerProfile	No	boolean, default true	Adds reviewerName, reviewerProfileUrl, reviewerId, and reviewerAvatarUrl to each review row.	true
proxyConfiguration	No	object (proxy editor)	Optional network routing for the run. Leave off unless your runs need it.	{"useApifyProxy": false}

No input parameter is required — an empty run simply collects nothing and exits with a warning.

{
  "targets": ["https://www.udemy.com/course/100-days-of-code/"],
  "reviewsPerCourse": 10,
  "expandInstructorCatalog": true,
  "maxCoursesPerInstructor": 5,
  "catalogSortBy": "most_reviews",
  "minCourseReviews": 100,
  "emitInstructorSummary": true,
  "includeReviewerProfile": true
}

Common pitfall: keywords is not a search box — it only accepts an exact course slug or numeric course ID, never a topic or free-text query. And maxItems is silently ignored whenever reviewsPerCourse has any value, including its own default of 10 — leave reviewsPerCourse empty if you specifically want the legacy maxItems field to take effect.

⬆️ Output sample

Every row is typed, normalized JSON with a consistent schema per type. Results are written to the run's Apify dataset and downloadable as JSON, CSV, Excel, or accessed via the Apify API and apify-client — no extra export step needed. Instructor summary rows are additionally mirrored into a separate per-run dataset named <runId>-instructor.

Review row:

{
  "type": "review",
  "isChild": true,
  "id": 35123456,
  "courseId": 2776760,
  "courseTitle": "100 Days of Code: The Complete Python Pro Bootcamp",
  "courseUrl": "https://www.udemy.com/course/100-days-of-code/",
  "discoveredVia": "target",
  "catalogRank": null,
  "instructorId": 31334738,
  "instructorName": "Dr. Angela Yu",
  "instructorProfileUrl": "https://www.udemy.com/user/4573e5a3-example/",
  "class": "course_review",
  "content": "Great course, very clear explanations and well-paced projects.",
  "rating": 5,
  "created": "2024-11-02T10:15:00Z",
  "modified": "2024-11-03T08:00:00Z",
  "user_modified": "2024-11-03T08:00:00Z",
  "user": {
    "_class": "user",
    "title": "Jordan K.",
    "name": "Jordan",
    "display_name": "Jordan K.",
    "image_50x50": "https://.../50x50.jpg",
    "initials": "JK",
    "tracking_id": "abc123",
    "public_display_name": "Jordan K."
  },
  "created_formatted_with_time_since": "2 years ago",
  "reviewerName": "Jordan K.",
  "reviewerProfileUrl": "https://www.udemy.com/user/jordan-k/",
  "reviewerId": 48213099,
  "reviewerAvatarUrl": "https://.../100x100.jpg",
  "scrapedAt": "2026-08-15T09:00:00Z"
}

Instructor summary row:

{
  "type": "instructor",
  "isChild": false,
  "instructorId": 31334738,
  "instructorName": "Dr. Angela Yu",
  "instructorJobTitle": "Lead Instructor at App Brewery",
  "instructorProfileUrl": "https://www.udemy.com/user/4573e5a3-example/",
  "coursesPublished": 8,
  "coursesSelected": 6,
  "seedCourseId": 2776760,
  "totalReviewsAcrossCatalog": 512340,
  "totalStudents": 2145980,
  "weightedAvgRating": 4.7231,
  "arithmeticAvgRating": 4.65,
  "highestRatedCourseId": 2776760,
  "highestRatedCourseTitle": "100 Days of Code: The Complete Python Pro Bootcamp",
  "highestRatedCourseRating": 4.8,
  "highestRatedCourseUrl": "https://www.udemy.com/course/100-days-of-code/",
  "lowestRatedCourseId": 1444556,
  "lowestRatedCourseTitle": "The Complete iOS 15 Developer Course",
  "lowestRatedCourseRating": 4.4,
  "lowestRatedCourseUrl": "https://www.udemy.com/course/ios-15-app-development/",
  "priceRangeMin": 12.99,
  "priceRangeMax": 199.99,
  "priceCurrency": "USD",
  "selectedCourseIds": [2776760, 1444556, 736024],
  "catalogCourses": [
    {
      "courseId": 736024,
      "courseTitle": "The Complete Web Developer in 2024",
      "courseUrl": "https://www.udemy.com/course/the-complete-web-developer-course-2/",
      "rating": 4.7,
      "numReviews": 187233,
      "numSubscribers": 933812,
      "price": "$19.99",
      "priceAmount": 19.99,
      "priceCurrency": "USD",
      "instructionalLevel": "All Levels",
      "contentInfo": "30.5 total hours",
      "headline": "Learn HTML, CSS, JavaScript, React, Node and more!",
      "badges": ["Bestseller"],
      "publishedAt": "2015-06-01T00:00:00Z",
      "lastUpdatedAt": "2024-08-10T00:00:00Z",
      "locale": "en_US"
    }
  ],
  "scrapedAt": "2026-08-15T09:00:00Z"
}

How do you filter and target specific reviews and courses?

This is a targeting Actor first: the goal is picking exactly which courses in an instructor's catalog get scraped, not just which course you start from.

Course vs. instructor targeting. A course URL or slug resolves to a single seed course and then expands to that course's instructor. An explicit instructor:31334738 reference skips course resolution entirely and expands straight to the full catalog — use it when you already know the instructor ID and don't care about a specific seed course.

Scope precision. maxCoursesPerInstructor caps how many catalog courses are taken per instructor (the seed course is always included and doesn't count against the cap). catalogSortBy decides which courses fill that cap when the catalog is larger than the limit — most_reviews, highest_rated, most_students, or newest.

Quality thresholds. minCourseReviews drops small or brand-new courses from the catalog before ranking and capping, so a cap of 5 doesn't get spent on courses with a handful of reviews.

Volume control. reviewsPerCourse is a per-course budget applied independently to every course in the run, including catalog-discovered ones — 0 removes the cap and takes as many reviews as the source returns for that course.

Seed course plus its full catalog:

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

Instructor-only, top 3 highest-rated established courses:

{ "targets": ["instructor:31334738"], "maxCoursesPerInstructor": 3, "catalogSortBy": "highest_rated", "minCourseReviews": 1000 }

Single course only, no catalog expansion, unlimited reviews:

{ "targets": ["https://www.udemy.com/course/100-days-of-code/"], "expandInstructorCatalog": false, "reviewsPerCourse": 0 }

▶️ Want to try other review scrapers?

Scraper	What it extracts
Goodreads Book Scraper: Review Sentiment Analysis	Book reviews and ratings from Goodreads
Google Play Scraper: Country Pricing & In-App Purchases	App listings, reviews, and per-country pricing from Google Play
Walmart Reviews Scraper With Seller & Variant Details	Product reviews, seller, and variant data from Walmart
Airbnb Review Scraper By Location Search	Guest reviews for Airbnb listings by location
Facebook Reviews Scraper — Headlines, Tags & Reviewer Detail	Page reviews, headlines, and reviewer detail from Facebook

How to extract Udemy data programmatically

This Actor runs as a standard Apify Actor: one API call starts the run, and results come back as structured JSON from the dataset — no separate signup or API key beyond your Apify account token.

Python example

from apify_client import ApifyClient

client = ApifyClient("<APIFY_API_TOKEN>")

run = client.actor("<your-username>/udemy-course-reviews-scraper-instructor-course-catalog").call(
    run_input={
        "targets": ["https://www.udemy.com/course/100-days-of-code/"],
        "reviewsPerCourse": 20,
        "maxCoursesPerInstructor": 5,
        "catalogSortBy": "highest_rated",
    }
)

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

Export to spreadsheets or CRM

Export the dataset directly as CSV or Excel from the Apify Console, or pull it via the API and map fields into your destination columns: courseTitle → Course, rating → Rating, content → Review Text, reviewerName → Reviewer, created → Review Date. Instructor rollup rows map the same way using instructorName, totalStudents, and weightedAvgRating.

⚖️ Is it legal to scrape Udemy?

Scraping publicly accessible Udemy course and review pages is generally lawful — this data is published for anyone to view without logging in, and this Actor only reads what's already public. Review rows include personal data about reviewers when Add Reviewer Identity Columns is on (reviewerName, reviewerProfileUrl, reviewerId, reviewerAvatarUrl), so GDPR and CCPA considerations apply to how you store and use that data, not just to whether you can collect it. You're responsible for having a lawful basis for any storage or downstream use of personal data, and for complying with Udemy's own Terms of Service. Consult legal counsel for commercial applications involving bulk storage of personal data.

❓ FAQ

What happens if a course has been removed from Udemy?

If a target course no longer exists, Udemy returns a not-found response and the Actor skips it without pushing a row, logging a warning and continuing with the rest of your targets. There is no "removed" flag in the output — a deleted course simply produces no rows.

Can I get the instructor's full catalog along with review text?

Yes. With expandInstructorCatalog on (default) and emitInstructorSummary on (default), every review row for every catalog course is collected alongside one instructor summary row per instructor, covering courses published, total students, weighted average rating, and price range.

How accurate is the reviewer identity data?

The Actor returns reviewer identity fields exactly as Udemy's API exposes them at request time. Coverage is not complete: reviewerProfileUrl is present on almost every review, while reviewerId is present on roughly 7–8 out of every 10 reviews. When a value is genuinely unavailable the column is null — it is never filled in with a guess, and Udemy publishes no additional reviewer history to draw from.

How many reviews can I get per run?

reviewsPerCourse sets a per-course budget (default 10), applied independently to every course including ones found through catalog expansion — set it to 0 to take as many reviews as the source returns for that course. There is no separate run-level cap; total row count scales with how many targets you supply and how wide maxCoursesPerInstructor is set.

How do I control which catalog courses get scraped?

Use catalogSortBy to rank the instructor's catalog (most_reviews, highest_rated, most_students, newest), minCourseReviews to drop small or new courses before ranking, and maxCoursesPerInstructor to cap how many of the ranked courses are taken. The seed course you supplied is always included and doesn't count against the cap.

Does it work with Claude, ChatGPT, and AI agent frameworks?

It isn't reachable through an MCP server. It's callable as a standard HTTP Actor endpoint via the Apify API, so any agent framework that can make an authenticated HTTP call — including custom tools built for Claude or ChatGPT — can trigger a run and read back the dataset.

How does this compare to a single-course Udemy review scraper?

A plain review scraper stops at the one course you give it. This Actor resolves that course to its instructor and adds every other course in that instructor's published catalog to the same run, with independent per-course review budgets and an instructor-level rollup row — so one input turns into an instructor's whole review footprint instead of one course's.

Can I use it without a Udemy API key or developer account?

Yes. The Actor makes anonymous, logged-out requests to Udemy's public course, catalog, and review pages — you never need a Udemy account, login, or API key. You only need an Apify account to start the run.

Do I need a proxy to run this?

No — proxyConfiguration is optional and off by default. The Actor starts on a direct connection and automatically escalates to Apify Proxy datacenter and then residential IPs on its own if a request is blocked, retrying before giving up on that page.

Conclusion

Udemy Course Reviews Scraper: Instructor Course Catalog turns a single course link into an instructor's full review footprint — every review on every course they publish, plus a portfolio-level rollup of ratings, students, and pricing. The catalog ranking, quality thresholds, and per-course review budgets give you precise control over exactly which courses get scraped instead of forcing an all-or-nothing catalog pull. Start a run from the Apify Console or trigger it through the API with apify-client to get structured, typed JSON back — no Udemy login required.