# DataCite Metadata Scraper (`parseforge/datacite-metadata-scraper`) Actor

Scrapes DataCite metadata records by search term, repository, publisher, resource type, year, or specific DOI. Returns each record as a flat row with DOI, title, creator, publisher, and publication year.

- **URL**: https://apify.com/parseforge/datacite-metadata-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.60 / 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.
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?

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### DataCite Metadata Scraper

**Scrape research metadata from DataCite by search term, repository, publisher, or resource type, up to a million records per run.** Every record returns its DOI, title, creator, publisher, publication year, and full metadata. No API key required. Export to CSV, JSON, Excel, or XML.

DataCite's API requires you to understand its complex query syntax and pagination logic, which slows down research discovery. This Actor reads the public DataCite REST API directly, letting you search by keyword, filter by repository like Zenodo or Dryad, or target a specific DOI, and returns each matching record in one consistent flat schema.

| Who uses it | What they scrape DataCite for |
|---|---|
| Research data librarians | Harvesting metadata for all datasets published by their institution's repository this quarter. |
| Meta-scientists | Tracking the growth of dataset publications across different repositories and disciplines. |
| Data journalists | Finding openly available research data behind a news story by searching for related keywords. |
| Repository managers | Auditing their own repository's metadata completeness and consistency against DataCite's records. |

### What it does

This Actor collects DataCite metadata records by search query, repository, publisher, resource type, year, or specific DOI, and returns each one as a flat row.

- 🔍 **Keyword search:** Find DOIs by any search term, from broad topics like 'climate' to specific project names.
- 🏛️ **Repository filter:** Limit results to a specific repository such as Zenodo, Dryad, Figshare, Dataverse, PANGAEA, or OSF.
- 📄 **Single DOI lookup:** Fetch the complete metadata for one known Digital Object Identifier.
- 📊 **Faceted filtering:** Narrow results by publisher name, resource type (Dataset, Software, Article, etc.), and publication year.
- ↕️ **Sort control:** Order results by creation date, last update, or publication year, ascending or descending.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with DataCite data

**📚 Build a research data catalog.**

A university librarian runs the Actor with their repository ID and the current year to harvest all newly registered DOIs for the institutional data portal.

**📈 Analyze open data trends.**

A meta-science researcher searches for 'cancer genomics' across all repositories, filters by Dataset, and exports five years of records to chart publication growth.

**🔎 Find data behind a paper.**

A data journalist enters a specific DOI from a journal article to retrieve the underlying dataset's title, creators, and repository link for a fact-checking piece.

**🛠️ Audit repository metadata.**

A Dryad administrator filters by their repository ID and the Text resource type to check how many records are missing abstracts before a metadata cleanup sprint.

### Why choose this scraper

|  | What you get |
|---|---|
| **Consistent flat schema** | Nested DataCite metadata is flattened into one predictable row per record, ready for analysis. |
| **No API key needed** | Uses the public DataCite REST API with no registration, no OAuth, and no rate-limit headaches. |
| **Bulk export ready** | Download up to a million records directly to CSV, JSON, Excel, or XML in one run. |
| **Precision filtering** | Combine repository, publisher, resource type, and year to zero in on exactly the records you need. |

### How it compares

This Actor offers faceted filtering by repository, publisher, resource type, and year, while the competitor focuses on a simpler keyword and DOI search.

| Feature | ParseForge | DataCite DOI Scraper - Research Metadata Search |
|---|---|---|
| Keyword search | Yes | Yes |
| Single DOI lookup | Yes | Yes |
| Filter by repository | Yes | Not listed |
| Filter by publisher | Yes | Not listed |
| Filter by resource type | Yes | Not listed |
| Filter by publication year | Yes | Not listed |
| Sort order control | Yes | Not listed |

### Configure the run

Drive the Actor from a search term, a specific DOI, or a combination of repository, publisher, resource type, and year filters, and each filter is applied as the API is queried so only matching records reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10,
  "query": "climate"
}
```

A larger pull:

```json
{
  "maxItems": 200,
  "query": "climate"
}
```

### Pricing

Pay-per-result: **$0.0075 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.75 |
| 1,000 results | $7.50 |
| 10,000 results | $75.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [DataCite Metadata Scraper](https://apify.com/parseforge/datacite-metadata-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to DataCite through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/datacite-metadata-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that your search term is not too narrow, and that your filters do not conflict. For example, a repository filter combined with a publisher that does not deposit there will return zero records. Try broadening one filter at a time.

**The Actor returns fewer records than my maxItems setting.**

This is normal when the total number of matching records in DataCite is smaller than your limit. The Actor stops when it has exhausted all available results for your query.

**My single DOI lookup returns an empty dataset.**

Ensure the DOI is entered in the correct format, such as 10.5281/zenodo.1234567. If the DOI is valid but still returns nothing, it may not be indexed in DataCite or may be restricted.

**The run takes a long time for a large maxItems value.**

The Actor respects DataCite's rate limits and paginates through results. For very large harvests, consider running it with a narrower filter or a smaller maxItems limit and chaining multiple runs.

**Some records have missing fields in the output.**

DataCite metadata completeness varies by repository and record. If a field like 'abstract' or 'subject' is empty, the original DOI registration did not include it. This is not an error in the Actor.

### FAQ

| Question | Answer |
|---|---|
| Do I need a DataCite API key or account? | No. This Actor uses the public DataCite REST API, which does not require authentication, registration, or an API key. |
| What metadata fields does each record include? | Each record returns the DOI, title, creator names, publisher, publication year, resource type, repository, and additional metadata such as descriptions and subjects, all flattened into a single row. |
| Can I search for a specific DOI? | Yes. Enter the full DOI in the DOI input field, and the Actor will fetch only that record, ignoring all other filters. |
| How many records can I collect in one run? | You can set the maximum records up to 1,000,000 per run. The Actor will stop when it reaches that limit or when no more matching records exist. |
| Which repositories can I filter by? | You can filter by Zenodo, Dryad, Figshare, Dataverse, PANGAEA, OSF, Zenodo.org, or the general DataCite repository. |
| What resource types are available? | The Actor supports filtering by Dataset, Software, Article, Text, Image, Video, Audio, Collection, Event, Physical Object, Service, and Other. |
| Can I combine filters, like repository and year? | Yes. All filters work together. For example, you can search for Dataverse datasets published in 2023 by a specific publisher. |
| How do I sort the results? | Use the Sort dropdown to order results by creation date, last update, or publication year, in either ascending or descending order. |
| What export formats are supported? | You can export your dataset to CSV, JSON, Excel, or XML directly from the Apify platform. |
| Is this Actor suitable for a full DataCite harvest? | Yes, but for a complete harvest of all DataCite records, run it with a broad search term and a high maxItems limit. Be mindful of the run time for very large sets. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by DataCite e.V. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

Maximum number of DataCite records to collect per run.

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

Search term to find DOIs.

## `doi` (type: `string`):

Specific Digital Object Identifier to retrieve (e.g., 10.5281/zenodo.1234567). If provided, only this DOI will be fetched.

## `repositoryId` (type: `string`):

Filter by repository identifier.

## `publisher` (type: `string`):

Filter by publisher name.

## `resourceType` (type: `string`):

Filter by resource type.

## `year` (type: `integer`):

Filter by publication year (4-digit year, e.g., 2023).

## `sort` (type: `string`):

Sort order for results.

## Actor input object example

```json
{
  "maxItems": 10,
  "query": "climate",
  "sort": "-created"
}
```

# Actor output Schema

## `dois` (type: `string`):

Complete dataset with all scraped DOI metadata including titles, creators, publishers, publication years, resource types, and comprehensive metadata

## `overview` (type: `string`):

Overview view of DOIs with key fields displayed in a table format

# 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 = {
    "maxItems": 10,
    "query": "climate"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/datacite-metadata-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 = {
    "maxItems": 10,
    "query": "climate",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/datacite-metadata-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 '{
  "maxItems": 10,
  "query": "climate"
}' |
apify call parseforge/datacite-metadata-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/datacite-metadata-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/6YwIgyUh09cEQD58C/builds/Fxk6Mfvwqipm9fTWL/openapi.json