# Zenodo Research Scraper — Datasets, Papers & Software (`hipersoft/zenodo-research-scraper`) Actor

Search Zenodo (CERN) research outputs in bulk: datasets, publications, software, images and more. Get title, DOI, authors with affiliations, description, keywords, license, access rights, views, downloads and file links. For academic research, lit reviews and n8n.

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

## Pricing

from $0.0005 / record scraped

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

## Zenodo Research Scraper — Datasets, Papers & Software

Search and export **Zenodo** — the open research repository built at **CERN** — into clean **JSON, CSV, Excel or XML**. Pull research outputs in bulk: **datasets, publications, software, images, videos, posters and presentations** with their **DOIs, authors and affiliations, description, keywords, license, access rights, view and download counts, and downloadable file links**.

Built for researchers, data teams, meta-analysts and pipelines that need structured research metadata at scale instead of clicking through the Zenodo site one record at a time.

### What does the Zenodo Research Scraper do?

Give it a **search query** — a topic like `climate change`, a method like `deep learning`, or an author or keyword — optionally narrow it to one **resource type**, and the actor paginates through Zenodo and returns one clean row per record:

- `title`, `doi` and a direct `url` to the record
- `type` (dataset, publication, software, image, video, poster, presentation)
- `publicationDate`
- `creators` — each with `name` and `affiliation`
- `description` (plain text, HTML stripped), `keywords`, `license` and `accessRight`
- `views` and `downloads` counts
- `files` — each with `name`, `size` and a download `link`

### What data can you get?

| Field | Type | Description |
| --- | --- | --- |
| `id` | integer | Zenodo record ID (unique identifier) |
| `doi` | string | Digital Object Identifier for the record |
| `title` | string | Record title |
| `type` | string | Resource type, e.g. `dataset`, `publication`, `software` |
| `publicationDate` | string | Publication date (YYYY-MM-DD) |
| `creators` | array | Authors, each `{ name, affiliation }` |
| `description` | string | Description as plain text (HTML stripped) |
| `keywords` | array | Keywords / tags assigned to the record |
| `license` | string | License identifier, e.g. `cc-by-4.0` |
| `accessRight` | string | Access level, e.g. `open`, `restricted`, `closed` |
| `views` | integer | Number of views recorded for the record |
| `downloads` | integer | Number of file downloads recorded |
| `files` | array | Attached files, each `{ name, size, link }` |
| `url` | string | Link to the record page |

### Use cases

- **Literature & data reviews** — collect every dataset, paper or software release on a topic with DOIs ready to cite.
- **Meta-analysis** — build a structured corpus of research outputs, filtered to one resource type.
- **Research monitoring** — track new outputs for a topic sorted by most recent.
- **Dataset discovery** — find open datasets and their downloadable file links for reuse.
- **Bibliometrics** — analyse views, downloads, licenses and access rights across a field.

### How to use it

1. Add the Zenodo Research Scraper to your Apify account and open the input form.
2. Enter a **Search query** (e.g. `climate change`).
3. Optionally pick a **Resource type** to narrow results to datasets, publications, software and so on.
4. Choose a **Sort order** — best match or most recent.
5. Set **Max items** to cap the export, then **Run**.
6. **Export** the dataset as JSON, CSV, Excel or XML, or pull it via the Apify API.

### Input

```json
{
  "query": "climate change",
  "resourceType": "dataset",
  "maxItems": 100,
  "sort": "bestmatch"
}
```

| Field | Type | Description |
| --- | --- | --- |
| `query` | string | Search string matching titles, descriptions, authors and keywords. |
| `resourceType` | string | Optional: `dataset`, `publication`, `software`, `image`, `video`, `poster` or `presentation`. Empty = all types. |
| `maxItems` | integer | Maximum records to return (default 100). |
| `sort` | string | `bestmatch` (relevance) or `mostrecent` (newest first). |

### Output

```json
{
  "id": 3461529,
  "doi": "10.5281/zenodo.3461529",
  "title": "ECMWF ERA5 Monthly surface air temperature anomalies",
  "type": "dataset",
  "publicationDate": "2019-09-26",
  "creators": [
    { "name": "Copernicus Climate Change Service", "affiliation": "ECMWF" }
  ],
  "description": "Monthly global-mean and European-mean surface air temperature anomalies...",
  "keywords": ["temperature", "climate", "global", "ECMWF", "ERA5"],
  "license": "cc-by-4.0",
  "accessRight": "open",
  "views": 856,
  "downloads": 769,
  "files": [
    {
      "name": "ts_1month_anomaly_Global_ea_2T_201908_v01.csv",
      "size": 10761,
      "link": "https://zenodo.org/api/records/3461529/files/ts_1month_anomaly_Global_ea_2T_201908_v01.csv/content"
    }
  ],
  "url": "https://zenodo.org/records/3461529"
}
```

### FAQ

**What is Zenodo?**
Zenodo is an open research repository operated by CERN. It lets researchers deposit and share datasets, papers, software, figures and other outputs, each assigned a citable DOI.

**How many records can I get?**
As many as your search returns. Use **Max items** to cap a run and keep it cheap, and **Resource type** to focus on exactly what you need.

**How does billing work?**
You pay only per record you get, so small, tightly filtered runs stay inexpensive.

**What export formats are supported?**
JSON, CSV, Excel and XML, plus direct access via the Apify API.

**Can I use this with n8n?**
Yes. Run the Zenodo Research Scraper from n8n with the [Apify node](https://n8n.io/integrations/apify/) — trigger a run, wait for it to finish, and read the dataset items straight into your workflow to build reading lists, enrich references or drive alerts. It also works with [Make](https://apify.com/integrations/make), [Zapier](https://apify.com/integrations/zapier) and the [Apify API](https://docs.apify.com/api/v2).

**Can I connect this to other tools?**
The Zenodo Research Scraper connects with almost any cloud service or web app through [integrations on the Apify platform](https://apify.com/integrations) — [Make](https://apify.com/integrations/make), [Zapier](https://apify.com/integrations/zapier), [Slack](https://docs.apify.com/platform/integrations/slack), [Google Drive](https://docs.apify.com/platform/integrations/drive) and [many more](https://apify.com/integrations), plus [webhooks](https://docs.apify.com/platform/integrations/webhooks) to trigger an action whenever a run finishes.

**Is this only public data?**
Yes. It returns only openly published research metadata. You are responsible for compliance with Zenodo's terms and the license of each record.

### Notes

Original clean-room implementation. Not affiliated with Zenodo or CERN. Records are contributed by Zenodo's users and made available under their respective licenses; cite the original works where required.

# Actor input Schema

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

Search string to find Zenodo research records (matches titles, descriptions, authors and keywords). E.g. 'climate change', 'deep learning', 'genomics'.

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

Optional filter to a single kind of research output. Leave empty to include all types.

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

Maximum number of records to collect for the query.

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

How to order results: 'bestmatch' by relevance to the query, or 'mostrecent' by newest first.

## Actor input object example

```json
{
  "query": "machine learning",
  "resourceType": "",
  "maxItems": 100,
  "sort": "bestmatch"
}
```

# Actor output Schema

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

The scraped results as dataset items.

# 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": "climate change"
};

// Run the Actor and wait for it to finish
const run = await client.actor("hipersoft/zenodo-research-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 = { "query": "climate change" }

# Run the Actor and wait for it to finish
run = client.actor("hipersoft/zenodo-research-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 '{
  "query": "climate change"
}' |
apify call hipersoft/zenodo-research-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hipersoft/zenodo-research-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/kIzWgqkvV1umeL61l/builds/ljUaBwjFSff7BG7Yj/openapi.json