# OpenAlex Research Papers Scraper: citations, abstracts, PDFs (`bepolabs/openalex-works`) Actor

Survey a field or feed AI agents with author IDs, institutions, topics and plain-text summaries of monographs and drafts. No login, no proxy.

- **URL**: https://apify.com/bepolabs/openalex-works.md
- **Developed by:** [BEPO Labs](https://apify.com/bepolabs) (community)
- **Categories:** AI, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.50 / 1,000 works

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

### 🎓 What is OpenAlex Research Papers?

Build a reading list in minutes: this Actor turns keywords, DOIs or one seed paper into a tidy table of publications from [OpenAlex](https://openalex.org), the open catalogue of over 300 million research papers and more (CC0). Each row brings venue, ORCID-tagged authors, citations, openness terms and the free PDF where one exists.

- **Literature reviews**: the most relevant or most cited open-access papers on a topic since a given year, in one spreadsheet
- **Citation tracking**: every new paper that cites your own study, a rival lab's or a landmark one, on a schedule
- **AI, RAG and research agents**: abstracts and free PDF links for a reading list of DOIs, ready for ChatGPT, Claude or a vector database
- **Research intelligence**: who publishes on a topic, at which institutions, in which journals
- **Reference checks**: resolve a list of DOIs to clean metadata and spot retracted papers

![OpenAlex Research Papers: Research papers in bulk from OpenAlex: search, DOI or citing works to clean rows with citations, abstracts and free PDF links.](https://api.apify.com/v2/key-value-stores/wdeAWGooHdIhvFgSY/records/openalex-works-hero.png)

#### ✨ Why use this Actor?

- ✅ **Three ways in**: search terms, direct DOI or OpenAlex id lookups, and "works citing this paper"
- ✅ **Abstracts in plain words**: OpenAlex stores each as a word index; the Actor rebuilds the readable passage
- ✅ **Free reading copies located**: open-access flag, the preferred location and the PDF address where one exists
- ✅ **Clean people data**: each contributor with OpenAlex id, ORCID and institutions
- ✅ **Filters that matter**: years, work type, open access only, sorted by relevance, citations or newest
- ✅ **Cheap and fair**: 0.5 USD per 1,000 works, deduped across your searches; you pay only for works saved

### 📦 What data can you get with OpenAlex Research Papers?

| | | |
|---|---|---|
| 📄 Title | 🔖 DOI and OpenAlex id | 📅 Year and publication date |
| 🏛️ Journal or venue and publisher | 👩‍🔬 Authors with ORCID | 🏫 Author institutions |
| 📈 Times cited | 📚 Reference count | 🔓 Open-access status and link |
| 📥 PDF link | ⚖️ Licence | 🧭 Topic and field |
| 📝 Abstract (plain text) | 🚫 Retraction flag | 🔗 OpenAlex and landing page URL |

### 🚀 How to use OpenAlex Research Papers

OpenAlex Research Papers works in a few clicks, no coding needed:

1. [Create a free Apify account](https://console.apify.com/sign-up) (the free plan includes 5 USD of monthly credit).
2. Open [OpenAlex Research Papers](https://apify.com/bepolabs/openalex-works) and click **Try for free**.
3. Enter keywords, DOIs or the papers whose citing works you want. Set the years, type and how many works each.
4. Click **Start** and wait for the run to finish (most runs take seconds).
5. Download your data as JSON, CSV, Excel, XML or HTML, or send it straight to Google Sheets, Make, Zapier or your AI agent.

![How OpenAlex Research Papers works](https://api.apify.com/v2/key-value-stores/wdeAWGooHdIhvFgSY/records/openalex-works-workflow.png)

### ⬇️ Input

Give at least one search term, DOI or OpenAlex work id, up to 200 per run. Everything else is optional.

##### Search, look up or follow citations

`queries` runs a full-text search over titles, abstracts and full texts. `works` looks up DOIs (`10.1038/nature14539`, `https://doi.org/...`) or OpenAlex ids (`W2194775991`) directly, 50 per call. `citingWorksOf` returns the works that cite each DOI or id.

##### Filters and sorting

Narrow with `fromYear`, `toYear`, `type` (article, review, preprint, book, book-chapter, dissertation, dataset) and `openAccessOnly`. Order by `relevance`, `cited` (most cited first) or `newest`. Citing lists are ranked by citations when relevance is chosen.

##### Free OpenAlex API key for big runs

OpenAlex gives every caller a small free daily budget. For runs of thousands of works, add your own free token from openalex.org/settings/api in `apiKey`; the Actor then pages with a cursor. If OpenAlex answers "rate limited", the run summary says so.

| Field | Type | What it does | Default |
|---|---|---|---|
| **Search terms** (`queries`) | array | Full-text search over titles, abstracts and full texts; one search per term, results deduped across terms. | `["large language models"]` |
| **DOIs or OpenAlex work ids** (`works`) | array | Look up these works directly, e.g. |  |
| **Works citing these** (`citingWorksOf`) | array | DOIs or OpenAlex work ids; returns the works that cite each one. |  |
| **Sort** (`sort`) | string | relevance (search terms only; citing lists use cited), cited (most cited first) or newest. | `"relevance"` |
| **From year** (`fromYear`) | integer | Keep works published in or after this year. | `2023` |
| **To year** (`toYear`) | integer | Keep works published in or before this year. | `2026` |
| **Type** (`type`) | string | Return only works of this type, for example "article", "review", "preprint", "book", "book-chapter", "dissertation" or "dataset". |  |
| **Open access only** (`openAccessOnly`) | boolean | Keep only works with a free full text. | `false` |
| **Include abstract** (`includeAbstract`) | boolean | Add the abstract text where OpenAlex has it. | `true` |
| **Max works per term** (`maxItemsPerQuery`) | integer | Per search term or citing list (1 to 2,000). | `100` |
| **OpenAlex API key** (`apiKey`) | string | Optional, free at openalex.org/settings/api. |  |
| **Contact email** (`email`) | string | Optional; OpenAlex asks for one in heavy use. |  |
| **Max retries** (`maxRetries`) | integer | Per request, on timeouts, rate limits and server errors. | `3` |

![OpenAlex Research Papers input form](https://api.apify.com/v2/key-value-stores/wdeAWGooHdIhvFgSY/records/openalex-works-input.png)

#### Input example

```json
{
    "queries": [
        "large language models"
    ],
    "fromYear": 2024,
    "openAccessOnly": true,
    "maxItemsPerQuery": 100
}
```

### ⬆️ Output

Every work becomes one row with the same fields, whichever route led to it; `source` names the search term, lookup or citing list. Works reached twice are kept once. The run summary in the key-value store (`OUTPUT`) lists every entry with its yield and the error if one failed.

![OpenAlex Research Papers output table](https://api.apify.com/v2/key-value-stores/wdeAWGooHdIhvFgSY/records/openalex-works-output.png)

#### Output example

One row of the dataset (search "large language models", open access, since 2024; authors and abstract shortened):

```json
{
    "id": "W4391136507",
    "doi": "10.1145/3641289",
    "title": "A Survey on Evaluation of Large Language Models",
    "year": 2024,
    "publicationDate": "2024-01-23",
    "type": "article",
    "language": "en",
    "venue": "ACM Transactions on Intelligent Systems and Technology",
    "publisher": "Association for Computing Machinery",
    "authors": [
        {
            "name": "Yupeng Chang",
            "id": "A5102930702",
            "orcid": "0000-0001-7178-6088",
            "institutions": [
                "Jilin University"
            ]
        },
        {
            "name": "Xu Wang",
            "id": "A5100407966",
            "orcid": "0009-0001-5904-5313",
            "institutions": [
                "Jilin University"
            ]
        }
    ],
    "citedByCount": 3005,
    "referencesCount": 263,
    "isOpenAccess": true,
    "openAccessStatus": "green",
    "openAccessUrl": "https://arxiv.org/pdf/2307.03109",
    "pdfUrl": "https://arxiv.org/pdf/2307.03109",
    "license": "cc-by",
    "topic": "Topic Modeling",
    "field": "Computer Science",
    "isRetracted": false,
    "abstract": "Large language models (LLMs) are gaining increasing popularity in both academia and industry, owing to their unprecedented performance in various applications. As LLMs continue to play a vital role in both research and...",
    "openalexUrl": "https://openalex.org/W4391136507",
    "landingPageUrl": "https://doi.org/10.1145/3641289",
    "source": "search: large language models"
}
```

#### Run summary (OUTPUT)

The key-value store record `OUTPUT` has the self-check and one line per query, so a failure is never silent:

```json
{
    "ok": true,
    "rows": 100,
    "problems": [],
    "tasks": [
        {
            "task": "large language models",
            "ok": true,
            "rows": 100,
            "error": null
        }
    ]
}
```

View the results as a table or JSON in the Output tab and download them as JSON, CSV, Excel, XML, HTML or RSS, all fields or only those you pick.

### 💰 How much does OpenAlex Research Papers cost?

OpenAlex Research Papers is priced **per event**: **0.5 USD per 1,000 works** (0.0005 USD each), with no monthly rental. Each work saved to the dataset is billed once, even if two searches reached it; a search without hits is free.

| You get | You pay |
|---|---|
| 100 works | 0.05 USD |
| 1,000 works | 0.5 USD |
| 10,000 works | 5 USD |
| 100,000 works | 50 USD |

💡 Apify's free plan gives you 5 USD of credit every month, enough for about **10,000 works** at no cost. Set a spending limit per run and the Actor stops there.

### ⚖️ OpenAlex Research Papers vs. the alternatives

| | OpenAlex Research Papers | Search engine scrapers | Manual export from a database |
|---|---|---|---|
| **Source** | ✅ open API, no scraping | scraped result pages, can break | web interface |
| **DOI lookup and citing works** | ✅ both | search only | one paper at a time |
| **Authors with ORCID and institutions** | ✅ | names only | varies |
| **Abstract and free PDF link** | ✅ | snippet only | often paywalled |
| **Licence of the data** | ✅ CC0, reuse freely | unclear | licence terms apply |
| **API, schedules and MCP for AI agents** | ✅ | ✅ | ❌ |

### 🔌 Integrations, API and MCP

#### Connect OpenAlex Research Papers to your AI agent (MCP)

Give Claude, ChatGPT, Cursor or any MCP client direct access to OpenAlex Research Papers through the [Apify MCP server](https://mcp.apify.com). Add this URL to its settings:

```text
https://mcp.apify.com/?actors=bepolabs/openalex-works
```

For Claude Desktop, add it under `mcpServers` in `claude_desktop_config.json`:

```json
{
    "mcpServers": {
        "openalex-works": {
            "command": "npx",
            "args": [
                "-y",
                "@apify/actors-mcp-server",
                "--actors",
                "bepolabs/openalex-works"
            ],
            "env": {
                "APIFY_TOKEN": "<your Apify API token>"
            }
        }
    }
}
```

Then ask: *"Find the 20 most cited open-access papers on retrieval-augmented generation since 2024 and summarise what each one found."*

#### Run it from your code

Python (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("bepolabs/openalex-works").call(run_input={"queries":["large language models"],"fromYear":2024,"openAccessOnly":true,"maxItemsPerQuery":100})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

JavaScript (`npm install apify-client`):

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('bepolabs/openalex-works').call({"queries":["large language models"],"fromYear":2024,"openAccessOnly":true,"maxItemsPerQuery":100});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### No-code integrations

Send results to **Google Sheets, Slack, Airtable, HubSpot, Make, Zapier, n8n** and more from the Integrations tab, start runs on a **schedule**, or trigger your own endpoint with a **webhook** when a run finishes. The [Apify API](https://docs.apify.com/api/v2) gives you full control over runs and datasets.

### ❓ FAQ

##### Where does the data come from?

From the official [OpenAlex API](https://docs.openalex.org). OpenAlex is a free, open index of scholarly works run by the non-profit OurResearch; it builds on Crossref, PubMed, arXiv, institutional repositories and more.

##### How many papers can I get?

Up to 2,000 works per search term or citing list and up to 200 terms, DOIs and ids per run. Split bigger pulls by year with `fromYear` and `toYear`.

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

No for small runs. OpenAlex gives every caller a modest free daily allowance; for regular or large runs add your own free key in `apiKey` so you never share it.

##### Can I get the full text?

The Actor gives you the abstract plus open-access and PDF addresses where OpenAlex knows one. Feed those to a document-to-text Actor for the full text.

##### How do I track new citations of my paper?

Put its DOI in `citingWorksOf`, set `sort` to `newest` and schedule the Actor weekly.

##### Is it legal to use OpenAlex Research Papers?

Yes. OpenAlex data is released under CC0 and the Actor reads it through OpenAlex's official public API. Abstracts and linked full texts stay under their publishers' and authors' terms: check the `license` field before you republish them.

##### What if something is missing or does not work?

Open an issue on the **Issues** tab; we read each one and reply. Feature requests are welcome too.

### 💬 Your feedback

Tell us what OpenAlex Research Papers should add on the **Issues** tab or leave a review; your notes decide what we work on next.

### 🔗 Related Actors

| Actor | What it does |
|---|---|
| 📄 [PDF to Text and Markdown](https://apify.com/bepolabs/pdf-to-text) | PDFs to clean text and Markdown, per page, per document or as RAG chunks, with columns in reading order and headers and footers removed. |
| 🔤 [Image OCR](https://apify.com/bepolabs/image-ocr) | Extract text from images in 29 languages: plain text, clean Markdown and every word with its pixel box and confidence. |
| 🏛️ [SEC EDGAR Filings](https://apify.com/bepolabs/sec-edgar) | Tickers or CIK numbers to SEC filings: 10-K, 10-Q, 8-K, Form 4 and any other form, with document links. |
| 📝 [Website to Markdown](https://apify.com/bepolabs/web-to-markdown) | Any web page or docs site to clean Markdown for LLMs, RAG and AI agents, with headings, links and ready-made chunks. |
| 📈 [Wikipedia Pageviews](https://apify.com/bepolabs/wikipedia-pageviews) | Daily or monthly views of any Wikipedia article in any language, with totals and averages, from the official Wikimedia API. |

# Changelog

This Actor's version history is a separate document: https://apify.com/bepolabs/openalex-works/changelog.md

# Actor input Schema

## `queries` (type: `array`):

Full-text search over titles, abstracts and full texts; one search per term, results deduped across terms.

## `works` (type: `array`):

Look up these works directly, e.g. 10.1038/nature14539, https://doi.org/... or W2194775991.

## `citingWorksOf` (type: `array`):

DOIs or OpenAlex work ids; returns the works that cite each one.

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

relevance (search terms only; citing lists use cited), cited (most cited first) or newest.

## `fromYear` (type: `integer`):

Keep works published in or after this year.

## `toYear` (type: `integer`):

Keep works published in or before this year.

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

Return only works of this type, for example "article", "review", "preprint", "book", "book-chapter", "dissertation" or "dataset". Leave empty for all types.

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

Keep only works with a free full text.

## `includeAbstract` (type: `boolean`):

Add the abstract text where OpenAlex has it.

## `maxItemsPerQuery` (type: `integer`):

Per search term or citing list (1 to 2,000).

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

Optional, free at openalex.org/settings/api. Without it OpenAlex allows about 100 search pages a day per caller.

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

Optional; OpenAlex asks for one in heavy use.

## `maxRetries` (type: `integer`):

Per request, on timeouts, rate limits and server errors.

## Actor input object example

```json
{
  "queries": [
    "large language models"
  ],
  "sort": "relevance",
  "fromYear": 2023,
  "toYear": 2026,
  "openAccessOnly": false,
  "includeAbstract": true,
  "maxItemsPerQuery": 100,
  "maxRetries": 3
}
```

# Actor output Schema

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

Dataset items, one row per result, in the overview table view.

# 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 = {
    "queries": [
        "large language models"
    ],
    "fromYear": 2023,
    "toYear": 2026
};

// Run the Actor and wait for it to finish
const run = await client.actor("bepolabs/openalex-works").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 = {
    "queries": ["large language models"],
    "fromYear": 2023,
    "toYear": 2026,
}

# Run the Actor and wait for it to finish
run = client.actor("bepolabs/openalex-works").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 '{
  "queries": [
    "large language models"
  ],
  "fromYear": 2023,
  "toYear": 2026
}' |
apify call bepolabs/openalex-works --silent --output-dataset

```

## MCP server setup

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

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/xFUROVPSwKFA78XL9/builds/guKVHMq3EUGNkokLK/openapi.json