# Academic Paper Search: OpenAlex, Crossref, arXiv, PubMed (`datagleaner/academic-literature-search`) Actor

Search scholarly papers across OpenAlex, Crossref, arXiv and PubMed in one call: title, authors, year, venue, DOI, abstract, citation count and open-access link. $0.004 per 25 works. For literature reviews, research agents and RAG.

- **URL**: https://apify.com/datagleaner/academic-literature-search.md
- **Developed by:** [Data Gleaner](https://apify.com/datagleaner) (community)
- **Categories:** AI, Education, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.16 / 1,000 scholarly works

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

## Academic Paper Search: OpenAlex, Crossref, arXiv, PubMed

**Search scholarly papers across OpenAlex, Crossref, arXiv and PubMed in one call. One row per work with title, authors, year, venue, DOI, abstract (where the licence allows), citation count and a free full-text link. $0.004 per 25 works.** No login, no API key needed, no CAPTCHA.

Built for people and AI agents that need literature search as a single tool call: "find the most cited papers on retrieval augmented generation since 2023", "look up these 40 DOIs", "what has been published on CRISPR base editing this year, open access only".

### Use cases

- **Literature reviews and related-work sections:** collect candidate papers on a topic from four indexes at once, already deduplicated by DOI and title.
- **AI research agents and RAG pipelines:** structured paper metadata with abstracts and open-access links, ready to feed into a retrieval index or a summariser.
- **Citation tracking and bibliometrics:** citation counts per work, with the source of each count stated.
- **Reading lists and newsletters:** `sortBy: newest` for the latest papers on a topic, `sortBy: citations` for the classics.
- **DOI enrichment:** turn a list of DOIs into titles, authors, venues, citation counts and open-access links.

### Where the data comes from

| Source | What it adds | Terms |
|---|---|---|
| OpenAlex | Abstracts, citation counts, open-access links, work type | Data is CC0 |
| Crossref | DOI metadata: titles, authors, venue, year, citation counts | Bibliographic facts from the public REST API |
| arXiv | Preprints with abstracts and PDF links | Metadata via the arXiv API, CC0 |
| PubMed | Biomedical records through NCBI E-utilities, PubMed Central links | NCBI usage policy: identified client, at most 3 requests a second |
| OpenCitations | Citation counts for works whose source gives none | Open citation index |

Only each provider's documented public API is called, and requests are paced to the provider's own limits: one arXiv request every 3 seconds, under 3 NCBI requests a second, polite-pool identification (a contact address) on OpenAlex and Crossref, and any Crawl-delay a host publishes.

**Authors** are the names as printed in the bibliographic record. No emails, affiliations or ORCID iDs are returned. **Abstracts** come from OpenAlex and arXiv only. Crossref and PubMed abstracts are left out because publishers hold their copyright; the `sourceUrl` points to the record where the abstract is shown.

### Input

| Field | Meaning |
|---|---|
| `queries` | Topics or keywords, one per line. arXiv field prefixes (`ti:`, `au:`) and PubMed syntax work in those sources. |
| `dois` | Specific works by DOI or doi.org link, looked up in OpenAlex, then arXiv (for arXiv DOIs) and Crossref. |
| `citationsFor` | Citation-graph mode: DOIs whose references (works they cite) and/or citing works are returned as ordinary rows with `relation` (`reference` or `citing`) and `seedDoi`. OpenAlex first (`referenced_works`, `cites:` filter), OpenCitations when OpenAlex has no answer. |
| `citationDirection` | `both` (default), `references` or `cited_by`. `maxResults` caps each direction per DOI; citing works come most cited first. |
| `sources` | Any of `openalex`, `crossref`, `arxiv`, `pubmed`. Default: all four. |
| `maxResults` | Works per topic after merging (default 25, up to 500). |
| `yearFrom`, `yearTo` | Publication year range. |
| `sortBy` | `relevance` (default), `citations` or `newest`. arXiv and PubMed have no citation sort and fall back to relevance. |
| `openAccessOnly` | Keep only works with a free full-text link. |
| `addCitationCounts` | Fill missing citation counts from OpenCitations (up to 150 lookups per run). Default on. |
| `openalexApiKey` | Optional. A free OpenAlex key raises OpenAlex's daily budget. Without one, OpenAlex can stop answering when the shared free budget is used up, and the other sources still run. |

Leave `queries`, `dois` and `citationsFor` empty to run a built-in example: 5 works on `large language model agents` (a few seconds, 5 x $0.00016).

```json
{
  "queries": ["retrieval augmented generation", "crispr base editing"],
  "yearFrom": 2023,
  "sortBy": "citations",
  "maxResults": 25
}
```

### Output

```json
{
  "title": "Large language models encode clinical knowledge",
  "authors": ["Karan Singhal", "Shekoofeh Azizi"],
  "year": 2023,
  "venue": "Nature",
  "doi": "10.1038/s41586-023-06291-2",
  "abstract": "Large language models (LLMs) have demonstrated impressive capabilities...",
  "citationCount": 4091,
  "citationSource": "openalex",
  "openAccessUrl": "https://www.nature.com/articles/s41586-023-06291-2.pdf",
  "isOpenAccess": true,
  "workType": "article",
  "source": "openalex",
  "sources": ["openalex", "crossref"],
  "sourceId": "W4384071683",
  "sourceUrl": "https://openalex.org/W4384071683",
  "query": "retrieval augmented generation",
  "rank": 5,
  "scrapedAt": "2026-11-01T16:00:00+00:00"
}
```

Results from the sources are mixed in round-robin order, each source in its own ranking. A work found in several sources is one row, with the gaps (abstract, open-access link, citation count) filled from the others and `sources` listing all of them.

### Pricing

Pay per event: **$0.004 per 25 works** ($0.00016 per work), charged for each work returned. Duplicates across sources are merged first and billed once. Worked examples:

- 25 works on one topic: $0.004.
- 4 topics at 50 works each (200 works): $0.032.
- 100 DOIs looked up: $0.016.
- Citation graph of one paper, 25 references and 25 citing works: $0.008.
- The empty-input example (5 works): $0.0008.

Set a maximum cost per run in the Apify run options; the Actor stops at that limit and says so in its status message.

### Limits

- Each source returns its own ranking; Crossref matching is looser than OpenAlex's, so on narrow topics a few Crossref rows can be only loosely related. Use `sources` to leave a source out.
- A source that is down or out of budget is skipped and named in the run's status message; the others still return rows.
- OpenCitations counts only citations in its own index, so the count of an arXiv or PubMed work can be lower than Google Scholar's.
- Citation-graph rows are billed like any work, once per run: a work linked to two seed DOIs appears under the first. Reference lists are as complete as the OpenAlex and OpenCitations indexes.
- At most 500 works per topic per run.

### FAQ

**Do I need API keys?** No. An optional OpenAlex key avoids the shared free daily budget.

**Can I get full text?** The `openAccessUrl` links to a free copy when one is known. The Actor does not download or store the papers.

**Is the same paper billed twice?** No. Works are merged by DOI and by title across sources and across the topics of one run, and billed once.

**Why is there no abstract on some rows?** Abstracts are returned only where the licence allows (OpenAlex, arXiv). Crossref and PubMed abstracts are publisher copyright.

### Responsible use

The data is public bibliographic metadata from open APIs. You are responsible for how you use it, including the copyright of the papers behind the links and any personal-data rules that apply to author names in your jurisdiction.

Use the output for literature review, research monitoring and citation work. It is not for building outreach, marketing or recruiting lists of researchers: the Actor returns author names only as printed in the record, with no emails, affiliations or ORCID iDs.

### Removal requests

If you are named in a record and want your name left out of this Actor's output, email datagleaner@gmail.com with the DOI or title. We answer within 30 days, record each request with its date and answer, and add a filter for it in the next release. The Actor keeps no copy of the data, and it cannot change the source records at OpenAlex, Crossref, arXiv or PubMed; ask those services to correct a record at the source.

# Actor input Schema

## `queries` (type: `array`):

Topics or keywords, one per line, e.g. `retrieval augmented generation` or `crispr base editing`. Each topic is searched separately in every chosen source. Leave this and DOIs empty to run a 5-work example.

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

Look up specific works by DOI, e.g. `10.1038/nature14539` or a doi.org link. Returned with the same fields as search results.

## `citationsFor` (type: `array`):

Citation-graph mode. For each DOI, return the works it cites (references) and/or the works that cite it, as ordinary rows with `relation` (`reference` or `citing`) and `seedDoi`. Uses OpenAlex, with OpenCitations as fallback. Max works per topic limits each direction per DOI. Each work is billed once per run, so a work shared by two seed DOIs appears under the first.

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

Used with the citation-graph DOIs.

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

Which sources to search. Results are merged by DOI and title, so a work found in several sources is one row.

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

Works returned per topic after merging the sources (a DOI list counts as one topic). You pay per work returned.

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

Only works published in this year or later.

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

Only works published in this year or earlier.

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

How each source ranks its matches before they are merged.

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

Keep only works with a free full-text link (openAccessUrl).

## `addCitationCounts` (type: `boolean`):

For works whose source gives no citation count (arXiv, PubMed), look up the count in the OpenCitations index, up to 150 lookups per run.

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

OpenAlex gives every user a free daily budget and a free key raises it. Without a key, OpenAlex may stop answering when the shared daily budget is used up; the other sources still run.

## Actor input object example

```json
{
  "queries": [
    "large language model agents"
  ],
  "citationDirection": "both",
  "sources": [
    "openalex",
    "crossref",
    "arxiv",
    "pubmed"
  ],
  "maxResults": 10,
  "yearFrom": 2023,
  "sortBy": "relevance",
  "openAccessOnly": false,
  "addCitationCounts": true
}
```

# 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 = {
    "queries": [
        "large language model agents"
    ],
    "maxResults": 10,
    "yearFrom": 2023
};

// Run the Actor and wait for it to finish
const run = await client.actor("datagleaner/academic-literature-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 = {
    "queries": ["large language model agents"],
    "maxResults": 10,
    "yearFrom": 2023,
}

# Run the Actor and wait for it to finish
run = client.actor("datagleaner/academic-literature-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 '{
  "queries": [
    "large language model agents"
  ],
  "maxResults": 10,
  "yearFrom": 2023
}' |
apify call datagleaner/academic-literature-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datagleaner/academic-literature-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/81WublEs4kxhcq5Xb/builds/fgHzeFxhmOhZVM1Ra/openapi.json