OpenAlex API

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.

Get my free API key See the request

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

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

$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

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.

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.

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.
`max_results`	integer	no	How many works to deliver at most (1–200). You pay only for delivered works.

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.

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 quantumproxies \
  -e QUANTUMPROXIES_API_KEY=qd_live_your_key_here \
  -- npx -y quantumproxies-mcp

# then, in the chat:
> run the openalex collector with query="large language models" and max_results=25

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

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.

Get my free API key