# OpenAlex MCP Server: 200M Papers & Authors for AI Agents (`dltik/mcp-server-openalex`) Actor

MCP server exposing 8 tools to query OpenAlex (200M+ scholarly works, authors, institutions, concepts, sources). HTTP-only, no API key. $0.005/tool-call.

- **URL**: https://apify.com/dltik/mcp-server-openalex.md
- **Developed by:** [Walid](https://apify.com/dltik) (community)
- **Categories:** AI, Developer tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.00005 / actor start

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## OpenAlex MCP Server: 200M Academic Papers, Authors, Institutions for AI Agents

> An Apify-hosted MCP server exposing **8 tools** to query [OpenAlex](https://openalex.org) — the open catalogue of 200M+ scholarly works, authors, institutions, sources, and concepts. HTTP-only, no API key. **$0.005 per tool-call**.

⭐ **Bookmark this OpenAlex MCP Server** — Apify ranks actors by bookmarks, so it directly helps the visibility of this actor on the Apify Store.
[→ Bookmark it on the Apify Store](https://apify.com/dltik/mcp-server-openalex)

### What can this OpenAlex MCP Server do?

- 📚 **Search 200M+ scholarly works** — papers, books, datasets across every discipline.
- 👩‍🔬 **Find authors with h-index, ORCID, institution** — full bibliometric profiles.
- 🏛️ **Resolve institutions & ROR IDs** — universities, hospitals, research orgs in 200+ countries.
- 🧠 **Query the OpenAlex concept taxonomy** — Wikidata-linked research topics, levels 0-5.
- 📰 **Discover sources** — journals, conferences, repositories, OA status, DOAJ flag.
- 🤖 **MCP-shaped for AI agents** — call from Claude, Cursor, Continue with one tool dispatcher.

### What data can you extract with the OpenAlex MCP Server?

| Field | Description |
|---|---|
| `openalex_id` | Stable OpenAlex identifier (W… / A… / I… / S… / C…) |
| `doi` | DOI of the work (when available) |
| `title` | Title of the work / author / institution / source |
| `publication_year` | Year published |
| `publication_date` | ISO publication date |
| `cited_by_count` | Total citation count |
| `authorships` | Full nested authorship objects (raw OpenAlex) |
| `authors` | Flat list of author display names |
| `primary_location` / `primary_source` | Hosting journal / repo info |
| `open_access` | `is_oa`, `oa_status`, `oa_url` (Unpaywall-style) |
| `concepts` | Wikidata-linked research topics with score |
| `type` | Work type (article, book, dataset, …) |
| `language` | ISO 639 code |
| `referenced_works_count` | Number of references the work cites |
| `abstract_inverted_index` | Raw inverted index (word → positions) |
| `abstract` | Reconstructed plain-text abstract (when `reconstruct_abstract: true`) |
| `bookmark_cta` | Last record — bookmark the actor to support visibility |

### How to use the OpenAlex MCP Server

1. **Open the actor** on Apify: [apify.com/dltik/mcp-server-openalex](https://apify.com/dltik/mcp-server-openalex).
2. **Discover the tool catalog** — run once with `mode=list_tools` (free, no charge).
3. **Pick a tool** — `search_works`, `get_work`, `search_authors`, etc.
4. **Pass arguments** — e.g. `{"query": "climate change", "limit": 10}`.
5. **Wire it into your agent** — Claude / Cursor / Continue / LangChain / LlamaIndex, via Apify's MCP bridge or `run-sync-get-dataset-items`.

### How much does the OpenAlex MCP Server cost?

**PAY\_PER\_EVENT — $0.005 per tool-call.** `list_tools` mode is free (discovery). Failed runs are not charged.

| Plan | Tool calls | Cost |
|---|---|---|
| Quick | 100 | $0.50 |
| Standard | 1,000 | $5.00 |
| Deep | 10,000 | $50.00 |
| Massive | 100,000 | $500.00 |

Per call, the OpenAlex MCP Server averages ~5 s of compute on 256 MB RAM and ~0.05 MB of bandwidth — fully covered by the per-event price.

### Input parameters

| Field | Type | Description |
|---|---|---|
| `mode` | enum | `call_tool` (charged) or `list_tools` (free). |
| `tool_name` | enum | `search_works`, `get_work`, `search_authors`, `get_author`, `search_institutions`, `get_institution`, `search_sources`, `search_concepts`. |
| `arguments` | object | Tool arguments — see `list_tools` for the per-tool schema. |
| `mailto` | string | Optional. Email passed to OpenAlex's polite-pool (~100k req/day). |
| `reconstruct_abstract` | bool | Default `true` — rebuilds the abstract from OpenAlex's inverted index. |

### Output example

```json
{
  "openalex_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",
  "type": "article",
  "publication_year": 2018,
  "publication_date": "2018-02-13",
  "language": "en",
  "cited_by_count": 1132,
  "referenced_works_count": 62,
  "open_access_status": "gold",
  "open_access_url": "https://peerj.com/articles/4375.pdf",
  "is_oa": true,
  "primary_source": {
    "id": "S2738156628",
    "display_name": "PeerJ",
    "issn_l": "2167-8359",
    "type": "journal"
  },
  "authors": ["Heather Piwowar", "Jason Priem", "Vincent Larivière", "Juan Pablo Alperin"],
  "n_authors": 8,
  "concepts": [
    {"id": "C2779343474", "display_name": "Open access", "level": 2, "score": 0.94}
  ],
  "abstract": "Despite growing interest in Open Access (OA) to scholarly literature ..."
}
```

### Use cases for the OpenAlex MCP Server

- **AI research assistants** — let Claude or Cursor pull verifiable citations from OpenAlex during a literature review.
- **Grant writing & competitive intelligence** — surface the top-cited authors and institutions on a topic in seconds.
- **CRM / lead-gen enrichment for academic SaaS** — enrich researcher records with h-index, ORCID, last institution, country.
- **Bibliometric dashboards** — track OA adoption, citation counts, journal coverage across a discipline.
- **Knowledge graph builders** — pull OpenAlex's concept taxonomy and author–institution edges into Neo4j / RDF.
- **Systematic reviews** — automate PRISMA-style filtering by year, OA status, concept score.

### API examples

**Python (Apify client):**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("dltik/mcp-server-openalex").call(run_input={
    "mode": "call_tool",
    "tool_name": "search_works",
    "arguments": {"query": "transformer architecture", "limit": 5, "sort": "cited_by_count:desc"}
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item.get("title"), "—", item.get("cited_by_count"))
```

**curl (synchronous run):**

```bash
curl -X POST "https://api.apify.com/v2/acts/dltik~mcp-server-openalex/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "call_tool",
    "tool_name": "get_work",
    "arguments": {"doi": "10.1038/s41586-021-03819-2"}
  }'
```

### FAQ — OpenAlex MCP Server

**Why use the OpenAlex MCP Server on Apify vs hitting api.openalex.org directly?**
Maintenance + agent-shape. The OpenAlex MCP Server normalizes nested objects, reconstructs abstracts from OpenAlex's inverted index, exposes a tool dispatcher native to MCP, and bills per call — no rate-limit handling, no schema-drift code in your agent.

**What's the polite pool and do I need to set `mailto`?**
OpenAlex serves anonymous requests with stricter limits. Passing an email via `mailto` puts you in the "polite pool" with ~100k req/day. The OpenAlex MCP Server injects a maintainer email by default — set your own `mailto` for high-volume usage.

**How are abstracts returned?**
OpenAlex stores abstracts as an inverted index (`{word: [positions]}`). When `reconstruct_abstract: true` (default), the OpenAlex MCP Server rebuilds the plain-text abstract into the `abstract` field. The raw `abstract_inverted_index` is always kept too.

**How do I paginate beyond 10,000 results?**
Pass `cursor: "*"` on the first call, then forward the next cursor returned by OpenAlex. The OpenAlex MCP Server exposes the `cursor` argument on `search_works` for exactly this.

**Is there a free tier?**
`list_tools` is always free (catalog discovery). `call_tool` is $0.005 per call, billed only on success.

***

⭐ **Found the OpenAlex MCP Server useful? Bookmark it** — it's the strongest signal for Apify Store visibility.
[→ Bookmark on the Apify Store](https://apify.com/dltik/mcp-server-openalex)

#### Other scrapers by dltik

| Actor | What it does |
|---|---|
| [arXiv MCP Server](https://apify.com/dltik/mcp-server-arxiv) | 5 tools for AI agents to query arXiv preprints |
| [HackerNews MCP Server](https://apify.com/dltik/mcp-server-hackernews) | 6 tools over 30M HN stories + comments |
| [SEC EDGAR MCP Server](https://apify.com/dltik/mcp-server-sec-edgar) | 10K+ US public companies for AI agents |
| [Pappers MCP Server](https://apify.com/dltik/mcp-server-pappers) | 26M French companies (SIREN, dirigeants, finances) |
| [Wikipedia MCP Server](https://apify.com/dltik/mcp-server-wikipedia) | Search, summaries, sections — all Wikipedia languages |

License: MIT · Author: [dltik](https://apify.com/dltik)

# Actor input Schema

## `mode` (type: `string`):

list\_tools (free, returns tool catalog) or call\_tool (charged $0.005 per call).

## `tool_name` (type: `string`):

Tool to invoke. Use mode=list\_tools to discover the full catalog and per-tool arguments.

## `arguments` (type: `object`):

Arguments for the chosen tool. See list\_tools mode for full schema per tool. Example: {"query": "climate change", "limit": 10}.

## `mailto` (type: `string`):

Email passed to OpenAlex via the mailto query param to unlock the 'polite pool' (~100k req/day). If empty, falls back to the maintainer's email env var. Recommended for heavy use.

## `reconstruct_abstract` (type: `boolean`):

OpenAlex returns abstracts as an inverted index (word -> \[positions]). When true, the actor reconstructs the plain-text abstract and adds it as 'abstract' on each work record.

## Actor input object example

```json
{
  "mode": "call_tool",
  "tool_name": "search_works",
  "arguments": {
    "query": "climate change",
    "limit": 5
  },
  "reconstruct_abstract": true
}
```

# 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 = {
    "arguments": {
        "query": "climate change",
        "limit": 5
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dltik/mcp-server-openalex").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 = { "arguments": {
        "query": "climate change",
        "limit": 5,
    } }

# Run the Actor and wait for it to finish
run = client.actor("dltik/mcp-server-openalex").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "arguments": {
    "query": "climate change",
    "limit": 5
  }
}' |
apify call dltik/mcp-server-openalex --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=dltik/mcp-server-openalex",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/aOso7rt5Us8gA7D74/builds/IfzOR3Yt3WynoY5ch/openapi.json