# OpenAlex API — $0.0004 per work

> OpenAlex API: Scholarly works from OpenAlex — title, authors, year, citations, DOI. $0.0004 per delivered work, nothing delivered means nothing charged.

[Home](https://quanticdata.io/)/[Collectors](https://quanticdata.io/collectors/)/*OpenAlex API*

# 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](https://app.quanticdata.io/register) [See the request](/collectors/academic-paper-api/#integration)

$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 / work**5,000 works on the free $2 every month

**Semantic input**query, year_from, max_results — no URL lists

**Up to 200**works per run, pagination handled for you

**No browser**read over HTTP/TLS — cheaper and faster than rendering

On this page: [What it is](/collectors/academic-paper-api/#what) [Output fields](/collectors/academic-paper-api/#output) [Inputs](/collectors/academic-paper-api/#input) [Pricing](/collectors/academic-paper-api/#pricing) [Integration](/collectors/academic-paper-api/#integration) [Use cases](/collectors/academic-paper-api/#use-cases) [Versus the alternatives](/collectors/academic-paper-api/#compare) [FAQ](/collectors/academic-paper-api/#faq)

## 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.

Input is meaning, not a URL *query* *year_from* *max_results*

## 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.0004**per delivered work*$0.4 per 1,000 delivered works*

**5,000 works**on the free allowance*$2 every month, no card*

**Zero rows**zero charge*blocks, captchas and retries are on us*

**−30%**on volume tiers*the 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

Most popular

### 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](https://quanticdata.io/web-data-api-for-ai/). 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 →](mailto:hello@quanticdata.io)

### 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](https://app.quanticdata.io/register)

Related: [All 65 collectors](https://quanticdata.io/collectors/) [Wikipedia API](https://quanticdata.io/collectors/wikipedia-api/) [Wikidata API](https://quanticdata.io/collectors/wikidata-api/) [Clinical trials API](https://quanticdata.io/collectors/clinical-trials-api/) [Documentation](https://quanticdata.io/docs/)

---

Source: https://quanticdata.io/collectors/academic-paper-api/ · Site index for AI: https://quanticdata.io/llms.txt