# OpenAIRE Scraper | Open Access Research Records (`parseforge/openaire-scraper`) Actor

Search OpenAIRE for open access publications, datasets, software, and funded projects with titles, authors, affiliations, DOI, abstracts, funders, and links. Power academic discovery, research analytics, bibliographic tooling, and science observatories with structured scholarly data.

- **URL**: https://apify.com/parseforge/openaire-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Education, Other, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🔬 OpenAIRE Research Publications Scraper

> 🚀 **Export open access research papers from OpenAIRE with abstracts, DOIs, and author data in seconds.** No login required. No API key. Pure open science.

> 🕒 **Last updated:** 2026-05-22 · **📊 12 fields** per record · **📚 100M+ publications** · **🌍 180+ countries**

The **OpenAIRE Research Publications Scraper** extracts structured metadata from [OpenAIRE Explore](https://explore.openaire.eu), the European Open Science platform aggregating research outputs from thousands of repositories, journals, and data sources worldwide. All data is pulled in real time from the OpenAIRE public API.

OpenAIRE indexes over 100 million research objects from PubMed, arXiv, Crossref, DBLP, Zenodo, and institutional repositories across 180+ countries. This Actor lets you query by keyword and year range to pull down publication metadata at scale, covering academic papers, conference proceedings, books, preprints, and datasets.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Academic researchers, data scientists, science journalists, grant managers, librarians, startups | Literature reviews, NLP training corpora, publication trend tracking, grant compliance reporting, discovery system feeds, research landscape mapping |

---

### 📋 What the OpenAIRE Scraper does

- 🔎 **Keyword search.** Full-text search across titles, abstracts, and metadata.
- 📅 **Year filtering.** Narrow to exact publication date ranges with `fromYear` / `toYear`.
- 🧾 **Rich metadata.** Title, DOI, authors, abstract, publisher, year, access type, language.
- 🔁 **Auto pagination.** 25 results per request, paginated up to your `maxItems` target.
- 🔗 **Source link back.** Every record points to the OpenAIRE Explore page for full detail.
- 🛑 **Clean free tier.** Free users get a 10-record preview before upgrading.

> 💡 **Why it matters:** OpenAIRE is the most comprehensive open science aggregator in the world, mandated by the European Commission. No other source indexes this breadth of research in a single queryable API.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>searchQuery</code></td><td>string</td><td><code>"machine learning"</code></td><td>Keywords to search across titles, abstracts, and metadata.</td></tr>
<tr><td><code>fromYear</code></td><td>integer</td><td><code>null</code></td><td>Earliest publication year (inclusive).</td></tr>
<tr><td><code>toYear</code></td><td>integer</td><td><code>null</code></td><td>Latest publication year (inclusive).</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example: basic search.**

```json
{
    "searchQuery": "machine learning",
    "maxItems": 100
}
````

**Example: filtered by year range.**

```json
{
    "searchQuery": "climate change",
    "fromYear": 2020,
    "toYear": 2024,
    "maxItems": 500
}
```

> ⚠️ **Good to Know:** the `fromYear` and `toYear` filters map to the `dateofacceptance` field in OpenAIRE, which represents when a paper was accepted for publication. This can differ slightly from the print publication date.

***

### 📊 Output

Each record contains **12 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Description |
|---|---|---|
| 📌 `title` | string | Full publication title |
| 🔗 `url` | string | Link to OpenAIRE Explore page |
| 🆔 `doi` | string | null | Digital Object Identifier |
| 👥 `authors` | array | List of author full names |
| 📝 `abstract` | string | null | Abstract or description |
| 🏛️ `publisher` | string | null | Journal or publisher name |
| 📅 `year` | integer | null | Publication year |
| 🔓 `accessType` | string | null | Open Access, Closed Access, etc. |
| 🌐 `language` | string | null | Language of the publication |
| 🔑 `openAireId` | string | Internal OpenAIRE identifier |
| 🕒 `scrapedAt` | string | ISO 8601 timestamp |
| ❌ `error` | string | null | Error message if scraping failed |

#### 📦 Sample record

<details>
<summary><strong>📄 Open Access survey paper, 2022</strong></summary>

```json
{
    "title": "Machine Learning for Climate Science: A Survey",
    "url": "https://explore.openaire.eu/search/publication?articleId=doi_dedup___::abc123",
    "doi": "10.1038/s41558-021-01156-9",
    "authors": ["Jane Smith", "Carlos Ruiz", "Yuki Tanaka"],
    "abstract": "This survey reviews the application of machine learning methods to climate modeling...",
    "publisher": "Nature Climate Change",
    "year": 2022,
    "accessType": "Open Access",
    "language": "English",
    "openAireId": "doi_dedup___::abc123",
    "scrapedAt": "2026-05-22T14:23:01.000Z",
    "error": null
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🌍 | **Global coverage.** 100M+ records from 180+ countries. |
| 🔓 | **No auth required.** Public API, zero login friction. |
| ⚡ | **Fast pagination.** 25 results per request, auto-paginated. |
| 📋 | **Rich metadata.** DOI, abstract, authors, access type in one shot. |
| 🎯 | **Keyword precision.** Full-text search across titles and abstracts. |
| 📅 | **Year filtering.** Narrow to exact publication ranges. |
| 🆓 | **Free preview.** 10 items free to verify output quality. |

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Structured | Setup |
|---|---|---|---|---|---|
| **⭐ OpenAIRE Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **100M+ records** | **Live per run** | Yes, 12 fields | ⚡ 2 min |
| Manual OpenAIRE browse | Free | Full | Manual | No | 🐢 Hours |
| Semantic Scholar API | Free, rate limited | Partial | Real time | Partial | ⏳ Moderate |
| PubMed API | Free | Medicine only | Real time | Partial | ⏳ Moderate |
| Scopus API | Subscription | Broad | Real time | Yes | 🗝️ Auth gated |

Pick this Actor when you want the broadest open science index in a single structured pull.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the OpenAIRE Research Publications Scraper page on the Apify Store.
3. 🎯 **Set input.** Enter your `searchQuery`, optional year range, and `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 📚 Academic Literature Reviews

- Automate systematic literature reviews
- Pull 500+ relevant papers in seconds
- Seed reference managers with structured records
- Filter by year, language, and access type

</td>
<td width="50%" valign="top">

#### 🧠 NLP and AI Training Data

- Build text corpora from scientific abstracts
- Filter Open Access English for redistribution
- Train summarization and classification models
- Power retrieval pipelines for research agents

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 💰 Grant Monitoring and Compliance

- Track research output from EU-funded projects
- Compile evidence of scientific activity
- Build reporting dashboards for funders
- Monitor topic-level output by year

</td>
<td width="50%" valign="top">

#### 📰 Science Journalism and Trends

- Spot emerging research trends early
- Compare publication volumes over time
- Identify accelerating fields by keyword
- Back articles with quantified research signals

</td>
</tr>
</table>

***

### 🔌 Automating OpenAIRE Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor weekly to track new publications in your field over time.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- PhD literature bootstrapping for new topics
- Reproducible bibliometric studies
- Cross-disciplinary research mapping
- Citation graph seed datasets

</td>
<td width="50%">

#### 🎨 Personal and creative

- Personal reading lists from niche topics
- Curiosity-driven topic exploration
- Hobbyist science writing projects
- Open-access reading recommendations

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Science communication for the public
- Open knowledge access initiatives
- NGO research reviews on policy topics
- Civic data literacy programs

</td>
<td width="50%">

#### 🧪 Experimentation

- Build AI research-discovery agents
- Prototype academic search interfaces
- Train scientific text classifiers
- Explore long-tail interdisciplinary topics

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20OpenAIRE%20Research%20Publications%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20OpenAIRE%20Research%20Publications%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20OpenAIRE%20Research%20Publications%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20OpenAIRE%20Research%20Publications%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 📚 What does OpenAIRE index?

OpenAIRE aggregates publications from PubMed, arXiv, Crossref, DBLP, Zenodo, European institutional repositories, and thousands of open access journals. It covers science, technology, humanities, and social sciences.

#### 🔓 Is this data freely available?

Yes. OpenAIRE is a public platform funded by the European Commission. The API is open and free to use without authentication.

#### 📝 Why are some abstracts null?

Abstracts are not always deposited with the publication metadata. Many records sourced from Crossref or DBLP contain only title, author, and DOI. Open Access repositories tend to have more complete records.

#### 📦 How many publications can I collect?

Free users get 10 per run as a preview. Paid users can collect up to 1,000,000 records per run. The OpenAIRE API has over 100 million indexed items.

#### 📅 How accurate are the year filters?

The `fromYear` and `toYear` filters map to the `dateofacceptance` field in OpenAIRE. This can differ slightly from the print publication date.

#### 🌐 Can I filter by language?

Not directly in the input, but the `language` field in the output lets you filter the downloaded dataset by language after the run completes.

#### 🆔 Are DOIs always present?

No. DOIs are only present when the source repository deposited them. Conference papers and preprints often lack DOIs. Expect roughly 60-80% DOI coverage depending on the search topic.

#### ⚡ How fast is it?

Approximately 25 records per API call with a 300ms delay between pages. Expect 1,000 records in around 15-20 seconds.

#### ⏰ Can I run this on a schedule?

Yes. Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run weekly searches and track new publications in your field.

#### ⚖️ Is this scraping legal?

Yes. This Actor uses the official OpenAIRE public API in compliance with their terms of service.

#### 📥 Can I export to Excel or Google Sheets?

Yes. Apify datasets export to CSV, JSON, Excel (XLSX), XML, and JSONL. CSV imports directly into Google Sheets.

#### 🆘 What if I need help?

Our support team is here to help. Use the Tally form linked below to reach out.

***

### 🔌 Integrate with any app

OpenAIRE Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe publication data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes.

***

### 🔗 Recommended Actors

- [**🩺 ClinicalTrials Scraper**](https://apify.com/parseforge/clinicaltrials-scraper) - Clinical trial registry data
- [**📊 EPA AQS Air Quality Scraper**](https://apify.com/parseforge/epa-aqs-air-quality-scraper) - U.S. EPA air quality measurements
- [**🔬 CDC WONDER Mortality Scraper**](https://apify.com/parseforge/cdc-wonder-mortality-scraper) - Public-health mortality datasets
- [**📈 BLS Scraper**](https://apify.com/parseforge/bls-scraper) - U.S. Bureau of Labor Statistics data
- [**🏛️ FINRA BrokerCheck Scraper**](https://apify.com/parseforge/finra-brokercheck-scraper) - FINRA broker and firm records

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more open-data and reference scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by OpenAIRE or the European Commission. All trademarks mentioned are the property of their respective owners. Only publicly available data from the OpenAIRE public API is collected. Data accuracy depends on what depositors provide to OpenAIRE.

# Actor input Schema

## `searchQuery` (type: `string`):

Keywords to search for (e.g. 'climate change', 'machine learning', 'COVID-19')

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Filter publications from this year (e.g. 2020)

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

Filter publications up to this year (e.g. 2024)

## Actor input object example

```json
{
  "searchQuery": "machine learning",
  "maxItems": 10
}
```

# 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 = {
    "searchQuery": "machine learning",
    "maxItems": 10
};

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

# Run the Actor and wait for it to finish
run = client.actor("parseforge/openaire-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQuery": "machine learning",
  "maxItems": 10
}' |
apify call parseforge/openaire-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/openaire-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenAIRE Scraper | Open Access Research Records",
        "description": "Search OpenAIRE for open access publications, datasets, software, and funded projects with titles, authors, affiliations, DOI, abstracts, funders, and links. Power academic discovery, research analytics, bibliographic tooling, and science observatories with structured scholarly data.",
        "version": "0.1",
        "x-build-id": "WwKenUUJg4jDjuicJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~openaire-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-openaire-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~openaire-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-openaire-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~openaire-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-openaire-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keywords to search for (e.g. 'climate change', 'machine learning', 'COVID-19')"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "fromYear": {
                        "title": "From Year",
                        "minimum": 1900,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "Filter publications from this year (e.g. 2020)"
                    },
                    "toYear": {
                        "title": "To Year",
                        "minimum": 1900,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "Filter publications up to this year (e.g. 2024)"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```