Udemy Course Reviews Scraper — Syllabus, Lectures & Quizzes

Udemy Course Scraper — Extract Reviews, Curriculum & Course Metrics

Udemy Course Reviews Scraper — Syllabus, Lectures & Quizzes collects three things for every course you point it at: written student reviews, the full curriculum outline (every section, lecture, quiz, practice test and coding exercise), and a course-content metrics row that summarizes how the course is actually built. Unlike scraping frameworks that return raw HTML, this Actor returns typed JSON — ready for your model, your database, or your pipeline without any parsing. This guide covers exactly what each row contains and how teams run it for enrichment, monitoring and dataset-building workloads.

---

🧭 What Does Udemy Course Scraper Do?

It takes a list of Udemy course links, IDs or slugs and, for each one, pulls the course's public text reviews, its published curriculum, and a computed summary of that curriculum's composition — lecture counts, hands-on percentage, video hours, free-preview coverage, and more. It calls Udemy's own public course, curriculum and review endpoints directly; no Udemy account, login or API key is required to run it.

• ⭐ Written student reviews with rating, content, timestamps and reviewer identity fields
• 🧱 Section-by-section curriculum: lectures, quizzes, practice tests, role plays and coding exercises
• 📊 One computed course-content metrics row per course (composition, duration, hands-on share)
• 🌍 Optional caption/language block (locale, closed captions, caption language list)
• 🎯 Optional syllabus-promises block (learning outcomes, requirements, target audience, course FAQ)
• 🆓 Free-preview filtering, so you can pull only the publicly previewable slice of a course
• 🔗 Two input paths (links or IDs/slugs) that merge into one target list per run

---

⚡ Features & Capabilities

The Actor's feature set splits into what it extracts, how it's built to survive Udemy's rate limiting, and how it fits alongside the rest of the Scrapio catalog.

Core features

• Three row types in one dataset — review, curriculumItem / curriculumSection, and courseContent, distinguished by a type field on every row
• Configurable curriculum depth — curriculumDetail switches between one row per lecture/quiz (sectionsAndItems) and one row per section (sections)
• Item-type and free-preview filtering — keep only lecture, quiz, practice, role_play or coding_exercise items, or only the items a course lets the public preview
• Text-only review sampling — the reviews endpoint is called with is_text_review: 1, so star-only ratings never dilute the sample
• Automatic network escalation — requests start direct, and escalate to an Apify Proxy datacenter tier and then a residential tier on 401, 403, 429 or 503 responses
• Denormalized content summary — attachContentToReviews copies lecture count, video hours, hands-on % and free-preview count onto every review row of that course
• Real output fields on the primary review row include id, content, rating, created, reviewerName, and a nested user object with display_name, initials, image_50x50 and tracking_id

Udemy Course Scraper within the Scrapio data stack

Udemy Course Scraper already covers all three entity types this Actor's title promises — reviews, curriculum and course-content metrics — in a single run, so there's no separate Scrapio Udemy Actor needed for curriculum-only or metrics-only jobs. If your workflow also needs review data from other marketplaces, Scrapio's Walmart Reviews Scraper and Airbnb Review Scraper follow the same review-row pattern (rating, content, reviewer identity) on different platforms — see Related Scrapers below for the full list.

---

Why do developers and data teams scrape Udemy?

Course review and curriculum data serves a narrower, more specific set of audiences than a general marketplace scraper — mostly people building on top of course catalog structure, not just review sentiment.

🏢 Course creators and instructor-support teams

An instructor or course-ops team pointing the Actor at their own course (or a competitor's) gets content and rating from every text review alongside sectionTitle, itemTitle and itemDuration from the curriculum — enough to see which sections draw complaints in reviews and cross-reference them against the actual lecture that section contains. Output lands in the default dataset as one row per review and one row per curriculum item, exportable straight to a spreadsheet or BI tool.

📊 AI training data and RAG indexing

The content field on review rows and itemTitle / itemDescription on curriculum rows are the high-information text fields — free-form natural language describing what a course teaches and how students reacted to it. For RAG enrichment, index itemTitle, itemDescription and the optional whatYouWillLearn / courseFaq blocks (from includeSyllabusPromises) so a support or course-recommendation bot can answer "what does this course cover" from real syllabus text. For training data, rating plus content gives a labeled sentiment pair with consistent structure across every course in the run.

📱 Competitive and market intelligence

Ed-tech and bootcamp teams track lectureCount, totalVideoHours, handsOnItemPct and freePreviewCount across a set of competitor courses to see how much free content they expose and how hands-on their curriculum actually is, re-running on a schedule to catch when a competitor restructures a course.

🔬 Research and academic use

MOOC and online-learning researchers use the curriculum and content-metrics rows to study how course structure (section count, hands-on percentage, video-hour totals) relates to review sentiment across a corpus of courses. The Actor only returns data Udemy already serves on its public course pages — there's no login-gated content in scope.

🎥 Product and SaaS development

Course-comparison sites, curriculum-aggregator directories and LMS integration tools build on the courseContent row directly — it's already a normalized per-course summary object, so a product can display "12 hours of video, 68% hands-on" for a catalog of courses without recomputing anything.

---

🍚 Input Parameters

All parameters are optional — there is no required field. Read directly from .actor/actor.json.

Parameter	Required	Type	Description	Example Value
courseLinks	No	array (stringList)	One or more Udemy course links. Add several to cover many courses in one run. Leave empty and use courseIdsOrSlugs instead if you already have identifiers.	["https://www.udemy.com/course/100-days-of-code/"]
courseIdsOrSlugs	No	array (stringList)	A numeric Udemy course ID (e.g. 2776760) or a course slug (e.g. 100-days-of-code). Added to whatever is in courseLinks. Anything unmatched is reported as not found instead of returning an empty result.	["2776760", "100-days-of-code"]
reviewSampleSize	No	integer (minimum 0, prefill 10)	How many reviews to collect per course. 0 skips reviews entirely and collects only the curriculum outline. Only reviews with written text are returned.	25
includeCurriculum	No	boolean (default true)	Add the course syllabus: sections, lectures, quizzes, practice tests, coding exercises, durations and free-preview flags.	true
curriculumDetail	No	string, enum: sectionsAndItems (default), sections	sectionsAndItems — one row per lecture/quiz/practice test. sections — one row per course section with its lecture count and total duration.	"sectionsAndItems"
curriculumItemTypes	No	array (select), enum items: lecture, quiz, practice, role_play, coding_exercise	Keep only these curriculum item types. Empty keeps every type. Applies to sectionsAndItems detail only.	["quiz"]
freePreviewOnly	No	boolean (default false)	Keep only curriculum items a course makes publicly previewable.	false
maxCurriculumItemsPerCourse	No	integer (minimum 0, default 0)	Cap curriculum rows produced per course, counted after type and free-preview filters. 0 means no cap.	0
includeContentMetrics	No	boolean (default true)	Add one summary row per course: section/lecture/quiz/practice/coding-exercise counts, hands-on %, free-preview count/%, workspace/lab item counts, total video hours, average lecture length, longest/shortest section, and the gaps between the published syllabus and the course-level counters.	true
attachContentToReviews	No	boolean (default false)	Copy a compact content summary (lecture count, total video hours, hands-on %, free-preview count) onto every review row of that course.	false
includeCaptionLanguages	No	boolean (default false)	Add course language, whether closed captions exist, caption-language count and the full language list.	true
includeSyllabusPromises	No	boolean (default false)	Add what the course claims to teach: learning outcomes, prerequisites, intended audiences and course FAQ question/answer pairs.	false
urls	No	array (stringList)	Legacy alias with the same meaning as courseLinks. Anything placed here is merged with it.	[]
maxItems	No	integer (minimum 0)	Legacy alias with the same meaning as reviewSampleSize. Used only when reviewSampleSize is left empty.	(unset)
proxyConfiguration	No	object (proxy editor, prefill {"useApifyProxy": false})	Optional network routing for the run. Leave default for normal use; enabling it is recommended for large batches or restricted networks.	{"useApifyProxy": true}

JSON input example

{
  "courseLinks": ["https://www.udemy.com/course/100-days-of-code/"],
  "courseIdsOrSlugs": [],
  "reviewSampleSize": 25,
  "includeCurriculum": true,
  "curriculumDetail": "sectionsAndItems",
  "curriculumItemTypes": [],
  "freePreviewOnly": false,
  "maxCurriculumItemsPerCourse": 0,
  "includeContentMetrics": true,
  "attachContentToReviews": false,
  "includeCaptionLanguages": true,
  "includeSyllabusPromises": false,
  "proxyConfiguration": { "useApifyProxy": true }
}

Supported URL types and input formats

Course targets are resolved by split_target() in the source, which accepts three forms and merges courseLinks + urls + courseIdsOrSlugs into one deduplicated target list:

• Full course URL — https://www.udemy.com/course/100-days-of-code/ (a trailing query string is stripped, trailing slash normalized)
• Course slug — 100-days-of-code (resolved to a numeric course ID via Udemy's course-lookup endpoint before scraping)
• Numeric course ID — 2776760 (used directly, no lookup call needed)

---

📦 Output Format

Every run pushes typed JSON rows to the default dataset, distinguished by a type field (review, curriculumItem, curriculumSection or courseContent). When a run ID is available, curriculum rows are additionally mirrored into a dataset named <runId>-curriculum and course-content rows into <runId>-course-content, so you can pull just one row type from the Apify API without a client-side filter on type. Review rows exist only in the default dataset.

Output for a review row (type: "review")

{
  "type": "review",
  "isChild": false,
  "courseUrl": "https://www.udemy.com/course/100-days-of-code/",
  "courseId": "2776760",
  "courseTitle": "100 Days of Code: The Complete Python Pro Bootcamp",
  "class": "course_review",
  "id": 123456789,
  "content": "Great course, the daily project structure kept me consistent.",
  "rating": 5,
  "created": "2025-11-02T14:22:10Z",
  "modified": "2025-11-02T14:22:10Z",
  "user_modified": null,
  "reviewerName": "Alex M.",
  "user": {
    "_class": "user",
    "title": "",
    "name": "Alex",
    "display_name": "Alex M.",
    "image_50x50": "https://img-c.udemycdn.com/user/50x50/12345678.jpg",
    "initials": "AM",
    "tracking_id": "9f2c1e|abcdef123456",
    "public_display_name": "Alex M."
  },
  "created_formatted_with_time_since": "3 months ago",
  "scrapedAt": "2026-08-15T09:12:03Z"
}

If attachContentToReviews is true, every review row also carries lectureCount, totalVideoHours, handsOnItemPct and freePreviewCount merged in from that course's content metrics.

Output for a curriculum item row (type: "curriculumItem", default sectionsAndItems detail)

{
  "type": "curriculumItem",
  "isChild": true,
  "courseId": "2776760",
  "courseUrl": "https://www.udemy.com/course/100-days-of-code/",
  "courseTitle": "100 Days of Code: The Complete Python Pro Bootcamp",
  "sectionIndex": 4,
  "sectionTitle": "Day 12 - 14: The Complete Guide to Functions",
  "sectionLectureCount": 9,
  "sectionDurationSeconds": 5412,
  "itemId": 34567890,
  "itemIndex": 3,
  "itemTitle": "Coding Exercise: Reeborg's World",
  "itemDescription": "Practice function scope with an interactive maze robot.",
  "itemType": "coding_exercise",
  "itemDuration": "12:34",
  "itemDurationSeconds": 754,
  "itemQuestionCount": null,
  "isFreePreview": false,
  "isCodingExercise": true,
  "isPracticeTest": false,
  "hasLinkedWorkspace": true,
  "hasLinkedLab": false,
  "lectureUrl": "https://www.udemy.com/course/100-days-of-code/learn/lecture/34567890",
  "scrapedAt": "2026-08-15T09:12:04Z"
}

With curriculumDetail: "sections", the Actor instead emits one curriculumSection row per section:

{
  "type": "curriculumSection",
  "isChild": true,
  "courseId": "2776760",
  "courseUrl": "https://www.udemy.com/course/100-days-of-code/",
  "courseTitle": "100 Days of Code: The Complete Python Pro Bootcamp",
  "sectionIndex": 4,
  "sectionTitle": "Day 12 - 14: The Complete Guide to Functions",
  "sectionLectureCount": 9,
  "sectionItemCount": 11,
  "sectionDurationSeconds": 5412,
  "sectionDurationText": "1hr 30min",
  "scrapedAt": "2026-08-15T09:12:04Z"
}

Output for a course-content metrics row (type: "courseContent")

{
  "type": "courseContent",
  "isChild": false,
  "courseId": "2776760",
  "courseUrl": "https://www.udemy.com/course/100-days-of-code/",
  "courseTitle": "100 Days of Code: The Complete Python Pro Bootcamp",
  "sectionCount": 44,
  "curriculumItemCount": 425,
  "lectureCount": 310,
  "quizCount": 24,
  "practiceCount": 12,
  "roleplayCount": 0,
  "otherItemCount": 79,
  "itemTypeCounts": { "lecture": 310, "quiz": 24, "practice": 12, "coding_exercise": 79 },
  "codingExerciseCount": 79,
  "handsOnItemPct": 26.59,
  "freePreviewCount": 46,
  "freePreviewPct": 10.82,
  "workspaceItemCount": 79,
  "labItemCount": 0,
  "totalVideoSeconds": 224640,
  "totalVideoHours": 62.4,
  "avgLectureSeconds": 724,
  "longestSectionTitle": "Day 33 - 35: Higher/Lower Game",
  "longestSectionSeconds": 6120,
  "shortestSectionTitle": "Day 0: Welcome",
  "shortestSectionSeconds": 180,
  "isPracticeTestCourse": false,
  "publicSyllabusLectureCount": 312,
  "apiLectureCount": 310,
  "syllabusCoverageDelta": 2,
  "sectionDurationSumSeconds": 224640,
  "estimatedContentLengthSeconds": 224700,
  "sectionDurationSumDelta": -60,
  "estimatedContentLengthText": "62.5 total hours",
  "itemDurationSumSeconds": 224580,
  "itemDurationSumDelta": 60,
  "courseLocale": "en_US",
  "courseLanguage": "English",
  "hasClosedCaption": true,
  "captionLanguages": ["English", "Spanish", "Portuguese"],
  "captionLanguageCount": 3,
  "whatYouWillLearn": ["Build 100 real Python projects", "Understand core data structures"],
  "courseRequirements": ["A computer with internet access"],
  "targetAudiences": ["Beginners with no coding experience"],
  "courseFaq": [{ "question": "Do I need prior experience?", "answer": "No, this course starts from zero." }],
  "scrapedAt": "2026-08-15T09:12:05Z",
  "curriculumRowsEmitted": 425
}

courseLocale through captionLanguageCount appear only with includeCaptionLanguages: true; whatYouWillLearn through courseFaq appear only with includeSyllabusPromises: true.

Schema stability and export options

Field names stay stable across runs — they come from Actor code, not from Udemy's front-end markup, so a Udemy page redesign does not change your column names. Every dataset supports Apify's standard export formats (JSON, CSV, Excel, XML, RSS) directly from the Console or via the API, and results are retrievable through apify_client in Python or Node.js, or the Apify API HTTP endpoints.

---

💡 Udemy Course Scraper Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

Trigger the Actor from your backend when a new course ID enters your system (a partner feed, an affiliate import, a manual add). Run with courseIdsOrSlugs set to that one ID, reviewSampleSize: 0 if you only need curriculum, and read lectureCount, totalVideoHours and handsOnItemPct off the resulting courseContent row to write back into your catalog database as enrichment fields — no separate lookup call needed.

🎯 Strategy 2: Scheduled monitoring and alerting

Set up an Apify schedule that re-runs the Actor weekly against a fixed course list with includeContentMetrics: true. Diff the new courseContent row against last week's on sectionCount, lectureCount and totalVideoHours — a jump signals the instructor restructured the course. Diff freePreviewCount separately to catch changes in how much content a competitor gives away for free.

🎯 Strategy 3: Bulk dataset build

Feed a large courseLinks or courseIdsOrSlugs list in a single run; the Actor processes courses concurrently, sharing a pool of 5 concurrent HTTP connections across all requested courses (a fixed property of the source, not user-configurable). Export the resulting dataset directly to CSV or JSON from the Console, or pull it with apify_client into a database for a research corpus.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Adding course metadata to an existing catalog record	Single-course, on-demand run	JSON row → written back to your system
Scheduled monitoring	Tracking curriculum or free-preview changes over time	Apify-scheduled recurring run, diffed against the last run	JSON, diffed on named fields
Bulk dataset build	Research corpora, competitor catalog snapshots	One run, large course list, concurrent processing	Dataset export (JSON/CSV/Excel)

---

🌴 Related Udemy Scrapers & Tools

Cross-platform review scrapers and adjacent content tools available on Scrapio:

Scraper Name	What it extracts
Walmart Reviews Scraper: Photos & Text Review Filtering	Product reviews with photo and text filtering — same review-row pattern, different marketplace
Airbnb Review Scraper: Category Ratings & Host Replies	Listing reviews with per-category ratings and host reply text
Facebook Reviews Scraper With Date & Keyword Filters	Page reviews filterable by date and keyword
Goodreads Book Scraper With Full Book Details	Book catalog and review data for a different content-education vertical
YouTube Video Subtitles Scraper: Caption Coverage Insights Data	Video caption/subtitle coverage — complements curriculum data when courses embed YouTube content
YouTube Video Summarizer & Most-Replayed Highlights	Video-level summaries, useful alongside curriculum lecture titles for content research
Google Scholar Scraper: Citation Network & Trends	Academic citation data, for researchers pairing MOOC data with scholarly output

---

How to integrate Udemy Course Scraper with your stack

Udemy Course Scraper works with any language or tool that can make an HTTP request — it's a standard Apify Actor, run through the Apify Console, the Apify API, or an official client library.

Python

from apify_client import ApifyClient
import csv

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run_input = {
    "courseLinks": [
        "https://www.udemy.com/course/100-days-of-code/",
        "https://www.udemy.com/course/the-complete-javascript-course/",
    ],
    "reviewSampleSize": 25,
    "includeCurriculum": True,
    "curriculumDetail": "sectionsAndItems",
    "includeContentMetrics": True,
}

run = client.actor("your-username/udemy-course-reviews-scraper-syllabus-lectures-quizzes").call(
    run_input=run_input
)

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())

with open("udemy_output.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=sorted({k for row in rows for k in row}))
    writer.writeheader()
    writer.writerows(rows)

print(f"Collected {len(rows)} rows across {len(run_input['courseLinks'])} course(s)")

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_API_TOKEN>' });

const input = {
    courseLinks: ['https://www.udemy.com/course/100-days-of-code/'],
    reviewSampleSize: 25,
    includeCurriculum: true,
    includeContentMetrics: true,
};

const run = await client.actor('your-username/udemy-course-reviews-scraper-syllabus-lectures-quizzes').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(`Collected ${items.length} rows`);

Async and scheduled pipelines

For large course lists, start the run and poll for completion instead of waiting synchronously — client.actor(...).start(run_input=...) returns immediately, and you check client.run(run_id).get()["status"] on your own interval. For recurring jobs, use an Apify schedule (Console → Schedules, or the Schedules API) to re-run the Actor on a cron expression without any code running on your side between runs.

---

🎯 Who Needs Udemy Course Scraper? (Use Cases & Industries)

🏢 Course creators and instructor-support teams

An instructor tracking their own course's rating and content fields alongside sectionTitle and itemDuration can see exactly which section of the curriculum a critical review is referring to, without manually cross-referencing the course page.

📊 AI / ed-tech product teams

Course-recommendation and support bots index itemTitle, itemDescription and whatYouWillLearn to answer "what will I learn in this course" from real syllabus text rather than a marketing blurb, with rating and content as a labeled sentiment signal per course.

📱 Ed-tech competitive intelligence

Bootcamp and course-marketplace teams track freePreviewCount, totalVideoHours and handsOnItemPct across competitor courses to benchmark how much value competitors give away for free versus behind a paywall.

🔬 Researchers

Online-learning and MOOC researchers use the courseContent row (section count, hands-on percentage, video-hour totals) alongside review rating/content to study how curriculum structure correlates with student sentiment across a course corpus — all from data Udemy already publishes on its public course pages.

🎥 Product and SaaS builders

Course-comparison directories and LMS integration tools consume the courseContent row directly as a pre-normalized per-course summary object, avoiding the need to recompute lecture counts or hands-on ratios from raw curriculum data.

---

Is it legal to scrape Udemy?

Scraping publicly accessible web pages is generally lawful in the United States — in hiQ Labs, Inc. v. LinkedIn Corp. (9th U.S. Circuit Court of Appeals, 2019), the court held that scraping data that is not behind a login does not violate the Computer Fraud and Abuse Act. That precedent addresses only unauthorized-access claims, not a website's own terms of service. Separately, violating a platform's Terms of Service is a matter of civil contract risk, not a criminal one, and Udemy's terms govern what you may do with data collected from its site. This Actor's review rows include personal data about reviewers — display names, initials and an avatar URL — so if you store or process that data, data protection obligations such as GDPR (EU) or CCPA (California) may attach depending on your jurisdiction and use case; the curriculum and course-content rows describe published course structure, not individuals, and carry no such obligation.

Udemy Course Scraper returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data.

---

❓ Frequently asked questions

Does Udemy Course Scraper work without a Udemy account?

No account, login or API key is required. The Actor calls Udemy's public course, curriculum and review endpoints with an unauthenticated request (x-udemy-cache-logged-in: 0 in the request headers).

How does Udemy Course Scraper handle Udemy's anti-scraping measures?

Requests start with a direct connection. On a 401, 403, 429 or 503 response the Actor escalates to an Apify Proxy datacenter tier, and then a residential tier, with a fresh session per retry attempt and a randomized delay between requests. Each review page is retried up to 3 times before that course is marked incomplete rather than silently skipped.

Can I run Udemy Course Scraper at scale without getting blocked?

The Actor processes requested courses concurrently, sharing a pool of 5 concurrent HTTP connections, and automatically escalates its network route on repeated blocking rather than failing immediately. No uptime or success-rate figure is published for this behavior — it depends on Udemy's own rate limiting at the time of your run.

How fresh is the data Udemy Course Scraper returns?

Every run fetches live from Udemy's course, curriculum and review endpoints — nothing is cached or reused between runs. Every row carries a scrapedAt timestamp recording exactly when it was collected.

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

For RAG, index content (review text) and itemTitle / itemDescription (curriculum text) — these carry the free-form natural language. If includeSyllabusPromises is enabled, whatYouWillLearn and courseFaq add structured syllabus-level text. For training data, rating paired with content gives a consistently structured labeled pair across every course in the run. All fields return as typed JSON primitives — no HTML parsing or normalization needed before passing them into a model context window.

Does Udemy Course Scraper collect personal data, and what are my obligations?

Yes — review rows include reviewerName and a nested user object with display_name, initials, image_50x50 and tracking_id, all publicly displayed by Udemy alongside the review itself. The Actor returns only what Udemy already makes publicly visible; the lawful basis for storing and using that data in your own systems sits with you as the data controller.

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

No MCP server integration is documented for this Actor. It is callable as a standard HTTP endpoint through the Apify API from any agent framework, and every row it returns is typed JSON — no parsing step is needed before passing a result into an LLM's context window.

Do curriculum filters change the numbers in the course-content metrics row?

No. curriculumItemTypes, freePreviewOnly and maxCurriculumItemsPerCourse only filter which curriculumItem rows get pushed — the courseContent metrics row is always computed from the course's full published syllabus, independent of those filters, so it stays a true whole-course summary even when your curriculum row export is narrowed.

What happens if a course link or ID doesn't resolve to a real course?

It's reported as not found in the run log and run statistics rather than returning an empty or silently missing result, and the run continues processing the remaining courses. If every requested course fails to resolve or return data, the run itself fails with a status message stating how many courses were requested, not found, and incomplete.

What counts as a billable row?

Every row pushed to the dataset — review, curriculum item, curriculum section, or course-content metrics — charges one row_result event. There is no separate free or uncharged accounting row. Because sectionsAndItems detail can emit hundreds of curriculum rows for a large course, your curriculumDetail, item-type and free-preview settings directly control how many billable rows a run produces.

---

ℹ️ Disclaimer

Udemy Course Scraper extracts only publicly available data from Udemy. This tool is intended for lawful use cases only. Users are responsible for complying with Udemy's terms of service and applicable data protection laws in their jurisdiction.