# Academic Paper Search: OpenAlex, Crossref & arXiv (`thriving_adder/academic-research-papers`) Actor

Search scholarly papers and look up DOIs or arXiv ids across OpenAlex and Crossref (arXiv optional). One deduplicated record per paper: title, authors, venue, year, abstract, citations, open-access PDF link.

- **URL**: https://apify.com/thriving_adder/academic-research-papers.md
- **Developed by:** [Adrian LHH](https://apify.com/thriving_adder) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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

## Academic Paper Search API: OpenAlex, Crossref & arXiv

**Search 250M+ scholarly works and look up DOIs or arXiv ids in one call.** Results from **OpenAlex**, **Crossref** and (optionally) **arXiv** are merged into **one deduplicated record per paper**: title, DOI, arXiv id, year, venue, authors, institutions, abstract, citation count, open-access status, PDF link, licence, topics and retraction flag. Built for literature reviews, research agents and RAG. **$1 per 1,000 papers. Empty searches and unknown ids are free.**

### What does it do?

- **Sources:** OpenAlex and Crossref by default. **arXiv is opt-in and off by default**: add `arxiv` to `sources` to also query arXiv's own API (slower, 1 request every 3 s). arXiv papers are still found through OpenAlex without it.
- **Keyword search** across OpenAlex and Crossref (and arXiv if enabled), with year range, open-access-only and sort (relevance, most cited, newest).
- **DOI lookup** in bulk (up to 10,000 per run) and **arXiv id lookup** (`1706.03762`, `2005.11401v4`).
- **Deduplication and merge:** the same paper from several sources becomes one row (matched by DOI, arXiv id or title + year); fields are combined and `sources` tells you where it came from. You pay once.
- Abstracts rebuilt from OpenAlex's inverted index, Crossref JATS or arXiv summaries.
- Two views: **Papers** and **Abstracts**.

### Input

| Field | Default | What it does |
|---|---|---|
| `queries` | – | Keyword searches (max 100). |
| `dois` | – | DOIs to look up (`10.1038/nature14539` or `https://doi.org/...`). |
| `arxivIds` | – | arXiv ids to look up. |
| `sources` | `openalex`, `crossref` | Add `arxiv` for arXiv's own search (slower: 1 request / 3 s). |
| `maxResultsPerQuery` | `25` | Per query **and** source (max 1,000); duplicates merged. |
| `yearFrom` / `yearTo` | – | Publication year range (searches only). |
| `openAccessOnly` | `false` | Only free-to-read papers. |
| `sort` | `relevance` | `relevance`, `cited`, `newest`. |
| `includeAbstract` | `true` | Return abstracts. |
| `includeAuthorNames` | `true` | Return author names (off = only `authorCount`). |
| `contactEmail` | – | Sent as `mailto` for Crossref/OpenAlex polite pools (recommended). |
| `openalexApiKey` | – | Your free OpenAlex key (secret) for your own daily budget. |

```json
{
  "queries": ["retrieval augmented generation", "protein structure prediction"],
  "dois": ["10.1038/nature14539"],
  "arxivIds": ["1706.03762"],
  "maxResultsPerQuery": 20,
  "yearFrom": 2020,
  "sort": "cited"
}
```

### Output

One row per paper (shortened):

```json
{
  "title": "Attention Is All You Need",
  "arxivId": "1706.03762",
  "openalexId": "W2626778328",
  "type": "preprint",
  "authors": ["Ashish Vaswani", "Noam Shazeer", "Niki Parmar", "..."],
  "authorCount": 8,
  "institutions": ["Google (United States)", "University of Southern California", "University of Toronto"],
  "abstract": "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks...",
  "citedByCount": 78342,
  "isOpenAccess": true,
  "pdfUrl": "https://arxiv.org/pdf/1706.03762",
  "topics": ["Natural Language Processing Techniques", "Topic Modeling"],
  "keywords": ["transformer models", "attention mechanism", "machine translation"],
  "isRetracted": false,
  "url": "https://arxiv.org/abs/1706.03762",
  "sources": ["openalex"],
  "lookup": "arxiv:1706.03762"
}
```

Queries or ids without results are listed with `error` / `errorCode` (`NO_RESULTS`, `NOT_FOUND`, `INVALID_DOI`, `ALL_SOURCES_FAILED`) and are **not charged**. The `SUMMARY` record shows per-source errors (for example an OpenAlex rate limit).

### How much does it cost?

| Event | Price |
|---|---|
| Paper (unique, merged) | $0.001 |

- 1,000 papers ≈ **$1**. A 50-paper literature scan ≈ $0.05.
- Apify's tiny run-start fee applies (512 MB default). Set **Maximum cost per run** to cap spending.

### Sources, licences and limits

- **OpenAlex** metadata is [CC0](https://openalex.org). OpenAlex gives keyless users a small shared daily budget; for regular or large runs add your free `openalexApiKey`. If OpenAlex is rate-limited, Crossref still answers and the SUMMARY reports it.
- **Crossref** metadata is free to reuse; **abstracts may be copyrighted by the publisher**: fine for search, screening and analysis, check before republishing.
- **arXiv** metadata is CC0 ("Thank you to arXiv for use of its open access interoperability"). The Actor follows the arXiv API terms (one request every 3 seconds), links to PDFs but never downloads or serves them, and is **off by default: it is only queried when you add `arxiv` to `sources`** (arXiv papers are also found via OpenAlex).
- Not affiliated with or endorsed by OpenAlex/OurResearch, Crossref or arXiv/Cornell University.

### Personal data

Author names are public bibliographic data and are included by default, because citations need them; switch off `includeAuthorNames` to get only `authorCount`. **ORCID iDs, e-mail addresses and raw affiliation strings (which can contain e-mails) are never returned**; only institution names are kept.

### Use it from code or an AI agent

```bash
curl -X POST "https://api.apify.com/v2/acts/thriving_adder~academic-research-papers/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" -H 'Content-Type: application/json' \
  -d '{"queries":["large language model evaluation"],"maxResultsPerQuery":10}'
```

Also available as a tool in **Apify's MCP server**, so research agents can search and cite papers.

### Use cases

- **Literature reviews:** pull the most cited or newest papers on a topic, with abstracts, into a spreadsheet for screening.
- **RAG and research agents:** search and cite papers by DOI, with open-access PDF links when they exist.
- **Reference cleanup:** look up a list of DOIs or arXiv ids and get consistent metadata.
- **Research monitoring:** schedule weekly searches for new papers on your topics.
- **Bibliometrics:** citation counts, venues, topics and open-access status for a set of papers.

### FAQ

**Why fewer rows than `maxResultsPerQuery` × sources?** Duplicates across sources are merged into one row (and charged once).

**Full text?** Not included; use `pdfUrl` / `oaUrl` to open the open-access copy.

**Problems or ideas?** Open an issue in the Issues tab. We answer within 2 business days.

### Related Actors

By the same publisher, built on the same safe, pay-per-result design:

- [Web Page to Markdown & llms.txt Generator](https://apify.com/thriving_adder/web-to-markdown-llms-txt): convert open-access pages and docs to Markdown for RAG.
- [SEC EDGAR Filings & XBRL Financials](https://apify.com/thriving_adder/sec-edgar-filings-xbrl): company filings and financial data.
- [Malaysia & Singapore Open Data API](https://apify.com/thriving_adder/sea-open-data): official Malaysian and Singapore statistics.

# Changelog

This Actor's version history is a separate document: https://apify.com/thriving_adder/academic-research-papers/changelog.md

# Actor input Schema

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

Keyword searches (title, abstract and full-text where the source supports it), e.g. "retrieval augmented generation". Max 100 per run.

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

DOIs (10.1038/nature14539 or https://doi.org/...). Max 10,000 per run.

## `arxivIds` (type: `array`):

arXiv ids such as 1706.03762 or 2005.11401v4 (the version is ignored).

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

Which open APIs to query. arXiv is opt-in: its API allows only 1 request every 3 s, so it is slower; arXiv papers are also found through OpenAlex.

## `maxResultsPerQuery` (type: `integer`):

Up to this many results from EACH selected source; duplicates across sources are merged and charged once.

## `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 free-to-read papers (OpenAlex is_oa; Crossref: Creative Commons licence; arXiv is always open).

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

Order of search results within each source.

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

Return abstracts when the source has them. Abstracts can be under the publisher's copyright: fine for research and search, check before republishing.

## `includeAuthorNames` (type: `boolean`):

Return author names as published (public bibliographic data). Off: only authorCount. ORCIDs, e-mails and raw affiliation strings are never returned.

## `contactEmail` (type: `string`):

Sent as mailto to Crossref and OpenAlex so they can contact you about heavy use (Crossref's faster 'polite' pool). Not stored in the output.

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

Your free OpenAlex key (openalex.org/settings/api) gives you your own $1/day budget (about 1,000 searches). Without it, OpenAlex shares a small daily budget per IP and may answer 429; Crossref then covers the search.

## Actor input object example

```json
{
  "queries": [
    "retrieval augmented generation"
  ],
  "sources": [
    "openalex",
    "crossref"
  ],
  "maxResultsPerQuery": 5,
  "openAccessOnly": false,
  "sort": "relevance",
  "includeAbstract": true,
  "includeAuthorNames": true
}
```

# Actor output Schema

## `results` (type: `string`):

One deduplicated row per paper (plus free rows for lookups without results).

## `summary` (type: `string`):

Counts, error codes, per-source errors and request statistics.

# 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": [
        "retrieval augmented generation"
    ],
    "maxResultsPerQuery": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("thriving_adder/academic-research-papers").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": ["retrieval augmented generation"],
    "maxResultsPerQuery": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("thriving_adder/academic-research-papers").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": [
    "retrieval augmented generation"
  ],
  "maxResultsPerQuery": 5
}' |
apify call thriving_adder/academic-research-papers --silent --output-dataset

```

## MCP server setup

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

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/rPryxbeO5OTYdsMPE/builds/SPFWQlU9C2IT7dY6c/openapi.json