# Crossref Works Scraper (`neuton/crossref-works-scraper`) Actor

Search Crossref scholarly works by query or DOI. Extract titles, authors, publishers, journals, publication dates, DOI URLs, references, licenses, and citation counts.

- **URL**: https://apify.com/neuton/crossref-works-scraper.md
- **Developed by:** [Neuton Scripts](https://apify.com/neuton) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 results

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Crossref Works Scraper

### Try a live sample

[Open the research-paper metadata Task](https://apify.com/neuton/crossref-works-scraper/examples/sample-crossref-works?utm_source=apify_store\&utm_medium=actor_readme\&utm_campaign=paid_signal_activation) to inspect a small editable query and DOI-backed output before scaling.

Search Crossref works or enrich a DOI list, then export publication metadata to CSV or JSON for literature reviews, citation workflows, and library enrichment. This Actor returns research-paper metadata, not paper PDFs or full text.

Use this actor when you need clean DOI-backed publication rows without maintaining your own Crossref integration. It is useful for publishers, universities, academic databases, AI/RAG teams, citation tools, research analysts, and market-intelligence workflows that need publication metadata at predictable cost.

### What it returns

- DOI, title, abstract, publisher, journal/container title
- Authors, publication dates, type, subject
- Reference count, citation count, indexed date, license records
- DOI URL and the query or DOI that produced the row

### Common use cases

- Enrich DOI lists with titles, authors, journal names, publishers, and dates
- Build scholarly datasets for RAG, literature reviews, or semantic search
- Collect results for publisher, journal, author, or keyword research
- Power citation workflows, library metadata cleanup, and research market maps
- Feed publication metadata into AI agents for summarization and deduplication

### Your first run

An Actor is the data-collection tool; a run is one execution. Its Dataset contains the returned rows. A saved Task keeps an input configuration for reuse.

1. Open the sample Task above or this Actor's Input tab.
2. Start with the ten-result query below. Review the live Pricing tab and your run's charge limit before starting.
3. When the run finishes, inspect its output Dataset. Check titles and DOIs for relevance before downloading CSV or JSON.
4. Save a Task once the input suits your workflow. Increase the query list only after checking the first output and charge.

### Example input: keyword search

Provide search queries, DOIs, or both. Crossref works best with publication titles, author names, journal names, or exact DOI values.

```json
{
  "queries": ["retrieval augmented generation"],
  "dois": [],
  "maxResults": 10
}
```

### Example input: one DOI

For DOI enrichment only, explicitly leave `queries` empty so the form's default search does not add unrelated results. Supply a DOI identifier, not a publisher-page URL.

```json
{
  "queries": [],
  "dois": ["10.1038/s41586-020-2649-2"],
  "maxResults": 1
}
```

#### Input limits

| Field | Meaning |
| --- | --- |
| `queries` | Up to 25 search strings, each up to 500 characters. |
| `dois` | Up to 100 DOI strings, each up to 300 characters. |
| `maxResults` | Results requested per query, from 1 to 100; default 50. It does not limit the number of DOI lookups. |

`maxResults` is not a global result or spending cap. Two queries with `maxResults: 10` plus five DOIs can return up to 25 rows before deduplication. Use a small input and Apify's run charge limit to bound your first attempt. If both input lists are empty, the Actor runs a small default search for retrieval augmented generation rather than doing nothing.

The Actor requests one result page per query. It does not exhaustively paginate Crossref or restrict results to papers published since your previous run. Repeated runs can return and charge for the same works again; deduplication applies within a run, not across runs.

### Output fields

Every returned row is saved to the default Apify Dataset with these field names:

| Fields | Content |
| --- | --- |
| `doi`, `url` | DOI identifier and publication/DOI URL. |
| `title`, `subtitle`, `abstract` | Title, subtitle, and abstract when supplied by Crossref. Abstracts may contain markup. |
| `publisher`, `type`, `containerTitle` | Publisher, work type, and journal or other container title. |
| `authors` | List of author objects with `name`, `orcid`, and `sequence`. |
| `issn`, `isbn`, `subjects` | Identifier and subject lists. |
| `publishedAt`, `createdAt`, `indexedAt` | Formatted dates when present. Missing month or day components are filled with `01`; do not treat that as verified day-level precision. |
| `referenceCount`, `isReferencedByCount` | Crossref's reference and citation counts when present. |
| `licenses` | Crossref license records, not a list of URL strings. |
| `sourceType`, `source` | Whether the row came from a query or DOI lookup, and the original input string. |

Missing scalar metadata can be `null`; missing lists are empty. A missing abstract does not mean the paper is missing. Crossref coverage depends on deposited metadata, and a citation count here is not a Google Scholar citation count.

The Actor retries temporary Crossref rate limits and upstream errors. Invalid or missing DOIs are reported in the non-billable `RUN_SUMMARY` key-value-store record instead of being written as paid dataset rows. One bad query or DOI does not cancel successful inputs in the same run.

### SEO keywords

Crossref scraper, DOI metadata scraper, Crossref works API, scholarly metadata export, academic publication scraper, citation data scraper, DOI to CSV, research paper metadata API.

### Pricing

Check the [live Pricing tab](https://apify.com/neuton/crossref-works-scraper/pricing) for the current per-result rate before running. Charges use the configured dataset-item event, not the number of search terms. This guide does not change the live price. Failed-input diagnostics are recorded separately in `RUN_SUMMARY`, not as dataset rows.

### Troubleshooting

- **Fewer results than requested:** Crossref may have fewer matches, duplicate works are removed within the run, or individual inputs may have failed. `maxResults` is a requested maximum, not a guaranteed count.
- **A DOI was skipped:** Check the run's key-value store record named `RUN_SUMMARY`. It includes `rowsSaved`, `queriesRequested`, `doisRequested`, and `failedInputs` with the affected input and error. Confirm the DOI exists in Crossref; not all DOI registration agencies use Crossref.
- **The run succeeded but the output is empty:** Inspect `RUN_SUMMARY` and the log. A completed process alone does not guarantee useful rows. Correct the input or wait for an upstream outage to clear before another attempt.
- **I need PDFs or every matching paper:** This Actor provides a bounded metadata lookup. It does not download papers or provide exhaustive search pagination.

### Responsible use

This actor extracts public metadata from Crossref. Respect Crossref API etiquette, publisher rights, and license terms for downstream use. Metadata can be incomplete or updated; verify critical bibliographic records before using them in formal publication, compliance, or procurement workflows.

### Automation ideas

Use saved Tasks, schedules, or the Apify API to send DOI batches into a citation manager, spreadsheet, or research pipeline. AI agents can summarize available abstracts and cluster topics while preserving DOI source links; do not invent missing authors, abstracts, or dates. In an Apify MCP workflow, select this Actor, pass the same input fields shown above, and inspect the Dataset before using it as evidence. Configure your AI client's connection separately; this Actor does not set it up for you.

# Actor input Schema

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

Search queries

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

DOIs

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

Max results per query

## Actor input object example

```json
{
  "queries": [
    "retrieval augmented generation"
  ],
  "dois": [],
  "maxResults": 50
}
```

# 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 = {};

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

# Run the Actor and wait for it to finish
run = client.actor("neuton/crossref-works-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 '{}' |
apify call neuton/crossref-works-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neuton/crossref-works-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/lJimRbdoZxXymZNsR/builds/aXGB0K7spHMo69iL6/openapi.json