# OpenAlex Scraper: Research Papers, Authors & Citations (`recordsdata/openalex-research-scraper`) Actor

Scrape OpenAlex, the open catalog of 250M+ research papers: titles, DOIs, citations, FWCI, abstracts and open access links, plus author h-index and institution records. Filter by keyword, year and open access. Export CSV, Excel, JSON. No login or API key.

- **URL**: https://apify.com/recordsdata/openalex-research-scraper.md
- **Developed by:** [RecordsData](https://apify.com/recordsdata) (community)
- **Categories:** Education, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

<p align="center">
  <img src="https://api.apify.com/v2/key-value-stores/AAm3a1h3Z9nYfrvh9/records/banner?v=3" alt="RecordsData" width="100%" />
</p>

## OpenAlex Scraper: Research Papers, Authors & Citations

> OpenAlex Scraper extracts research papers, author profiles, institutions, journals, topics, funders and publishers from OpenAlex, the open catalog of 250M+ scholarly works. Search by title or abstract, year, minimum citations, paper type and open access, or pass any OpenAlex filter. Each paper row has up to 97 columns: DOI, PMID, citations, FWCI, citation percentile, retraction flag, open access status, license, PDF link, abstract, keywords and funding awards. Run up to 50 searches at once. Export CSV, Excel, JSON or XML. No login; an OpenAlex API key is optional. Verified on cloud build 0.1.9 on 2026-10-10.

In our cloud check with `crispr`, at least 500 citations, type article and open access only, 5 of 5 rows came back with an open access status and a retraction flag. The same actor returns researcher profiles with h-index, institution records and four catalog types.

### 🔎 What does OpenAlex Scraper do?

- Search papers by title, or title and abstract, and filter by year range, minimum citations, paper type (17 values such as article, review, preprint, dataset) and open access.
- Pass any OpenAlex filter in the free-form `filter` box, for example `is_retracted:false`.
- Run several searches in one run (one per line, up to 50). Every row carries a `searchQuery` column, and a record found by two searches is delivered and charged once.
- Look up researcher profiles, institutions, journals and sources, topics, funders and publishers.
- Sort by citations, date or relevance; cursor paging passes 10,000 rows (up to 1,000,000 per run on paid plans).

### 📋 What data can you extract from OpenAlex?

The schema has 100 keys (97 data columns plus three error keys) and six views: Overview, Papers, Authors, Institutions, Journals and sources, Topics funders publishers.

| Record | Main fields |
|---|---|
| Paper | openalexId, title, doi, pmid, publicationDate, year, type, language, isRetracted, journal, publisher, authors, authorsDetails (ORCID), citedByCount, fwci, citationPercentile, openAccessStatus, oaUrl, pdfUrl, license, apcListUsd, topic, keywords, funders, awards, abstract (up to 5,000 characters), url |
| Author | openalexId, name, orcid, worksCount, citedByCount, hIndex, i10Index, institution |
| Institution | openalexId, name, country, type, worksCount, citedByCount, hIndex, ror |
| Journal or source | name, issnL, publisher, isOpenAccess, isInDoaj, apcUsd, worksCount, hIndex |
| Topic, funder, publisher | name, description, field, domain, country, awardsCount, worksCount, citedByCount |

Every row also has `recordType`, `searchQuery` and `scrapedAt`. The original columns show "Not Available" or "Not Disclosed" unless you switch on `omitMissing`.

### 📊 OpenAlex Scraper sample output

A real paper row from an earlier cloud run (query "crispr", sorted by citations). Newer builds add columns such as `isRetracted` and `openAccessStatus`; authors and abstract are shortened:

```json
{
  "recordType": "work",
  "openalexId": "W2064815984",
  "title": "Multiplex Genome Engineering Using CRISPR/Cas Systems",
  "doi": "https://doi.org/10.1126/science.1231143",
  "year": 2013,
  "type": "article",
  "authors": ["Le Cong", "F. Ann Ran", "Feng Zhang"],
  "citedByCount": 16049,
  "fwci": 453.5513,
  "isOpenAccess": true,
  "topic": "CRISPR and Genetic Engineering",
  "abstract": "Functional elucidation of causal genetic variants and elements requires precise genome editing technologies. ...",
  "url": "https://doi.org/10.1126/science.1231143",
  "scrapedAt": "2026-10-04T04:07:48.850Z"
}
```

### 💰 How much does it cost to scrape OpenAlex?

Pay per event, only for records saved. Live prices read on 2026-10-10:

| Event | When it is charged | Free plan tier | Highest tier |
|---|---|---|---|
| work-record, author-record, institution-record | One paper, researcher profile or institution saved | $0.012 | $0.010 |
| catalog-record | One journal or source, topic, funder or publisher saved | $0.005 | $0.005 |

There is no start fee. You are not charged for empty searches, invalid input, error rows, duplicates or failed runs, and the run stops cleanly at your maximum charge limit. Free users get a 10 row preview per run.

Worked examples: 1,000 papers cost 1,000 x $0.012 = $12.00 on the free plan tier, or $10.00 at the lowest tier. 800 papers, 150 authors and 50 institutions is also $12.00. A run of 1,000 journal rows costs 1,000 x $0.005 = $5.00 on every tier.

### 🚀 How to scrape OpenAlex in 3 steps

1. Click **Try for free**.
2. Type searches in "Papers search" (one per line), optionally set years, citations, type or filter, or fill the authors, institutions, journals, topics, funders or publishers boxes.
3. Set **Max Items**, click **Start**, then download the dataset as CSV, Excel, JSON or XML.

### ⚙️ OpenAlex Scraper input

| Field | Default | Description |
|---|---|---|
| `worksQuery` | crispr | Paper searches, one per line, up to 50 |
| `searchIn` | title | title, or titleAndAbstract |
| `yearFrom` / `yearTo`, `minCitations` | none, 0 | Year range; only papers cited at least this many times |
| `workType` | any | article, review, preprint, book, dataset and 12 more types |
| `onlyOpenAccess` | false | Keep only papers with a free full-text link |
| `filter` | empty | OpenAlex filter syntax, for example `language:en,is_oa:true` |
| `sortBy` | cited_by_count | cited_by_count, publication_date or relevance |
| `authorsQuery`, `institutionsQuery`, `sourcesQuery`, `topicsQuery`, `fundersQuery`, `publishersQuery` | empty | One search per line for each catalog |
| `omitMissing` | false | Leave empty fields out instead of "Not Available" |
| `openalexApiKey` | empty | Optional free OpenAlex key for a bigger daily budget |
| `maxItems` | 10 | Total rows across everything, max 1,000,000 |

Use `*` in an entity box to browse a catalog by size (`entityFilter` filters non-paper searches). Example input:

```json
{
  "worksQuery": "large language models\nretrieval augmented generation",
  "searchIn": "titleAndAbstract",
  "yearFrom": 2023,
  "minCitations": 50,
  "workType": "article",
  "onlyOpenAccess": true,
  "maxItems": 100
}
```

At least one search or filter must be given. Otherwise the run ends as succeeded with one free error row that says what to fix. If you use only the entity boxes, leave `worksQuery` empty, because its default is still `crispr`.

### 📦 OpenAlex Scraper output

All record types share one dataset, told apart by `recordType`. If a search matches nothing, the run finishes with "No results found for this search" and an empty dataset. If OpenAlex fails and no rows were delivered, the run fails.

If you upgraded: columns grew from 34 to 100 keys and were reordered, so scripts reading by position need a check. Saved inputs keep working and bill the same.

### ⚖️ OpenAlex scraper vs alternatives

Compared on 2026-10-10 from the Apify Store pages of parseforge/openalex-scraper and arman-bd/openalex-scraper:

| Capability | This actor | parseforge | arman-bd |
|---|---|---|---|
| Entity types | Papers, authors, institutions, plus 4 catalog types | 7 entity types, one per run | 8 entity types |
| Output fields | Up to 97 | Not stated | Not stated |
| Several searches per run | Yes, up to 50 | Not stated | Yes |
| Price per 1,000 records | $12 (Free), $10 (top tier) | $12 plus $0.16 per run | $1 |

parseforge asks the same $12 per 1,000 records plus a $0.16 start fee. Cheaper OpenAlex actors exist: arman-bd at $1, themineworks at $1 plus a $0.005 start fee, logiover at $3, and shahidirfan on platform usage only. For a basic list at the lowest cost, pick one of those. This actor costs more per record; the premium buys retraction and percentile flags, open access status, license, authors with ORCID, six dataset views and cursor paging past 10,000 rows in one actor.

### 💼 OpenAlex data use cases

- **Technology scouting and literature reviews:** most-cited recent papers per topic, with authors and institutions.
- **Integrity and open access audits:** retraction flags, open access status, license and APC price.

### 🔌 Run OpenAlex Scraper via API and integrations

```bash
curl -X POST "https://api.apify.com/v2/acts/RecordsData~openalex-research-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"worksQuery":"crispr","minCitations":500,"workType":"article","maxItems":10}'
```

Schedule runs and connect the dataset to Make, Zapier, n8n or Google Sheets.

### 🤖 OpenAlex Scraper MCP server for AI agents

AI agents can call this Actor through the Apify MCP server at `https://mcp.apify.com?tools=RecordsData/openalex-research-scraper`. The URL loads only this Actor as a tool:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=RecordsData/openalex-research-scraper"
    }
  }
}
```

Example agent prompt:

> Use the OpenAlex Scraper to find the 15 most-cited open access articles on "large language models" published since 2023 with at least 50 citations, and list the title, journal, citedByCount, fwci, openAccessStatus and DOI of each.

Tool description: choose this actor when an agent needs citation counts, DOIs, abstracts, retraction flags, open access status, researcher h-index or journal, funder and publisher statistics from OpenAlex. It takes the same fields as the input table above and returns one dataset row per record.

### 🛡️ Is it legal to scrape OpenAlex?

The actor reads the official public OpenAlex API with an identified contact address, and OpenAlex data is released under CC0. It collects scholarly metadata only. Researcher profiles hold public professional information; follow GDPR and local rules when you store personal data.

### ❓ Frequently asked questions

#### Why do some OpenAlex papers have no abstract?

OpenAlex only redistributes abstracts that publishers allow, so the scraper cannot return one for every paper. Where OpenAlex has none, the column shows "Not Available", or the field is left out if you switch on `omitMissing`. Abstracts go up to 5,000 characters.

#### Does OpenAlex Scraper search the full text of papers?

No. By default it matches your keywords against paper titles, which keeps results precise. Set `searchIn` to titleAndAbstract to match words in the abstract too, which finds more papers. Combine several words to narrow results. Full text is not searched at all.

#### Why did my OpenAlex Scraper run return 0 results?

The keywords matched no paper, or the year, citation, type and filter settings were too strict. The run then finishes as succeeded with "No results found for this search" and an empty dataset, and you are not charged. Try broader keywords or a lower `minCitations`.

#### What is FWCI in OpenAlex Scraper output?

FWCI stands for Field-Weighted Citation Impact, returned in the fwci field of each paper row. It is the citation count normalised by field and publication year, so 1.0 is the world average and 2.0 means twice as many citations as expected, which makes papers comparable across fields.

#### Can I search papers, authors and institutions in one OpenAlex Scraper run?

Yes. Fill any combination of the query boxes (papers, authors, institutions, journals, topics, funders, publishers) and one run returns all record types in the same dataset, told apart by recordType. The maxItems input is the total across everything, not a limit per search.

#### How many results can I get from OpenAlex Scraper?

Up to 1,000,000 rows per run on paid Apify plans. OpenAlex plain paging stops at 10,000 rows, but the actor uses cursor paging, and a cloud run delivered 10,200 rows. Free Apify users get a 10 row preview per run, enough to check the fields.

#### Am I charged for failed or empty OpenAlex Scraper runs?

No. The scraper charges only for records saved to the dataset, and each record is charged once. Empty searches, invalid input, error rows, duplicates and failed runs cost nothing. Paper, author and institution records cost $0.012 on the free tier, and catalog records $0.005.

#### Can I limit my spending on OpenAlex Scraper?

Yes. Set a maximum charge per run in the Apify run options, or lower the maxItems input. The scraper stops cleanly when the limit is reached and keeps the records it already delivered. At $0.012 per record, 100 records cost $1.20, and the cap applies to the whole run.

#### What happens if I send an empty or invalid input to OpenAlex Scraper?

If there is no search and no filter, years are reversed, or there are more than 50 searches, the run still ends as succeeded. It saves one free error row with errorType set to invalid-input plus a hint explaining what to fix, and nothing is charged.

#### How do I filter by minimum citations or paper type?

Set `minCitations` to keep only papers cited at least that many times, and pick a `workType` such as article, review, preprint or dataset (17 values). For anything else, use the `filter` box with OpenAlex syntax, for example `language:es,is_oa:true,publication_year:2020-2024`. An unknown filter key returns one free error row.

#### Can I run several searches at once and see which one found a row?

Yes. Put one search per line in `worksQuery`, `authorsQuery`, `institutionsQuery` or the other query boxes, up to 50 lines. Every row has a `searchQuery` column with the line that found it. A record found by two searches is delivered and charged once, and maxItems is split across the lines.

#### Are the journal, topic, funder and publisher modes priced?

Yes. The four catalog modes (`sourcesQuery`, `topicsQuery`, `fundersQuery`, `publishersQuery`) use the catalog-record event at a flat $0.005 per row on every plan tier, so 1,000 journals, topics, funders or publishers cost $5.00. Paper, author and institution records cost $0.012 on the free tier and $0.010 at the top tier.

#### Can I get more than 10,000 rows from OpenAlex?

Yes. The scraper uses cursor paging, which continues past the 10,000 row limit of plain paging. A cloud run of 10,200 rows worked. The actor stops 90 seconds before the run timeout and keeps the rows it already has, so a long run never ends empty.

#### What is the OpenAlex daily budget and do I need an API key?

OpenAlex gives each network address a daily budget of about 1,000 credits without a key: a search costs 10, a list page 1 and a single record 0. A free key from openalex.org gives about 10 times more. On HTTP 429 the actor stops with a message. Paste the key in `openalexApiKey` or set OPENALEX_API_KEY.

#### Why do I see "Not Available" and how does omitMissing work?

The original columns write "Not Available" or "Not Disclosed" when OpenAlex has no value, so old exports keep their shape. Switch on `omitMissing` (off by default) to leave those fields out of the row, so numbers stay numbers. Newer columns are always left out when empty.

#### Did the column order change?

Yes. Rows now have up to 97 data columns instead of 34, and the order changed: `name` sits next to `title` and new columns are interleaved. Scripts that read by name keep working; scripts that read by position need a check. Saved inputs still run and bill the same.

#### Can I find retracted papers?

Yes. Every paper row has an `isRetracted` flag. Use `filter` with `is_retracted:false` to exclude retracted papers, or `is_retracted:true` to list them, or choose `workType` retraction to get retraction notices. Combine the flag with years, citations or a topic search to audit a reading list.

### 🧭 Want more research data? Other RecordsData scrapers

[arXiv Research Papers Scraper](https://apify.com/RecordsData/arxiv-research-papers-scraper), [PubMed Articles Scraper](https://apify.com/RecordsData/pubmed-articles-scraper) and [Clinical Trials Scraper](https://apify.com/RecordsData/clinical-trials-scraper).

### 🛟 Support

Use the Issues tab on this actor's page, or write to contact.punkrecordsdata@gmail.com. Custom solutions are available on request.

Last updated: 2026-10-11

# Actor input Schema

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

Search research papers by keywords (e.g. crispr, large language models). One search per line: each line is a separate search and every row is tagged with the search that found it. Use \* to list papers by the filters below only. Leave empty to skip papers.

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

Where the papers search looks for the words. Title only is the original behaviour; title and abstract finds more papers.

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

Only papers published from this year onward.

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

Only papers published up to this year.

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

Only papers cited at least this many times (0 = no limit).

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

Only papers of this OpenAlex type. Any keeps all types. For a type that is not listed, use the filter box (type:...).

## `onlyOpenAccess` (type: `boolean`):

Keep only papers with a free full-text link.

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

Extra OpenAlex filter for papers: key:value pairs separated by commas or new lines, for example language:en,authorships.countries:US,is_retracted:false,open_access.oa_status:gold or doi:https://doi.org/10.1038/nature14539|https://doi.org/10.7717/peerj.4375. Combined with the other paper inputs. A key OpenAlex does not know returns a clear error row and nothing is charged.

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

Order of the papers results. Relevance needs a papers search text.

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

Search researcher profiles by name (h-index, citations, affiliation). One search per line. Use \* to list authors by the entity filter only.

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

Search universities and research institutions by name. One search per line. Use \* to list institutions by the entity filter only.

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

Search journals, repositories and conferences by name (ISSN, publisher, open access flags, citation metrics). One search per line. Use \* to list sources by the entity filter only.

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

Search OpenAlex research topics by name (field, subfield, domain, keywords, related topics). One search per line. Use \* to list topics by the entity filter only.

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

Search research funders by name (country, awards, works funded, citation metrics). One search per line. Use \* to list funders by the entity filter only.

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

Search academic publishers by name (hierarchy, countries, works, citation metrics). One search per line. Use \* to list publishers by the entity filter only.

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

Extra OpenAlex filter applied to every non-paper search above, key:value pairs separated by commas or new lines, for example country_code:CO,type:education for institutions or is_oa:true,type:journal for sources. Keys differ per type; an unknown key returns a clear error row and nothing is charged.

## `omitMissing` (type: `boolean`):

Off (default): a missing value in the original columns is written as the text Not Available or Not Disclosed, as before. On: those fields are left out of the row, so numbers stay numbers and nothing needs cleaning.

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

Free key from openalex.org/settings/api. OpenAlex gives every network address a small free daily budget (about 100 searches); a key gives you your own budget 10 times larger. Needed only for very large runs or when you see a daily budget message.

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000. It is the total over all searches; it is shared out between several searches of the same kind.

## Actor input object example

```json
{
  "worksQuery": "crispr",
  "searchIn": "title",
  "minCitations": 0,
  "workType": "any",
  "onlyOpenAccess": false,
  "filter": "",
  "sortBy": "cited_by_count",
  "authorsQuery": "",
  "institutionsQuery": "",
  "sourcesQuery": "",
  "topicsQuery": "",
  "fundersQuery": "",
  "publishersQuery": "",
  "entityFilter": "",
  "omitMissing": false,
  "maxItems": 10
}
```

# Actor output Schema

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

Key fields per row

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

Research papers with citations, FWCI, open access status and topics

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

Researcher profiles with h-index, ORCID and affiliation

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

Universities and research institutions with metrics and ROR

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

Journals, repositories and conferences with ISSN, publisher and open access flags

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

Research topics, funders and publishers

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

Complete dataset with all fields

# 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 = {
    "worksQuery": "crispr",
    "filter": "",
    "authorsQuery": "",
    "institutionsQuery": "",
    "sourcesQuery": "",
    "topicsQuery": "",
    "fundersQuery": "",
    "publishersQuery": "",
    "entityFilter": "",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("recordsdata/openalex-research-scraper").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 = {
    "worksQuery": "crispr",
    "filter": "",
    "authorsQuery": "",
    "institutionsQuery": "",
    "sourcesQuery": "",
    "topicsQuery": "",
    "fundersQuery": "",
    "publishersQuery": "",
    "entityFilter": "",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("recordsdata/openalex-research-scraper").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 '{
  "worksQuery": "crispr",
  "filter": "",
  "authorsQuery": "",
  "institutionsQuery": "",
  "sourcesQuery": "",
  "topicsQuery": "",
  "fundersQuery": "",
  "publishersQuery": "",
  "entityFilter": "",
  "maxItems": 10
}' |
apify call recordsdata/openalex-research-scraper --silent --output-dataset

```

## MCP server setup

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

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/RVJmnctpkNSoIIyEN/builds/EPkDjbygvBQqThVLI/openapi.json