# EU Funding Calls API: Horizon Europe, Digital Europe (`conserving_celerytop/eu-funding-calls-api`) Actor

Get open and forthcoming EU funding calls from the Funding & Tenders Portal: Horizon Europe, Digital Europe, LIFE and more. Filter by programme, keyword and deadline. One row per call with budget and conditions. $4.00 per 1,000 calls. Independent tool, not affiliated with the European Commission.

- **URL**: https://apify.com/conserving_celerytop/eu-funding-calls-api.md
- **Developed by:** [Don Mangu](https://apify.com/conserving_celerytop) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

Use this EU funding calls API to list open, forthcoming and closed calls of the European Commission funding programmes for $4.00 per 1,000 calls. It covers Horizon Europe, Digital Europe, LIFE, Erasmus+, CERV, the European Defence Fund, the Connecting Europe Facility and more. Filter by programme, keyword, deadline range and budget. Every row is one call with its status, deadlines, budget, description, conditions and a link to the portal page.

You need no login, no API key and no proxy. The Actor reads the public search of the EU Funding & Tenders Portal. This is an unofficial tool built by an independent developer. It is not affiliated with, endorsed by or operated by the European Commission.

### What this EU funding calls API returns

One row is one call. The portal calls the main kind of record a topic: a funding topic with its own identifier, deadline and budget. The Actor also returns two other kinds of records that the portal lists in the same search: calls from the EuropeAid list and competitive calls published by funded projects. The field recordType tells them apart.

The fields of a row:

- Identity: recordId (unique key of the row), identifier, title, callIdentifier, callTitle, destination and projectName.
- Programme: programme (name), programmeCode (such as HORIZON, DIGITAL or LIFE), programmePeriod, typeOfAction and recordType.
- Dates: status (open, forthcoming or closed), openingDate, deadline (the next deadline, or the last one when all have passed), deadlines (all cut-offs), deadlineModel and deadlinePassed.
- Money: budgetTotal, budgetCurrency, minGrant, maxGrant and expectedGrants.
- Text: description and conditionsText as plain text. The default shortens each to about 2,000 characters. Switch on Full text for the complete text.
- Other: crossCuttingPriorities, url (portal page), lastIngestedAt, attribution and retrievedAt.

Fields that the portal does not fill for a call are null. Older records often have no description, no conditions and no budget. Contact e-mail addresses in the text are removed.

#### Sorting and the expired open calls

Rows come out with the soonest upcoming deadline first. Calls without a deadline follow, then calls whose deadlines have all passed, latest first. The portal still lists some old calls as open, although every deadline has passed. About 300 of the 540 open records are of this kind on 11.10.2026. The option Skip expired open calls is on by default and removes them. Switch it off to see them. The STATS record of the run counts what was skipped.

### How to get EU funding calls, step by step

1. Open the Actor and go to Input.
2. Pick Call status. Open calls accept proposals now. Forthcoming calls open later. Closed calls need a deadline range, or the Actor reads the deadlines of the last 365 days.
3. Enter Programmes, one per line, such as HORIZON, DIGITAL, LIFE or ERASMUS+. Leave the field empty for every programme.
4. Enter Keywords, one per line, such as hydrogen or artificial intelligence. A call matches when its title, call title, destination or description holds any keyword.
5. Set Deadline from and Deadline to to find calls that close in a period, and Minimum budget (EUR) for large calls only.
6. Open Advanced to change Skip expired open calls, Full text or Record types. Record types limits the rows to topics, EuropeAid calls or competitive calls.
7. Set Max results. Start small, for example 10.
8. Start the run. Download the rows as JSON, CSV or Excel, or read them through the API.
9. Schedule the Actor to run every week to keep a list of new calls.

A run reads the whole list that matches the status and programme first, then filters and sorts it. Open calls are about 540 records and need 6 requests. Open and forthcoming calls together are about 1,200 records and need 13 requests, about 15 seconds. The Actor sends at most 2 requests per second and one at a time. A run reads at most 6,000 records. A search above that limit stops with a message that asks you to narrow the dates or programmes.

### Run it every day

Switch on Only new since the last run to get each call once. A daily run then returns only the calls that earlier runs of the same monitor did not deliver.

1. Open the Actor and fill the filters, for example Call status = Open for proposals and Programmes = HORIZON.
2. Switch on Only new since the last run and type a Monitor name, for example horizon-open.
3. Save the input as a Task.
4. In the Apify Console go to Schedules, choose Create new, pick the Task and enter a cron expression for once a day, for example `0 7 * * *`.

The first run returns every call that matches and becomes the baseline. Every later run returns only calls that are new for this monitor. The memory lives in a key-value store in your own account named `eufunding-monitor-<monitorName>` (letters are lower case). It holds the portal reference of each call (the recordId field) and no call content. A call counts as delivered when it is saved to the dataset, so a call that Max results cut off in one run comes in the next run. Calls that the memory skips cost no row price.

A call is delivered once. A later change of its deadline, its budget or its status does not deliver it again. This keeps an extended deadline from costing a second row. To get each call once at the moment it opens, run a Task with only Call status = Open for proposals.

Use one Monitor name per saved Task. The memory is also split by the filters (status, programmes, keywords, deadline range, minimum budget, record types and Skip expired open calls), so the same name with other filters starts a new baseline. Full text and Max results do not split the memory.

Worked example with the prices of this page: the open Horizon Europe Task from the pricing section returns 60 calls. The first run costs 60 x $0.004 + $0.00005 = $0.24005. Assume that 10 new calls appear during the next 29 days (this number is an assumption, it depends on the programme and the season). The 29 daily runs then cost 10 x $0.004 + 29 x $0.00005 = $0.04145, and the month costs $0.24005 + $0.04145 = $0.2815. The same Task without Only new since the last run returns all open calls on every run: 30 x $0.24005 = $7.2015.

Each run writes the counts (new delivered, already delivered and skipped, first run) to the monitor part of the STATS record and to the final status message.

### EU funding calls API pricing

The price is $0.004 per call returned ($4.00 per 1,000 calls) on the Free plan, plus $0.00005 for each run start. Paid Apify plans pay less per call: $0.0036 (Bronze), $0.0032 (Silver) and $0.0028 (Gold), which is $3.60, $3.20 and $2.80 per 1,000. Only a call saved to the dataset is charged. A run that finds nothing, a run with a wrong input and a run that stops on a portal error charge the start fee and no call.

Worked example on the Free plan: a weekly run for open Horizon Europe topics returns 60 calls. Cost is 60 x $0.004 + $0.00005 = $0.24005 per run, and 4 weekly runs cost 4 x $0.24005 = $0.9602 per month. A one-off pull of all open and forthcoming calls (about 1,200 rows) costs 1,200 x $0.004 + $0.00005 = $4.80005. Set Max results or the maximum charge of the run to cap the cost: the Actor stops when the limit is reached.

### Input example

This is the input of the Task below. It returns the 10 open Horizon Europe topics with the soonest deadlines.

```json
{
  "statuses": ["open"],
  "programmes": ["HORIZON"],
  "recordTypes": ["topic"],
  "maxResults": 10
}
```

The default input of the form reads open calls of every programme and stops after 10 rows.

```json
{
  "statuses": ["open"],
  "maxResults": 10
}
```

### Output example

Both rows come from real runs of this Actor against the live portal search on 11.10.2026. The first run (open Horizon Europe topics, 3 requests, 3 seconds, 10 rows) returned this row as its third row.

```json
{
  "recordId": "51572985TOPICSen",
  "identifier": "HORIZON-EIC-2026-DEFENCE-01",
  "title": "EIC defence call",
  "status": "open",
  "programme": "Horizon Europe",
  "programmeCode": "HORIZON",
  "programmePeriod": "2021 - 2027",
  "recordType": "topic",
  "typeOfAction": "HORIZON EIC Equity Only",
  "callIdentifier": "HORIZON-EIC-2026-STEP-DEFENCE-01",
  "callTitle": "EIC STEP Scale Up Defence",
  "destination": null,
  "projectName": null,
  "openingDate": "2026-06-30",
  "deadline": "2026-10-28",
  "deadlines": [
    "2026-10-28"
  ],
  "deadlineModel": "single-stage",
  "deadlinePassed": false,
  "budgetTotal": 100000000,
  "budgetCurrency": "EUR",
  "minGrant": 10000000,
  "maxGrant": 30000000,
  "expectedGrants": 10,
  "description": null,
  "conditionsText": "General conditions\n1. Admissibility conditions: Proposal page limit and layout\nThe EIC STEP Scale-Up call for defence technologies supports projects falling within the defence strategic technology areas as described in STEP (Second Guidance Note on STEP), namely:\n Air and missile defence: this can for example include integrated multi-layered air and missile defence systems, interceptors, detection systems (including radars);\n Artillery and precision strike: this can for example include artillery systems, long range precision strike capabilities, advanced munitions;\n Missiles and ammunition: this can for example include guided missiles and ammunition, conventional munitions, warheads, propellants;\n Drones and counter-drones: this can for example include unmanned aerial systems (all classes), swarming systems, jammers, anti-UAV systems;\n Strategic enablers: this can for example include space assets and their protection, space situational awareness, space-based services (Earth Observation, PNT, secure communications), protection of critical infrastructure and energy security;\n Cyber, AI and electronic warfare: this can for example include AI for command and control, cyber-defence, information warfare, electromagnetic spectrum operations, electronic warfare systems, digital transformation of armed forces, optronics and radiofrequency systems;\n Military mobility: this can for example include warehousing and engineering capabilities, sustainable and agile logistics, additive manufacturing for combat maintenance;\n Ground combat: this can for example include close fire support systems, soldier systems, manned and unmanned ground combat systems;\n Maritime: this can for example include maritime situational awareness, surface and underwater combat systems, manned and unmanned platforms, seabed and anti submarine warfare systems;\n Air combat: this can for example include air combat systems, airborne early warning, tactical and strategic air transport, rotorcraft...",
  "crossCuttingPriorities": null,
  "url": "https://ec.europa.eu/info/funding-tenders/opportunities/portal/screen/opportunities/topic-details/HORIZON-EIC-2026-DEFENCE-01",
  "lastIngestedAt": "2026-07-01T10:24:32.993+0200",
  "attribution": "Source: European Commission, Funding & Tenders Portal, CC BY 4.0",
  "retrievedAt": "2026-10-11T12:17:39.421Z"
}
```

The second run (default input, 6 requests, 7 seconds, 10 rows) returned this row as its first row. It is a call of the EuropeAid list, which holds no description and no conditions.

```json
{
  "recordId": "186824PROSPECTSEN",
  "identifier": "EuropeAid/186824/DD/ACT/PS",
  "title": "Strengthening the Palestinian Monetary Authority and its role to support the stability, transparency, accountability and the digital transition of the financial sector in Palestine",
  "status": "open",
  "programme": "EuropeAid external action",
  "programmeCode": "EUROPEAID",
  "programmePeriod": "2014 - 2020; 2021 - 2027",
  "recordType": "europeaid-call",
  "typeOfAction": null,
  "callIdentifier": "186824",
  "callTitle": null,
  "destination": null,
  "projectName": null,
  "openingDate": "2026-06-17",
  "deadline": "2026-10-12",
  "deadlines": [
    "2026-10-12"
  ],
  "deadlineModel": null,
  "deadlinePassed": false,
  "budgetTotal": 2000000,
  "budgetCurrency": "EUR",
  "minGrant": null,
  "maxGrant": null,
  "expectedGrants": null,
  "description": null,
  "conditionsText": null,
  "crossCuttingPriorities": null,
  "url": "https://ec.europa.eu/info/funding-tenders/opportunities/portal/screen/opportunities/topic-details/186824PROSPECTSEN",
  "lastIngestedAt": "2026-08-21T16:01:05.390+0200",
  "attribution": "Source: European Commission, Funding & Tenders Portal, CC BY 4.0",
  "retrievedAt": "2026-10-11T12:15:50.108Z"
}
```

Each run also writes a STATS record in the key-value store with the number of records the portal reported, the records read, the rows kept and skipped by each filter, the requests, the retries, the duration and the peak memory.

### Related Actors

- [EU and UK Public Tenders](https://apify.com/conserving_celerytop/eu-uk-public-tenders): public procurement tenders from TED and UK notices. Use it for contracts. This Actor lists grants.
- [USAspending Awards API](https://apify.com/conserving_celerytop/usaspending-awards-api): awarded US federal grants and contracts.
- [Crossref Works Search](https://apify.com/conserving_celerytop/crossref-works-search): scholarly works with funder data, to check what a funder paid for.

### FAQ

**Is it legal to use this data?** The data is public. The Commission legal notice (https://commission.europa.eu/legal-notice_en) says: "This means that reuse is allowed, provided appropriate credit is given and changes are indicated." It names the licence Creative Commons Attribution 4.0 International (CC BY 4.0) for content owned by the EU, unless otherwise indicated. Each row therefore holds the field attribution: "Source: European Commission, Funding & Tenders Portal, CC BY 4.0". Keep it when you publish the data. Changes made by this Actor: HTML is removed from texts, texts are shortened to about 2,000 characters unless you switch on Full text, whitespace is collapsed, e-mail addresses are removed, dates are cut to year-month-day and field names are renamed. The legal notice has no sentence about automated access. The file robots.txt of ec.europa.eu has no rule for the portal search. This is not legal advice. Check your own use of the data.

**Which source does the Actor read, and can it break?** It reads the public search API that the portal web page uses (api.tech.ec.europa.eu, with the public key SEDIA that the page sends). The Commission does not document this API for third parties. It can change or add limits without notice. The Actor stops with a clear message on an HTTP 401, 403 or repeated 429 answer and does not try to get around it. It retries server errors up to 5 times with waits of 2, 4, 8, 16 and 32 seconds and honors the Retry-After header.

**Is the list complete?** The Actor compares the number of records the portal reports with the records it read. On 11.10.2026 the portal reported 1,197 open and forthcoming records and the Actor returned 1,196, because the portal lists one record twice. The row recordId is unique. Competitive calls of one project share the same identifier and url, so use recordId as the key.

**Why do some calls have no budget, description or conditions?** Older records and the EuropeAid list hold only a title, dates and a budget. The Actor returns null for what the portal does not fill. The budget of a topic is the sum of the planned yearly budgets of its own action. The currency of a competitive call is not listed by the portal and stays null.

**Are the deadlines exact?** The Actor returns dates only, year-month-day, taken from the cut-off dates of the portal. Closing times and time zones are on the portal page. Check the portal page of a call before you apply.

**Why is a closed search limited?** The portal holds about 18,000 closed records. One run reads at most 6,000 records, so closed calls need a deadline range. Without one the Actor uses the last 365 days (about 1,300 records).

**How are the programme names matched?** Enter the code (HORIZON, DIGITAL, LIFE, CERV, EDF, CEF, SMP, ERASMUS+) or a part of the name of at least 5 letters. A code that the Actor does not know, such as ERC, is matched against the start of the identifier.

**The run stopped with a message about the portal.** The portal search answered 401, 403 or 429, or an error that stayed after the retries. Nothing is charged for such a run apart from the start fee. Run again later.

This is an unofficial, independent tool. It is not affiliated with, endorsed by or operated by the European Commission.

# Actor input Schema

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

Pick the call statuses to return. Open calls accept proposals now. Forthcoming calls open later. Closed calls need a deadline range, or the Actor reads the deadlines of the last 365 days.

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

Enter one programme code or name per line, such as HORIZON, DIGITAL, LIFE, ERASMUS+, CERV, EDF, CEF or SMP. Leave the field empty to return every programme.

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

Enter one word or phrase per line, such as hydrogen or artificial intelligence. A call matches when its title, call title, destination or description holds any keyword.

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

Enter the first deadline date as year-month-day, such as 2026-11-01. A call matches when one of its deadlines falls in the range.

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

Enter the last deadline date as year-month-day, such as 2026-12-31.

## `minBudget` (type: `integer`):

Return calls with a total budget of at least this many euros. Only calls that list a budget are compared.

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

Return only items that this monitor has not delivered before. The first run returns everything and becomes the baseline. Use it with a daily schedule.

## `monitorName` (type: `string`):

Names the memory of this monitor. Use one name per saved task, so two tasks never share their memory.

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

Return at most this many calls in total. Each call returned is one charged result.

## `skipExpired` (type: `boolean`):

Leave out open and forthcoming calls whose last deadline lies in the past. The portal still lists some of them as open.

## `fullText` (type: `boolean`):

Return the complete description and conditions. The default shortens each text to about 2,000 characters.

## `recordTypes` (type: `array`):

Pick the kinds of records to return. Leave the field empty to return all three kinds.

## Actor input object example

```json
{
  "statuses": [
    "open"
  ],
  "onlyNew": false,
  "monitorName": "default",
  "maxResults": 10,
  "skipExpired": true,
  "fullText": false
}
```

# Actor output Schema

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

No description

## `stats` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "statuses": [
        "open"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("conserving_celerytop/eu-funding-calls-api").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 = {
    "statuses": ["open"],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("conserving_celerytop/eu-funding-calls-api").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 '{
  "statuses": [
    "open"
  ],
  "maxResults": 10
}' |
apify call conserving_celerytop/eu-funding-calls-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,conserving_celerytop/eu-funding-calls-api"
        }
    }
}
```

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/MOrJv3bNM0O6ZFSv5/builds/x18pPPXw0jfMBDK2K/openapi.json
