# Academic Paper Search — Crossref DOIs, Authors, Citations (`dalbian/academic-literature-search`) Actor

Search 160 million scholarly works through Crossref by topic, author, journal, funder, date and licence. Returns DOIs, authors with ORCID, citation counts, abstracts and open-access links.

- **URL**: https://apify.com/dalbian/academic-literature-search.md
- **Developed by:** [Benjamin Jerez](https://apify.com/dalbian) (community)
- **Categories:** AI, Developer tools, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 search runs

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 — Crossref DOIs, Authors, Citations

Search the **Crossref** registry — the metadata backbone of scholarly publishing, roughly 160 million registered works — by topic, author, journal, funder, date and licence. Get back DOIs, authors with their ORCID identifiers and affiliations, citation counts, abstracts and open-access links.

### What comes back

Searching *solid state battery* in titles, 2025 onward:

| Title | Journal | Cited by | Open |
| --- | --- | --- | --- |
| Advanced Solid-State Lithium-Oxygen Battery | — | — | yes |
| Toward a full solid state aluminum battery | — | — | yes |
| Phase Diagrams Enable Solid-State Battery Design | — | — | yes |

Each work carries its DOI, publication date, volume and pages, every author with ORCID and affiliation, citation and reference counts, subjects, funders, licence URLs, direct full-text links where the publisher provides them, and a relevance score.

### Choosing where to search

**Title** is the right default for a topic. It is the most precise field and keeps the results on subject.

**Everything** searches titles, authors and journal names together. Broader, and useful when you are not sure how a field names a thing — but a word like *state* or *battery* will pull in unrelated work, so expect to skim.

**Author** finds a researcher's output; combine it with `withOrcidOnly` to follow one person across institutions and name spellings rather than everyone who shares a surname.

**Journal** shows what a specific publication has printed.

### A note on sorting

Relevance is the default and usually right. Sorting by **citation count** reorders everything Crossref considered a match, so with a broad query it will surface heavily-cited work that is only loosely on topic — the most-cited genomics paper of 2025 outranks a precise battery paper on almost any broad query. Pair citation sorting with a narrow title search, or keep relevance.

Sorting by **publication date** is how you watch a field week by week.

### For building a corpus

Three filters matter if you are feeding a model or building a search index:

`withAbstractOnly` keeps only works whose publisher deposited an abstract — a title alone carries little signal. `openAccessOnly` keeps works you can actually read in full. `workTypes` set to `posted-content` gives you preprints, where new results appear months before formal publication.

Results page reliably in the thousands, so a topic corpus is one run.

### Who uses this

Researchers and librarians running systematic reviews. R\&D and competitive-intelligence teams watching a technical field. Anyone building a RAG index or a literature dataset who needs citable metadata rather than scraped pages. Funders and institutions tracing what their money produced, via the funder DOI filter.

### Source and licence

**Crossref**, through its public REST API and the polite pool it recommends for identified callers. Crossref metadata is openly available and free to reuse; the Actor sends a contact address with every request as the API asks.

Abstracts and full text belong to their publishers. This Actor returns the abstract where the publisher deposited it with Crossref and a link where they provide one; it does not fetch article text from behind a paywall.

### Frequently asked

**Why is an abstract missing?**
Because the publisher never deposited one. Coverage varies enormously by field — strong in life sciences, patchy in the humanities. `withAbstractOnly` filters to what exists.

**Why is a paper I know of absent?**
Crossref indexes registered DOIs. A work without a DOI, or one registered with DataCite instead, will not appear.

**Are citation counts the same as Google Scholar's?**
No. Crossref counts citations from works that deposited their references with Crossref, so the figure is lower and more conservative. It is consistent and auditable, which is what matters for comparison.

**Can I fetch specific papers instead of searching?**
Yes — put DOIs in the `dois` field, with or without the `https://doi.org/` prefix, and each is fetched directly.

# Actor input Schema

## `queries` (type: `array`):

What to search for, one query per line. Plain words work best — Crossref matches across titles, abstracts and metadata rather than requiring exact phrases.

## `searchField` (type: `string`):

Where the query applies. 'Everything' is the broadest. 'Author name' finds a researcher's output; 'Journal' finds what a specific publication has printed.

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

Exact DOIs to fetch, one per line, with or without the https://doi.org/ prefix. Use this to enrich a reading list or a bibliography you already have rather than to search.

## `fromDate` (type: `string`):

Earliest publication date, as YYYY-MM-DD or just YYYY. Leave empty for no lower bound.

## `toDate` (type: `string`):

Latest publication date, as YYYY-MM-DD or just YYYY.

## `workTypes` (type: `array`):

Keep only these kinds of work. Leave empty for all. 'posted-content' means preprints, which is where the newest results appear months before formal publication.

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

Keep only works carrying a licence, which in practice means you can read the full text. Note that Crossref records the licence the publisher declared, so a few paywalled works slip through.

## `withAbstractOnly` (type: `boolean`):

Keep only works whose publisher deposited an abstract. Essential when you are feeding the results to a model or building a RAG index — a title alone carries little signal.

## `withOrcidOnly` (type: `boolean`):

Keep only works where at least one author has an ORCID identifier, which lets you follow a researcher across institutions and name variants.

## `funderIds` (type: `array`):

Funder DOIs from the Crossref Funder Registry, one per line, such as 10.13039/501100000780 for the European Commission. Use this to see what a funding body's money has produced.

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

How to order results. Citation count surfaces the established work; publication date surfaces what is happening now.

## `maxResultsPerQuery` (type: `integer`):

How many works to return per query. Crossref pages through results reliably, so a large number simply takes longer.

## `maxAuthorsPerWork` (type: `integer`):

Cap on authors returned per work. Some physics and genomics papers list thousands.

## Actor input object example

```json
{
  "queries": [
    "solid state battery"
  ],
  "searchField": "any",
  "workTypes": [],
  "openAccessOnly": false,
  "withAbstractOnly": false,
  "withOrcidOnly": false,
  "sortBy": "relevance",
  "maxResultsPerQuery": 100,
  "maxAuthorsPerWork": 20
}
```

# Actor output Schema

# 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 = {
    "queries": [
        "solid state battery"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dalbian/academic-literature-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 = { "queries": ["solid state battery"] }

# Run the Actor and wait for it to finish
run = client.actor("dalbian/academic-literature-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 '{
  "queries": [
    "solid state battery"
  ]
}' |
apify call dalbian/academic-literature-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dalbian/academic-literature-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/F7MN3M15hPbqIlqAx/builds/teVMxROQITrDjSl3B/openapi.json