# CORDIS EU Research Projects Scraper (`automation-lab/cordis-eu-research-projects-scraper`) Actor

🇪🇺 Export official CORDIS grants with funding, calls, topics, objectives, consortium participants, roles, contributions, and public deliverable links.

- **URL**: https://apify.com/automation-lab/cordis-eu-research-projects-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 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.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## CORDIS EU Research Projects Scraper

Export EU-funded research projects, grants, consortium organizations, funding amounts, calls, topics, objectives, and public deliverable links from official CORDIS open data.

The Actor downloads one current European Commission dataset bundle per run, applies your filters, joins project records to participants and public links, and saves clean project-centric JSON rows. No CORDIS login or API key is required.

### What does CORDIS EU Research Projects Scraper do?

Use this Actor to turn the official CORDIS bulk files into a focused dataset that is ready for analysis.

- 🔎 Search project titles, acronyms, objectives, keywords, and topic codes.
- 💶 Filter projects by EU contribution range.
- 🏢 Find grants involving a named organization or participant country.
- 📅 Limit results by project status and start date.
- 🔗 Collect official project, publication, and deliverable links.
- 🤝 Export consortium members, roles, addresses, and contributions.
- ♻️ Schedule recurring exports to monitor newly updated grants.

Each dataset row represents one project. Participants and links are nested under that project, so users do not need to reconstruct joins between multiple CORDIS CSV files.

### Who is it for?

#### Grant intelligence teams

Track funded themes, compare contribution levels, and build prospect lists around active EU programmes.

#### Universities and research offices

Find relevant calls, inspect successful consortium structures, and discover repeat collaborators.

#### Research consultancies

Build evidence-backed landscapes for clients without manually downloading and joining bulk files.

#### Policy analysts

Analyze funding distribution by country, topic, organization type, dates, or programme.

#### Vendors and business development teams

Find funded organizations that may need scientific equipment, software, compliance, or professional services.

### Why use this Actor?

CORDIS already publishes excellent open data, but its programme bundles are large and normalized across several CSV tables. A useful export normally requires downloading a ZIP, parsing semicolon-delimited records, handling European decimal commas, and joining project IDs to organizations and links.

This Actor performs that workflow automatically while preserving source URLs and update dates.

- Official European Commission source
- Repeatable input and output contract
- Export to JSON, CSV, Excel, XML, RSS, or Parquet through Apify
- API, webhook, schedule, Make, Zapier, Google Sheets, and MCP support
- Low result limits for inexpensive first runs

### Supported framework programmes

Choose one programme for each run:

| Input value | Programme |
|---|---|
| `HORIZON` | Horizon Europe |
| `H2020` | Horizon 2020 |
| `FP7` | Seventh Framework Programme |
| `FP6` | Sixth Framework Programme |

One bundle is downloaded per run. Separate scheduled runs are recommended when you need several programmes.

### What data can I extract?

| Field | Description |
|---|---|
| `projectId` | CORDIS grant/project identifier |
| `acronym`, `title`, `status` | Core project identity |
| `startDate`, `endDate` | Project dates |
| `totalCost`, `euContribution` | Project cost and maximum EU contribution |
| `topics`, `masterCall`, `subCall` | Topic and call identifiers |
| `frameworkProgramme`, `fundingScheme` | Programme and scheme |
| `objective`, `keywords` | Research description and keywords |
| `participants` | Organizations, countries, roles, addresses, and contributions |
| `publicLinks` | Public deliverable, publication, and related links |
| `contentUpdateDate` | CORDIS record update timestamp |
| `projectUrl`, `sourceDatasetUrl` | Traceable official sources |

Optional source fields may be absent on older records. The Actor omits unavailable optional values instead of inventing them.

### How to search EU research grants

1. Open the Actor input page.
2. Select a framework programme.
3. Enter a keyword such as `solar`, `quantum`, or `carbon capture`.
4. Add topic, call, date, funding, or consortium filters if needed.
5. Set a small `maxItems` value for the first run.
6. Click **Start**.
7. Open the Dataset tab to preview or export projects.

All populated filter groups are combined with AND logic. Within `topics`, `calls`, or `participantCountries`, any supplied value may match.

### Input reference

| Input | Type | Purpose |
|---|---|---|
| `framework` | string | Programme bundle, default `HORIZON` |
| `maxItems` | integer | Maximum project rows, 1–10,000 |
| `projectIds` | string[] | Exact grant IDs |
| `statuses` | string[] | Exact CORDIS statuses |
| `keyword` | string | Search core project text |
| `topics` | string[] | Topic code fragments |
| `calls` | string[] | Master/sub-call fragments |
| `startDateFrom`, `startDateTo` | string | Inclusive YYYY-MM-DD boundaries |
| `minEuContribution`, `maxEuContribution` | number | Inclusive euro range |
| `participantCountries` | string[] | Two-letter country codes |
| `participantQuery` | string | Organization name, ID, short name, or VAT |
| `includeParticipants` | boolean | Join organization details |
| `includeLinks` | boolean | Join public links |

### Example input: solar research projects

```json
{
  "framework": "HORIZON",
  "keyword": "solar",
  "statuses": ["SIGNED"],
  "minEuContribution": 1000000,
  "maxItems": 25,
  "includeParticipants": true,
  "includeLinks": true
}
````

### Example input: consortium partner discovery

```json
{
  "framework": "HORIZON",
  "participantCountries": ["FI", "SE", "DK"],
  "participantQuery": "university",
  "topics": ["CL5"],
  "maxItems": 100
}
```

### Example output

```json
{
  "projectId": "101069359",
  "acronym": "SolDAC",
  "status": "SIGNED",
  "title": "Full spectrum SOLar Direct Air Capture & conversion",
  "startDate": "2022-09-01",
  "endDate": "2025-08-31",
  "totalCost": 2073781.25,
  "euContribution": 2073781.25,
  "topics": ["HORIZON-CL5-2021-D2-01-11"],
  "fundingScheme": "HORIZON-RIA",
  "participants": [{
    "organizationId": "912743326",
    "name": "LOMARTOV SL",
    "country": "ES",
    "role": "participant",
    "ecContribution": 299250
  }],
  "projectUrl": "https://cordis.europa.eu/project/id/101069359"
}
```

### Filtering behavior

Text matching is case-insensitive. `keyword` searches the project ID, acronym, title, objective, keywords, and topics.

Participant country and participant query filters are evaluated against organization rows before projects are selected. A project qualifies when at least one participant satisfies both populated participant filters.

Date comparisons use ISO `YYYY-MM-DD` values. Invalid or unparseable numeric source values fail closed for funding filters.

### How much does it cost to scrape CORDIS projects?

The Actor uses pay-per-event pricing: a small start charge plus a charge for each saved project. The current BRONZE baseline is shown on the Actor pricing tab; higher Apify plans receive automatic volume discounts.

You are charged for project rows, not for every participant or link nested inside them. Set `maxItems` to control output and use precise filters for focused exports.

Apify provides monthly platform credits on eligible plans. Check the live pricing panel before a large run because the Store pricing configuration is authoritative.

### Performance and large exports

The Actor streams CSV records and writes the expanded bundle to temporary run storage instead of loading the full source into memory.

A narrow export still downloads the selected official programme bundle because participants and links live in separate files. Run time therefore depends more on bundle size and network speed than on `maxItems` alone.

For recurring workflows, schedule one purposeful export rather than many overlapping small runs.

### Data freshness

CORDIS controls publication and refresh timing. Every output includes `contentUpdateDate`, `sourceDatasetUrl`, and `scrapedAt` so downstream systems can distinguish the source update time from the extraction time.

The Actor does not modify or infer official grant values.

### Scheduling and monitoring

Create an Apify schedule to run daily, weekly, or monthly. Typical monitoring patterns include:

- Newly started projects in a topic
- Updated projects involving target organizations
- Signed grants above a funding threshold
- Projects involving participants in selected countries
- Newly published deliverables or links

Use dataset exports or webhooks to compare snapshots in your own warehouse.

### Integrations

#### Google Sheets

Use the Apify Google Sheets integration to send a filtered project table to grant or sales teams.

#### Make and Zapier

Trigger downstream enrichment, CRM creation, notifications, or document generation after a run succeeds.

#### Webhooks

Attach a run-succeeded webhook and fetch the default dataset from your application.

#### Cloud warehouses

Export JSON, CSV, or Parquet and load records into BigQuery, Snowflake, PostgreSQL, or a lakehouse.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/cordis-eu-research-projects-scraper').call({
  framework: 'HORIZON',
  keyword: 'quantum',
  maxItems: 50
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/cordis-eu-research-projects-scraper').call(run_input={
    'framework': 'HORIZON',
    'participantCountries': ['DE', 'FR'],
    'maxItems': 50,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~cordis-eu-research-projects-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"framework":"HORIZON","keyword":"battery","maxItems":20}'
```

### Use the Actor through MCP

Connect Apify Actors to Claude Code with the Apify MCP server:

```bash
claude mcp add --transport http apify https://mcp.apify.com/?tools=automation-lab/cordis-eu-research-projects-scraper
```

For **Claude Desktop**, **Cursor**, or **VS Code**, add this MCP JSON block to the client MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/cordis-eu-research-projects-scraper"
    }
  }
}
```

Example prompts:

- “Find 30 Horizon Europe projects about direct air capture and summarize their consortium countries.”
- “Export signed quantum projects with more than €2 million in EU contribution.”
- “Find Horizon projects involving Finnish universities and list coordinators.”

### Tips for reliable results

- Start with `maxItems: 10` to validate filters.
- Use official two-letter country codes such as `DE`, `ES`, or `FI`.
- Use topic fragments when you do not know the complete CORDIS code.
- Disable participant or link joins when you only need project metadata.
- Run separate programme exports instead of combining incompatible time periods.
- Preserve `projectId` as the stable key in downstream databases.

### FAQ and troubleshooting

#### Why did my run return zero projects?

Your combined filters may be too strict. Remove participant or funding filters one at a time, verify the selected framework, and try a broader keyword.

#### Why does a small export still take time?

CORDIS publishes programme-wide bulk bundles. The Actor downloads and parses the selected bundle before joining the requested project rows.

#### Why is an optional field missing?

Older programmes and individual projects do not always provide every organization, DOI, keyword, cost, or link field. Missing source values are omitted.

### Legality and responsible use

CORDIS provides public European Commission research information and open-data downloads. Follow the source terms, applicable database rights, privacy laws, and your organization’s compliance requirements.

Participant contact-form URLs are official project contact routes, not permission for unsolicited messaging. Use exported information responsibly and avoid spam or discriminatory profiling.

This Actor is an independent extraction tool and is not affiliated with or endorsed by the European Commission.

### Related research data Actors

Combine this Actor with other automation-lab research and public-data tools where relevant:

- [NSF Research Awards Scraper](https://apify.com/automation-lab/nsf-research-awards-scraper) for US National Science Foundation awards
- [ORCID Researcher Profile Scraper](https://apify.com/automation-lab/orcid-researcher-profile-scraper) for public researcher profiles
- [OpenAlex Works Search Scraper](https://apify.com/automation-lab/openalex-works-search-scraper) for scholarly works

### Source and support

Data source: [CORDIS — EU research results](https://cordis.europa.eu/).

If a source schema changes or a filter behaves unexpectedly, open an issue from the Actor page and include the run ID plus a minimal input example.

# Actor input Schema

## `framework` (type: `string`):

Official CORDIS programme bundle to search.

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

Maximum project records to save.

## `projectIds` (type: `array`):

Optional exact CORDIS project IDs, for example 101069359.

## `statuses` (type: `array`):

Keep exact CORDIS statuses such as SIGNED, CLOSED, or TERMINATED.

## `keyword` (type: `string`):

Case-insensitive text search across title, acronym, objective, keywords, topics and project ID.

## `topics` (type: `array`):

Topic codes or fragments; any supplied value may match.

## `calls` (type: `array`):

Master/sub-call codes or fragments; any supplied value may match.

## `startDateFrom` (type: `string`):

Inclusive project start date in YYYY-MM-DD format.

## `startDateTo` (type: `string`):

Inclusive project start date in YYYY-MM-DD format.

## `minEuContribution` (type: `number`):

Inclusive minimum EC/EU contribution.

## `maxEuContribution` (type: `number`):

Inclusive maximum EC/EU contribution.

## `participantCountries` (type: `array`):

Two-letter CORDIS country codes; matches projects with a participant in any supplied country.

## `participantQuery` (type: `string`):

Search organization name, short name, organization ID, or VAT number.

## `includeParticipants` (type: `boolean`):

Join participant organizations, roles, addresses and contributions.

## `includeLinks` (type: `boolean`):

Join CORDIS public deliverable, publication and related links.

## Actor input object example

```json
{
  "framework": "HORIZON",
  "maxItems": 10,
  "projectIds": [],
  "statuses": [],
  "keyword": "solar",
  "topics": [],
  "calls": [],
  "participantCountries": [],
  "includeParticipants": true,
  "includeLinks": true
}
```

# Actor output Schema

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

Open the project-centric CORDIS dataset in the overview table view.

# 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 = {
    "framework": "HORIZON",
    "maxItems": 10,
    "projectIds": [],
    "statuses": [],
    "keyword": "solar",
    "topics": [],
    "calls": [],
    "participantCountries": [],
    "includeParticipants": true,
    "includeLinks": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/cordis-eu-research-projects-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 = {
    "framework": "HORIZON",
    "maxItems": 10,
    "projectIds": [],
    "statuses": [],
    "keyword": "solar",
    "topics": [],
    "calls": [],
    "participantCountries": [],
    "includeParticipants": True,
    "includeLinks": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/cordis-eu-research-projects-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 '{
  "framework": "HORIZON",
  "maxItems": 10,
  "projectIds": [],
  "statuses": [],
  "keyword": "solar",
  "topics": [],
  "calls": [],
  "participantCountries": [],
  "includeParticipants": true,
  "includeLinks": true
}' |
apify call automation-lab/cordis-eu-research-projects-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/cordis-eu-research-projects-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CORDIS EU Research Projects Scraper",
        "description": "🇪🇺 Export official CORDIS grants with funding, calls, topics, objectives, consortium participants, roles, contributions, and public deliverable links.",
        "version": "0.1",
        "x-build-id": "K9kAGEfGGsra0ksox"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~cordis-eu-research-projects-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-cordis-eu-research-projects-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/automation-lab~cordis-eu-research-projects-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-cordis-eu-research-projects-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/automation-lab~cordis-eu-research-projects-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-cordis-eu-research-projects-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": {
                    "framework": {
                        "title": "🇪🇺 Framework programme",
                        "enum": [
                            "HORIZON",
                            "H2020",
                            "FP7",
                            "FP6"
                        ],
                        "type": "string",
                        "description": "Official CORDIS programme bundle to search.",
                        "default": "HORIZON"
                    },
                    "maxItems": {
                        "title": "Maximum projects",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum project records to save.",
                        "default": 10
                    },
                    "projectIds": {
                        "title": "Grant / project IDs",
                        "type": "array",
                        "description": "Optional exact CORDIS project IDs, for example 101069359.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "statuses": {
                        "title": "Project statuses",
                        "type": "array",
                        "description": "Keep exact CORDIS statuses such as SIGNED, CLOSED, or TERMINATED.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Case-insensitive text search across title, acronym, objective, keywords, topics and project ID."
                    },
                    "topics": {
                        "title": "Topics",
                        "type": "array",
                        "description": "Topic codes or fragments; any supplied value may match.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "calls": {
                        "title": "Calls",
                        "type": "array",
                        "description": "Master/sub-call codes or fragments; any supplied value may match.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startDateFrom": {
                        "title": "Starting on or after",
                        "type": "string",
                        "description": "Inclusive project start date in YYYY-MM-DD format."
                    },
                    "startDateTo": {
                        "title": "Starting on or before",
                        "type": "string",
                        "description": "Inclusive project start date in YYYY-MM-DD format."
                    },
                    "minEuContribution": {
                        "title": "Minimum EU contribution (€)",
                        "type": "number",
                        "description": "Inclusive minimum EC/EU contribution."
                    },
                    "maxEuContribution": {
                        "title": "Maximum EU contribution (€)",
                        "type": "number",
                        "description": "Inclusive maximum EC/EU contribution."
                    },
                    "participantCountries": {
                        "title": "Participant countries",
                        "type": "array",
                        "description": "Two-letter CORDIS country codes; matches projects with a participant in any supplied country.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "participantQuery": {
                        "title": "Participant name or ID",
                        "type": "string",
                        "description": "Search organization name, short name, organization ID, or VAT number."
                    },
                    "includeParticipants": {
                        "title": "Include participants",
                        "type": "boolean",
                        "description": "Join participant organizations, roles, addresses and contributions.",
                        "default": true
                    },
                    "includeLinks": {
                        "title": "Include public links",
                        "type": "boolean",
                        "description": "Join CORDIS public deliverable, publication and related links.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
