# Research Papers API - Google Scholar Alternative (OpenAlex) (`lost.fany/research-papers-google-scholar-alternative`) Actor

Search tens of millions of scientific papers via OpenAlex, Crossref and arXiv: title, authors, abstract, DOI, citations, open access PDF links and funding. A Google Scholar alternative, no key. dryRun prices a run first; charged only for papers delivered.

- **URL**: https://apify.com/lost.fany/research-papers-google-scholar-alternative.md
- **Developed by:** [Natalia Ivanova](https://apify.com/lost.fany) (community)
- **Categories:** AI, News, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 paper rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Research Papers API - Google Scholar Alternative (OpenAlex, Crossref, arXiv)

Search **scientific papers across three open catalogues in one run** and get a clean dataset back: title, authors, abstract, DOI, citation count, open-access PDF link, journal or conference, topics and language. No API key, no login, no scraping of a search engine's result page.

The Actor queries **OpenAlex** (260M+ works, CC0 metadata), **Crossref** (the publisher record behind DOIs) and the **arXiv** Atom API (preprints with free full-text PDFs) in parallel, merges the answers and removes duplicates, so one paper is one row no matter how many catalogues indexed it.

### What a Google Scholar alternative gives you

Google Scholar has no API and forbids automated access. These three sources are built for it:

- **Literature reviews and systematic searches** — every hit on a topic, with abstracts, in a spreadsheet instead of twenty browser tabs.
- **Citation screening** — filter by year and minimum citations and keep what matters.
- **Open-access reading lists** — only papers you can actually read, with a direct PDF link.
- **RAG and dataset building** — abstracts are plain text in the row, ready for an embedding pipeline.
- **Research monitoring** — the same query every week, sorted newest first, to see what is new in a field.
- **AI agents** — "find me recent papers on retrieval augmented generation" through the Apify MCP server.

### Sources: OpenAlex, Crossref and arXiv papers

| Source | What it adds | Citations | Abstracts |
|---|---|---|---|
| OpenAlex | the broadest index, topics, open-access status, PDF links | yes | often |
| Crossref | the publisher's own DOI metadata, journal, licence | yes | sometimes |
| arXiv papers | preprints months before publication, always a free PDF | no | always |

Results are deduplicated by DOI and, where a preprint has none, by its normalised title — so the arXiv version and the published version of the same paper become a single row. The `foundIn` field lists every source the paper was seen in.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `query` | string | — | **Required.** Topic, title, author or phrase. |
| `sources` | array | all three | Any of `openalex`, `crossref`, `arxiv`. |
| `fromYear` / `toYear` | integer | — | Publication-year bounds. |
| `openAccessOnly` | boolean | `false` | Keep only papers that are free to read. |
| `minCitations` | integer | `0` | Keep only papers with at least this many citations. |
| `sortBy` | select | `relevance` | `relevance`, `date` or `citations`. |
| `contactEmail` | string | — | Optional. An address you own puts the run in the polite pool of OpenAlex and Crossref; a placeholder such as `you@example.com` is ignored. |
| `maxItems` | integer | `1000` | Stop after this many papers. |
| `proxyConfiguration` | object | off | Optional; the APIs are public. |

Examples:

```json
{ "query": "retrieval augmented generation", "maxItems": 100 }
```

```json
{ "query": "graphene oxide membranes", "fromYear": 2024, "toYear": 2026, "openAccessOnly": true, "minCitations": 5, "sortBy": "date" }
```

```json
{ "query": "dense passage retrieval", "sources": ["openalex", "crossref"], "sortBy": "citations", "contactEmail": "you@example.com", "maxItems": 500 }
```

### Output - scientific publications in one schema

```json
{
  "title": "Dense Passage Retrieval for Open-Domain Question Answering",
  "authors": ["Vladimir Karpukhin", "Barlas Oğuz", "Sewon Min"],
  "publicationYear": 2020,
  "publicationDate": "2020-01-01",
  "venue": "Conference on Empirical Methods in Natural Language Processing (EMNLP)",
  "publisher": "Association for Computational Linguistics",
  "doi": "10.18653/v1/2020.emnlp-main.550",
  "source": "openalex",
  "foundIn": ["openalex", "crossref", "arxiv"],
  "citationCount": 3413,
  "isOpenAccess": true,
  "oaStatus": "hybrid",
  "pdfUrl": "https://www.aclweb.org/anthology/2020.emnlp-main.550.pdf",
  "landingUrl": "https://doi.org/10.18653/v1/2020.emnlp-main.550",
  "abstract": "Open-domain question answering relies on efficient passage retrieval…",
  "concepts": ["Topic Modeling", "Information Retrieval and Search Behavior", "cs.CL"],
  "language": "en",
  "type": "article",
  "openalexId": "W3034758599",
  "arxivId": "2004.04906v3",
  "scrapedAt": "2026-10-12T11:30:00Z"
}
```

A run summary — rows per source, papers after deduplication, how many were found in more than one source, errors — is written to the `OUTPUT` record of the key-value store.

### Use cases for the research papers API

#### Search scientific publications across all three sources

```json
{ "query": "retrieval augmented generation", "maxItems": 200 }
```

#### arXiv papers only, newest first

```json
{ "query": "mechanistic interpretability", "sources": ["arxiv"], "sortBy": "date", "maxItems": 100 }
```

#### Highly cited open-access work since 2020

```json
{ "query": "protein structure prediction", "fromYear": 2020, "openAccessOnly": true, "minCitations": 50, "sortBy": "citations" }
```

### Pricing

Pay per event: a small fee per Actor start and a fee per paper returned. Deduplicated rows are charged once, not once per source. Current prices are in the **Pricing** tab.

### Good to know

- **Abstracts.** OpenAlex stores abstracts as an inverted index; the Actor rebuilds the running text. Crossref abstracts arrive as JATS XML and are converted to plain text. Where two sources disagree, the fuller abstract is kept.
- **Politeness.** OpenAlex and Crossref serve self-identifying clients from a faster pool, so filling in `contactEmail` with an address you own speeds the run up. arXiv asks for one request every three seconds and the Actor obeys that, which makes large arXiv runs the slow part of a job.
- **Citations.** Counts come from OpenAlex and Crossref and differ between them; the higher of the two is reported. A paper found only on arXiv has no count, so any `minCitations` above 0 drops it.
- **Open access.** OpenAlex reports it directly, arXiv is open by definition, and a Crossref-only paper counts as open only when it carries a Creative Commons licence — a Crossref PDF link can still sit behind a paywall.
- **Query handling.** arXiv joins bare words with OR, which would match hundreds of thousands of papers, so terms are ANDed; put a phrase in double quotes to keep it together. Crossref is always asked for its relevance order and re-sorted locally, because sorting its loose text match by date or citations server-side returns the newest or most cited paper that shares any single word with the query.
- **Year filters** drop papers whose publication year is unknown, which is a small share of Crossref records.

### Use with AI agents (MCP)

Add the Actor to the [Apify MCP server](https://apify.com/apify/actors-mcp-server): "recent open-access papers on diffusion models" → `{ "query": "diffusion models", "fromYear": 2025, "openAccessOnly": true, "sortBy": "date" }`.

### Related Actors

- [SEC EDGAR Filings & Funding](https://apify.com/lost.fany/sec-edgar-filings)
- [Hacker News Search API](https://apify.com/lost.fany/hacker-news-search-scraper)
- [Prediction Markets API](https://apify.com/lost.fany/polymarket-kalshi-prediction-markets)

### Disclaimer

Metadata comes from OpenAlex (CC0), Crossref and arXiv through their public APIs. This Actor is not affiliated with any of them, and it does not redistribute full texts: PDF links point at the publisher or repository. Citation counts are those reported by the sources.

### Cost control

Pay per event only works if you can see the bill before you pay it:

- Set `dryRun` to count every result and print what a full run would cost - nothing is charged, and only a few sample rows are stored.
- You are charged only for rows actually delivered to the dataset; a run that finds nothing costs nothing beyond the start event.
- `maxItems` is respected exactly, and the run stops before the platform's Max total charge for the run.
- Every run writes a `COST` record to the key-value store: chargeable events, charged events, the amount in USD and whether a limit was hit.

# Actor input Schema

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

What to search for: a topic, a title, an author name or a phrase. Searched in titles, abstracts and full text where the sources index it. Required — the Actor stops with a clear message if it is empty.

## `sources` (type: `array`):

Which open catalogues to query. OpenAlex is the broadest (260M+ works, CC0 metadata), Crossref is the publisher record of DOIs, arXiv adds preprints with full-text PDFs. All three by default; results are merged and deduplicated.

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

Keep papers published in this year or later, e.g. 2020. Empty = no lower bound. Papers with no known publication year are dropped when a year bound is set.

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

Keep papers published in this year or earlier, e.g. 2026. Empty = no upper bound.

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

Keep only papers that are free to read. OpenAlex reports open access directly, every arXiv preprint is open, and a Crossref-only paper counts as open when it carries a Creative Commons licence.

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

Keep only papers with at least this many citations. Citation counts come from OpenAlex and Crossref; a paper found only on arXiv has none and is dropped by any value above 0.

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

Order of the rows in the dataset. The same order is asked of every source, so a 'date' run returns the newest papers rather than the most relevant ones.

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

Optional. OpenAlex and Crossref serve clients that identify themselves from a faster 'polite pool'. Any address you actually own works; a placeholder address is ignored.

## `maxItems` (type: `integer`):

Stop after this many papers (counted after deduplication). Each source is read up to this many rows, so the raw number of API rows can be up to three times higher.

## `proxyConfiguration` (type: `object`):

Optional. All three APIs are public and are queried directly by default; a proxy only helps if the run is rate-limited.

## `dryRun` (type: `boolean`):

Count every result and show what a full run would cost, without charging for it. Only a few sample rows are stored. Use it to check the price before you pay.

## Actor input object example

```json
{
  "query": "retrieval augmented generation",
  "sources": [
    "openalex",
    "crossref",
    "arxiv"
  ],
  "openAccessOnly": false,
  "minCitations": 0,
  "sortBy": "relevance",
  "contactEmail": "you@example.com",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "dryRun": false
}
```

# Actor output Schema

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

One row per paper: title, authors, abstract, DOI, citations, open-access PDF link, journal or conference, topics and the sources it was found in.

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

Rows per source, papers after deduplication, how many were found in more than one source, and any source errors.

# 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",
    "sources": [
        "openalex",
        "crossref",
        "arxiv"
    ],
    "openAccessOnly": false,
    "minCitations": 0,
    "sortBy": "relevance",
    "contactEmail": "you@example.com",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("lost.fany/research-papers-google-scholar-alternative").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",
    "sources": [
        "openalex",
        "crossref",
        "arxiv",
    ],
    "openAccessOnly": False,
    "minCitations": 0,
    "sortBy": "relevance",
    "contactEmail": "you@example.com",
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("lost.fany/research-papers-google-scholar-alternative").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",
  "sources": [
    "openalex",
    "crossref",
    "arxiv"
  ],
  "openAccessOnly": false,
  "minCitations": 0,
  "sortBy": "relevance",
  "contactEmail": "you@example.com",
  "maxItems": 100
}' |
apify call lost.fany/research-papers-google-scholar-alternative --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lost.fany/research-papers-google-scholar-alternative"
        }
    }
}
```

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/rsPucfW82wwfMPmcA/builds/o6HqdwPDOYppi4q9w/openapi.json