OpenAlex API

Research & science · v1.1.0 · openalex

$0.0004 / work

$0.40 / 1K · pay per delivered work

An OpenAlex API searches the open index of research papers and returns one row per work: the title, the authors, the year, the citation count, the DOI, the type, the host venue and the open-access status and URL. It is keyless, which is what makes it the practical alternative to Google Scholar — Scholar blocks automated access, while OpenAlex is built to be queried.

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

Run in dashboard See the request

$0.0004 per delivered work · $2 free every month · Failed runs never billed

What it does

What an OpenAlex API does

OpenAlex does not ship the abstract as text — it stores it as an inverted index, a map of each word to the positions it occupies in the paragraph. This reconstructs the original abstract from that index and returns it as a plain string, so the text you would search or embed sits on the row instead of a position map you rebuild yourself.

Every work carries its citation count and DOI, the two fields a literature dataset is usually sorted and joined on. Keep the DOI as the stable key that links a paper across your own tables and any other bibliographic source, order a field by influence with the citation count, and trim to recent work with a single year filter.

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	Search terms across title, abstract and metadata.
`year_from`	integer	no	Only works published this year or later.
`year_to`	integer	no	Only works published up to this year.
`open_access`	boolean	no	Only works with a free full text.
`sort`	string	no	relevance (default), cited (most cited first) or newest. One of: `relevance`, `cited`, `newest`.
`max_results`	integer	no	How many works to deliver at most (1–200). You pay only for delivered works.

Outputs — 32 fields, one row per work

What one work looks like

Every delivered work 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.
`id`	string	OpenAlex work id.
`title`	string	Paper title.
`authors`	string[]	Author names.
`year`	integer · nullable	Publication year.
`cited_by_count`	integer · nullable	Citation count.
`doi`	string · nullable	DOI.
`type`	string · nullable	Work type (article, review…).
`venue`	string · nullable	Host venue/journal.
`is_open_access`	boolean	Open-access flag.
`oa_url`	string · nullable	Open-access PDF/landing URL.
`abstract`	string · nullable	Abstract (reconstructed).
`url`	string	OpenAlex work URL.
`author_count`	integer	Number of authors.
`institutions`	string[]	Author institutions (up to 10).
`countries`	string[]	Author countries (ISO codes).
`publication_date`	string · nullable	Publication date (YYYY-MM-DD).
`language`	string · nullable	Language code.
`fwci`	number · nullable	Field-weighted citation impact (1.0 = field average).
`referenced_works_count`	integer · nullable	Number of works cited.
`venue_type`	string · nullable	Venue type (journal, repository, conference…).
`issn`	string · nullable	Linking ISSN of the venue.
`volume`	string · nullable	Volume.
`issue`	string · nullable	Issue.
`pages`	string · nullable	Page range.
`oa_status`	string · nullable	Open-access status (gold, green, hybrid, bronze, closed).
`pdf_url`	string · nullable	Direct PDF link, when one is open.
`license`	string · nullable	License of the open copy.
`topic`	string · nullable	Primary topic.
`field`	string · nullable	Field of the primary topic.
`keywords`	string[]	Keywords (up to 10).
`is_retracted`	boolean	Whether the work was retracted.

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/openalex/run.

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

import requests

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

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/openalex/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"query":"large language models","max_results":25}),
  },
);
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 openalex collector with query="large language models" and max_results=25

Example response

POST /v1/scraper/collectors/openalex/run

$ curl $QD/openalex/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"query": "large language models", "max_results": 25}'
{ "status": "done", "count": 25,
  "results": [
    {
      "id": "…",
      "title": "…",
      "authors": […],
      "year": … } ],
  "cost": 0.01 }
# 25 works × $0.0004 · nothing delivered, nothing charged

Try it

Academic papers (OpenAlex), 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

OpenAlex API: from query, QuanticData reads the OpenAlex works and returns one row per work with title, year and cited_by_count, at $0.0004 per delivered work. — You send query and year_from; the run reads the source and comes back as works with rank, id and title — 32 fields on every row — and you are billed $0.0004 for each work actually delivered, nothing for a run that delivers none.

$0.0004 / work5,000 works on the free $2 every month

Semantic inputquery, year_from, max_results — no URL lists

Up to 200works per run, pagination handled for you

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

Pricing

OpenAlex API pricing

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

$0.0004per delivered work$0.4 per 1,000 delivered works

5,000 workson 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.

What people build with the OpenAlex API

Three shapes of work this endpoint was designed around.

Literature datasets

Run a topic query and get a ranked table of works with citation counts and abstracts — the corpus a review or a model needs, without scraping a results page.

Citation-weighted ranking

The cited_by_count on each row orders a field by influence, surfacing the papers a topic is actually built on rather than merely the newest ones.

Grounding an agent

Hand a model the reconstructed abstract, the authors and the DOI as separate fields, instead of a PDF to open or a Scholar page it cannot reach.

OpenAlex API versus rolling your own

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

	DIY scraper	This collector
Access	Google Scholar blocks automated queries	Keyless, and built to be queried
Abstract	An inverted index of word positions	The abstract rebuilt as plain readable text
Recency	Post-filter the entire result set	year_from trims to recent work at the source

What people search for

Live autocomplete demand around Academic papers (OpenAlex), pulled with our own Keyword ideas collector.

OpenAlex API: the POST to the openalex collector, 25 works delivered and the bill, 25 × $0.0004 = $0.01 in usage.cost_usd; zero works would cost $0. — The same call you would paste into a terminal: a Bearer key, query and year_from in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many works arrived and usage.cost_usd is $0.01, which is 25 × $0.0004. 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 OpenAlex API.

Something else? Ask us

Is this a Google Scholar API?

It is the practical substitute for one. Google Scholar has no public API and blocks automated access; OpenAlex indexes the same kind of scholarly works and is designed to be queried, so this returns Scholar-style results as rows.

Why does OpenAlex not just return the abstract?

OpenAlex stores abstracts as an inverted index — a map from each word to its positions — rather than as running text. This rebuilds the paragraph from that index and returns it in the abstract field, so you get readable text without reconstructing it.

Can I restrict results to recent papers?

Yes — set year_from and only works published that year or later are returned, so a query for an active field is not diluted by decades of older results.

Is there a free OpenAlex API?

Every account gets $2 of credit every month with no card, which is about 5,000 delivered works on this endpoint at $0.0004 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.0004. A run capped at 200 works — the maximum for this collector — costs $0.08 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 OpenAlex API now

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

Run in dashboard

Illustration: three coloured zones of the page that is read (OpenAlex works) turn into clean JSON with the fields title, year and cited_by_count; 32 fields on every row.