# OpenAlex Papers Search: Scholarly Works, Citations & Abstracts (`private_image_hg9/openalex-papers-search`) Actor

Search 250M+ scholarly papers in OpenAlex by keyword, title, author, institution and year. Clean rows with authors, venue, DOI, open-access PDF link, citation count, full abstract and topics. A free, legal alternative to scraping Google Scholar.

- **URL**: https://apify.com/private_image_hg9/openalex-papers-search.md
- **Developed by:** [Michael Shanker](https://apify.com/private_image_hg9) (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

$0.70 / 1,000 paper saveds

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

## OpenAlex Papers Search: Scholarly Works, Citations & Abstracts

Search more than 250 million scholarly papers, preprints, books and datasets in **OpenAlex**, the free and open index of the world's research. Search by keywords or title, author, institution and year, and get clean, flat rows with authors, venue, DOI, citation count, the full abstract, topics and a link to a free PDF when one exists.

No login, no cookies, no proxies, no browser. It reads the official OpenAlex API, so runs are fast, results are reliable, and you don't have to fight Google Scholar's blocks and captchas.

**$0.70 per 1,000 papers.** You pay only for papers saved to your dataset. Searches with no matches and authors or institutions that can't be found cost nothing.

### What you can use it for

- **Literature reviews and research:** pull every paper on a topic into one sheet, sorted by citations or date.
- **AI and RAG pipelines:** clean titles, abstracts and topics ready to embed, with free-PDF links for full text.
- **Research offices and funders:** list what an institution or a group of authors published in a period, with citation impact.
- **Biotech, pharma and deep-tech teams:** track new work in your field and spot the most-cited labs and authors.
- **Monitoring:** schedule a daily or weekly run sorted by **Newest first** to see what was just published.

### Input

| Field | What it does |
|---|---|
| **Keywords or title** | Words to search for, e.g. `crispr gene editing`. Use double quotes for an exact phrase and `AND`, `OR`, `NOT` in capitals for more control. |
| **Search in** | Title, abstract and full text (default), title and abstract, or title only. |
| **Authors** | Names (`Jennifer Doudna`), ORCID iDs or OpenAlex author IDs (`A5023888391`). Names use OpenAlex's best match, shown in the log and in the `SUMMARY` record. |
| **Institutions** | Names (`Stanford University`), ROR IDs (`https://ror.org/00f54p054`) or OpenAlex institution IDs (`I97018004`). |
| **From year / To year** | Publication year range, inclusive. |
| **Open access only** | Keep only papers that are free to read somewhere. |
| **Minimum citations** | Keep only papers cited at least this many times. |
| **Work type** | Article, review, preprint, book chapter, book, dataset, dissertation or report. |
| **Sort by** | Relevance (needs keywords), most cited, newest or oldest. |
| **Max results** | Stop after this many papers (default 100). |
| **Include abstract** | Adds the abstract as plain text (on by default). |
| **OpenAlex API key** | Optional. Your own free key raises OpenAlex's daily budget 10x. See below. |
| **Contact email for OpenAlex** | Optional. Passed to OpenAlex so they can reach you about heavy use. |

Example input:

```json
{
  "query": "\"large language models\" evaluation",
  "searchIn": "titleAbstract",
  "fromYear": 2023,
  "openAccessOnly": true,
  "minCitations": 20,
  "sort": "citations",
  "maxResults": 500
}
```

### Output

One row per paper. Example (shortened, values illustrative):

```json
{
  "openAlexId": "W4000000003",
  "title": "Highly accurate protein structure prediction with AlphaFold",
  "authors": ["John Jumper", "Demis Hassabis"],
  "authorCount": 2,
  "firstAuthor": "John Jumper",
  "institutions": ["Google DeepMind"],
  "countries": ["GB"],
  "year": 2021,
  "publicationDate": "2021-07-15",
  "type": "article",
  "venue": "Nature",
  "venueType": "journal",
  "publisher": "Springer Nature",
  "issn": "0028-0836",
  "volume": "596",
  "issue": "7873",
  "pages": "583-589",
  "doi": "10.1038/s41586-021-03819-2",
  "doiUrl": "https://doi.org/10.1038/s41586-021-03819-2",
  "landingPageUrl": "https://www.nature.com/articles/s41586-021-03819-2",
  "isOpenAccess": true,
  "oaStatus": "hybrid",
  "openAccessPdfUrl": "https://www.nature.com/articles/s41586-021-03819-2.pdf",
  "license": "cc-by",
  "citationCount": 25890,
  "referencesCount": 84,
  "fwci": 900.1,
  "abstract": "Proteins are essential to life, and understanding their structure can facilitate a mechanistic understanding of their function. ...",
  "primaryTopic": "Protein Structure and Dynamics",
  "subfield": "Molecular Biology",
  "field": "Biochemistry, Genetics and Molecular Biology",
  "domain": "Life Sciences",
  "topics": ["Protein Structure and Dynamics"],
  "concepts": ["Protein structure prediction", "Deep learning"],
  "keywords": ["AlphaFold", "Protein structure prediction"],
  "authorDetails": [{"name": "John Jumper", "orcid": null, "position": "first", "isCorresponding": true, "institutions": ["Google DeepMind"]}],
  "openAlexUrl": "https://openalex.org/W4000000003",
  "query": null,
  "scrapedAt": "2026-11-02T18:00:00+00:00"
}
```

- **Abstracts** come from OpenAlex as a word index; the Actor puts the words back in order so you get readable text. Some publishers don't allow abstracts to be shared, so a few papers have none.
- **openAccessPdfUrl** is a direct PDF link from the best free copy OpenAlex knows (publisher or repository such as arXiv or PubMed Central). **openAccessUrl** is the best free copy even when it's a web page.
- **topics** use OpenAlex's current topic system. **concepts** are OpenAlex's older tags, kept because many tools still use them.
- **fwci** is the field-weighted citation impact (1.0 means average for the field and year).

Download results as JSON, CSV or Excel, or send them to Google Sheets, Zapier, Make or n8n. The run also saves a `SUMMARY` record in the key-value store with the total number of matching papers, which author and institution each of your inputs matched, and why the run stopped.

### Pricing

Pay per event: **$0.0007 per paper saved ($0.70 per 1,000 papers)**. No start fee. Set a maximum charge per run in the run options and the Actor stops cleanly when it's reached.

### OpenAlex limits and the optional API key

OpenAlex is free, and it gives every caller a small daily budget. Without a key one run can return up to 10,000 papers per search, which covers most uses. If you run large or frequent searches, create a free key at openalex.org (Settings > API) and paste it into **OpenAlex API key**. It raises the daily budget 10x and lets one search go past 10,000 papers. The key is stored encrypted by Apify and is never written to your results.

If OpenAlex's daily budget runs out mid-run, the Actor keeps the papers it already saved, explains why in the log and the `SUMMARY`, and you're charged only for what was saved. The budget resets at midnight UTC.

### Tips

- An author name can match more than one person. Check the log or `SUMMARY` to see who was matched, and use an ORCID iD or OpenAlex author ID when you need to be exact.
- Leave **Keywords** empty to list everything by an author or institution.
- For Google Scholar-style results, search with **Search in: Title and abstract** and **Sort by: Most cited**.

### Data source and terms

Data comes from [OpenAlex](https://openalex.org), run by the nonprofit OurResearch and released under the CC0 public-domain dedication. The Actor uses only the official, documented OpenAlex API, keeps well under its rate limits, and reads bibliographic metadata only. It doesn't scrape Google Scholar or publisher websites and doesn't log in anywhere. Free-PDF links point to copies OpenAlex lists as open access. Please respect each copy's license.

# Actor input Schema

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

Words to search for, e.g. crispr gene editing. Put a phrase in double quotes for an exact match, and use AND, OR, NOT (in capitals) for more control. Leave empty to search only by author or institution.

## `searchIn` (type: `string`):

Where the keywords must appear.

## `authors` (type: `array`):

Author names (e.g. "Jennifer Doudna"), ORCID iDs (e.g. 0000-0002-1825-0097) or OpenAlex author IDs (e.g. A5023888391). Names use OpenAlex's best match, shown in the log and the SUMMARY record. Papers by any of these authors are kept.

## `institutions` (type: `array`):

Institution names (e.g. "Stanford University"), ROR IDs (e.g. https://ror.org/00f54p054) or OpenAlex institution IDs (e.g. I97018004). Papers with an author at any of these are kept.

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

Earliest publication year (inclusive). Leave empty for no lower limit.

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

Latest publication year (inclusive). Leave empty for no upper limit.

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

Keep only papers that are free to read somewhere (publisher or repository).

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

Keep only papers cited at least this many times. 0 means no minimum.

## `workType` (type: `string`):

Limit to one kind of work. Leave on All types for everything.

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

Relevance needs keywords. Without keywords, relevance falls back to most cited.

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

Stop after this many papers. Without an OpenAlex API key OpenAlex serves at most 10,000 per search.

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

Add the abstract as plain text when OpenAlex has it.

## `apiKey` (type: `string`):

Not needed for normal use. OpenAlex gives every caller a small free daily budget; your own free key (from openalex.org/settings/api) raises it 10x and allows more than one page of results in some cases. Stored encrypted and never written to the output.

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

Sent to OpenAlex as the mailto parameter and in the User-Agent so they can reach you about heavy use. This used to unlock OpenAlex's faster "polite pool"; since February 2026 OpenAlex uses API keys for that instead.

## Actor input object example

```json
{
  "query": "large language models",
  "searchIn": "all",
  "openAccessOnly": false,
  "minCitations": 0,
  "workType": "any",
  "sort": "relevance",
  "maxResults": 100,
  "includeAbstract": true
}
```

# Actor output Schema

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

Every row the run saved, in the default dataset.

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

Counts and notes for the run, including anything skipped and why.

# 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"
};

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

# Run the Actor and wait for it to finish
run = client.actor("private_image_hg9/openalex-papers-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"
}' |
apify call private_image_hg9/openalex-papers-search --silent --output-dataset

```

## MCP server setup

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