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

Scrape Horizon Europe and Framework Programme research projects from CORDIS public search API. Get project topic, budget, coordinator, participants, dates, deliverables. No API key required.

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

## Pricing

from $34.05 / 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://raw.githubusercontent.com/ParseForge/apify-assets/main/parseforge-banner.png)

## 🇪🇺 CORDIS EU Research Projects Scraper

> 🚀 **Export Horizon Europe and Framework Programme research projects in seconds.** Filter by free-text query across the entire CORDIS catalog. No API key, no registration, no manual CSV wrangling.

> 🕒 **Last updated:** 2026-05-12 · **📊 28 fields** per record · **🇪🇺 Horizon Europe + FP1-FP9** · **💶 EU-funded research grants** · **♻️ Live per run**

The **CORDIS EU Research Projects Scraper** queries the European Commission's official research projects database and returns **28 fields per record**, covering project identity, objective, budget, EC contribution, coordinator organisation, participant countries, call identifier, framework programme, EuroSciVoc taxonomy, and key dates. CORDIS (Community Research and Development Information Service) has tracked every EU-funded research project since the first Framework Programme launched in 1984.

The catalog spans the current Horizon Europe programme, the prior Horizon 2020 and FP7 generations, and decades of legacy projects across science, engineering, health, environment, and the social sciences. Each record links coordinator and participant organisations to their country, VAT number, and SME status. This Actor returns the same JSON CORDIS exposes through its public search, with server-side filtering and pagination already handled.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Research office managers, grant strategists, technology transfer offices, science journalists, policy analysts, consulting firms, scientometrics teams | Proposal benchmarking, partner discovery, collaboration network analysis, EU funding landscape research, science of science studies, journalism on public research spend |

---

### 📋 What the CORDIS EU Research Projects Scraper does

A flexible query workflow in a single run:

- 🔍 **Free-text search.** Match any term across project titles, objectives, and keywords, like `artificial intelligence`, `quantum`, or `vaccine`.
- 🧬 **Framework taxonomy.** Each project tagged with `HORIZON`, `H2020`, `FP7`, or earlier framework codes.
- 🏢 **Coordinator details.** Legal name, VAT number, country, city, EC contribution, and SME flag.
- 🌍 **Participant geography.** Country code list across all participating organisations.
- 💶 **Budget capture.** Total project cost and EC maximum contribution in EUR.

Each record includes the project ID, RCN, acronym, full title, objective text, keyword list, status, framework, total cost, EC contribution, start and end dates, duration in months, grant DOI, coordinator details, participant count and countries, call identifier and title, topic title, EuroSciVoc classifications, and EC signature and update timestamps.

> 💡 **Why it matters:** the EU has committed over €95 billion to Horizon Europe alone. CORDIS is the canonical record of who received it, for what, with whom, and on what timeline. Building your own pipeline means parsing CORDIS XML, handling pagination, and normalising legacy data. This Actor returns the catalog as flat JSON on every run.

---

### 🎬 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>query</code></td><td>string</td><td><code>"artificial intelligence"</code></td><td>Free-text query. Supports CORDIS syntax like <code>quantum AND framework=h2020</code>. Leave at default or change as needed.</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: 200 AI-related projects, default search.**

```json
{
    "maxItems": 200,
    "query": "artificial intelligence"
}
````

**Example: quantum projects in Horizon 2020 only.**

```json
{
    "maxItems": 500,
    "query": "quantum AND framework=h2020"
}
```

> ⚠️ **Good to Know:** CORDIS paginates 50 records at a time. The catalog has hundreds of thousands of projects across all framework programmes, so very broad queries can return long result sets. Combine search terms with the `framework=` operator for targeted exports.

***

### 📊 Output

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

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `id` | string | `"101071795"` |
| 🔗 `url` | string | `"https://cordis.europa.eu/project/id/101071795"` |
| 🏷️ `rcn` | string | `"239576"` |
| 🅰️ `acronym` | string | null | `"TIME"` |
| 📰 `title` | string | `"Trustworthy and Inclusive MLOps made in Europe"` |
| 📝 `objective` | string | null | `"TIME aims at accelerating..."` |
| 🏷️ `keywords` | string | null | `"Trustworthy AI, MLOps, Fairness..."` |
| 📊 `status` | string | null | `"CLOSED"` |
| 🇪🇺 `framework` | string | null | `"HORIZON"` |
| 💶 `totalCost` | number | null | `0` |
| 💶 `ecMaxContribution` | number | null | `75000` |
| 📅 `startDate` | ISO 8601 | null | `"2022-06-01"` |
| 📅 `endDate` | ISO 8601 | null | `"2022-11-30"` |
| ⏱️ `duration` | number | null | `6` |
| 🔗 `grantDoi` | string | null | `"10.3030/101071795"` |
| 🏢 `coordinatorName` | string | null | `"CLEARBOX AI SOLUTIONS SRL"` |
| 🆔 `coordinatorVatNumber` | string | null | `"IT12161430017"` |
| 🌍 `coordinatorCountry` | string | null | `"IT"` |
| 🏙️ `coordinatorCity` | string | null | `"TORINO"` |
| 💶 `coordinatorEcContribution` | number | null | `75000` |
| 🤝 `coordinatorIsSme` | boolean | null | `true` |
| 👥 `participantsCount` | number | null | `1` |
| 🌐 `participantCountries` | string\[] | `["IT", "DE", "FR"]` |
| 📞 `callIdentifier` | string | null | `"HORIZON-EIE-2021-CONNECT-01"` |
| 📰 `callTitle` | string | null | `"Marie Skłodowska-Curie Actions (MSCA)"` |
| 🏷️ `topicTitle` | string | null | `"MSCA Postdoctoral Fellowships 2021"` |
| 🏷️ `euroSciVoc` | string\[] | `["artificial intelligence", "machine learning"]` |
| 📅 `ecSignatureDate` | ISO 8601 | null | `"2022-05-12"` |
| 📅 `contentCreationDate` | ISO 8601 | null | `"2022-05-12"` |
| 📅 `lastUpdateDate` | ISO 8601 | null | `"2023-02-08"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-12T16:30:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>🇪🇺 SME WomenTechEU project: Trustworthy MLOps (TIME)</strong></summary>

```json
{
    "id": "101071795",
    "url": "https://cordis.europa.eu/project/id/101071795",
    "rcn": "239576",
    "acronym": "TIME",
    "title": "Trustworthy and Inclusive MLOps (Machine Learning Operations) made in Europe",
    "objective": "Trustworthy and Inclusive MLOps made in Europe (TIME) aims at accelerating the realisation of the strategic ambition of Clearbox AI...",
    "keywords": "Trustworthy AI, MLOps, Fairness, Bias mitigation, Inclusion in AI, Open Source, Data-centric AI, Machine Learning",
    "status": "CLOSED",
    "framework": "HORIZON",
    "totalCost": 0,
    "ecMaxContribution": 75000,
    "startDate": "2022-06-01",
    "endDate": "2022-11-30",
    "duration": 6,
    "grantDoi": "10.3030/101071795",
    "coordinatorName": "CLEARBOX AI SOLUTIONS SRL",
    "coordinatorVatNumber": "IT12161430017",
    "coordinatorCountry": "IT",
    "coordinatorEcContribution": 75000,
    "coordinatorIsSme": true,
    "participantsCount": 1,
    "participantCountries": ["IT"],
    "scrapedAt": "2026-05-12T16:30:00.000Z"
}
```

</details>

<details>
<summary><strong>🇪🇺 Large multi-million Euro AI Factory: Pharos-CY (Cyprus)</strong></summary>

```json
{
    "id": "101263007",
    "url": "https://cordis.europa.eu/project/id/101263007",
    "rcn": "286727",
    "acronym": "Pharos-CY",
    "title": "Pharos-CY: Accelerating Trustworthy AI Innovation in Cyprus",
    "objective": "Pharos-CY is the AI Factory Antenna of Cyprus, established to accelerate the development and adoption of trustworthy, high-impact artificial intelligence (AI) solutions...",
    "keywords": "AI Factory Antenna; Trustworthy Artificial Intelligence (AI); AI-Ready Datasets; AI Services & Tools",
    "status": "SIGNED",
    "framework": "HORIZON",
    "totalCost": 6000000,
    "ecMaxContribution": 3000000,
    "startDate": "2026-04-01",
    "endDate": "2029-03-31",
    "duration": 36,
    "grantDoi": "10.3030/101263007",
    "coordinatorName": "THE CYPRUS INSTITUTE",
    "coordinatorVatNumber": "CY10167225J",
    "coordinatorCountry": "CY",
    "coordinatorCity": "NICOSIA",
    "coordinatorEcContribution": 600000,
    "coordinatorIsSme": false,
    "scrapedAt": "2026-05-12T16:30:00.000Z"
}
```

</details>

<details>
<summary><strong>🇪🇺 MSCA postdoc fellowship: AI focus in firms (AIFocus)</strong></summary>

```json
{
    "id": "101066876",
    "url": "https://cordis.europa.eu/project/id/101066876",
    "rcn": "240500",
    "acronym": "AIFocus",
    "title": "The causes and consequences of firms' focus on artificial intelligence",
    "status": "SIGNED",
    "framework": "HORIZON",
    "totalCost": 0,
    "ecMaxContribution": 203464.32,
    "startDate": "2023-01-01",
    "endDate": "2024-12-31",
    "duration": 24,
    "grantDoi": "10.3030/101066876",
    "coordinatorName": "UNIVERSITEIT MAASTRICHT",
    "coordinatorVatNumber": "NL003475268B01",
    "coordinatorCountry": "NL",
    "coordinatorCity": "Maastricht",
    "coordinatorEcContribution": 203464.32,
    "coordinatorIsSme": false,
    "participantsCount": 1,
    "participantCountries": ["NL"],
    "callIdentifier": "HORIZON-MSCA-2021-PF-01",
    "callTitle": "Marie Skłodowska-Curie Actions (MSCA)",
    "topicTitle": "MSCA Postdoctoral Fellowships 2021",
    "scrapedAt": "2026-05-12T16:30:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🇪🇺 | **Official CORDIS feed.** Pulls directly from the European Commission's public research projects database. |
| 🧬 | **Multi-framework coverage.** Horizon Europe, Horizon 2020, FP7, and earlier framework programmes in one query interface. |
| 💶 | **Budget transparency.** Total cost, EC contribution, and per-coordinator breakdown for every project. |
| 🏢 | **Coordinator identity.** Legal name, VAT, country, and SME flag for downstream organisation matching. |
| ⚡ | **Fast.** 50 projects per page, 10,000 records in under fifteen minutes. |
| 🔁 | **Always fresh.** Every run pulls live CORDIS data so newly signed projects appear within days. |
| 🚫 | **No authentication.** Works with open EU research data. No login or API key needed. |

> 📊 The EU has committed more than €95 billion to Horizon Europe. CORDIS is the public record of how that money is being spent.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ CORDIS EU Research Projects Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **All FP1 to Horizon Europe** | **Live per run** | free-text + framework | ⚡ 2 min |
| Official CORDIS search UI | Free | Same data, manual | Live | UI filters | 🐢 Manual export per query |
| Bulk CSV dumps from EU Open Data | Free | Periodic snapshot | Quarterly | None | 🕒 Manual ETL |
| Paid research-intelligence platforms | $1,000+/month | Multi-funder aggregated | Daily | Many | ⏳ Vendor onboarding |

Pick this Actor when you want the live CORDIS catalog in clean JSON, with server-side query support and zero ETL.

***

### 🚀 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 CORDIS EU Research Projects Scraper page on the Apify Store.
3. 🎯 **Set input.** Type a free-text query, add framework filters if you want, and set `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">

#### 🏛️ Research Offices & Grant Strategy

- Benchmark proposals against funded projects in your field
- Map active calls and topics relevant to your institution
- Track success rates by framework programme and topic
- Find collaboration partners with prior EU funding

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

#### 🔗 Technology Transfer & Partnerships

- Identify SME coordinators in your sector and region
- Source consortium partners by participant country
- Spot emerging research themes ahead of commercial deals
- Map technology readiness through project timelines

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

#### 📊 Policy & Funding Analysts

- EU research spend by country, theme, and framework
- Trend analyses across decades of public R\&D
- Compare framework programme priorities over time
- Quantify funding flows to SMEs and large research orgs

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

#### 📰 Science Journalism & Comms

- Investigate large grants and their lead organisations
- Story leads from newly signed projects
- Profile coordinator labs and their funding history
- Cross-reference grants with publication output

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

***

### 🌟 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

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

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

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

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

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

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

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

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

***

### 🔌 Automating CORDIS EU Research Projects 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 on any cron interval. Hourly, daily, or weekly refreshes keep downstream databases in sync automatically.

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Type a free-text query (with optional CORDIS syntax like `framework=h2020`), click Start, and the Actor calls the official CORDIS search endpoint, flattens each project XML payload into 28 columns, and emits clean JSON. No browser automation, no captchas, no setup.

#### 📏 How accurate is the data?

Records come straight from the European Commission's CORDIS database, the authoritative public record of EU-funded research. Free-text fields like objective follow the original proposal language. Numeric fields like total cost reflect what each consortium reported.

#### 🔁 How often is the dataset refreshed?

CORDIS updates continuously as new projects are signed and existing projects publish results. Every run of this Actor fetches the live feed, so your dataset reflects the catalog at run time.

#### 🧬 Which framework programmes are covered?

All of them. Horizon Europe, Horizon 2020, FP7, FP6, FP5, and earlier programmes are searchable through the same query interface. Use the `framework=` operator to scope to a specific generation.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (hourly, daily, weekly) and keep a downstream database in sync.

#### ⚖️ Is this data legal to use?

CORDIS is published by the European Commission under the Commission Reuse Decision and is intended for public reuse, including for commercial purposes. Attribution is required for derivative works.

#### 💼 Can I use this data commercially?

Yes. CORDIS data is open under the Commission Reuse policy and commercial use is permitted. Research-intelligence and grant-strategy products are commonly built on this feed.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you access to scheduling, higher concurrency, and larger datasets.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, you can inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from failed runs are preserved so you never lose progress.

#### 📚 Can I get publication or deliverable lists?

Not in this Actor. CORDIS exposes results and deliverables as separate document types. If you need a companion scraper for project outputs, reach out via the contact form below.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

CORDIS EU Research Projects 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 research 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. Push fresh project data into your CRM, or alert your research office when new grants land in your themes.

***

### 🔗 Recommended Actors

- [**📜 UK Contracts Finder Scraper**](https://apify.com/parseforge/uk-contracts-finder-scraper) - UK public sector procurement notices
- [**🔬 UKRI Gateway to Research Scraper**](https://apify.com/parseforge/ukri-gateway-to-research-scraper) - UK research council grants and projects
- [**⚖️ eCFR US Federal Regulations Scraper**](https://apify.com/parseforge/ecfr-code-federal-regulations-scraper) - US Code of Federal Regulations full text
- [**🇫🇮 Finland YTJ Companies Scraper**](https://apify.com/parseforge/finland-ytj-companies-scraper) - Finnish business registry with 1M+ companies
- [**🔬 Figshare Scraper**](https://apify.com/parseforge/figshare-scraper) - Open research datasets and publications

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data 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 CORDIS, the European Commission, or any EU body. All trademarks mentioned are the property of their respective owners. Only publicly available open data published under the Commission Reuse policy is collected.

# Actor input Schema

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

Free-text query, supports CORDIS query syntax (e.g. 'quantum AND framework=h2020')

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

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

## Actor input object example

```json
{
  "query": "artificial intelligence",
  "maxItems": 10
}
```

# Actor output Schema

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

Overview of scraped data

## `fullData` (type: `string`):

Complete dataset

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "artificial intelligence",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/cordis-eu-research-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "query": "artificial intelligence",
    "maxItems": 10,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CORDIS EU Research Projects Scraper",
        "description": "Scrape Horizon Europe and Framework Programme research projects from CORDIS public search API. Get project topic, budget, coordinator, participants, dates, deliverables. No API key required.",
        "version": "0.0",
        "x-build-id": "X2I7XuJ7hJwQox8e6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~cordis-eu-research-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-cordis-eu-research-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~cordis-eu-research-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-cordis-eu-research-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~cordis-eu-research-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-cordis-eu-research-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": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text query, supports CORDIS query syntax (e.g. 'quantum AND framework=h2020')",
                        "default": "artificial intelligence"
                    },
                    "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"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
