# EU Grants Scraper - Horizon Europe & EU Funding Calls (`tinyrex/eu-grants-scraper`) Actor

Search open and upcoming EU funding calls from the official EU Funding & Tenders Portal: Horizon Europe, Digital Europe, LIFE, Erasmus+, cascade funding. Deadlines, budgets, type of action. Only-new mode. Pay per call.

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

## Pricing

from $3.00 / 1,000 funding calls

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## EU Grants Scraper – Horizon Europe & EU Funding Calls

Search **open and upcoming EU funding calls** from the official **EU Funding & Tenders Portal** and get clean, structured data: identifier, title, programme, real status, opening date, deadlines, budget, expected grants, EU contribution per project, type of action and a direct link. Covers **Horizon Europe, Digital Europe, LIFE, Erasmus+, CEF, Creative Europe, EU4Health, Innovation Fund** and every other programme on the portal, plus **cascade funding** (open calls for SMEs and startups run by EU-funded projects) and **EuropeAid** calls. Schedule it weekly with **Only new calls** to get a funding alert feed.

**Why this one:** it reads the **official portal search API** (the same one the portal uses), so there is no fragile HTML scraping. It also **fixes stale statuses**: the portal keeps hundreds of expired calls flagged as *open* or *forthcoming*, so this Actor computes the real status from the opening date and deadlines. Pay only for calls saved to your dataset, at a low price per 1,000. Calls filtered out and calls skipped as *already seen* are **free**.

### Why this scraper

- **Official source.** Data comes straight from the EU Funding & Tenders Portal search API (ec.europa.eu/info/funding-tenders).
- **Real status, not stale flags.** In our tests, more than half of the records the portal flags as open or forthcoming had deadlines that already passed. You get `status` computed from the dates, with the portal's own flag kept as `portalStatus`.
- **Budget data, flat.** Topic budget, budget years, expected number of grants, minimum and maximum EU contribution per project.
- **Better keyword search.** For open and forthcoming calls, keywords are matched in titles, identifiers, portal keywords and full descriptions, which finds more than the portal's own search box.
- **Funding alerts built in.** Turn on *Only new calls* and schedule the Actor. Each run returns only calls you have not received before.
- **Sorted by nearest deadline**, with `daysToDeadline` ready for filtering.

### Use cases

- **Grant consultants and proposal writers.** Weekly list of new Horizon Europe or Digital Europe topics in your field, with budgets and deadlines.
- **Startups and SMEs.** Cascade funding calls (EIC, EIT, Eurostars, startup accelerators) that pay EUR 10k–500k with light applications.
- **Universities and research offices.** Feed all open calls into a shared sheet or intranet.
- **AI agents and funding newsletters.** Clean JSON for matching calls to companies or researchers.

### How to use

1. Pick programmes (or leave empty for all) and add keywords, e.g. `artificial intelligence`, `"green hydrogen"`, `circular*`.
2. Keep the default status (open + forthcoming) or add closed calls for research.
3. Optionally set a deadline window and **Max calls** (default 100, `0` = all).
4. Run it, or schedule it weekly with **Only new calls** on.

#### Example input

```json
{
  "programmes": ["HORIZON", "DIGITAL"],
  "keywords": ["artificial intelligence", "robotics"],
  "statuses": ["open", "forthcoming"],
  "deadlineTo": "2027-06-30",
  "maxResults": 200
}
```

#### Example output (shortened)

```json
{
  "identifier": "HORIZON-CL5-2026-10-D2-03",
  "title": "Integrated Production and Product Development for Next-Generation Lithium-based Batteries for Mobility",
  "callIdentifier": "HORIZON-CL5-2026-10",
  "callTitle": "BATTERIES and MOBILITY",
  "recordType": "topic",
  "programme": "Horizon Europe (HORIZON)",
  "programmeCode": "HORIZON",
  "status": "open",
  "openingDay": "2026-06-04",
  "deadlineDay": "2026-10-08",
  "deadlineModel": "single-stage",
  "typeOfAction": "HORIZON Innovation Actions",
  "budget": 100000000,
  "budgetCurrency": "EUR",
  "expectedGrants": 3,
  "minContribution": 33300000,
  "maxContribution": 33300000,
  "url": "https://ec.europa.eu/info/funding-tenders/opportunities/portal/screen/opportunities/topic-details/HORIZON-CL5-2026-10-D2-03",
  "description": "Expected Outcome: Proposals are expected to contribute to ..."
}
```

Run totals, filters used and warnings are saved to the `SUMMARY` record in the run's key-value store.

### Pricing

Pay per event:

- **Funding call** (`funding-call`): one charge per call or topic saved to your dataset.
- **Free:** calls removed by your filters, calls skipped as already seen in *Only new calls* mode, and duplicates.

See the *Pricing* tab for the current price. Set a maximum cost per run and the Actor stops gracefully when it is reached.

### Limitations

- Covers what the EU Funding & Tenders Portal publishes. National and regional funds (ERDF programmes run by member states, national grants) are not on the portal.
- Topic budgets are as published; some programmes publish one budget shared by several topics.
- Deadlines published without a time are treated as open until the end of that day (UTC). Always confirm the exact time on the portal before submitting.
- For searches that include **closed** calls, keywords use the portal's own full-text search, which mostly matches titles and summaries.

### Use with AI agents (MCP)

This Actor works as a tool for AI agents through the **Apify MCP server** at `https://mcp.apify.com`. Connect Claude, Cursor, VS Code, n8n or any other MCP client to `https://mcp.apify.com?tools=tinyrex/eu-grants-scraper` and the agent can run it from a plain-language request, for example: *"Find open Horizon Europe calls about AI in healthcare with a deadline before June"*. Results come back as clean, structured JSON at the same pay-per-result price.

📘 **Step-by-step guide with Python, JavaScript, curl and MCP examples:** [How to export open EU funding calls (Horizon Europe, Digital Europe, cascade funding) to CSV or JSON](https://emirmrkaljevic.github.io/tinyrex-data-tools/eu-funding-calls-horizon-europe-api/)

### Related actors

- [TED EU Tenders Scraper](https://apify.com/tinyrex/ted-tenders-scraper): EU public tenders and contract awards from TED, the other half of EU public money (procurement instead of grants).
- [Tech Stack Detector](https://apify.com/tinyrex/tech-stack-detector): Check the technologies behind partner or applicant websites.
- [ATS Jobs Scraper](https://apify.com/tinyrex/ats-jobs-scraper): See who funded companies are hiring: jobs from Greenhouse, Lever, Ashby, Personio and more.

### FAQ

**Is this legal?** The EU Funding & Tenders Portal is a public EU website and its search API is openly used by the portal itself. This Actor only reads public call information, no personal data.

**How fresh is the data?** The portal updates calls continuously. A weekly schedule with *Only new calls* catches new topics and cascade funding calls.

**What is cascade funding?** EU-funded projects (EIC, EIT, Eurostars, Horizon Europe partnerships) re-grant part of their budget through their own open calls, often EUR 10k–500k for SMEs and startups. These calls are listed on the portal and included here.

# Actor input Schema

## `keywords` (type: `array`):

Words to find in the call (title, identifier, description, portal keywords). Each line is one search: all its words must appear; use "quotes" for an exact phrase and \* as a prefix wildcard (hydro\*). Several lines = any of them. Empty = all calls matching the other filters.

## `programmes` (type: `array`):

Empty = all programmes.

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

Default: open and forthcoming. Status is computed from the real opening date and deadlines, because the portal often keeps expired calls marked as open.

## `deadlineFrom` (type: `string`):

Keep calls whose next deadline is on or after this date (YYYY-MM-DD).

## `deadlineTo` (type: `string`):

Keep calls whose next deadline is on or before this date (YYYY-MM-DD).

## `callTypes` (type: `array`):

Empty = all types.

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

Maximum number of calls saved (one charge per call). 0 = all matching calls. Open/forthcoming calls are sorted by nearest deadline.

## `includeDescription` (type: `boolean`):

Add the topic description (expected outcome, scope) as plain text.

## `descriptionMaxLength` (type: `integer`):

Cut descriptions to this many characters. 0 = full text.

## `onlyNew` (type: `boolean`):

Return only calls you have not received in earlier runs with the same state key. Perfect for weekly schedules and funding alerts. The first run returns everything that matches and remembers it.

## `stateKey` (type: `string`):

Name of the memory used by 'Only new calls'. Use a different key for each schedule or search.

## Actor input object example

```json
{
  "keywords": [
    "artificial intelligence"
  ],
  "programmes": [],
  "statuses": [
    "open",
    "forthcoming"
  ],
  "callTypes": [],
  "maxResults": 100,
  "includeDescription": true,
  "descriptionMaxLength": 3000,
  "onlyNew": false,
  "stateKey": "default"
}
```

# Actor output Schema

## `calls` (type: `string`):

Calls and topics with programme, status, opening date, deadline, budget, type of action and link.

## `summary` (type: `string`):

Filters used, portal records checked, calls saved, already-seen calls skipped, errors.

# 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 = {
    "keywords": [
        "artificial intelligence"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tinyrex/eu-grants-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 = { "keywords": ["artificial intelligence"] }

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

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "artificial intelligence"
  ]
}' |
apify call tinyrex/eu-grants-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tinyrex/eu-grants-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Y02QF2aSnEJUZzE6D/builds/K30VREMHNlCK74MBh/openapi.json