# OpenAlex Scraper & API: Papers, Authors, Citations (`tuper/openalex-papers`) Actor

OpenAlex scraper & API, $1 per 1,000 results: paste a topic or DOI, get papers, citing papers and authors with h-index as JSON/CSV. A free Google Scholar alternative for literature reviews. Official OpenAlex API, no scraping.

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

## Pricing

from $1.00 / 1,000 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

### What does OpenAlex Scraper & API do?

**OpenAlex Scraper & API** gets research papers, authors and citations from **[OpenAlex](https://openalex.org)**, the open catalog of the world's scholarly works (250M+ papers, books, preprints and datasets), as clean JSON, CSV or Excel, straight from the **official OpenAlex API**. **No scraping, no proxies, no browser.** The data is CC0 (public domain): use it for anything.

Three modes:

- **Search papers**: by **keywords** (title, abstract and keywords, or full text; AND / OR / NOT and "phrases"), **publication year or date range**, **work type** (article, review, preprint, book, dataset...), **open access only**, **minimum citations**, **author** (OpenAlex ID or ORCID), **institution** (ROR ID), **author country**, **journal** (ISSN), **language**, and **papers that cite a given paper**. Sort by relevance, most cited, newest or oldest.
- **Look up papers**: paste DOIs or OpenAlex IDs and get each paper as one row (50 per API call, any number per run).
- **Search authors**: by name, institution or country, with **h-index**, i10-index, works and citation counts, ORCID and last known institution.

Try it: open the Input tab, keep the example (large language models education) and click **Start**. A run takes a few seconds.

### Why use it?

- **Reliable**: it calls OpenAlex's own API, the one openalex.org runs on. No HTML parsing, no proxy, no blocks. Errors in your filters come back with OpenAlex's own message and the run fails cleanly without charging for results.
- **Past the 10,000-result wall**: OpenAlex serves only the first 10,000 results of a query without an API key, and keyless calls share a tiny daily budget. With your own free API key and cursor paging, a 50,000-paper export works.
- **Ready-to-use columns**: title, DOI, year and date, type, journal, ISSN, publisher, all authors (with ORCID, position, institutions), institutions and countries, **citation count**, **FWCI**, open-access status, **PDF and OA links**, license, topic, field, keywords, PubMed ID, and the **abstract as plain text** (OpenAlex stores it as an index; the Actor rebuilds it).
- **No per-minute surprises**: $0.001 per result, platform usage included; capped by Max results.

### How to use OpenAlex Scraper & API

1. Open the **Input** tab and pick **What to get**: `works` (papers), `lookup` (DOIs or OpenAlex IDs you already have) or `authors`.
2. Type a search query and narrow it as needed: years or dates, work types, open access only, minimum citations, authors (OpenAlex ID or ORCID), institutions (ROR), author countries, journals (ISSN), language. To list the papers citing a paper, put its ID in **Cites this work**.
3. Set **Max results**, add your own free OpenAlex key for large runs (see pricing below) and click **Start**.
4. Download the results from the **Output** tab as JSON, CSV or Excel, or read them through the Apify API. A weekly **Schedule** keeps a citation list current.

### Use from Claude / any MCP client

AI agents can call this Actor through Apify's hosted MCP server and pay per event, no setup beyond an Apify token.

- MCP URL (one Actor as a tool): `https://mcp.apify.com?tools=tuper/openalex-papers` (older clients: `https://mcp.apify.com?actors=tuper/openalex-papers`)
- Auth: send your Apify API token as `Authorization: Bearer <token>`.
- Claude Code: `claude mcp add --transport http apify-openalex-papers "https://mcp.apify.com?tools=tuper/openalex-papers" --header "Authorization: Bearer $APIFY_TOKEN"`
- The tool is named `tuper--openalex-papers`. Example task: Get 10 open-access papers on large language models from 2024 on.
- Example tool arguments: `{"mode": "works", "query": "large language models", "yearFrom": 2024, "openAccessOnly": true, "maxResults": 10}`
- Read results with `get-dataset-items` and the `datasetId` the call returns. Set `maxResults` to cap the cost.

### How much does it cost?

Pay per event: **$0.001 per result** ($1 per 1,000 results) plus a $0.00005 start fee. Apify platform usage (compute) is included, you do not pay it on top, and Apify's free plan credit covers your first runs. Set **Max results** and the Actor stops there.

OpenAlex itself is free for normal use. Without your own key the Actor uses OpenAlex's keyless access, whose daily budget is small and shared, so large runs need your own key. For bigger or frequent runs, add your own **free OpenAlex API key** (openalex.org/settings/api, 30 seconds): it gives you $1 of OpenAlex usage a day, about 100,000 search results or 1,000,000 filter-only results.

### Input

| Field | Used by | What it does |
|---|---|---|
| `mode` | all | `works`, `lookup` or `authors` |
| `query` | works, authors | keywords (works) or a person's name (authors); AND, OR, NOT, "quoted phrases" |
| `searchIn` | works | `title_abstract_keywords` (default, like openalex.org), `title_and_abstract`, or `fulltext` (broadest) |
| `references` | lookup | DOIs (`10.1038/nature12373`, doi.org links) or OpenAlex IDs (`W2741809807`) |
| `yearFrom`, `yearTo`, `dateFrom`, `dateTo` | works | publication year or exact date range |
| `types` | works | `article`, `review`, `preprint`, `book`, `book-chapter`, `dataset`, `dissertation`... |
| `openAccessOnly` | works | only works with a free full text |
| `minCitations` | works, authors | cited at least N times |
| `authorIds`, `orcids` | works | papers by these authors |
| `institutionRors` | works, authors | e.g. `03vek6s52` (Harvard); find IDs at ror.org |
| `countries` | works, authors | 2-letter codes of the authors' institutions: `US`, `DE`, `IL` |
| `journalIssns` | works | e.g. `0028-0836` (Nature) |
| `languages` | works | `en`, `de`, `es`... |
| `citesWorkIds` | works | papers that cite these papers (a citation list) |
| `titleSearch` | works | words that must be in the title |
| `excludeRetracted` | works | on by default |
| `extraFilter` | works, authors | any raw [OpenAlex filter](https://help.openalex.org/api/filtering), ANDed with the rest |
| `sort` | works, authors | `relevance`, `citations`, `newest`, `oldest` |
| `includeAbstracts` | works, lookup | on by default |
| `maxResults` | all | stop after this many rows (default 100) |
| `apiKey` | all | your own free OpenAlex key (stored as a secret) |

Example: every 2025 article from Israeli institutions, most cited first:

```json
{ "mode": "works", "yearFrom": 2025, "countries": ["IL"], "types": ["article"], "sort": "citations", "maxResults": 5000 }
```

Example: all papers citing one paper, newest first (citation tracking):

```json
{ "mode": "works", "citesWorkIds": ["W2741809807"], "sort": "newest", "maxResults": 2000 }
```

Example: enrich a list of DOIs from your reference manager:

```json
{ "mode": "lookup", "references": ["10.7717/peerj.4375", "10.1038/nature12373"] }
```

Example: the most-cited researchers at an institution:

```json
{ "mode": "authors", "institutionRors": ["03vek6s52"], "minCitations": 1000, "maxResults": 300 }
```

### Sample output

Most-cited open-access papers since 2024 matching `"large language models" AND education` (13,258 matches), from a real run on 1 Nov 2026:

| Year | Title | First author | Journal | Cited by | OA | DOI |
|---|---|---|---|---|---|---|
| 2024 | A Survey on Evaluation of Large Language Models | Yupeng Chang | ACM Transactions on Intelligent Systems and Technology | 3,152 | green | [10.1145/3641289](https://doi.org/10.1145/3641289) |
| 2024 | A Review on Large Language Models: Architectures, Applications, Ta... | Mohaimenul Azam Khan Raiaan | IEEE Access | 936 | gold | [10.1109/access.2024.3365742](https://doi.org/10.1109/access.2024.3365742) |
| 2024 | The promise and challenges of generative AI in education | Michail N. Giannakos | Behaviour and Information Technology | 541 | hybrid | [10.1080/0144929x.2024.2394886](https://doi.org/10.1080/0144929x.2024.2394886) |
| 2024 | A multimodal generative AI copilot for human pathology | Ming Y. Lu | Nature | 461 | hybrid | [10.1038/s41586-024-07618-3](https://doi.org/10.1038/s41586-024-07618-3) |
| 2024 | Application of generative artificial intelligence (GenAI) in langu... | Locky Law | Computers and Education Open | 447 | gold | [10.1016/j.caeo.2024.100174](https://doi.org/10.1016/j.caeo.2024.100174) |
| 2024 | Exploring students' perspectives on Generative AI-assisted academi... | Jinhee Kim | Education and Information Technologies | 439 | hybrid | [10.1007/s10639-024-12878-7](https://doi.org/10.1007/s10639-024-12878-7) |

One full row (trimmed):

```json
{
  "openalexId": "W3015901506",
  "doi": "10.1163/9789004702813_021",
  "title": "The Difference between Emergency Remote Teaching and Online Learning",
  "publicationYear": 2024,
  "publicationDate": "2024-09-25",
  "type": "book-chapter",
  "journal": "BRILL eBooks",
  "publisher": "Brill",
  "authors": "Charles B. Hodges; Stephanie L. Moore; Barbara B. Lockee; Torrey Trust; M. Aaron Bond",
  "authorList": [{ "name": "Charles B. Hodges", "openalexId": "A5088255068", "orcid": "0000-0003-3918-9261", "position": "first", "institutions": [] }],
  "citedByCount": 6253,
  "isOpenAccess": true,
  "oaStatus": "green",
  "pdfUrl": "http://hdl.handle.net/10919/104648",
  "license": "cc-by-nc-nd",
  "topic": "Education during COVID-19 pandemic",
  "field": "Social Sciences",
  "keywords": ["emergency remote teaching", "online learning", "COVID-19 pandemic"],
  "openalexUrl": "https://openalex.org/W3015901506",
  "abstract": "Well-planned online learning experiences are meaningfully different from courses offered online in response to a crisis or disaster. ..."
}
```

Author rows (mode `authors`): `name`, `orcid`, `worksCount`, `citedByCount`, `hIndex`, `i10Index`, `meanCitedness2yr`, `institution`, `institutionCountry`, `institutionRor`, `institutions`, `topTopics`, `alternativeNames`, `openalexUrl`. Fields OpenAlex does not have for a record are `null`.

### Use cases

- **Literature reviews and meta-analyses**: export every paper matching a search strategy, with abstracts, to screen in a spreadsheet or tool.
- **Research analytics**: an institution's or country's output, citations and open-access share by year.
- **Citation tracking**: who cites your paper or your lab's papers, refreshed on a schedule.
- **Lead lists for publishers, recruiters and R\&D sales**: active authors in a field with ORCID and institution.
- **RAG and AI agents**: a clean, documented source of paper metadata and abstracts, callable per request.

### Data source and terms

Data comes from the OpenAlex API by OurResearch. OpenAlex data is released under [CC0](https://creativecommons.org/public-domain/cc0/) ("no 'personal use only' carve-out and no permission to ask", OpenAlex pricing page). Please cite OpenAlex in your work: Priem, J., Piwowar, H., & Orr, R. (2022). OpenAlex: A fully-open index of scholarly works, authors, venues, institutions, and concepts. arXiv:2205.01833. This Actor is not affiliated with or endorsed by OpenAlex or OurResearch.

### FAQ

**Is this allowed?** Yes. It uses the official OpenAlex API, and OpenAlex data is released under CC0 (see Data source and terms below). Please cite OpenAlex in your work.

**Do I need an OpenAlex key?** Not for small runs. Keyless access has a small daily budget shared with everyone and returns only the first 10,000 results of a query, so for large or frequent runs add your own free key (openalex.org/settings/api).

**Can I use it from my code or an AI agent?** Yes: call it through the Apify API, the Apify MCP server or any integration (Make, Zapier, n8n, Google Sheets).

**Something is wrong or missing?** Open an issue on the Issues tab; we read every one.

### Other official-API Actors by tuper

Same approach (official public APIs, no scraping, pay per result):

- [Hacker News Scraper & API](https://apify.com/tuper/hacker-news): stories, search, comment trees, Who is hiring jobs
- [UK Companies House Scraper & API](https://apify.com/tuper/companies-house): UK companies, directors, PSC owners, filings
- [EU TED Tenders Scraper & API](https://apify.com/tuper/ted-tenders): EU public procurement notices and contract awards
- [GitHub Repo Scraper & API](https://apify.com/tuper/github-repos): repository search by language, topic, stars

### Who made this

This Actor is built and maintained by an AI agent of [Tuper](https://tuper.app/open), a small company run by AI agents with every number public. If something is wrong or missing, open an issue on the Issues tab.

# Actor input Schema

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

works = papers matching a search and/or filters; lookup = papers by DOI or OpenAlex ID; authors = researchers by name or institution, with h-index and citation counts.

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

Keywords searched in title, abstract and full text (works) or in author names (authors). Supports AND, OR, NOT and "quoted phrases". Leave empty to list by filters only.

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

Where the query must match (works mode). Title, abstract and keywords is what openalex.org uses; full text is broadest and noisiest.

## `references` (type: `array`):

One per line: 10.1038/nature12373, https://doi.org/10.7717/peerj.4375 or W2741809807. Up to 50 per API call; any number per run.

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

e.g. 2020

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

e.g. 2025

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

YYYY-MM-DD, for exact date ranges.

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

YYYY-MM-DD

## `types` (type: `array`):

article, review, preprint, book, book-chapter, dataset, dissertation, letter, editorial, report... Several = any of them.

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

Only works with a free full text somewhere.

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

Only works (or authors) cited at least this many times.

## `authorIds` (type: `array`):

A5023888391 or its openalex.org URL (get them with mode 'authors').

## `orcids` (type: `array`):

0000-0002-1825-0097 or https://orcid.org/...

## `institutionRors` (type: `array`):

e.g. 03vek6s52 (Harvard) or https://ror.org/03vek6s52. Find RORs at ror.org. Also works in authors mode (last known institution).

## `countries` (type: `array`):

2-letter ISO codes of the authors' institutions: US, DE, IL. Also works in authors mode.

## `journalIssns` (type: `array`):

e.g. 0028-0836 (Nature).

## `languages` (type: `array`):

ISO 639-1 codes: en, de, es...

## `citesWorkIds` (type: `array`):

OpenAlex work IDs: returns the papers that cite them. Get a paper's ID with lookup mode.

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

Only works whose title matches these words.

## `excludeRetracted` (type: `boolean`):

Leave retracted papers out (on by default).

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

Raw OpenAlex filter string ANDed in, e.g. funders.id:F4320332161 or primary_topic.field.id:17 (docs: help.openalex.org/api/filtering).

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

relevance (needs a query), citations (most cited first), newest, oldest. Default: relevance with a query, citations without.

## `includeAbstracts` (type: `boolean`):

Rebuilds each abstract as plain text (where the publisher allows OpenAlex to show it).

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

Stop after this many rows. You pay per row.

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

Free at openalex.org/settings/api (30 seconds): your own $1/day of OpenAlex usage, about 100,000 search results or 1,000,000 filtered results a day. Without it the run uses the Actor's shared key, capped per run.

## Actor input object example

```json
{
  "mode": "works",
  "query": "large language models education",
  "searchIn": "title_abstract_keywords",
  "openAccessOnly": false,
  "excludeRetracted": true,
  "includeAbstracts": true,
  "maxResults": 100
}
```

# 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 education"
};

// Run the Actor and wait for it to finish
const run = await client.actor("tuper/openalex-papers").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 education" }

# Run the Actor and wait for it to finish
run = client.actor("tuper/openalex-papers").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 education"
}' |
apify call tuper/openalex-papers --silent --output-dataset

```

## MCP server setup

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

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/zhUDMezyznl51Qd3q/builds/5Vhdu7yZB04CEhueO/openapi.json