# Academic Paper Search & Citations (OpenAlex Scholarly API) (`wintersworks/scholarly-paper-search`) Actor

Input: a keyword, author, institution or DOI query. Output: academic paper search results from OpenAlex with abstract, citation counts, open-access PDF links, references and citing papers. $1.50 per 1,000 papers.

- **URL**: https://apify.com/wintersworks/scholarly-paper-search.md
- **Developed by:** [Winters Works](https://apify.com/wintersworks) (community)
- **Categories:** AI, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 paper returneds

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 & Citations (OpenAlex Scholarly API)

Search **250M+ scholarly works** and export clean, flat records: title, DOI, authors with ORCID, institutions, venue, citation count, open-access PDF link, reconstructed abstract, topics and more. No API key, no scraping, no proxies.

### What it does

- Search by **keyword, title, author, institution**, or a **list of DOIs**
- Filter by **year range, open access only, minimum citations**; sort by relevance, citations, newest or oldest
- **Citing papers** mode: every paper that cites a given DOI
- **References** mode: every paper a given DOI cites
- Optional **Crossref enrichment** (volume, pages, funders, licenses)
- Full-text **abstracts** rebuilt from OpenAlex's inverted index, ready for LLMs

### Use cases

- Literature reviews and citation chaining (snowballing forward and backward)
- RAG pipelines and AI agents that need abstracts and open-access PDF URLs
- Bibliometrics: top-cited papers by author, institution or topic
- Finding open-access full texts for a reading list of DOIs
- Monitoring new publications on a research topic

### Input example

```json
{
  "mode": "search",
  "query": "retrieval augmented generation",
  "fromYear": 2020,
  "openAccessOnly": true,
  "minCitations": 50,
  "sortBy": "citations",
  "maxResults": 100
}
```

Citing papers: `{"mode":"citing","targetDoi":"10.1038/nature14539","maxResults":200}`
DOI lookup: `{"dois":["10.1038/nature14539","10.1145/3292500.3330701"]}`

### Output example

```json
{
  "title": "Active Retrieval Augmented Generation",
  "doi": "10.18653/v1/2023.emnlp-main.495",
  "year": 2023,
  "authors": [{ "name": "Zhengbao Jiang", "orcid": "https://orcid.org/0000-0002-0315-6727" }],
  "institutions": [{ "name": "Carnegie Mellon University", "country": "US", "ror": "https://ror.org/05x2bcf33" }],
  "venue": "Proceedings of EMNLP",
  "citationCount": 462,
  "referencedWorksCount": 40,
  "isOpenAccess": true,
  "oaStatus": "hybrid",
  "pdfUrl": "https://aclanthology.org/2023.emnlp-main.495.pdf",
  "abstract": "Despite the remarkable ability of large language models ...",
  "topics": ["Topic Modeling"],
  "openalexUrl": "https://openalex.org/W..."
}
```

Export as JSON, CSV, Excel or via the API.

### Pricing

Pay per result: about **$1.50 per 1,000 papers** ($0.0015 each). You only pay for papers returned. Set **Max results** and the run's maximum cost to stay in control.

### FAQ

**Where does the data come from?** [OpenAlex](https://openalex.org), an open catalog released under the CC0 license. Crossref is used only if you enable enrichment.
**Is it legal?** Yes. It uses the official public APIs with the polite-pool identification they request.
**Why is an abstract missing?** Some publishers do not allow OpenAlex to distribute abstracts.
**Why is the PDF URL empty?** Only open-access papers have one.
**How many results can I get?** Up to 100,000 per run via cursor paging.
**How fresh is it?** OpenAlex updates continuously.

Built by Winters Works. Issues and feature requests are welcome in the Issues tab.

### Is it legal? (public data only)

Yes, in the sense that it only reads public or official data: the open OpenAlex and Crossref APIs. It does not log in, bypass paywalls or access private data. You remain responsible for how you use the results, including privacy, copyright and marketing laws. Not affiliated with or endorsed by the data sources.

### Quick start and cost

Run it with the prefilled input to see sample output in seconds; the default run costs only a few cents at most. Then adjust the input and schedule it.

### Use from code and AI agents

Call it from any language with the Apify API, or let an AI agent find and run it through the [Apify MCP server](https://mcp.apify.com).

```python
from apify_client import ApifyClient
run = ApifyClient("<YOUR_APIFY_TOKEN>").actor("wintersworks/scholarly-paper-search").call(run_input={"mode": "search", "query": "large language models", "maxResults": 25})
items = ApifyClient("<YOUR_APIFY_TOKEN>").dataset(run["defaultDatasetId"]).list_items().items
```

Results land in the run's dataset (JSON, CSV, Excel). Set a maximum charge per run in the run options to cap spend.

### About

Built and maintained by Winters Works. Questions or feature requests: open an issue on the Actor page or email wintersworks.shop@gmail.com.

# Actor input Schema

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

Search papers, find papers citing a DOI, or list the references of a DOI.

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

Keywords searched in title and abstract.

## `titleQuery` (type: `string`):

Words that must appear in the title.

## `author` (type: `string`):

Author name; the best OpenAlex match is used.

## `institution` (type: `string`):

Institution name (e.g. MIT); best match is used, including child institutions.

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

Look up specific papers by DOI. If set, other search filters are ignored.

## `targetDoi` (type: `string`):

DOI of the paper for citing or references mode.

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

Earliest publication year.

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

Latest publication year.

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

Only return open-access papers.

## `minCitations` (type: `integer`):

Only papers cited at least this many times.

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

Result order.

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

Maximum papers to return (you are charged per paper).

## `enrichWithCrossref` (type: `boolean`):

Add volume, pages, funders and licenses from Crossref (slower).

## Actor input object example

```json
{
  "mode": "search",
  "query": "large language models",
  "openAccessOnly": false,
  "sortBy": "relevance",
  "maxResults": 25,
  "enrichWithCrossref": false
}
```

# Actor output Schema

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

All result items from the run's default 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

```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": "large language models",
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("wintersworks/scholarly-paper-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 = {
    "query": "large language models",
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("wintersworks/scholarly-paper-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 '{
  "query": "large language models",
  "maxResults": 25
}' |
apify call wintersworks/scholarly-paper-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,wintersworks/scholarly-paper-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/yL8I1zJAINswL7ZyK/builds/aBguKcglgunIG8EDL/openapi.json