# OpenAlex Scraper - Research Papers, Citations & Authors API (`deanko/openalex-scraper`) Actor

OpenAlex API scraper: export research papers, citations, authors, institutions, journals and topics from 250M+ scholarly works to CSV, Excel or JSON. Abstracts included. $3 per 1,000 results.

- **URL**: https://apify.com/deanko/openalex-scraper.md
- **Developed by:** [dean ko](https://apify.com/deanko) (community)
- **Categories:** AI, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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

## OpenAlex Scraper: research papers, citations and authors API

Export research papers, citation counts, authors, institutions, journals and topics from **OpenAlex**, the free and open catalog of **250M+ scholarly works** (the successor to Microsoft Academic Graph). You get clean, flat rows ready for Excel, Google Sheets, BI tools, pandas or your database, with the **full abstract** rebuilt as plain text.

Use it as a no-code **OpenAlex API** and **Google Scholar alternative**. It runs on the official OpenAlex REST API, so there are no proxies, no browser and no blocking, and it costs **$3 per 1,000 results**.

### What does the OpenAlex Scraper do?

It turns an OpenAlex search into a dataset with **one row per record**. Pick what to export:

- **Works** (papers, articles, preprints, books, datasets, dissertations): OpenAlex ID, DOI, title, year, publication date, type, language, citation count, FWCI, authors, author IDs, institutions, countries, journal or repository, ISSN, publisher, open-access status, open-access URL, PDF URL, license, primary topic, field, keywords, PubMed ID, reference count, retraction flag and the **abstract**.
- **Authors**: name, ORCID, works count, citations, h-index, i10-index, current institution, country and top topics.
- **Institutions**: name, ROR, type, country, city, homepage, works, citations, h-index and top topics.
- **Sources** (journals, repositories, conferences): name, ISSN, publisher, open-access and DOAJ flags, APC price, works, citations and h-index.
- **Topics** and legacy **concepts**: name, description, subfield, field, domain, keywords, works and citations.

Every list (authors, institutions, keywords...) is joined with `; ` into one cell, so the CSV opens cleanly in Excel.

#### Who is it for?

- **Researchers and librarians.** Build literature-review datasets, bibliometric analyses and citation reports without writing code.
- **AI and RAG teams.** Collect titles and abstracts on a topic to build training sets, embeddings or a research-assistant knowledge base.
- **R\&D, pharma and tech intelligence.** Track what a company, university or competitor publishes, and which topics are growing.
- **Recruiters and BD teams.** Find the most-cited authors in a field, with ORCID and current institution, for hiring or partnership outreach.
- **Publishers, funders and universities.** Benchmark journals and institutions by output, citations, h-index and open-access share.
- **Monitoring.** Schedule a daily run sorted by newest to catch new papers from an institution, author or topic.

### Why use this OpenAlex scraper?

- **Low price.** $3 per 1,000 results, about 13x cheaper than other OpenAlex actors. You pay only for rows saved.
- **Official API, not HTML scraping.** It runs on the OpenAlex API, so it doesn't break when a website changes. It respects the 10 requests/second limit and retries automatically on rate limits and server errors.
- **Abstracts included.** OpenAlex stores abstracts as an inverted index. The Actor rebuilds the plain text for you.
- **CSV-friendly.** No nested JSON. Every field is a single value, ready for spreadsheets.
- **Simple filters plus full power.** Year range, open access, work type, institution, author, topic and country fields cover most needs, and the advanced field accepts any raw OpenAlex filter.
- **Bring your own key (optional).** Works out of the box with no key. Add your free OpenAlex API key for very large exports.

### How to scrape OpenAlex

1. Click **Try for free** (or **Start**) on this page.
2. Choose **What to scrape** (works, authors, institutions, sources, topics or concepts).
3. Enter a **search query** and any filters.
4. Set **Max results** to cap the number of rows, and with it your cost.
5. Click **Start**, then download the results as **CSV, Excel, JSON, XML or HTML**, or read them via the API.

#### Input examples

The 50 most relevant papers on large language models since 2023 (the prefilled example, about $0.15):

```json
{
  "entity": "works",
  "search": "large language models",
  "fromYear": 2023,
  "maxResults": 50
}
```

The 1,000 most-cited open-access articles from Harvard published 2020 to 2024:

```json
{
  "entity": "works",
  "institutionId": "I136199984",
  "fromYear": 2020,
  "toYear": 2024,
  "openAccessOnly": true,
  "workType": "article",
  "sort": "cited_by_count:desc",
  "maxResults": 1000
}
```

The 200 most-cited authors working on CRISPR in Germany:

```json
{
  "entity": "authors",
  "search": "CRISPR",
  "countryCode": "DE",
  "sort": "cited_by_count:desc",
  "maxResults": 200
}
```

Newest preprints with more than 10 citations, using a raw OpenAlex filter:

```json
{
  "entity": "works",
  "workType": "preprint",
  "extraFilter": "cited_by_count:>10,language:en",
  "sort": "publication_date:desc",
  "maxResults": 500
}
```

| Field | What it does | Example |
|---|---|---|
| `entity` | What to export | `works`, `authors`, `institutions`, `sources`, `topics`, `concepts` |
| `search` | Full-text search (title, abstract, full text for works; name for others) | `"graph neural networks"` |
| `fromYear` / `toYear` | Publication year range (works) | `2020` / `2024` |
| `openAccessOnly` | Only open-access works or fully OA journals | `true` |
| `workType` | Work type (works) | `article`, `review`, `preprint`, `book`, `dataset` |
| `institutionId` | OpenAlex institution ID or URL (works, authors) | `I136199984` |
| `authorId` | OpenAlex author ID or URL (works) | `A5023888391` |
| `topicId` | Topic ID, or legacy concept ID for works | `T10346`, `C41008148` |
| `countryCode` | Two-letter country code | `US`, `KR` |
| `extraFilter` | Any raw OpenAlex filter, appended with AND | `cited_by_count:>100,has_doi:true` |
| `sort` | Sort order | `cited_by_count:desc`, `publication_date:desc` |
| `maxResults` | Maximum rows to save (default 100) | `1000` |
| `mailto` | Optional email sent to OpenAlex as a courtesy | `you@example.com` |
| `apiKey` | Optional free OpenAlex API key | |

Don't know an institution, author or topic ID? Run the Actor once with `entity` set to `institutions`, `authors` or `topics` and a search query. The `id` column has the ID to use.

### Output sample

A works row (abstract shortened):

```json
{
  "entity": "works",
  "id": "W4362515116",
  "url": "https://openalex.org/W4362515116",
  "citedByCount": 2068,
  "doi": "10.1007/s11704-026-60308-3",
  "title": "A Survey of Large Language Models",
  "year": 2026,
  "publicationDate": "2026-05-09",
  "type": "article",
  "language": "en",
  "fwci": 1251.5361,
  "authors": "Wayne Xin Zhao; Kun Zhou; Junyi Li; Tianyi Tang; Zican Dong; Yupeng Hou; ...; Jian-Yun Nie; Ji-Rong Wen",
  "authorsCount": 23,
  "authorIds": "A5037145565; A5100363220; A5030566556; ...",
  "institutions": "Renmin University of China; Université de Montréal",
  "countries": "CN; CA",
  "sourceName": "Frontiers of Computer Science",
  "sourceType": "journal",
  "issn": "2095-2228",
  "publisher": "Higher Education Press",
  "isOa": true,
  "oaStatus": "hybrid",
  "oaUrl": "https://link.springer.com/content/pdf/10.1007/s11704-026-60308-3.pdf",
  "pdfUrl": "https://link.springer.com/content/pdf/10.1007/s11704-026-60308-3.pdf",
  "license": "cc-by",
  "primaryTopic": "Topic Modeling",
  "field": "Computer Science",
  "keywords": "large language models; pre-training; self-supervised learning; fine-tuning; alignment; in-context learning",
  "pmid": null,
  "referencedWorksCount": 0,
  "isRetracted": false,
  "abstract": "Abstract The rapid evolution of large language models (LLMs) has driven a transformative shift in artificial intelligence (AI), reshaping both research paradigm...",
  "updatedDate": "2026-10-22T09:42:04.148104",
  "scrapedAt": "2026-10-23T04:34:51.480Z"
}
```

| Field | Type | Description |
|---|---|---|
| `entity` | string | Which entity the row is (`works`, `authors`...) |
| `id`, `url` | string | Short OpenAlex ID and full OpenAlex URL |
| `citedByCount` | number | Times cited |
| `doi` | string | DOI without the `https://doi.org/` prefix |
| `title`, `year`, `publicationDate`, `type`, `language` | string, number | Bibliographic basics |
| `fwci` | number | Field-weighted citation impact |
| `authors`, `authorIds`, `authorsCount` | string, number | Authors in order, their OpenAlex IDs, and the count |
| `institutions`, `countries` | string | De-duplicated author affiliations and country codes |
| `sourceName`, `sourceType`, `issn`, `publisher` | string | Journal, repository or conference |
| `isOa`, `oaStatus`, `oaUrl`, `pdfUrl`, `license` | boolean, string | Open-access status and the best free copy |
| `primaryTopic`, `field`, `keywords` | string | Subject classification |
| `pmid` | string | PubMed ID, when available |
| `referencedWorksCount`, `isRetracted` | number, boolean | Reference count and retraction flag |
| `abstract` | string | Full abstract as plain text |
| `name`, `orcid`, `worksCount`, `hIndex`, `i10Index`, `institution`, `countryCode`, `topTopics` | | Author, institution and source fields |
| `scrapedAt` | string | When the row was collected (ISO 8601) |

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

This Actor uses **pay-per-event** pricing:

- **$0.003 per result saved** ($3 per 1,000 results)
- **$0.00005 per run start** per GB of memory (the Actor runs on 256 MB, so about $0.0000125 per run)

**Worked example:** exporting 10,000 papers on a topic costs 10,000 × $0.003 = **$30.00**, plus about $0.00001 for the run start. The prefilled 50-paper example costs about **$0.15**, so the $5 of monthly free credit on the Apify Free plan covers around 1,600 results.

Set **Max results** or a maximum charge per run, and the Actor stops as soon as it reaches the limit.

### Integrations and API

Call the Actor from your own code with the official `apify-client`, or connect it to Make, Zapier, n8n, Google Sheets, Slack, webhooks and more from the **Integrations** tab.

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("deanko/openalex-scraper").call(run_input={
    "search": "retrieval augmented generation",
    "fromYear": 2024,
    "sort": "cited_by_count:desc",
    "maxResults": 200,
})
for paper in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(paper["year"], paper["citedByCount"], paper["title"])
```

**JavaScript / Node.js**

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('deanko/openalex-scraper').call({
    entity: 'authors',
    search: 'protein folding',
    sort: 'cited_by_count:desc',
    maxResults: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((a) => `${a.name} (${a.institution}) h=${a.hIndex}`));
```

You can also run it with one HTTP request through the `run-sync-get-dataset-items` endpoint and get the rows back in the response.

### FAQ

**Where does the data come from?**
It comes from the official [OpenAlex API](https://docs.openalex.org), run by the nonprofit OurResearch. OpenAlex data is released under **CC0**, so you can reuse it freely, including commercially.

**Do I need an OpenAlex API key?**
No. Without a key the Actor uses OpenAlex's free shared budget and can return up to 10,000 results per query. For bigger exports, or if you run many large jobs in a day, add your free key from [openalex.org/settings/api](https://openalex.org/settings/api) in the **OpenAlex API key** field. The key is stored as a secret input.

**What is the `mailto` field for?**
OpenAlex asks API users to identify themselves. If you enter your email, it is sent to OpenAlex with each request. It's optional and the Actor never stores it.

**How fast is it?**
It fetches 100 records per request at up to 10 requests per second. The 50-row example finishes in a few seconds, and 10,000 rows take about a minute.

**Is OpenAlex a good Google Scholar alternative?**
For bulk data, yes. Google Scholar has no API and blocks scrapers, while OpenAlex covers a similar body of literature with open, structured metadata, citation counts and abstracts.

**How do I get only new papers every day?**
Schedule the Actor (Console → Schedules) with `sort` set to `publication_date:desc` and a small `maxResults`, or put `from_publication_date:2026-10-01` in `extraFilter`.

**Why are some abstracts empty?**
Some publishers don't allow abstracts to be redistributed, so OpenAlex doesn't have them. The field is `null` in that case.

**Why does a search return a slightly odd top result when sorted by citations?**
Sorting by citations ranks every match, including loosely matching works. Use the default relevance sort, add a year range, or narrow with `workType` and `extraFilter`.

### Limitations

- Without an API key, OpenAlex limits each query to the first 10,000 results. Add a free key to go further.
- Very large dumps (millions of rows) are better served by the free [OpenAlex snapshot](https://docs.openalex.org/download-all-data/openalex-snapshot).
- Lists such as referenced works, related works and per-year citation counts are not included, to keep rows flat.
- Data is only as complete as OpenAlex itself, and author disambiguation is automated.

### Legal and privacy

OpenAlex data is CC0. This Actor is not affiliated with or endorsed by OpenAlex or OurResearch. Author records contain names and ORCID IDs that researchers publish publicly. You are responsible for using the data in line with the laws that apply to you.

### Support and feedback

Missing a field or filter you need, or found a bug? Open an issue in the **Issues** tab on this page. If the Actor saves you time, a short review helps other people find it.

# Actor input Schema

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

OpenAlex entity type to export. Works are papers and other research outputs.

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

Full-text search. For works it matches title, abstract and full text; for other entities it matches the name. Supports AND, OR, NOT and "exact phrases". Leave empty to list everything matching the filters.

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

Works only. Earliest publication year (inclusive).

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

Works only. Latest publication year (inclusive).

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

Works and sources only. Return only open-access works (or fully open-access journals).

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

Works only. Restrict to one work type.

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

Works and authors. OpenAlex institution ID or URL, e.g. I136199984 (Harvard). Find IDs by running this Actor with entity = institutions.

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

Works only. OpenAlex author ID or URL, e.g. A5023888391. Find IDs by running this Actor with entity = authors.

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

OpenAlex topic ID (T10346) or legacy concept ID (C41008148, works only). Find IDs by running this Actor with entity = topics.

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

Two-letter ISO country code, e.g. US, DE, KR. Works: any author's institution country. Authors: last known institution. Institutions and sources: their country.

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

Any raw OpenAlex filter string, appended to the filters above, e.g. cited_by_count:>100,has_doi:true,language:en. See https://docs.openalex.org for all filters.

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

Sort order. Default is relevance when you search, otherwise OpenAlex's default order.

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

Maximum number of rows to save. You are charged per row, so this caps your cost (100 rows is about $0.30; 1,000 rows is about $3).

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

Optional. Sent to OpenAlex as the mailto parameter so they can contact you about your usage. Not stored by the Actor.

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

Optional. Your free OpenAlex API key (https://openalex.org/settings/api) gives you your own daily budget instead of the shared per-IP one. Recommended for very large exports.

## Actor input object example

```json
{
  "entity": "works",
  "search": "large language models",
  "fromYear": 2023,
  "openAccessOnly": false,
  "workType": "",
  "institutionId": "",
  "authorId": "",
  "topicId": "",
  "countryCode": "",
  "extraFilter": "",
  "sort": "",
  "maxResults": 50,
  "mailto": ""
}
```

# 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 = {
    "entity": "works",
    "search": "large language models",
    "fromYear": 2023,
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("deanko/openalex-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 = {
    "entity": "works",
    "search": "large language models",
    "fromYear": 2023,
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("deanko/openalex-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 '{
  "entity": "works",
  "search": "large language models",
  "fromYear": 2023,
  "maxResults": 50
}' |
apify call deanko/openalex-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deanko/openalex-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/XMY60vPRYG31Egbpx/builds/XfTDdLMYkFR6g3cru/openapi.json