# Crossref Scraper - Academic Papers & DOI Lookup (`treesap_1127/crossref-scraper`) Actor

Search scholarly works by keyword or look up DOIs with the public Crossref REST API. Get title, journal, publisher, date, citation count, licenses and full-text links as clean JSON, CSV or Excel. No API key or login needed.

- **URL**: https://apify.com/treesap_1127/crossref-scraper.md
- **Developed by:** [TaeSung Lee](https://apify.com/treesap_1127) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 apify-default-dataset-items

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

## Crossref Scraper - Academic Papers & DOI Lookup

Search scholarly works by keyword or look up a list of DOIs, and get clean, structured metadata: title, journal, publisher, publication date, citation count, licenses and full-text links. The Actor reads the **public Crossref REST API**, so it needs no browser, no proxy, no API key and no login.

Use it to:

- build a reading list on a topic, sorted by relevance, citations or date,
- enrich a list of DOIs from a spreadsheet or reference manager with journal, publisher and citation data,
- feed a literature-review pipeline, RAG system or AI agent (n8n, Make, MCP) with a legal, stable source of paper metadata,
- run a weekly search for the newest papers on a topic and send the results to a webhook.

### What you get

- **One row per work** with 20 fields: DOI, link, title, journal or book title, publisher, work type, publication date, citation count, reference count, number of authors, ISSN, ISBN, volume, issue, pages, license URLs, full-text links and funder names.
- **Filters**: publication year range and work type (journal article, conference paper, book chapter, book, preprint, dataset, report, dissertation).
- **Sorting**: by relevance, most cited, or newest.
- **Export** as JSON, CSV, Excel, XML or HTML from the Apify dataset, or read it through the Apify API.
- **Run summary**: the `RUN_SUMMARY` key in the key-value store lists requests, results and the status of every input.

### How to use it

#### 1. Search a topic

```json
{
  "searchQueries": ["large language models"],
  "maxItemsPerQuery": 50,
  "fromYear": 2023,
  "workType": "journal-article",
  "sortBy": "mostCited"
}
```

#### 2. Look up DOIs

```json
{
  "dois": ["10.1038/nature14539", "https://doi.org/10.1126/science.ade2574"]
}
```

DOIs can be bare, start with `doi:`, or be full `doi.org` links. Each DOI returns one row.

#### 3. Weekly new papers

Create an Apify Schedule that runs the Actor with `"sortBy": "newest"` and `"fromYear"` set to the current year, then connect a webhook or integration to receive the dataset. The Actor does not remember earlier runs, so remove duplicates by `doi` on your side.

### Input

| Field | Description |
|---|---|
| `searchQueries` | Keywords, titles, journals or years to search for. Each query is run separately. |
| `dois` | DOIs or DOI links to look up. |
| `maxItemsPerQuery` | Results per search query, 1 to 1000 (default 50). A DOI always gives one result. |
| `fromYear`, `untilYear` | Only works published in this year range. Searches only. |
| `workType` | `any` or one work type. Searches only. |
| `sortBy` | `relevance` (default), `mostCited` or `newest`. Searches only. |

Provide at least one search query or DOI. Duplicate queries and DOIs are merged, and values that are not DOIs are skipped with a warning.

### Output

Every result is one dataset item. The columns of the default table view are title, journal, published, citations, type, DOI and link.

```json
{
  "doi": "10.1126/science.ade2574",
  "url": "https://doi.org/10.1126/science.ade2574",
  "title": "Evolutionary-scale prediction of atomic-level protein structure with a language model",
  "containerTitle": "Science",
  "publisher": "American Association for the Advancement of Science (AAAS)",
  "type": "journal-article",
  "publishedDate": "2023-03-17",
  "citationCount": 6228,
  "authorCount": 15,
  "inputType": "searchQuery",
  "input": "large language models"
}
```

The full item has 20 fields; see `sample-output.json` for a real example.

#### Field notes

- `publishedDate` is `YYYY`, `YYYY-MM` or `YYYY-MM-DD`, depending on what the publisher deposited. It is the earlier of the print and online dates, so for works at the edge of your year filter it can fall one year before `fromYear`.
- `citationCount` is the number of citations known to Crossref, not Google Scholar or Scopus.
- `newest` ignores records with future dates: unless you set an earlier `untilYear`, results are capped at today.
- `fullTextLinks` and `licenseUrls` are the links publishers deposit. Many are for text mining and may need a subscription or a license.
- Abstracts, author names, ORCID iDs and affiliations are deliberately not returned; only `authorCount` is. See the Legal section.
- `inputType` and `input` tell you which query or DOI produced a row.

### Pricing

The Actor uses pay-per-event pricing: you pay per result, meaning one saved dataset item. Empty searches, DOIs that do not exist and failed inputs are not saved and not charged. You can test with a small `maxItemsPerQuery`. If you set a maximum cost per run, the Actor stops cleanly when the limit is reached and keeps what it already saved. The current price is shown on the Store page.

### Speed and limits

- The Actor sends about one request per second, one at a time, as asked by the rate-limit headers of the public Crossref API. A request returns up to 100 results, so 1,000 results take roughly 10 requests, about half a minute.
- On HTTP 429 or temporary errors it waits and retries up to three times. On HTTP 403 it stops instead of trying to get around the block.
- Up to 1,000 results per query. This is a search tool, not a full database dump.
- Only Crossref metadata is returned. Items that are not registered with Crossref (for example many arXiv-only papers) are not found.

### Legal

This is an unofficial tool. It is not affiliated with or endorsed by Crossref and does not use Crossref logos or trademarks.

The Actor only calls the public Crossref REST API, which according to the Crossref documentation can be used by anyone: "Anyone can access the REST API, no signup or registration is required". Crossref also states that "The majority of metadata is considered to be 'facts' which are not copyrightable and are thus in the public domain (CC0)", with the exception of abstracts, which are subject to publisher or author copyright. For that reason the Actor does not return abstracts, and it does not return author names, ORCID iDs or affiliations (personal data). It only fetches the queries and DOIs you provide, with no bulk crawl mode, and it identifies itself with a User-Agent that names this Actor.

You are responsible for using the data lawfully, including applicable laws and the license of each publisher (see `licenseUrls`) before you use any full-text link. This section is not legal advice.

### FAQ

#### Do I need a Crossref account or API key?

No. The Actor uses the public API pool without any key.

#### Why are some results not about my topic?

Crossref ranks by bibliographic match on titles, journals and authors, not by meaning. Use more specific phrases, a year range or a work type to narrow results.

#### Can I get abstracts or author names?

No. Abstracts are subject to copyright and names are personal data, so the Actor returns only metadata about the work. To read a paper, open the `url` field.

#### Can I get a larger result set?

Set `maxItemsPerQuery` up to 1000 per query and add more queries, or split a topic by year with `fromYear` and `untilYear`.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords, titles, journals or years to search for. Each query returns up to 'Max results per query' works (Crossref bibliographic search).

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

DOIs or DOI links to look up, one work each. Examples: 10.1038/nature14539 or https://doi.org/10.1038/nature14539.

## `maxItemsPerQuery` (type: `integer`):

Maximum number of works to save for each search query (1-1000). DOI lookups always return one work.

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

Only works published in this year or later. Applies to search queries only.

## `untilYear` (type: `integer`):

Only works published up to this year. Applies to search queries only.

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

Only return this type of work. Applies to search queries only.

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

Relevance uses the Crossref match score. Most cited sorts by citation count. Newest sorts by publication date.

## Actor input object example

```json
{
  "searchQueries": [
    "large language models"
  ],
  "dois": [],
  "maxItemsPerQuery": 10,
  "workType": "any",
  "sortBy": "relevance"
}
```

# Actor output Schema

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

No description

# 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 = {
    "searchQueries": [
        "large language models"
    ],
    "maxItemsPerQuery": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("treesap_1127/crossref-scraper").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 = {
    "searchQueries": ["large language models"],
    "maxItemsPerQuery": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("treesap_1127/crossref-scraper").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 '{
  "searchQueries": [
    "large language models"
  ],
  "maxItemsPerQuery": 10
}' |
apify call treesap_1127/crossref-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,treesap_1127/crossref-scraper"
        }
    }
}
```

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/7owE3vATHorBt9bXj/builds/TMUC2OTQwmKGcu8GE/openapi.json