# Research Papers Search – OpenAlex, arXiv, PubMed & Crossref API (`extractlyspace/academic-papers-search`) Actor

Returns research papers for a topic from OpenAlex, Crossref, arXiv and PubMed in one call, merged by DOI: title, authors, year, venue, DOI, abstract, citation count, open-access PDF link and source IDs. Filter by author, year and open access; look up DOIs. No login.

- **URL**: https://apify.com/extractlyspace/academic-papers-search.md
- **Developed by:** [Spase Nikolov](https://apify.com/extractlyspace) (community)
- **Categories:** AI
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.50 / 1,000 papers

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

## Research Papers Search – OpenAlex, arXiv, PubMed & Crossref API

This Actor returns research papers for a topic from the open scholarly databases OpenAlex, Crossref, arXiv and PubMed in one call, read live at run time through their official APIs. A paper that several sources know is returned once, merged by DOI, arXiv id or PubMed id. Each row has the title, authors, year, publication date, journal or venue, type, DOI, link, free PDF link when there is one, open-access flag, citation count, abstract and the ids the paper has in each source. Filter by author, year range and open access, sort by relevance, date or citations, and look up papers by DOI or arXiv id. No login is needed.

### Use this to

- **Run a literature search**: "Find 20 recent open-access papers on malaria vaccines."
- **Check what a researcher published**: "List the papers on graph neural networks by Kipf from 2016 to 2018."
- **Resolve references**: "Give me title, authors, abstract and a PDF link for these DOIs and arXiv ids."
- **Feed an agent or a workflow**: one flat row per paper, the same fields every time, ready for a spreadsheet, a vector store or an n8n flow.

### Sample output

| recordType | title | firstAuthor | year | venue | doi | citationCount | sources |
|---|---|---|---|---|---|---|---|
| paper | An Example Study of Gene Editing | Ada Example | 2024 | Journal of Examples | 10.1234/example.2024.001 | 12 | crossref, pubmed |

These values are invented for illustration. Every paper row has the same 19 fields: `recordType`, `title`, `authors`, `firstAuthor`, `year`, `publicationDate`, `venue`, `type`, `doi`, `url`, `pdfUrl`, `isOpenAccess`, `citationCount`, `abstract`, `sources`, `openalexId`, `arxivId`, `pmid` and `scrapedAt`. A value no source provides is returned as `null`.

- `authors` lists the names in order, joined by commas; after 50 names it ends with `et al.` `firstAuthor` is the first name.
- `publicationDate` is as precise as the source gives it: `2024-03-05`, `2024-03` or `2024`. For a paper only arXiv knows, it is the date of the first version.
- `type` is `article`, `review`, `preprint`, `book-chapter`, `book`, `report`, `dissertation`, `dataset` or another type as the source names it.
- `doi` is lower case without a link prefix. A journal DOI is preferred; a paper only arXiv knows gets its arXiv DOI (`10.48550/arxiv.<id>`).
- `url` is the `doi.org` link, the arXiv page for a preprint, or the source's own page.
- `pdfUrl` is a free PDF link when OpenAlex, arXiv or an openly licensed Crossref record gives one.
- `isOpenAccess` is `true` when a source says the paper is free to read (an open licence, a PubMed Central copy, PubMed's free full text, an arXiv preprint), `false` when OpenAlex says it is not, and `null` when no source says.
- `citationCount` comes from OpenAlex, otherwise from Crossref; arXiv and PubMed have no counts, so a paper only they know has `null`.
- `abstract` is plain text, up to 10,000 characters, preferring PubMed's, then OpenAlex's, arXiv's and Crossref's.
- `sources` names where the paper was found: `openalex`, `crossref`, `arxiv`, `pubmed`, joined by commas.

### Pricing

Draft price, not final. You pay per event:

- `paper`: $0.0005 for each paper returned.

Examples: 20 papers cost $0.01. 200 papers cost $0.10.

Explanatory rows (see below) are never charged. The run stops when it reaches your spending limit.

### Input

Send a `query`, a list of `dois`, or both.

- **query**: the topic, up to 300 characters, such as `CRISPR gene editing`. PubMed also accepts its own search syntax.
- **author**: only papers by this author, such as `Jennifer Doudna`. A full name works best.
- **dois**: DOIs, `doi.org` links or arXiv ids to look up, up to 50, such as `10.1038/nature14539` or `arXiv:1706.03762`. They are returned first. Without a `query` only these papers are returned; with one, papers on the topic fill the rest up to `maxResults`. Every listed paper that is found is returned, even when there are more of them than `maxResults`.
- **sources**: any of `openalex`, `crossref`, `arxiv`, `pubmed`. Leave empty for all available sources.
- **fromYear**, **toYear**: only papers published in this range of years, 1800 to 2100.
- **openAccessOnly**: only papers a source marks as free to read (default off). Papers listed in `dois` are always returned.
- **sort**: `relevance` (default), `newest` or `most_cited`. Relevance takes each source's best matches in turn, a paper found by several sources first among equals. Papers without a known date or citation count come last.
- **maxResults**: the most papers to return, 1 to 200 (default 20), raised to the number of `dois` when that is larger. Each returned paper is charged.
- **includeAbstract**: adds the abstract (default on). Turn it off for smaller rows.

A typical call of 20 papers takes a few seconds. arXiv asks for one request every three seconds, so a call that also looks up arXiv ids takes about three seconds longer.

### What you get when nothing matches

An input the form itself rejects, such as a text where a list belongs, is refused before the run starts. When nothing matches or the input needs correcting in another way, the run succeeds and returns a short explanatory row instead of an empty result. The run fails, with a clear message, only when no source could be read and nothing was returned. The explanatory row has `recordType: "status"`, a `message` in plain language and a `subject`. The `status` is one of:

- `invalid_input`: neither a `query` nor `dois`, `fromYear` after `toYear`, an entry in `dois` that is not a DOI or an arXiv id, or more than 50 DOIs. The message says what to change, with an example.
- `no_results`: `No paper in SOURCES matches the search.`
- `not_found`: `None of the sources that answered (SOURCES) knows DOI.` for a listed DOI or arXiv id that no answering source has; the other papers are returned.
- `partial`: `SOURCE could not be read right now; the papers come from the other sources. Try again later.` The papers from the other sources are returned.
- `limit_reached`: `Stopped: the spending limit for this run was reached. Delivered N papers.`
- `unavailable`: you named OpenAlex in `sources` and this Actor cannot read it at the moment. The other sources you chose still answer; if OpenAlex was the only one, nothing is returned.

### Limits

- Each source is asked for up to `maxResults` papers per run and searched with its own engine, so results differ from the sources' websites and are not a complete bibliography.
- `most_cited` sorts the papers the sources return for the topic; it does not find the most cited papers of a whole field.
- `openAccessOnly` relies on what each source says: Crossref records count only with an open (Creative Commons) licence.
- Author filters use each source's own name matching; a common surname can match other people.
- Sources limit how fast they may be asked. When one is busy or down, the run returns the others and says which one was missing.

### FAQ

**Where does the data come from?** From the public APIs of OpenAlex, Crossref, arXiv and PubMed (NCBI E-utilities), read live when the run happens. The Actor keeps no copy of its own and is not affiliated with or endorsed by any of them. Thank you to arXiv for use of its open access interoperability.

**Is this a Google Scholar scraper?** No. It reads only official, open APIs, so it does not get blocked and needs no proxy.

**Do I need an account or an API key?** No.

**Why is a paper listed twice?** Two records are merged only when they share a DOI, an arXiv id or a PubMed id. A preprint and its journal version with different DOIs stay separate unless a source links them.

This Actor reports usage statistics to its developer to keep it reliable: the Actor's name and build number, the time of the run, the run's outcome, row counts, events charged, an estimate of the revenue from those events, an estimate of what paid data sources cost for the run (reported as zero for this Actor), duration, a short error category when a run fails, partly fails or meets upstream data in an unexpected shape, how the run was started, whether the account is on a paid plan, and a one-way hash of the Apify user ID. It never reports your inputs or the data returned.

# Actor input Schema

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

Topic to search titles, abstracts and other metadata, up to 300 characters. Needed unless dois is given. PubMed also accepts its own search syntax. Example: "CRISPR gene editing"

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

Only papers by this author. A full name works best. Leave empty for any author. Example: "Jennifer Doudna"

## `dois` (type: `array`):

DOIs, doi.org links or arXiv ids to look up, up to 50, returned first. Without a query only these are returned; with one, topic results fill up to maxResults. Example: \["10.1038/nature14539", "arXiv:1706.03762"]

## `sources` (type: `array`):

Which sources to search. Values: openalex, crossref, arxiv, pubmed. Leave empty for all available. Each row's sources field names where the paper was found. Example: \["arxiv", "pubmed"]

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

Only papers published in this year or later, from 1800 to 2100. Example: 2020

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

Only papers published in this year or earlier, from 1800 to 2100. Example: 2024

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

Only papers a source marks as free to read (an open licence, a PubMed Central copy, or an arXiv preprint). DOIs you list are always returned. Example: true

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

Order of the papers. Values: relevance, newest, most_cited. Papers without a known date or citation count come last. Example: newest

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

The most papers to return, from 1 to 200; raised to the number of dois when that is larger. Each returned paper is charged. Example: 20

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

Add the abstract as plain text, up to 10,000 characters, when a source has it. Turn off for smaller rows. Example: false

## Actor input object example

```json
{
  "query": "CRISPR gene editing",
  "dois": [],
  "sources": [],
  "openAccessOnly": false,
  "sort": "relevance",
  "maxResults": 10,
  "includeAbstract": true
}
```

# Actor output Schema

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

One row per paper (recordType "paper"). Explanatory rows (recordType "status", with status, message and subject) say when nothing matched, a DOI was not found, a source could not be read, or the spending limit was reached.

# 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": "CRISPR gene editing",
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("extractlyspace/academic-papers-search").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": "CRISPR gene editing",
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("extractlyspace/academic-papers-search").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": "CRISPR gene editing",
  "maxResults": 10
}' |
apify call extractlyspace/academic-papers-search --silent --output-dataset

```

## MCP server setup

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

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/xxXsYJzKEAOf6L0f7/builds/J1MnNB5aE16oBbmCV/openapi.json
