OpenAlex MCP Server

Search OpenAlex papers, authors, institutions and citations. Hosted on Apify; needs an Apify token.

Hosted MCP Server

npx add-mcp 'https://agentic-solutions--openalex-mcp.apify.actor/mcp'

Installs into Claude Code, Codex, Cursor and more

Documentation

OpenAlex MCP Server – Research Papers, Authors & Citations (`agentic_solutions/openalex-mcp`) Actor

MCP server for Claude, Cursor and AI agents: search scholarly works, authors and institutions in OpenAlex, and follow citations and references. Compact JSON with abstracts. $0.015 per successful call. Not affiliated with or endorsed by OpenAlex or OurResearch.

URL: https://apify.com/agentic_solutions/openalex-mcp.md
Developed by: Agentic Solutions (community)
Categories: AI, Agents, MCP servers
Stats: 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
User rating: No ratings yet

Pricing

from $15.00 / 1,000 tool calls

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 section below.

Each client library has reference documentation the quickstart does not restate: JavaScript/TypeScript (npm install apify-client) and Python (pip install apify-client).

README

OpenAlex MCP Server: Scholarly Papers, Authors & Citations

An MCP (Model Context Protocol) server that gives AI agents and assistants such as Claude, Cursor and custom agents fast, low-cost access to OpenAlex: 250M+ scholarly works, plus authors, institutions and the citation graph. Results are compact JSON, with abstracts reconstructed from OpenAlex's inverted index and trimmed to about 1,200 characters, so they fit comfortably in an LLM context.

🔑 Bring your own OpenAlex API key (recommended)

OpenAlex gives every account a free API key with a daily usage budget and up to 30 requests/second. Create one at openalex.org, then set it as OpenAlex API key in this Actor's settings, or send it per request in the x-openalex-api-key header. Your key is stored as a secret.

Without a key the server falls back to keyless access: at most 10 requests/second and a small daily budget shared with everyone calling OpenAlex keylessly from the same infrastructure. Under load you may get rate-limit (429) errors. The server logs a warning when no key is set.

Price: $0.015 per successful MCP tool call. Failed calls are free, and so are normal (non-Standby) health-check runs.

Quick start (copy-paste)

Add this to Claude Desktop or Cursor's mcp.json, replacing YOUR_APIFY_TOKEN with your Apify API token:

{"mcpServers": {"openalex": {"url": "https://agentic-solutions--openalex-mcp.apify.actor/mcp",
  "headers": {"Authorization": "Bearer YOUR_APIFY_TOKEN"}}}}

Tools

Tool	What it does
`search_works`	Full-text search with filters: `year_from`/`year_to`, `open_access`, `type` (article, review, preprint…), `topic` (OpenAlex topic `T…` or concept `C…` ID), `sort` (relevance, cited, newest, oldest), `per_page` ≤ 50, `page`, `include_abstract`
`get_work`	One work by OpenAlex ID (`W…`) or DOI, with abstract
`get_citations`	Works that cite a work (OpenAlex `cites:` filter)
`get_references`	Works a work references (`cited_by:` filter)
`search_authors` / `get_author`	Authors by name, or by OpenAlex ID / ORCID: works and citation counts, h-index, institutions, top topics
`search_institutions`	Universities, companies and hospitals, optionally filtered by `country` (ISO-2)

Journal covers and front matter (OpenAlex "paratext") are filtered out of work searches.

Connect an MCP client

The server speaks streamable HTTP at the Actor's Standby URL plus /mcp:

https://<username>--openalex-mcp.apify.actor/mcp

Every request needs your Apify API token: Authorization: Bearer <APIFY_TOKEN>.

Claude Desktop / Cursor (mcp.json):

{"mcpServers": {"openalex": {"url": "https://<username>--openalex-mcp.apify.actor/mcp",
  "headers": {"Authorization": "Bearer <APIFY_TOKEN>"}}}}

For clients that only support stdio: npx mcp-remote https://<username>--openalex-mcp.apify.actor/mcp --header "Authorization: Bearer <APIFY_TOKEN>".

Python (FastMCP):

from fastmcp import Client
async with Client("https://<username>--openalex-mcp.apify.actor/mcp", auth="<APIFY_TOKEN>") as c:
    print(await c.call_tool("search_works", {"query": "CRISPR delivery", "year_from": 2022, "per_page": 5}))

Settings (all optional)

OpenAlex API key (secret): your own free key gives a bigger daily budget and up to 30 requests per second. You can also send it per request in the x-openalex-api-key header.
Contact email (mailto): always sent to OpenAlex. If you don't set one, the operator's contact address is used. You can also send it in the x-openalex-mailto header.

The server paces itself at 9 requests/second without a key (OpenAlex's limit is 10) and 25 with one. It retries 429s and 5xx errors, honouring Retry-After, before returning a clear error message.

A normal (non-Standby) run is a free health check: one sample search_works call, results saved to the dataset, no charge. Only MCP tool calls made in Standby mode are charged.

Example output (`get_work`)

{"id": "W2741809807", "doi": "https://doi.org/10.7717/peerj.4375",
 "title": "The state of OA: a large-scale analysis of the prevalence and impact of Open Access articles",
 "year": 2018, "type": "article", "authors": ["Heather Piwowar", "Jason R Priem", "..."], "authorCount": 9,
 "venue": "PeerJ", "openAccess": {"isOa": true, "status": "gold", "url": "https://doi.org/10.7717/peerj.4375"},
 "citedByCount": 1210, "topic": "Academic Publishing and Open Access", "abstract": "Despite growing interest in Open Access (OA) ... …"}

How it compares (prices checked on the Apify Store, 17 Oct 2026)

Actor	Price per search / tool call	Per-run start fee
This Actor	$0.015 per successful call (failed calls free)	none
themineworks/academic-research-mcp	$0.0625 per paper search; $0.05 citation graph	$0.005
nexgendata/academic-research-mcp-server	$0.02 per tool call	$0.00005
johnvc/google-scholar-api (Google Scholar, not MCP)	$0.015 per query (FREE tier)	$0.005

Prices are taken from each Actor's public Store pricing and can change; check the Actor page before relying on them.

FAQ

Do I need an OpenAlex API key? No, but it's recommended. Keyless access is capped at 10 requests/second with a small shared daily budget, so you may see 429s. A free key gives your own budget and up to 30 requests/second.

What counts as a tool call? One successful call to any tool above. These aren't charged: errors (bad ID, rejected key, upstream failure after retries), MCP handshakes and tool listings, and normal health-check runs.

What else does Apify bill? In Standby mode, Apify also charges its normal platform usage (compute) on top of the per-call price.

Can I use a scoped Apify token? Yes, but set its Actor run access mode to Full access. Scoped tokens in restricted mode are rejected by Standby with HTTP 400 (actor-restricted-access-permission-mode-not-supported).

Which clients work? Any MCP client with streamable HTTP and custom headers (Claude Desktop, Cursor, VS Code, FastMCP). Stdio-only clients can use npx mcp-remote.

What do errors look like? The tool returns a plain error message, such as "Not found in OpenAlex", a rejected-key message, or a rate-limit message, instead of JSON.

Can I reuse the data? Yes. OpenAlex data is CC0; please cite OpenAlex (see below).

Credit and licence

Data from OpenAlex, built by OurResearch. OpenAlex data is released under CC0 (public domain). Please cite OpenAlex in your work: Priem, J., Piwowar, H., & Orr, R. (2022). OpenAlex: A fully-open index of scholarly works, authors, venues, institutions, and concepts. arXiv:2205.01833.

This Actor is independent and is not affiliated with, endorsed by or sponsored by OpenAlex or OurResearch.

Listed on:

Actor input Schema

`openAlexApiKey` (type: `string`):

Your own free OpenAlex API key (openalex.org → account). Gives a larger daily budget and up to 30 req/s. Without it the server uses keyless access (10 req/s, smaller daily budget). MCP clients can also send it per request in the 'x-openalex-api-key' header.

`mailto` (type: `string`):

Contact email always sent to OpenAlex as 'mailto'. If empty, the operator's contact (jeff_assist@mail.grokbot.com) is used. Can also be sent per request in the 'x-openalex-mailto' header.

`testQuery` (type: `string`):

Used only for normal (non-Standby) runs, which are a FREE health check: one sample search_works call saved to the dataset, not charged.

`testPerPage` (type: `integer`):

Number of works the normal-run test search returns.

Actor input object example

{
  "testQuery": "large language models",
  "testPerPage": 5
}

Actor output Schema

`results` (type: `string`):

Works from the normal-run test search (dataset).

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

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 = {
    "testQuery": "large language models"
};

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

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 = { "testQuery": "large language models" }

# Run the Actor and wait for it to finish
run = client.actor("agentic_solutions/openalex-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

echo '{
  "testQuery": "large language models"
}' |
apify call agentic_solutions/openalex-mcp --silent --output-dataset

MCP server setup

{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,agentic_solutions/openalex-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/bzrnZZeanZLGIpkIX/builds/og28z31e54XaP6SN1/openapi.json