# Crossref Scraper | 13 Fields, 50K Works/Run, No API Key (`themineworks/crossref-scholarly-metadata`) Actor

Scrape 150M+ scholarly works from Crossref: DOIs, authors, journals & citation counts by topic, year and type. Clean structured JSON for bibliometrics, literature reviews and RAG. No API key. Use it as an MCP server in Claude, ChatGPT & AI agents.

- **URL**: https://apify.com/themineworks/crossref-scholarly-metadata.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Education, AI, MCP servers
- **Stats:** 13 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 works

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

## Crossref Scraper: 13 Fields, 50K Works/Run, No API Key

Pay only for results delivered. [Browse all Actors](https://apify.com/themineworks?fpr=ymnoit\&utm_source=apify-readme\&utm_medium=referral).

💰 From $0.60 / 1,000 results.

Guide and FAQs: [Crossref Scraper on themineworks.com](https://themineworks.com/actors/crossref-scholarly-metadata/). Tutorial: [Crossref API: Free DOI Metadata and Citation Counts](https://themineworks.com/blog/crossref-doi-metadata-api/).

Search Crossref's scholarly record and get **13 fields per work**: DOI, title, type, publication year and full date, author list, journal, publisher, citation count, reference count, ISSNs, resolved URL and capture timestamp. Filter by keyword, publication-year range and work type, and pull up to **50,000 works in a single run** using Crossref's deep cursor pagination.

Pure HTTP against the official Crossref REST API. **No API key, no login, no browser.** An optional `mailto` puts your requests in Crossref's faster polite pool.

### Why use this Crossref scraper

- **50,000 works per run, properly paginated.** Crossref's offset paging breaks past a few thousand results; this Actor uses the `cursor` deep-paging API, so a large corpus actually completes.
- **Citation counts on every row.** `cited_by_count` (Crossref's `is-referenced-by-count`) and `references_count` come back without a second API call, which is what makes bibliometrics possible in one pass.
- **Eight work types to filter on.** Journal article, book chapter, proceedings article, posted content (preprints), book, dataset and report, or leave it empty for everything.
- **A narrow field selection, so responses stay small.** The Actor requests only the fields it maps, which keeps large runs fast and cheap.
- **Polite pool support.** Supply `mailto` and Crossref routes you to its higher-priority infrastructure at no cost.

### Search a topic across a year range

```json
{
  "query": "large language models",
  "fromYear": 2023,
  "toYear": 2026,
  "workType": "journal-article",
  "maxResults": 500
}
```

The standard literature-review pull: one topic, one window, peer-reviewed articles only.

### Build a large bibliometric corpus

```json
{
  "query": "CRISPR gene editing",
  "fromYear": 2015,
  "maxResults": 20000,
  "mailto": "you@example.com"
}
```

Deep cursor paging plus the polite pool is what makes a 20,000-work pull practical. Leave `toYear` off for everything published since the start year.

### Find conference papers and preprints only

```json
{
  "query": "diffusion models",
  "workType": "proceedings-article",
  "maxResults": 1000
}
```

Switch `workType` to `posted-content` for preprints. In fast-moving fields the preprint record is often months ahead of the journal record.

### Track the most-cited work on a topic

```json
{
  "query": "retrieval augmented generation",
  "fromYear": 2022,
  "maxResults": 2000
}
```

Pull the corpus, then sort locally by `cited_by_count`, Crossref does not offer a citation-count sort, but the field is on every row so the ranking is a one-liner downstream.

### What data does the Crossref scraper return

```json
{
  "doi": "10.1038/s41586-023-06004-9",
  "title": "Example study on language model scaling",
  "type": "journal-article",
  "year": 2023,
  "published_date": "2023-5-17",
  "authors": ["Jane Doe", "John Smith"],
  "journal": "Nature",
  "publisher": "Springer Science and Business Media LLC",
  "cited_by_count": 412,
  "references_count": 63,
  "issn": ["0028-0836", "1476-4687"],
  "url": "https://doi.org/10.1038/s41586-023-06004-9",
  "scraped_at": "2026-08-01T12:00:00.000Z"
}
```

| Field | Description |
| --- | --- |
| `doi` | Digital Object Identifier |
| `title` | Work title (first title where a work has several) |
| `type` | Crossref work type |
| `year`, `published_date` | Publication year and the fullest date Crossref holds |
| `authors[]` | Author names, given plus family, flattened |
| `journal`, `publisher` | Container title and publisher |
| `cited_by_count` | How many Crossref-indexed works cite this one |
| `references_count` | How many references this work deposits |
| `issn[]` | Journal ISSNs |
| `url` | Publisher URL, falling back to the DOI resolver |
| `scraped_at` | Capture timestamp |

Metadata quality on Crossref depends on what each publisher deposits. Missing author lists, dates or ISSNs come back empty rather than reconstructed.

### How the scraper works without an API key

Crossref's REST API is open and keyless. This Actor requests 100 works per page with an explicit `select` field list, follows `next-cursor` for deep pagination, and retries 429 and 5xx with a capped backoff. Adding `mailto` opts you into Crossref's polite pool, which is more reliable under load and costs nothing.

### What can you build with Crossref data

**Literature reviews.** A filtered, deduplicated corpus with DOIs, ready to hand to a reference manager or a RAG index.

**Bibliometrics and research assessment.** Citation and reference counts per work, aggregated by author, journal or year.

**Journal and publisher benchmarking.** Output volume and citation profile per venue over a period.

**Reference resolution.** Turn free-text citations into DOIs, then follow them with a citation-graph Actor.

### How much does it cost to scrape Crossref

Pay per work delivered: **$0.001 on the Apify Free plan, $0.0006 on Gold and above**. A query that matches nothing is never charged. Every run also carries a $0.005 start fee.

### How do I use Crossref in Claude or ChatGPT

```
https://mcp.apify.com/?tools=themineworks/crossref-scholarly-metadata
```

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('themineworks/crossref-scholarly-metadata').call({
  query: 'large language models',
  fromYear: 2023,
  maxResults: 500,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

### Crossref scraper FAQ

**Do I need an API key?** No. Crossref is open. `mailto` is optional and only improves routing.

**What is the polite pool?** Crossref runs separate infrastructure for requests that identify themselves. Supplying a real email in `mailto` gets you onto it, free.

**Why is `cited_by_count` lower than Google Scholar?** Crossref counts only citations from works deposited with Crossref. It is a floor, not a total.

**How deep can pagination go?** Up to 50,000 works per run via cursor paging.

**Can I search by author or journal?** `query` is Crossref's free-text search across the record, so an author or journal name works as a query term, though it is not a strict field match.

### Complete your research intel pipeline

- **[OpenCitations Scraper](https://apify.com/themineworks/opencitations-citation-graph?fpr=ymnoit\&utm_source=apify-readme\&utm_medium=referral)**, expand any DOI into its citing and cited works.
- **[PubMed Scraper](https://apify.com/themineworks/pubmed-ncbi-scraper?fpr=ymnoit\&utm_source=apify-readme\&utm_medium=referral)**, biomedical abstracts and MeSH terms for the same literature.
- **[arXiv Scraper](https://apify.com/themineworks/arxiv-preprint-search?fpr=ymnoit\&utm_source=apify-readme\&utm_medium=referral)**, the preprint record, usually months ahead of the journal.

Found a bug or want a field added? Open an issue on the Actor's Apify Console page.

### Related guides

- [Building an Academic Research Data Stack: Crossref, OpenAlex, and Citation-Aware RAG](https://themineworks.com/blog/literature-review-five-databases-one-call)
- [Crossref API: 150 Million DOIs, Citation Counts, and Bibliographic Data for Free](https://themineworks.com/blog/crossref-doi-metadata-api)

*Last verified: 2026-08*

# Actor input Schema

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

Search across titles, authors, and metadata (e.g. crispr, large language models).

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

Only works published in or after this year.

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

Only works published in or before this year.

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

Filter by type (e.g. journal-article, book-chapter, proceedings-article). Leave empty for all.

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

Maximum number of works to return.

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

Crossref gives faster, more reliable service when you supply a contact email, e.g. "research@university.edu". Recommended.

## Actor input object example

```json
{
  "query": "large language models",
  "workType": "journal-article",
  "maxResults": 25,
  "mailto": "research@university.edu"
}
```

# 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 = {
    "query": "large language models",
    "workType": "journal-article",
    "maxResults": 25,
    "mailto": "research@university.edu"
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/crossref-scholarly-metadata").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",
    "workType": "journal-article",
    "maxResults": 25,
    "mailto": "research@university.edu",
}

# Run the Actor and wait for it to finish
run = client.actor("themineworks/crossref-scholarly-metadata").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",
  "workType": "journal-article",
  "maxResults": 25,
  "mailto": "research@university.edu"
}' |
apify call themineworks/crossref-scholarly-metadata --silent --output-dataset

```

## MCP server setup

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

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/5lBiD3Kfqf6de5daK/builds/FhMcbeO9mwS6c00JG/openapi.json