# Research Papers Scraper - OpenAlex 250M+ Works, $0.50/1K (`plotpointtech/research-papers-scraper-openalex`) Actor

Search 250M+ research papers from the open OpenAlex catalog: titles, DOIs, abstracts, authors with ORCIDs and institutions, citations, topics and open-access PDF links. Author, institution and citation lookups. $0.50 per 1,000 records.

- **URL**: https://apify.com/plotpointtech/research-papers-scraper-openalex.md
- **Developed by:** [Plot Point Technologies](https://apify.com/plotpointtech) (community)
- **Categories:** AI, Developer tools, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.31 / 1,000 records

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

## Research Papers Scraper: search 250M+ scholarly works from OpenAlex

**Get research papers as clean, structured records: title, DOI, abstract, authors with ORCIDs and institutions, venue, topics, citation counts and open-access PDF links.** This research papers scraper reads the official, open OpenAlex API, the free catalog of the world's research (more than 250 million works, CC0-licensed). Search by keyword, look up DOIs, pull an author's or a university's publications, or walk a paper's citation network. No browser, no login, no blocking. **$0.50 per 1,000 records.**

We do not scrape Google Scholar. OpenAlex is an open data source built for automated use, so results are stable and the data can be reused freely.

### What can this research papers scraper do?

- **Search papers** by keywords in the title and abstract, the title only, or the full text, with `AND`, `OR`, `NOT` and "exact phrases".
- **Filter** by publication year range, open access only, work type (article, review, preprint, book, dataset, dissertation...), OpenAlex topics (enter a name like `CRISPR` or an ID like `T10878`), minimum citations, language, abstract present, and exclude retracted papers.
- **Sort** by relevance, most cited, newest or oldest.
- **Get papers by ID:** DOIs, OpenAlex work IDs or PubMed IDs, looked up in batches of 50.
- **Authors + their papers:** names, ORCIDs or OpenAlex author IDs. You get the author profile (works count, citations, h-index, i10-index, last known institutions, main topics) followed by their papers.
- **Institutions + their papers:** names, ROR IDs or OpenAlex institution IDs. You get the institution profile (country, city, type, homepage, works, citations, h-index) followed by its papers.
- **Citation expansion:** for seed papers, get the papers that cite them (cited by), the papers they cite (references), or both.
- **Large result sets:** pages through results automatically, 100 per request, with cursor paging when you supply an OpenAlex API key.

### What data do you get?

Every paper record has: `openAlexId`, `title`, `doi`, `doiUrl`, `publicationYear`, `publicationDate`, `type`, `language`, `venue` (journal, repository or conference), `venueType`, `issn`, `publisher`, `volume`, `issue`, `pages`, `authorNames`, `firstAuthor`, `authorsCount`, `authors` (each with `name`, `orcid`, `openAlexId`, `position`, `isCorresponding`, `institutions`, `countries`), `institutions`, `abstract` (rebuilt from OpenAlex's inverted index into plain text), `primaryTopic`, `subfield`, `field`, `domain`, `topics`, `keywords`, `citedByCount`, `referencesCount`, `fwci` (field-weighted citation impact), `isOpenAccess`, `oaStatus`, `oaUrl`, `pdfUrl`, `landingPageUrl`, `license`, `isRetracted`, `pmid`, `openAlexUrl` and `apiUrl`. Optional: `referencedWorks` (IDs of every paper it cites).

Records also say where they came from: `query` (search), `input` (ID lookups), `seedType`, `seedId`, `seedName` (author or institution), or `relation` (`seed`, `citing`, `referenced`) and `seedTitle` (citations).

Author and institution profiles have `recordType` set to `author` or `institution`, so you can filter them out of a paper list.

### Who uses it?

- **Researchers and students** building literature reviews, reading lists and systematic-review screening sets.
- **Research offices and libraries** tracking their institution's output, open-access share and citations.
- **R\&D, pharma and biotech teams** monitoring new publications on a target, method or competitor lab.
- **Grant, funding and policy analysts** measuring research activity by topic, country or institution.
- **AI and data teams** collecting abstracts and metadata for RAG systems, classifiers and knowledge graphs.
- **Recruiters and business developers** finding active experts in a field through their recent papers (public academic profiles only).

### How to use it

1. Click **Try for free** (or **Start**). With no changes it returns the 50 most relevant papers for "large language models" in a few seconds.
2. Choose **What to get**: search papers, get papers by ID, authors, institutions or citations.
3. Enter your query, IDs, author names or institutions, and set any filters (years, open access, type, topics, minimum citations, sort).
4. Set **Maximum results** and run it.
5. Download the results as Excel, CSV, JSON or HTML, or schedule the run to watch for new papers.

### Input example

```json
{
  "mode": "searchWorks",
  "query": "large language models",
  "searchIn": "titleAbstract",
  "yearFrom": 2023,
  "openAccessOnly": true,
  "workTypes": ["article", "review"],
  "minCitations": 20,
  "sortBy": "citations",
  "maxResults": 500
}
```

More examples:

- Papers by DOI: `{"mode": "getWorks", "workIds": ["10.1038/nature14539", "W2741809807", "26771483"]}`
- Author and their most cited papers: `{"mode": "authors", "authors": ["0000-0001-9161-999X", "Geoffrey Hinton"], "maxWorksPerSeed": 100, "sortBy": "citations"}`
- A university's open-access papers since 2024: `{"mode": "institutions", "institutions": ["https://ror.org/042nb2s44"], "yearFrom": 2024, "openAccessOnly": true, "maxWorksPerSeed": 1000}`
- Who cites a paper: `{"mode": "citations", "workIds": ["10.1038/nature14539"], "citationDirection": "citedBy", "maxWorksPerSeed": 1000, "sortBy": "newest"}`

### Output example

From a real default run (abstract and lists shortened here):

```json
{
  "recordType": "work",
  "openAlexId": "W4362515116",
  "title": "A Survey of Large Language Models",
  "doi": "10.1007/s11704-026-60308-3",
  "doiUrl": "https://doi.org/10.1007/s11704-026-60308-3",
  "publicationYear": 2026,
  "publicationDate": "2026-05-09",
  "type": "article",
  "language": "en",
  "venue": "Frontiers of Computer Science",
  "venueType": "journal",
  "issn": "2095-2228",
  "publisher": "Higher Education Press",
  "volume": "20",
  "issue": "12",
  "firstAuthor": "Wayne Xin Zhao",
  "authorsCount": 23,
  "authors": [
    {
      "name": "Wayne Xin Zhao",
      "orcid": "0000-0002-8333-6196",
      "openAlexId": "A5037145565",
      "position": "first",
      "isCorresponding": false,
      "institutions": ["Renmin University of China"],
      "countries": ["CN"]
    }
  ],
  "institutions": ["Renmin University of China", "Université de Montréal"],
  "abstract": "The rapid evolution of large language models (LLMs) has driven a transformative shift in artificial intelligence (AI), reshaping both research paradigms and practical applications...",
  "primaryTopic": "Topic Modeling",
  "subfield": "Artificial Intelligence",
  "field": "Computer Science",
  "domain": "Physical Sciences",
  "topics": ["Topic Modeling", "Natural Language Processing Techniques", "Multimodal Machine Learning Applications"],
  "keywords": ["large language models", "pre-training", "self-supervised learning", "model architecture"],
  "citedByCount": 2093,
  "isOpenAccess": 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",
  "landingPageUrl": "https://doi.org/10.1007/s11704-026-60308-3",
  "license": "cc-by",
  "isRetracted": false,
  "openAlexUrl": "https://openalex.org/W4362515116",
  "query": "large language models"
}
```

### How much does it cost?

**$0.50 per 1,000 records** ($0.0005 each), plus a $0.00005 start fee per run. A record is one paper, author profile or institution profile.

| You get | You pay |
|---|---|
| The default search (50 papers) | about $0.03 |
| A 1,000-paper literature search | $0.50 |
| An author profile plus their 500 papers | about $0.25 |
| 100,000 papers on a topic | $50 |

**Volume discounts on higher Apify plans.** The prices above are for the Apify Free plan. On paid plans the per-record price drops automatically: about 15% lower on Bronze, 25% lower on Silver and 38% lower on Gold and above.

**OpenAlex usage.** OpenAlex gives every network address a small shared free daily budget for keyless use, and a free API key with its own budget ($1 of OpenAlex usage a day, enough for roughly 100,000 search results or about a million filtered results). For big or frequent jobs, create a free key at [openalex.org/settings/api](https://openalex.org/settings/api) and paste it into **OpenAlex API key**. Without a key, results are limited to the first 10,000 per query.

### Use it via API, Make, Zapier, n8n or an AI agent

**Apify API.** Start a run and get the results back in one HTTP request (replace `YOUR_API_TOKEN` with the token from Apify Console > Settings > Integrations):

```bash
curl -X POST "https://api.apify.com/v2/acts/plotpointtech~research-papers-scraper-openalex/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query": "large language models", "yearFrom": 2024, "sortBy": "citations", "maxResults": 100}'
```

For longer jobs, start the run asynchronously and read the dataset when it finishes. Official `apify-client` libraries exist for Python and JavaScript; the **API** tab on this page has ready-made code.

**No-code automation.** Connect the tool to **Make, Zapier, n8n, Google Sheets, Slack, Airtable** or any webhook with Apify integrations, and use **Schedules** in Apify Console to run it daily or weekly (for example, sort by newest to get each week's new papers on a topic).

**AI agents (MCP).** Give Claude, ChatGPT, Cursor, VS Code or any MCP-compatible agent direct access to this tool through the hosted Apify MCP server. Add this server URL to your client:

```
https://mcp.apify.com?tools=plotpointtech/research-papers-scraper-openalex
```

The agent can then call the tool with the same input fields shown above and read the results.

### FAQ

**Is it legal to use this data?**
Yes. The tool does not scrape web pages. It calls the official OpenAlex API, which is published for automated use, and OpenAlex releases its data under the CC0 public-domain dedication, so you can reuse it commercially. Abstracts come from OpenAlex as published; some publishers do not allow OpenAlex to show abstracts, so those records have `abstract` empty. Author records contain only public academic information (names, ORCIDs, affiliations, publications). You remain responsible for how you use it under the laws that apply to you.

**Is this a Google Scholar scraper?**
No. Google Scholar does not allow automated access. OpenAlex covers a similar range of literature (journals, repositories, preprints, books, conferences) and is free to reuse, which makes it a practical Google Scholar alternative for data work.

**Why do citation counts differ from Google Scholar or Scopus?**
Each index covers different sources and counts citations differently. Counts here are OpenAlex's, updated continuously.

**Does it download the PDFs?**
No. It returns `pdfUrl`, `oaUrl` and `landingPageUrl` so you can fetch open-access full texts yourself. Our PDF to Text tool (below) can turn those PDFs into text.

**How are author names matched?**
A name search returns the most relevant OpenAlex author profile (set **Author matches per name** to see more). For exact results use ORCIDs or OpenAlex author IDs.

**What if I see "daily budget is used up"?**
The shared keyless OpenAlex budget for the run's network address ran out. Add your free OpenAlex API key and run again.

### Related tools from Plot Point Technologies

- [PDF to Text & Tables Extractor - Markdown + OCR](https://apify.com/plotpointtech/pdf-text-markdown-tables-extractor): turn open-access paper PDFs into clean text and tables.
- [Wikipedia Scraper - Wikidata Facts, Summaries & Images](https://apify.com/plotpointtech/wikipedia-wikidata-entity-extractor): structured facts about people, organizations and concepts.
- [News Scraper - Worldwide News Search by Keyword](https://apify.com/plotpointtech/worldwide-news-search): news coverage of a research topic or institution.
- [Website to Markdown Crawler for AI, LLM & RAG](https://apify.com/plotpointtech/website-to-markdown-crawler): add lab and journal web pages to your RAG pipeline.

Plot Point Technologies is not affiliated with OpenAlex or OurResearch.

***

If this tool saved you time, we would be grateful for a short review on this page; it helps other people find it. If something did not work as expected, please open an issue on the **Issues** tab and we will look into it quickly.

# Actor input Schema

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

Search works by keyword and filters, fetch specific works by DOI/ID, look up authors or institutions with their works, or expand the citation network of seed papers.

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

Keywords to search for (search papers mode). Supports AND, OR, NOT and "exact phrases".

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

Where to match the query: title and abstract (default, precise), title only, or full text (title, abstract and indexed full text; widest).

## `workIds` (type: `array`):

For 'Get papers' and 'Citations' modes: DOIs (10.1038/nature14539 or https://doi.org/...), OpenAlex work IDs (W2741809807 or URL) or PubMed IDs.

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

Citations mode: papers that cite each seed (cited by), papers each seed cites (references), or both.

## `includeSeedWorks` (type: `boolean`):

Citations mode: also output each seed paper itself.

## `authors` (type: `array`):

Authors mode: names (e.g. Jennifer Doudna), ORCIDs (0000-0001-9161-999X) or OpenAlex author IDs (A5067184382).

## `matchesPerName` (type: `integer`):

Authors mode: how many matching author profiles to return for a name search (names can be ambiguous; ORCIDs are exact).

## `institutions` (type: `array`):

Institutions mode: names (e.g. MIT), ROR IDs (https://ror.org/042nb2s44) or OpenAlex institution IDs (I63966007).

## `includeWorks` (type: `boolean`):

Authors / institutions mode: also output their papers (filters and sort below apply).

## `maxWorksPerSeed` (type: `integer`):

Upper limit of papers per author, institution or seed paper (the overall maximum still applies).

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

Only papers published in or after this year.

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

Only papers published in or before this year.

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

Only papers that are free to read somewhere (gold, green, hybrid, bronze or diamond).

## `hasAbstract` (type: `boolean`):

Skip records without an abstract in OpenAlex.

## `workTypes` (type: `array`):

Only these types. Leave empty for all.

## `topics` (type: `array`):

Only papers in these OpenAlex topics. Enter topic names (matched to the closest OpenAlex topic, shown in the log) or topic IDs like T10181.

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

Only papers cited at least this many times.

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

Two-letter language code, e.g. en, de, es, zh. Leave empty for all.

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

Skip papers flagged as retracted.

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

Relevance (searches only; otherwise falls back to most cited), most cited, newest or oldest.

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

Stop after this many records in total (papers plus author / institution profiles).

## `includeReferencedWorkIds` (type: `boolean`):

Add the list of OpenAlex IDs each paper cites (referencedWorks).

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

Your free OpenAlex API key (https://openalex.org/settings/api). Recommended for large jobs: it gives you your own daily OpenAlex budget and unlocks results beyond the first 10,000 per query. Without it, the tool uses OpenAlex's shared free budget.

## Actor input object example

```json
{
  "mode": "searchWorks",
  "query": "large language models",
  "searchIn": "titleAbstract",
  "citationDirection": "citedBy",
  "includeSeedWorks": true,
  "matchesPerName": 1,
  "includeWorks": true,
  "maxWorksPerSeed": 100,
  "openAccessOnly": false,
  "hasAbstract": false,
  "excludeRetracted": true,
  "sortBy": "relevance",
  "maxResults": 50,
  "includeReferencedWorkIds": false
}
```

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

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

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

```

## MCP server setup

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

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/ghgjEcMJ1hMbHbHzf/builds/XX4bYJcdgrLQglJce/openapi.json