Coursera Scraper API

A Coursera scraper API that searches the catalog for a keyword and returns one flat row per result: title, the partner or university offering it, rating, the exact review count, difficulty level, duration, product type — course, specialization, professional certificate, degree — the skills it teaches, a paid-placement flag, URL and image. Filter by level and product type.

By Aldo Morese, founder of QuanticData · Published Aug 21, 2026 · Updated Sep 3, 2026

Get my free API key See the request

$0.001 per delivered result · $2 free every month · Failed runs never billed

POST /v1/scraper/collectors/coursera_courses/run

$ curl $QD/coursera_courses/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"query": "python", "max_results": 12}'
{ "status": "done", "count": 12,
  "results": [
    {
      "id": "…",
      "title": "…",
      "partner": "…",
      "partners": […] } ],
  "cost": 0.012 }
# 12 results × $0.001 · nothing delivered, nothing charged

Coursera Scraper API: query and level in, a residential exit in the middle, delivered rows with rank, id and title on the right, $0.001 per result. — You send query and level; the run goes out through a residential exit and comes back as results with rank, id and title — 17 fields on every row — and you are billed $0.001 for each result actually delivered, nothing for a run that delivers none.

$0.001 / result2,000 results on the free $2 every month

Semantic inputquery, level, product_type — no URL lists

Up to 60results per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

Try it

Coursera course search, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

What a Coursera scraper API does

Coursera server-renders its search page with the Apollo cache inline, and the search response sits in that cache with every field this collector reports — name, partners, the average rating, the exact number of ratings, level, duration, product type, skills and the sponsored flag — plus the real result total. That is what is read, on a plain fetch, with no browser anywhere.

The DOM is not used, for two reasons, and the second is the dangerous one. The card packs rating, level and duration into one run-on string with segments simply missing when a product has no rating, and it rounds review counts to “44K” where the cache states 43,784. Worse, a search that matches nothing still renders a dozen product cards, because the zero-result page falls back to recommendation carousels — a DOM collector would report twelve unrelated products as results for a query that has none. The cache states the truth: an empty list. Coursera’s own search API is a GraphQL POST, which this tier does not make; the embedded cache is the same payload.

Limits, in plain numbers

Everything that bounds one run of this collector. No hidden throttles.

Max per run

60 results

Price

$0.001 / result

Per 1,000

$1.00

Failed runs

Free zero rows, zero charge

Free every month

$2 no card

Rate limit

60 req/min on the free tier

What one result looks like

Every delivered result carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`rank`	integer	1-based position in the delivered set, in Coursera's own result order.
`id`	string · nullable	Coursera's typed product id, e.g. "course~ejOz7RDUEei99hK0xs-tsg" or "s12n~F-h1g0w7EeWeOApO_l5R1w" — the stable de-duplication key.
`title`	string · nullable	Course, specialization or degree title.
`partner`	string · nullable	First listed partner — the university or company offering it.
`partners`	string[]	Every listed partner, in Coursera's order (co-branded programmes carry more than one).
`rating`	number · nullable	Average rating out of 5, to 2 decimals. Null on products Coursera has never rated, such as degrees.
`reviews`	integer · nullable	Exact number of ratings the average is based on — the site's cards round this to "44K".
`level`	string · nullable	Difficulty as the card states it: Beginner, Intermediate, Advanced or Mixed. Null on degrees, which state none.
`duration`	string · nullable	Time commitment as the card states it, e.g. "1 - 3 Months", "Less Than 2 Hours", "1 - 4 Years".
`product_type`	string · nullable	What kind of product this is: Course, Specialization, Professional Certificate, Guided Project, Project or Degree.
`url`	string · nullable	Absolute URL of the product page.
`image`	string · nullable	Course artwork URL.
`skills`	string[]	Skills Coursera lists for this product.
`sponsored`	boolean	True when Coursera marks the row as a paid placement. These are mixed into the ranked list, so a sponsored row's rank is a bought slot, not a relevance position.
`is_free`	boolean	True when Coursera marks the course itself as free.
`in_coursera_plus`	boolean	True when the product is included in a Coursera Plus subscription.
`is_new`	boolean	True when Coursera flags the product as new content.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`query`	string	yes	What to search Coursera for — a topic, technology or skill.
`level`	string	no	Restrict to one difficulty level. Coursera's own filter values. One of: `Beginner`, `Intermediate`, `Advanced`, `Mixed`.
`product_type`	string	no	Restrict to one kind of product. Coursera's own filter values — use "Courses" to exclude degrees and certificates. One of: `Courses`, `Specializations`, `Guided Projects`, `Professional Certificates`, `Projects`, `Degrees`.
`country`	string	no	ISO 3166-1 alpha-2 code for the proxy exit (default us).
`max_results`	integer	no	How many results to deliver at most (1–60). You pay only for delivered results.

Pricing

Coursera Scraper API pricing

$0.001 per delivered result. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 2,000 results before you spend anything.

$0.001per delivered result$1 per 1,000 delivered results

2,000 resultson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/coursera_courses/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/coursera_courses/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"python","max_results":12}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/coursera_courses/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "query": "python",
        "max_results": 12
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/coursera_courses/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"query":"python","max_results":12}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the coursera_courses collector with query="python" and max_results=12

What people build with the Coursera scraper API

Three shapes of work this endpoint was designed around.

Course-market research

What a keyword returns across partners, with level, duration and product type, to size an audience or spot a gap.

Partner benchmarking

Ratings and exact review counts by university or company across a topic.

Catalog monitoring

Re-run a keyword and diff by id: new courses, new certificates, changed ratings.

Coursera Scraper API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Review counts	“44K” from the card	43,784 from the cache
Empty searches	Twelve recommendation cards delivered as results	An empty list, as the cache states
Fields	One run-on string per card	Typed fields: level, duration, type, skills
Placements	Unmarked	`sponsored` per row

What people search for

Live autocomplete demand around Coursera course search, pulled with our own Keyword ideas collector.

Coursera Scraper API: the POST to /v1/scraper/collectors/coursera_courses/run with query and level on the left, and the JSON envelope on the right with 12 results and usage.cost_usd $0.012. — The same call you would paste into a terminal: a Bearer key, query, level and product_type in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many results arrived and usage.cost_usd is $0.012, which is 12 × $0.001. A run that delivers nothing costs nothing. The key is good for 60 req/min on the free tier.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the Coursera scraper API.

Something else? Ask us →

Does Coursera have a public catalog API?

Coursera exposes catalog APIs to partners under agreement. This collector reads the public search page and its embedded cache, which is the same search response, with no key.

Can I filter by level or type?

Yes: level (Beginner, Intermediate, Advanced, Mixed) and product_type (Courses, Specializations, Guided Projects, Professional Certificates, Projects, Degrees) are passed to Coursera’s own search.

Why does a very specific query return zero rows?

Because it matched nothing. The page would show recommendation cards in that case; the collector reports the empty result rather than delivering unrelated products.

Are prices included?

Coursera’s search does not state prices; the row carries is_free and in_coursera_plus, which the cache does state.

Is there a free Coursera scraper API?

Every account gets $2 of credit every month with no card, which is about 2,000 delivered results on this endpoint at $0.001 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.001. A run capped at 60 results — the maximum for this collector — costs $0.06 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Run the Coursera scraper API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Get my free API key