# OpenAlex Scraper & Academic Papers API: DOIs, Citations (`stazis/openalex-works-api`) Actor

Scholarly papers from OpenAlex by keyword or bulk DOI list: title, DOI, year, venue, citations, open-access link, authors, institutions, topics and abstract. Simple year, citation, type and open-access filters. CC0 data.

- **URL**: https://apify.com/stazis/openalex-works-api.md
- **Developed by:** [Stanislav](https://apify.com/stazis) (community)
- **Categories:** Education, AI, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 work results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## OpenAlex Scraper & Academic Paper API: Bulk DOI, Citations

Search **OpenAlex**, the open index of scholarly papers, by keyword with simple **year, citation, type and open-access filters**, or **look up a list of DOIs** in bulk. Every row has title, DOI, year, venue, citation count, open-access link, authors, institutions, topics and abstract.

- **Who it's for:** researchers and librarians, literature reviews and meta-analyses, R\&D and patent teams, bibliometrics, AI/RAG dataset builders.
- **Source:** the official OpenAlex API (CC0 open data). No scraping, no login; an OpenAlex API key is optional.
- **Bulk DOIs:** paste DOIs in any form; 50 per API call; DOIs not in OpenAlex are listed in the status and not charged.
- **Output:** JSON, CSV or Excel; pay per paper returned (see the Pricing tab).

### Quick start (one click)

Open the Actor and press **Start**: the form is prefilled with this input.

```json
{
  "query": "large language models",
  "filter": "publication_year:2025,is_oa:true",
  "maxResults": 50
}
```

Sample output (one row, more fields in the dataset):

| id | doi | title | publicationYear | venue |
|---|---|---|---|---|
| https://openalex.org/W... | https://doi.org/10.... | A Comprehensive Overview of Large Language Models | 2025 | arXiv |

### Use cases

**Literature review starter.** Most-cited papers on a topic since 2020.

```json
{"query": "retrieval augmented generation", "yearFrom": 2020, "sort": "cited_by_count:desc", "maxResults": 200}
```

**Bulk DOI enrichment.** Citations, venue, authors and open-access link for a DOI list.

```json
{"dois": ["10.1038/nature14539", "10.48550/arXiv.1706.03762"]}
```

**Open-access corpus for RAG.** Open-access papers with abstracts, for an LLM corpus.

```json
{"query": "battery recycling", "openAccessOnly": true, "maxResults": 1000}
```

**Research-group leads.** Recent papers on a topic, to find active institutions and authors.

```json
{"query": "protein design", "yearFrom": 2025, "type": "article", "maxResults": 300}
```

### How it compares

Checked against the most-used academic paper search actors in the Apify Store (their Store pages, input forms, reviews and Issues tabs, 23 Oct 2026). Alternatives are described generically; every claim about them is visible on their public pages.

| | This actor | Common in the alternatives |
|---|---|---|
| Source | OpenAlex, the open scholarly index (CC0 data), via its official API | Several alternatives scrape a search engine's result pages instead |
| Simple filters | `yearFrom`, `yearTo`, `minCitations`, `type`, `openAccessOnly` as form fields; raw OpenAlex filter still available | The OpenAlex-based alternative has similar fields; scrapers usually offer only year range |
| Bulk DOI lookup | Paste up to thousands of DOIs (bare or `https://doi.org/...`); 50 per API call; DOIs not found are listed in the status and not charged | Rare |
| Cost predictability | $0.50 per 1,000 works + $0.005 per run; you can cap spend with "Max charge per run" | A review of one alternative: "this one costed me more than 4 euros" vs 0.3 euro elsewhere for the same task |
| Output | Title, DOI, year, type, citations, open-access URL, venue, authors, institutions, topics, abstract (rebuilt from OpenAlex's inverted index) | Search-result snippets on scrapers |
| Not included | Author email addresses (not in OpenAlex) | Requested in an issue on one alternative, also not supported there |

#### Ready-to-copy inputs

Open-access papers on a topic, 2024 or later, cited at least 20 times:

```json
{"query": "retrieval augmented generation", "yearFrom": 2024, "minCitations": 20, "openAccessOnly": true, "maxResults": 200}
```

Metadata for a list of DOIs:

```json
{"dois": ["10.1038/nature14539", "https://doi.org/10.1145/3065386"]}
```

### Features and details of this OpenAlex API

Search **250M+ scholarly works** from [OpenAlex](https://openalex.org), the open (CC0) successor of Microsoft Academic Graph. One clean JSON row per paper. No scraping, no login, no proxies.

#### What you get per work

| field | example |
|---|---|
| id, doi | `https://openalex.org/W...`, `https://doi.org/10....` |
| title, type, language | `A Comprehensive Overview of Large Language Models`, `article`, `en` |
| publicationYear, publicationDate | `2025`, `2025-03-01` |
| venue, publisher | journal / conference / repository name |
| isOpenAccess, oaUrl, landingPageUrl | free full-text link when available |
| citedByCount | `412` |
| authors, institutions | names only (published bibliographic metadata, no emails) |
| topics | top 3 OpenAlex topics |
| abstract | reconstructed plain text |

#### API key (optional, free)

Without a key the actor uses OpenAlex's keyless access, which shares one small daily budget and allows at most 10,000 results. For bigger or repeated pulls, create a **free** key at openalex.org (Settings → API key, ~30 s) and paste it into **OpenAlex API key**. It is stored as an Apify secret input and only sent to api.openalex.org; usage counts against your own OpenAlex account. If OpenAlex answers **429** and no key is set, the run stops with a clear message telling you to add one (you are only charged for results actually returned).

#### Data licence

OpenAlex data is CC0. Please cite OpenAlex (Priem et al., 2022) in published work.

#### Pricing

Pay per result: one charge per work returned, plus a small per-run start fee. Cap spend with "Max charge per run".

### How to use the OpenAlex API

1. Open the Actor, fill in the input form (or paste the JSON below).
2. Click **Start**. Results land in the dataset as JSON, CSV, Excel or via the Apify API.
3. For alerts or regular refreshes, add an Apify **Schedule**. You can cap spend with "Max charge per run".

### Input example

```json
{
  "query": "large language models",
  "filter": "publication_year:2025,is_oa:true",
  "sort": "cited_by_count:desc",
  "maxResults": 500
}
```

### Output example

```json
{
  "id": "https://openalex.org/W...",
  "doi": "https://doi.org/10....",
  "title": "A Comprehensive Overview of Large Language Models",
  "publicationYear": 2025,
  "venue": "arXiv",
  "isOpenAccess": true,
  "oaUrl": "https://arxiv.org/pdf/...",
  "citedByCount": 412,
  "authors": [
    "..."
  ],
  "topics": [
    "Natural Language Processing"
  ],
  "abstract": "..."
}
```

Values above are illustrative; field names match the dataset schema.

### FAQ

#### Do I need an OpenAlex API key?

No for small runs. Keyless access shares a small daily budget and stops at 10,000 results; a free key from openalex.org removes that bottleneck.

#### Is this a Google Scholar scraper?

No. It uses OpenAlex's official open API, not Google Scholar, so coverage and citation counts can differ from Scholar.

#### Can I use the data commercially?

OpenAlex data is CC0. Please cite OpenAlex (Priem et al., 2022) in published work.

#### How much does it cost?

$0.50 per 1,000 papers plus $0.005 per run.

#### Are there limits I should know about?

Yes. Results are only as complete and current as the official source. If a source is down, the run logs the error instead of returning made-up data. Report problems in the Issues tab.

### Use it from code, AI agents and automations

The same input as the form above works everywhere. Results are the run's dataset (JSON, CSV, Excel). You need an Apify API token (Console → Settings → API & Integrations).

**Python** (`pip install apify-client`)

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("stazis/openalex-works-api").call(run_input={
  "query": "large language models",
  "filter": "publication_year:2025,is_oa:True",
  "maxResults": 50
})
for item in client.dataset(run.default_dataset_id).iterate_items():  # apify-client < 3: run["defaultDatasetId"]
    print(item)
```

**JavaScript / TypeScript** (`npm i apify-client`)

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('stazis/openalex-works-api').call({
  "query": "large language models",
  "filter": "publication_year:2025,is_oa:true",
  "maxResults": 50
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**HTTP, one call** (waits for the run, up to 5 minutes, and returns the items)

```bash
curl -X POST "https://api.apify.com/v2/acts/stazis~openalex-works-api/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"query": "large language models", "filter": "publication_year:2025,is_oa:true", "maxResults": 50}'
```

**AI agents (MCP).** This Actor runs with limited permissions, so AI agents can use it through the hosted Apify MCP server (Claude, Cursor, VS Code, Codex and other MCP clients). Add this to your MCP client config and sign in with Apify on first use:

```json
{ "mcpServers": { "openalex-works-api": { "url": "https://mcp.apify.com?tools=stazis/openalex-works-api" } } }
```

Agents without an Apify account can pay per run in USDC through [agi.apify.com](https://agi.apify.com) (x402). Pricing is pay-per-event, so an agent pays only for the results it gets.

**LangChain** (`pip install langchain-apify`, set `APIFY_TOKEN`): `from langchain_apify import ApifyActorsTool` and `tool = ApifyActorsTool("stazis/openalex-works-api")` gives your agent this Actor as a tool.

**No-code and scheduling:** use the Apify app in Make, n8n or Zapier ("Run an Actor", then pick `stazis/openalex-works-api`), or create a Schedule in Apify Console to run it daily and send results to a webhook, Slack or Google Drive through Apify integrations.

### Other data APIs by stazis

- [Greenhouse, Lever & Ashby Jobs Scraper API](https://apify.com/stazis/ats-jobs-api): Scrape job postings from company career sites via official Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Recruitee job-board APIs.
- [UK Companies House Search API: Bulk Company Data](https://apify.com/stazis/companies-house-api): Search all ~5.
- [Grants.gov & SAM.gov API: US Federal Grants and Contracts](https://apify.com/stazis/gov-opportunities-api): Get US federal grant opportunities from Grants.
- [SEC EDGAR Filings Scraper API: 8-K, 10-K, Full-Text Search](https://apify.com/stazis/sec-edgar-filings-api): Search SEC EDGAR filings by full text, form type (8-K, 10-K, 10-Q, S-1, Form D), date and state, or list recent filings for any ticker or CIK.
- [Bulk WHOIS & RDAP Domain Lookup API: Expiry, DNS](https://apify.com/stazis/domain-rdap-api): Bulk domain lookup via official RDAP (the WHOIS successor) plus live DNS: registrar, status, created/updated/expiry dates, nameservers, DNSSEC, A/AAAA/MX/NS/TXT records.

# Actor input Schema

## `query` (type: `string`):

Full-text search over titles, abstracts and full text, e.g. 'large language models'. Leave empty to use only filters.

## `dois` (type: `array`):

DOIs or doi.org links, one per line. Looked up 50 per request; DOIs OpenAlex doesn't know are listed in the run status and not charged.

## `yearFrom` (type: `integer`):

Only works published in or after this year.

## `yearTo` (type: `integer`):

Only works published in or before this year.

## `minCitations` (type: `integer`):

Only works cited at least this many times.

## `type` (type: `string`):

Limit to one work type.

## `openAccessOnly` (type: `boolean`):

Only works with a free full-text version (oaUrl in the output).

## `filter` (type: `string`):

Optional raw OpenAlex filter string, combined with the fields above, e.g. institutions.country_code:de,language:en. See https://docs.openalex.org.

## `sort` (type: `string`):

Result order (default: relevance when a query is given).

## `maxResults` (type: `integer`):

Max works to return. Without an API key, capped at 10,000 and limited by OpenAlex's shared keyless daily budget.

## `apiKey` (type: `string`):

Your own free OpenAlex API key (openalex.org -> Settings -> API key). Gives 10x daily budget and unlimited cursor paging. Usage counts against your OpenAlex account. Without it, runs may stop with a 429 'budget' error.

## Actor input object example

```json
{
  "query": "large language models",
  "openAccessOnly": false,
  "filter": "publication_year:2025,is_oa:true",
  "maxResults": 50
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "large language models",
    "filter": "publication_year:2025,is_oa:true",
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("stazis/openalex-works-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "query": "large language models",
    "filter": "publication_year:2025,is_oa:true",
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("stazis/openalex-works-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "large language models",
  "filter": "publication_year:2025,is_oa:true",
  "maxResults": 50
}' |
apify call stazis/openalex-works-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,stazis/openalex-works-api"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/fMUJdhfcdqnbvJVvo/builds/MhLk3TBhOTkkSJdiL/openapi.json