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

Scrape Zenodo by keyword, record ID, or community. Extract title, DOI, authors, description, type, license, downloads, views & files. No API key, no login. Ideal for researchers, data scientists, and academic analysts.

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

## Pricing

from $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.
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 Scraper — Research Datasets, Papers, Software & More

Scrape Zenodo's open research repository by keyword, record ID, or community — no API key, no login. Extract full metadata, citations, download stats, and file links for any record type.

### What does Zenodo Scraper do?

Zenodo Scraper connects directly to Zenodo's public REST API (`https://zenodo.org/api/records`) to collect structured data about research outputs — datasets, publications, software packages, images, videos, and more. It supports three modes of operation: keyword search across the full Zenodo index (210,000+ records for popular topics), bulk record fetching by ID, and community-scoped searches. The actor paginates automatically through results using Zenodo's cursor-based `links.next` mechanism, delivering up to 10,000 records per run without any authentication. Each record returns 16 fields including DOI, authors, stripped-HTML description, resource type, license identifier, access rights, download/view statistics, and direct file download URLs. Resource type filtering (dataset, publication, software, etc.) is available as an input parameter.

### Who is it for?

- **Academic researchers** building literature reviews or meta-analyses across disciplines
- **Data scientists** sourcing open datasets for machine learning and training pipelines
- **Research librarians** cataloguing open-access outputs and tracking citation impact
- **Science journalists** monitoring newly published findings on a topic
- **Open-data engineers** building pipelines that ingest peer-reviewed datasets automatically

### Use cases

- Download all open datasets tagged "climate change" with their file URLs and citation metadata
- Monitor weekly uploads in a Zenodo community (e.g., biodiversity, neuroscience) for new content
- Build a curated database of open-source research software with license and download statistics
- Cross-reference DOIs from a reading list with Zenodo metadata (views, downloads, version history)
- Export author lists from a keyword search to identify top contributors in a research niche

### Why use Zenodo Scraper?

- **Keyless and loginless** — Zenodo's public REST API requires zero credentials; runs out of the box
- **16 output fields** — id, DOI, title, creators, description, publication date, resource type, keywords, license, access right, download URL, views, downloads, communities, record URL, version
- **Bulk pagination** — chains Zenodo's `links.next` cursor to retrieve hundreds or thousands of records per run
- **Type filtering** — narrow results to datasets, publications, software, images, videos, lessons, or other types
- **Clean output** — HTML stripped from descriptions, authors joined as semicolon-delimited strings, JSON-ready arrays
- **Export ready** — one-click CSV / JSON / Excel / JSONL via Apify dataset export; pay-per-result pricing

### What data can you extract?

Every record returns the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Zenodo internal record ID |
| `doi` | string | Digital Object Identifier (e.g. `10.5281/zenodo.1234567`) |
| `title` | string | Title of the record |
| `creators` | string | Semicolon-delimited list of author/creator names |
| `description` | string | Plain-text description (HTML stripped) |
| `publicationDate` | string | Publication date (ISO 8601, e.g. `2024-03-15`) |
| `resourceType` | string | Type: dataset, publication, software, image, video, lesson, other |
| `keywords` | string | Comma-delimited keyword list |
| `license` | string | License identifier (e.g. `cc-by-4.0`, `mit`) |
| `accessRight` | string | `open`, `embargoed`, `restricted`, or `closed` |
| `downloadUrl` | string | Direct URL to primary file or archive download |
| `views` | number | Total view count |
| `downloads` | number | Total download count |
| `communities` | string | Comma-delimited Zenodo community slugs |
| `recordUrl` | string | Canonical HTML URL to the record page |
| `version` | string | Version string if specified by uploader |

**Example output record:**

```json
{
  "id": "3715409",
  "doi": "10.5281/zenodo.3715409",
  "title": "Global Surface Temperature Dataset 1880–2023",
  "creators": "Hansen, James; Ruedy, Reto; Sato, Makiko",
  "description": "Monthly global surface temperature anomalies relative to 1951-1980 baseline. Covers land and ocean combined. Updated annually from NASA GISS records.",
  "publicationDate": "2024-01-12",
  "resourceType": "dataset",
  "keywords": "climate, temperature, global warming, surface temperature",
  "license": "cc-by-4.0",
  "accessRight": "open",
  "downloadUrl": "https://zenodo.org/api/records/3715409/files-archive",
  "views": 12430,
  "downloads": 8712,
  "communities": "copernicus-climate",
  "recordUrl": "https://zenodo.org/records/3715409",
  "version": "v2.1"
}
```

### How to use

#### Option A — Keyword search (records mode)

Search across all Zenodo records by keyword or Zenodo query syntax.

1. Open the actor and set **Mode** to `Records (Keyword Search)`
2. Enter your **Search Query** (e.g. `"machine learning" dataset`)
3. Optionally set **Resource Type Filter** (e.g. `dataset`)
4. Set **Max Results** (e.g. `500`)
5. Click **Run**

**Input JSON:**

```json
{
  "mode": "records",
  "query": "machine learning dataset",
  "resourceType": "dataset",
  "maxResults": 500
}
```

#### Option B — Fetch by record IDs (recordDetail mode)

Fetch specific records when you already know the Zenodo record IDs.

1. Set **Mode** to `Record Detail (by ID)`
2. Add one or more **Record IDs** (e.g. `3715409`, `10580891`)
3. Click **Run**

**Input JSON:**

```json
{
  "mode": "recordDetail",
  "ids": ["3715409", "10580891", "7025386"]
}
```

#### Option C — Community records (communityRecords mode)

Scrape all records from a specific Zenodo community.

1. Set **Mode** to `Community Records`
2. Enter the **Community Slug** (e.g. `biodiversity`, `zenodo`)
3. Set a **Search Query** to further filter within the community (optional)
4. Click **Run**

**Input JSON:**

```json
{
  "mode": "communityRecords",
  "community": "biodiversity",
  "query": "species occurrence",
  "maxResults": 300
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string | `records` | `records`, `recordDetail`, or `communityRecords` |
| `query` | string | — | Keyword search query (supports Zenodo query syntax) |
| `resourceType` | string | — | Filter: `dataset`, `publication`, `software`, `image`, `video`, `lesson`, `other` |
| `ids` | array | — | Record IDs to fetch (for `recordDetail` mode) |
| `community` | string | — | Community slug (for `communityRecords` mode) |
| `maxResults` | integer | `200` | Maximum records to return (1–10000) |
| `proxy` | object | auto | Apify proxy configuration |

**Full input example:**

```json
{
  "mode": "records",
  "query": "climate change",
  "resourceType": "dataset",
  "maxResults": 1000,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["DATACENTER"]
  }
}
```

### Output example

```json
{
  "id": "10580891",
  "doi": "10.5281/zenodo.10580891",
  "title": "Microbiome Diversity Dataset — Amazon Rainforest Soil Samples 2022",
  "creators": "Silva, Maria; Dos Santos, Pedro; Oliveira, Carla",
  "description": "16S rRNA amplicon sequencing data from 847 soil samples collected across 12 Amazon biomes. Includes OTU tables, taxonomy assignments, and environmental metadata. Sequenced on Illumina MiSeq 2x250bp.",
  "publicationDate": "2024-02-01",
  "resourceType": "dataset",
  "keywords": "microbiome, amazon, soil, 16S rRNA, biodiversity",
  "license": "cc-by-4.0",
  "accessRight": "open",
  "downloadUrl": "https://zenodo.org/api/records/10580891/files/sequences.tar.gz/content",
  "views": 3241,
  "downloads": 1892,
  "communities": "biodiversity, open-science",
  "recordUrl": "https://zenodo.org/records/10580891",
  "version": "1.0"
}
```

### Tips for best results

- **Use Zenodo query syntax** — combine terms with `AND`, `OR`, `NOT`; quote phrases; filter by `creators.name:Hansen`
- **Combine query + resourceType** — `query: "neural network" + resourceType: software` returns very targeted results
- **Set realistic maxResults** — 200–500 is enough for most research workflows; 10,000 is the ceiling
- **Use communityRecords for niche domains** — communities like `biodiversity`, `astronomy`, `linguistics` are curated and high-quality
- **Check accessRight** — filter downstream for `open` records if you need direct file downloads
- **Download URLs** — the `downloadUrl` field points to the primary file; some records have multiple files, use Zenodo's files API for the full list
- **Sorted by bestmatch** — results are ranked by relevance; for chronological order, use Zenodo's `sort=mostrecent` query param via the API directly
- **Rate limits** — Zenodo applies soft rate limits; the actor includes automatic back-off for 429 responses
- **Empty results** — if a community search returns zero results, the community slug may not accept the `communities` filter; fall back to `records` mode with a topic query

### Integrations

Connect your Zenodo data to 1,500+ tools via Apify integrations:

- **Google Sheets** — auto-sync scraped records to a spreadsheet for collaborative annotation
- **Slack** — get notified when new records matching your query are published
- **Zapier / Make** — route records to Airtable, Notion, HubSpot, or any SaaS tool
- **Webhooks** — POST results to your own API endpoint in real time
- **Schedule** — run weekly to monitor a community or keyword for new publications
- **Apify API** — call programmatically from Python, Node.js, or any language

### API usage

**cURL:**

```bash
curl -X POST "https://api.apify.com/v2/acts/logiover~zenodo-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"records","query":"climate change","resourceType":"dataset","maxResults":200}'
```

**Node.js:**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('logiover/zenodo-scraper').call({
  mode: 'records',
  query: 'climate change',
  resourceType: 'dataset',
  maxResults: 200,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("logiover/zenodo-scraper").call(run_input={
    "mode": "records",
    "query": "climate change",
    "resourceType": "dataset",
    "maxResults": 200,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Use with AI agents (MCP)

Zenodo Scraper is available as an MCP (Model Context Protocol) tool, so you can drive it directly from AI agents like Claude or GPT. Example prompt: *"Use Zenodo Scraper to find the top 100 open-access machine learning datasets published in 2023, and return their titles, DOIs, and download counts."* The actor returns structured JSON that AI agents can parse, filter, and summarize without writing any scraping code.

### FAQ

#### Does this require an API key or account?

No. Zenodo's search and record API is fully public. The actor works without any credentials.

#### What types of records does it cover?

All Zenodo record types: datasets, publications (articles, preprints, reports, theses), software, images, videos, lessons, and "other" types.

#### How many records can I get per run?

Up to 10,000 per run. For broader coverage, run multiple queries with different keywords or date ranges.

#### Why are some results returning zero records?

Zero results usually mean your query has no matches, or the community slug is incorrect. Try simplifying the query or removing the `resourceType` filter. Check the community slug at `zenodo.org/communities/<slug>`.

#### Some fields are empty or null — is that normal?

Yes. Not all records provide all metadata. Keywords, version, communities, and license are optional fields that some uploaders omit.

#### Can I export to CSV or Excel?

Yes. After the run, click **Export** in the dataset view and choose CSV, Excel, JSONL, or XML.

#### How fast does it run?

Typically 200 records in 30–60 seconds, 1,000 records in 3–5 minutes. Speed depends on Zenodo API response times and proxy latency.

#### Is there a rate limit on the Zenodo API?

Zenodo applies soft rate limits (HTTP 429). The actor handles these automatically with exponential back-off.

#### How often is Zenodo updated?

Zenodo ingests new records continuously. Hundreds of new records are published daily. The `sort=bestmatch` default returns the most relevant results; use `sort=mostrecent` for the latest uploads.

#### What is the pagination limit?

Zenodo's API paginates 25 records per page with no hard cap on page count (up to Zenodo's index depth). The actor chains pages automatically via `links.next`.

#### Can I filter by date range?

Yes, via Zenodo's query syntax: `publication_date:[2023-01-01 TO 2024-01-01]` in the query field.

#### What communities are available?

Search communities at `zenodo.org/communities`. Popular ones include `zenodo`, `biodiversity`, `openaireplus`, `astronomy`, `nlp`, `covid-19`.

### Is it legal?

Zenodo is an open-access research repository operated by CERN and funded by the European Commission. All metadata is publicly available under open licenses, and the Zenodo API is provided for programmatic access. This actor only accesses data that Zenodo makes publicly available without authentication. Usage should comply with Zenodo's Terms of Use (zenodo.org/terms). Respect rate limits, do not use the data for spam, and attribute records correctly using their DOI when citing in publications.

### Related scrapers

- **[arXiv Scraper](https://apify.com/logiover)** — Extract preprints and papers from arXiv by category or keyword
- **[OpenAlex Scraper](https://apify.com/logiover)** — Scrape the OpenAlex academic graph (200M+ works, authors, institutions)
- **[GitHub Activity Scraper](https://apify.com/logiover/github-activity-scraper)** — Track open-source research software by stars, commits, and contributors
- **[CVE Advisory Scraper](https://apify.com/logiover/cve-advisory-scraper)** — Export CVE vulnerability data for research and security analysis

### 📝 Changelog

#### 2026-08-01

- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.
- Added stable run-wide ID/DOI/canonical-URL deduplication across pagination and record-detail inputs, plus repeated next-page URL protection, so overlapping Zenodo pages cannot emit duplicate records.

#### 2026-08-01 — Health-check remediation

- August 2026 monthly health-check remediation is in progress; this build contains fixes verified from empty/default, Console-default, targeted live probes, or field-level semantic review.
- Added stable run-wide ID/DOI/canonical-URL deduplication across pagination and record-detail inputs, plus repeated next-page URL protection, so overlapping Zenodo pages cannot emit duplicate records.
- The final four-input matrix verdict will be appended after post-build cloud revalidation.

***

\*Maintained: last verified 2026-09-01 — checked end-to-end against live run history (reliability, output fields and types, and time/memory budgets).

# Actor input Schema

## `mode` (type: `string`):

Scraping mode. 'records' = keyword/browse search (leave the query empty to browse recent records), 'recordDetail' = fetch specific record IDs, 'communityRecords' = records from a community slug.

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

Optional keyword/query string (records & communityRecords modes). Supports Zenodo query syntax, e.g. 'climate change', 'machine learning dataset'. Leave EMPTY to browse the most recent records.

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

Filter by resource type. Leave on 'All types' to include everything.

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

How to order results. 'Most recent' is the default when no query is given; 'Best match' when searching by keyword.

## `ids` (type: `array`):

List of Zenodo record IDs to fetch (used in 'recordDetail' mode).

## `community` (type: `string`):

Zenodo community slug/ID for 'communityRecords' mode (e.g. 'biodiversity', 'lantern'). Leave empty to browse all records.

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

Maximum number of records to scrape (default 200). Raise to pull more; empty input stays fast and cheap.

## `proxy` (type: `object`):

Apify proxy configuration. Defaults to Apify Proxy (automatic). The actor also falls back to a direct connection on the final retry, so a proxy is optional for this public API.

## Actor input object example

```json
{
  "mode": "records",
  "resourceType": "",
  "sort": "",
  "maxResults": 200,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.

# 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 = {
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/zenodo-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 = { "proxy": { "useApifyProxy": True } }

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

```

## MCP server setup

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