# Academic Research MCP: Papers, Citations & Authors (OpenAlex) (`oldjard/academic-research-mcp`) Actor

Search 250M+ scholarly papers from Claude, Cursor or any MCP client, or in a normal run: titles, authors, DOIs, abstracts, citation counts, open-access PDFs. Walk citations and references, list an author's papers, get a topic overview. OpenAlex with Crossref fallback.

- **URL**: https://apify.com/oldjard/academic-research-mcp.md
- **Developed by:** [Joshua White](https://apify.com/oldjard) (community)
- **Categories:** MCP servers, AI, Agents
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 papers

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Research MCP: Papers, Citations & Authors

Search **250 million+ scholarly papers** from Claude, Cursor or any other MCP client, or in a normal Apify run.
Every paper comes with its title, authors, year, venue, DOI, citation count, open-access PDF link and topics, and
`get_paper` adds the abstract. Your agent can also follow the citation graph both ways, list a researcher's papers,
and get a one-call overview of a topic.

The data comes from [OpenAlex](https://openalex.org), the open catalogue of scholarly works (journal articles,
conference papers, books and preprints, arXiv included). When OpenAlex can't answer a search,
[Crossref](https://www.crossref.org) answers it instead.

Every paper has a real DOI or OpenAlex ID, so an agent can cite sources instead of inventing them.

### Tools

| Tool | What it does |
|---|---|
| `search_papers` | Papers whose title or abstract match a query. Sort by relevance, citations or newest; filter by year range and open access |
| `get_paper` | One paper by DOI, OpenAlex ID or arXiv ID, with its abstract, citation and reference counts, and whether it was retracted |
| `citing_papers` | Papers that cite a paper (forward citations): follow-up work, replications, critiques |
| `references` | The papers a paper cites (its bibliography), most cited first |
| `author_papers` | A researcher by name, ORCID or OpenAlex ID: their institution, h-index, total citations and top papers. Lists other authors with the same name |
| `literature_report` | A topic overview in one call: the most cited, most relevant and newest papers, papers per year, leading venues, authors and topics, the open-access share, and any retracted papers in the sample |

A call returns at most 50 papers. Each paper looks like this:

```json
{
  "title": "Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks",
  "doi": "10.48550/arxiv.2005.11401",
  "year": 2020,
  "date": "2020-05-22",
  "type": "preprint",
  "venue": "arXiv (Cornell University)",
  "authors": ["Patrick Lewis", "Ethan Perez", "Aleksandra Piktus", "…"],
  "citedBy": 3048,
  "referencesCount": 59,
  "openAccess": true,
  "openAccessUrl": "https://arxiv.org/pdf/2005.11401",
  "url": "https://doi.org/10.48550/arxiv.2005.11401",
  "topics": ["Safety Systems Engineering in Autonomy", "Ethics and Social Impacts of AI", "Adversarial Robustness in Machine Learning"],
  "retracted": false,
  "openalexId": "W3027879771",
  "source": "openalex"
}
```

### Connect your agent

Use the MCP URL from this Actor's *Endpoints* tab (it ends in `/mcp`) and your Apify API token. For Claude Code:

```
claude mcp add --transport http academic-research https://<username>--academic-research-mcp.apify.actor/mcp \
  --header "Authorization: Bearer <your Apify API token>"
```

Other clients (Claude Desktop, Cursor, Windsurf, VS Code) take the same URL and the same `headers` in their JSON
config. Then ask your agent something like:

- *"Find the 10 most cited papers on microplastics in drinking water since 2018 and summarize what they agree on."*
- *"Who cites 10.1038/nature12373? Show the newest five."*
- *"Give me a literature overview of CRISPR off-target effects."*
- *"List Jennifer Doudna's most cited papers."*

Apify starts the server when your agent calls it and stops it when it goes quiet, so nothing runs while you don't use it.

### Normal runs (no MCP client needed)

Click **Start** with a search query, a list of paper IDs, or both. Each paper becomes one row in the dataset, ready
to download as CSV, Excel or JSON.

- **Search:** a query, an optional year range, open-access-only, sort order, and up to 1,000 papers.
- **Look up IDs:** paste DOIs, OpenAlex IDs or arXiv IDs to get their metadata, abstracts and citation counts (for
  example, to enrich a reference list). IDs that aren't found are listed in the run's status and cost nothing.

### Pricing

Pay per event: you pay only for what works.

| Event | Price (Free plan) |
|---|---|
| MCP tool call (`search_papers`, `get_paper`, `citing_papers`, `references`, `author_papers`) | $0.008 |
| `literature_report` (three searches merged) | $0.03 |
| One paper saved in a normal run | $0.002 |

Bronze, Silver and Gold subscribers pay 10%, 20% and 30% less. Failed calls are free. Apify's platform usage is
included in these prices.

### OpenAlex API key (optional)

OpenAlex gives every API user a daily budget. Single-paper lookups are free; searches use the budget. Without a key,
your searches share this Actor's budget, and when it runs out for the day, searches come from Crossref instead (the
answer says so). Crossref has no open-access links or topics and can't filter by open access.

For your own budget, get a free key at [openalex.org/settings/api](https://openalex.org/settings/api) and send it in
the `X-OpenAlex-Api-Key` header (add `--header "X-OpenAlex-Api-Key: <key>"` to the command above), or put it in
the Actor's input for normal runs. It is stored encrypted.

### Good to know

- **Coverage:** OpenAlex covers journals, conferences, books, repositories and preprint servers in every field.
  Citation counts are OpenAlex's own and can differ from Google Scholar's or Scopus's.
- **Duplicates:** a preprint and its published version are separate records upstream. Searches keep the better-ranked
  one and fill in its DOI from the other.
- **Topics:** OpenAlex assigns them by machine and they are sometimes off (the example above is a real record).
- **Abstracts:** come from OpenAlex where the publisher made them available; some papers have none.
- **Full texts:** this Actor returns links to free full texts (`openAccessUrl`); it doesn't download PDFs.
- **arXiv:** arXiv papers are included through OpenAlex. This Actor doesn't call arXiv's own API.
- **Data licences:** OpenAlex data is CC0. Crossref metadata is open for reuse. This Actor isn't affiliated with or
  endorsed by OpenAlex, Crossref or arXiv.

### Support

Found a problem or need another field or tool? Open an issue in the **Issues** tab; I read every one.

# Actor input Schema

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

Papers whose title or abstract match these words, e.g. "microplastics drinking water". Used in a normal run; AI agents connected over MCP send their own queries.

## `ids` (type: `array`):

Optional. DOIs (10.1038/nature12373 or doi.org URLs), OpenAlex work IDs (W2741809807) or arXiv IDs (2005.11401). Each becomes one row with its abstract and citation count.

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

Order of the search results.

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

Only papers published in or after this year.

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

Only papers published in or before this year.

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

Only papers with a free full text (the row has its PDF or landing-page link).

## `includeAbstracts` (type: `boolean`):

Add each search result's abstract. Looked-up IDs always include it.

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

Stop after this many search results (up to 1,000). You pay per paper saved.

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

Optional. A free key from openalex.org/settings/api gives your searches their own daily OpenAlex budget. Without one, searches use the Actor's shared budget and fall back to Crossref when it runs out. MCP clients can send it in the X-OpenAlex-Api-Key header instead.

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

Optional. Crossref routes requests that carry a contact address to its faster "polite" pool. Only sent to Crossref.

## Actor input object example

```json
{
  "query": "retrieval augmented generation",
  "sort": "relevance",
  "openAccessOnly": false,
  "includeAbstracts": false,
  "maxResults": 20
}
```

# Actor output Schema

## `papers` (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": "retrieval augmented generation",
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("oldjard/academic-research-mcp").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": "retrieval augmented generation",
    "maxResults": 20,
}

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

```

## MCP server setup

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

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/j36ccjrsSlfEA0E1W/builds/fQwxSn38axgiiMAnx/openapi.json