# EU Funding & Tenders Portal Scraper (`parseforge/eu-funding-tenders-scraper`) Actor

Scrapes 48,000+ EU grants, calls for proposals and tenders from the European Commission Funding & Tenders Portal with deadlines, budgets, eligibility and documents.

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

## Pricing

from $6.23 / 1,000 opportunities

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?

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### EU Funding and Tenders Portal Scraper - Horizon Europe

**Scrape all 48,184 opportunities on the European Commission Funding & Tenders Portal: 17,584 Horizon Europe and other grant topics, 25,058 calls for tenders, 3,933 EuropeAid external action calls and 1,609 cascade funding calls.** Every row carries 44 fields including status, programme, call identifier, every submission deadline, budget in euro and a plain-text summary. No login, no EU Login account, no API key. Export to CSV, JSON, Excel or XML.

The portal's own search screen paginates 50 results at a time behind an Angular app, and its filter values are numeric codes like `31094502` and `43108390` that mean nothing outside the page. This reads the same public search API the portal calls, resolves its numeric codes to English labels, and returns one flat row per opportunity across all four sections in a single run.

| Who uses it | What they scrape EU funding data for |
|---|---|
| Grant consultants | Open calls by programme and deadline, ranked by what closes next |
| Research offices | Horizon Europe topics for a faculty, with budget and eligibility |
| Bid and capture teams | Commission tenders by CPV code, country and procedure type |
| Startups and SMEs | Cascade funding calls that pay sub-grants without a consortium |
| Market analysts | Programme-level budget and deadline series across 2014 to 2027 |

### What it does

This Actor collects opportunities from all four sections of the EU Funding & Tenders Portal and returns each one as a flat row. Every opportunity carries:

- 🧾 **Core fields:** title, identifier, type, status, portal URL, call identifier and call title, framework programme, programme period and publication date.
- ⏰ **Every deadline:** the next upcoming cut-off, the full list of cut-offs, how many there are, the deadline model (single-stage, two-stage or multiple cut-off) and days remaining.
- 💶 **Money:** budget amount and currency, taken from the work programme line for grant topics and from the estimated procedure value for tenders.
- 🏷️ **Classification:** types of action, keywords, cross-cutting priorities, contract type, procedure type, award method, main CPV code and label, and target countries.
- 🧩 **Sixteen optional blocks:** full description, eligibility and topic conditions, budget breakdown per year and per action, submission links, call documents, tender lots, change log, support info, destination text, CPV list, geography, contracting authority, tender terms, corrigenda, programme structure and the raw upstream record.

Results export to CSV, JSON, Excel or XML, or stream from the API.

### What you can do with EU funding data

**🎯 Build a deadline pipeline.**

Filter to open opportunities with a future deadline, sort by deadline ascending, and get a working list of what closes next across every EU programme at once.

**🔬 Map a programme.**

Pick Horizon Europe and a destination group, and pull every topic in that work programme block with its budget line, expected number of grants and minimum and maximum EU contribution.

**📑 Track Commission tenders.**

Filter tenders by CPV code, procedure type, award method and place of performance, then add tender terms for the TED notice number, submission method and estimated value.

**💡 Find cascade funding.**

Cascade funding calls pay sub-grants to SMEs without needing a consortium. They are a separate opportunity type here, filterable on their own, with the funding project and duration attached.

### Why choose this scraper

| | What you get |
|---|---|
| **All four sections in one run** | Grants, tenders, EuropeAid calls and cascade funding, in one schema, from one input. |
| **Codes resolved to labels** | The portal's own code dictionary is read live each run, so `31094502` arrives as "Open for submission". |
| **Every deadline, not just one** | Topics with multiple cut-offs return the whole list plus the next one still ahead. |
| **Past the 10,000 ceiling** | The portal API stops at 10,000 results per query. The Actor slices by type, then year, then month, automatically. |
| **Twenty-three filters** | Programme, period, status, type, CPV, country, place of performance, mission, destination group, priority, procedure, award method, focus area, objective and four date bounds. |
| **Pay only for what returns** | Sixteen optional blocks, each off by default and billed only when the source actually returned it. |

### How it compares

Four other Actors read this portal, and none of them has more than three monthly users. Two cover grants and tenders, one pairs Horizon calls with CORDIS projects, and none resolve the portal's numeric codes or handle the 10,000 result ceiling. This one is the only one that returns tenders, grants, EuropeAid calls and cascade funding in the same schema, and it is the more expensive option because it does more per row.

| Feature | ParseForge | maximedupre | studio-amba | jungle\_synthesizer |
|---|---|---|---|---|
| Grants, tenders, EuropeAid and cascade calls | All four | Grants and tenders | Grants and tenders | Horizon calls plus CORDIS |
| Numeric codes resolved to English labels | Yes, live per run | No | No | No |
| Automatic slicing past the 10,000 result cap | Yes | No | No | No |
| Every submission cut-off, not only the first | Yes | No | No | No |
| Optional enrichment blocks | 16, billed on delivery | No | No | No |
| Price per 1,000 rows | $7.00 | Not published | $2.00 | $0.40 |

### What an opportunity looks like

```json
{
  "opportunityId": "ERC-2026-POC",
  "reference": "48939636TOPICSen",
  "title": "ERC PROOF OF CONCEPT GRANTS",
  "opportunityType": "Grant topic",
  "opportunityTypeCode": "1",
  "status": "Open for submission",
  "statusCode": "31094502",
  "isOpen": "Yes",
  "url": "https://ec.europa.eu/info/funding-tenders/opportunities/portal/screen/opportunities/topic-details/ERC-2026-POC",
  "callIdentifier": "ERC-2026-POC",
  "callTitle": "Call for proposals for ERC Proof of Concept",
  "callId": "48939656",
  "topicId": "48939636",
  "programme": "Horizon Europe (HORIZON)",
  "programmeCode": "43108390",
  "programmePeriod": "2021 - 2027",
  "publicationDate": "2026-01-20T00:00:00.000Z",
  "deadlineDate": "2026-09-17T00:00:00.000Z",
  "allDeadlines": [
    "2026-03-17T00:00:00.000Z",
    "2026-09-17T00:00:00.000Z"
  ],
  "deadlineCount": 2,
  "deadlineModel": "multiple cut-off",
  "daysUntilDeadline": 21,
  "closingDate": "N/A",
  "lastUpdated": "N/A",
  "typesOfAction": [
    "HORIZON ERC Proof of Concept Grants"
  ],
  "keywords": [
    "ERC-2026-POC",
    "ERC-2026-POC"
  ],
  "crossCuttingPriorities": [],
  "destination": "N/A",
  "contractType": "N/A",
  "procedureType": "N/A",
  "awardMethod": "N/A",
  "mainCpvCode": "N/A",
  "mainCpvLabel": "N/A",
  "countries": [],
  "budgetAmount": "60000000",
  "budgetCurrency": "EUR",
  "beneficiaryAdministration": "N/A",
  "projectAcronym": "N/A",
  "projectName": "N/A",
  "fundedProjectId": "N/A",
  "durationMonths": "N/A",
  "allowsPartnerSearch": "Yes",
  "summary": "ERC PROOF OF CONCEPT GRANTS",
  "scrapedAt": "2026-08-27T16:57:39.171Z"
}
```

Fields that do not apply to a record type come back as `N/A`, and fields the portal withholds come back as `Not Disclosed`. A grant topic has no CPV code; a tender has no types of action. That is the record's real state, not a parsing gap.

### Configure the run

Drive it three ways, alone or together: a keyword, portal detail URLs, or bare identifiers. With none of them set it lists everything the filters match. Filters run server side on the portal API, so only matching opportunities are read, written and billed. The Input tab lists every parameter.

Everything closing soon, across all four sections:

```json
{ "opportunityStatus": ["open"], "onlyFutureDeadlines": true, "sortBy": "deadline", "sortOrder": "ASC", "maxItems": 500 }
```

Horizon Europe topics about hydrogen, with the budget breakdown and submission links:

```json
{ "searchKeywords": "hydrogen", "programmes": ["43108390"], "opportunityTypes": ["grant"], "includeBudgetBreakdown": true, "includeActionTypes": true, "maxItems": 300 }
```

Open Commission tenders for research services, with the terms and the documents:

```json
{ "opportunityTypes": ["tender"], "opportunityStatus": ["open"], "cpvCodes": ["73000000"], "includeTenderTerms": true, "includeDocuments": true, "maxItems": 200 }
```

### Pricing

Pay-per-event: **$0.007 per opportunity**, dropping to $0.00623 at higher volume, plus a $0.02 run-start fee and $0.01 per search page paginated. The sixteen optional blocks cost $0.002 to $0.004 each and are charged only when the source actually returned that block. You pay only for rows written to your dataset.

| Opportunities collected | Approximate cost |
|---|---|
| 100 | $0.73 |
| 1,000 | $7.12 |
| 10,000 | $71.02 |

Those figures are the base row alone. At higher monthly volume the per-opportunity rate drops to $0.00623, so 10,000 opportunities runs about $63. New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 opportunities as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 opportunities per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [EU Funding & Tenders Portal Scraper](https://apify.com/parseforge/eu-funding-tenders-scraper?fpr=vmoqkp).
3. Pick your `opportunityTypes` and `opportunityStatus`, add a keyword or a programme, tick any optional blocks, and click **Start**.
4. Export the results as CSV, Excel, JSON or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to EU funding calls through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/eu-funding-tenders-scraper"
```

Then prompt it in plain language:

- *"List every Horizon Europe topic still open for submission that closes in the next 60 days, with its budget."*
- *"Find open EU calls for tenders with CPV code 73000000 and tell me the submission method and deadline for each."*
- *"Pull all cascade funding calls open right now and summarise which ones an SME can apply to alone."*

Copy this into ChatGPT, Claude, or Cursor to start:

```
Use the Apify Actor "parseforge/eu-funding-tenders-scraper" to collect EU funding opportunities from the European Commission Funding & Tenders Portal. Input: { "searchKeywords": "<keyword>", "opportunityTypes": ["grant","tender","external-action","cascade"], "opportunityStatus": ["open"], "onlyFutureDeadlines": true, "maxItems": <n> }. It returns opportunityId, title, opportunityType, status, programme, callIdentifier, publicationDate, deadlineDate, allDeadlines, daysUntilDeadline, budgetAmount, budgetCurrency and url per opportunity. Call it with the ApifyClient and my APIFY_TOKEN.
```

### Troubleshooting

**Why am I getting no results?**

A filter value that does not exist returns zero rows rather than an error. Check that your `cpvCodes` and `callIdentifier` are exact, and remember that combining `opportunityStatus: ["open"]` with `onlyFutureDeadlines: true` leaves 704 of the portal's 1,865 open records.

**Why fewer opportunities than I asked for?**

The portal API serves at most 10,000 results per query. The Actor slices the query by type, then by year, then by month to get past that, but a slice that still exceeds 10,000 is capped and the log says how many were left behind. Narrow the filters and the ceiling stops mattering.

**Why is a status "Open for submission" when the deadline has passed?**

That is the portal's own flag, and 1,161 of its 1,865 open records are stale that way. Tick **Only Opportunities Still Accepting Submissions** to filter on the deadline instead of the status.

**Why is the deadline sort out of order?**

The portal sorts on its deadline index, which uses a topic's first cut-off. A topic that opened in 2021 with a cut-off every September sorts by 2021, not by the one still ahead. Sort your export on `deadlineDate`, which is the next cut-off still in the future.

**Why is the run slow?**

Eligibility conditions, submission links, support info, the change log and raw metadata are not available in the portal's compact response, so ticking any of them makes the Actor fetch whole records. That path runs at about 11 rows per second against about 100 without them.

**Why is a field empty?**

Grant topics carry no CPV code, procedure type or contracting authority; tenders carry no types of action, destination or partner search flag. Each type fills its own half of the schema.

### FAQ

| Question | Answer |
|---|---|
| Do I need an EU Login account or an API key? | No. It reads the portal's public search API, which needs no account, no token and no proxy. |
| Which sections of the portal does it cover? | All four: grant topics (17,584), calls for tenders (25,058), EuropeAid external action calls (3,933) and cascade funding calls (1,609). |
| Can I get Horizon Europe topics only? | Yes. Set `opportunityTypes` to `grant` and `programmes` to Horizon Europe, or pick any of the 64 programmes in the dropdown. |
| Does it return the full topic conditions? | Yes, as an optional block: admissibility, eligibility, financial capacity and award criteria, about 10 KB of text per topic. |
| How many opportunities per run? | Free plan: 10. Paid: up to 1,000,000, bounded by the portal's 10,000 results per query, which the Actor works around by slicing. |
| Can I scrape one specific topic or tender? | Yes. Paste its portal URL into `startUrls`, or its identifier into `opportunityIds`. |
| Are the budgets reliable? | Grant budgets come from the work programme line for that topic and tender values from the estimated procedure value. Both are the portal's own numbers and are absent on many records. |
| What are call summary rows? | An optional extra row per distinct call, aggregating its topics, statuses and deadlines. They do not count against Max Items. |
| Does it cover TED procurement notices? | Only the Commission tenders published on this portal. For the full TED database use the [TED Europa Tenders Scraper](https://apify.com/parseforge/ted-europa-tenders-scraper?fpr=vmoqkp). |
| Is this an official European Commission product? | No. It is unofficial and reads only public portal data. |

### Related actors

- [TED Europa Tenders Scraper](https://apify.com/parseforge/ted-europa-tenders-scraper?fpr=vmoqkp): the full EU procurement notice database behind Tenders Electronic Daily.
- [CORDIS EU Research Projects Scraper](https://apify.com/parseforge/cordis-eu-research-scraper?fpr=vmoqkp): the projects that these calls funded, with participants and results.
- [Grants.gov Federal Grant Scraper](https://apify.com/parseforge/grants-gov-scraper?fpr=vmoqkp): the United States equivalent, federal grant opportunities.
- [ANAC Italy Public Procurement Scraper](https://apify.com/parseforge/anac-italy-procurement-scraper?fpr=vmoqkp): Italian national tenders and awards.
- [EUR-Lex Scraper](https://apify.com/parseforge/european-eur-lex-scraper?fpr=vmoqkp): the EU legal acts these programmes are established by.

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by the European Commission. It collects only publicly available data from the Funding & Tenders Portal. You are responsible for using the data in compliance with the portal's terms and applicable laws, including GDPR, CCPA, and PIPL. Do not use it to identify, profile, or target individuals.

# Actor input Schema

## `searchKeywords` (type: `string`):

Full text search over title, description, keywords, call identifier, types of action and destination text. Leave empty to list everything the filters match. Example: "hydrogen" returns 787 opportunities, "artificial intelligence" 1,916.

## `startUrls` (type: `array`):

Topic or tender detail URLs copied from the portal, for example https://ec.europa.eu/info/funding-tenders/opportunities/portal/screen/opportunities/topic-details/HORIZON-CL5-2026-09-D4-03. When set, the filters below are ignored and only these opportunities are returned.

## `opportunityIds` (type: `array`):

Topic identifiers (HORIZON-CL5-2026-09-D4-03), call identifiers (HORIZON-CL5-2026-09), EuropeAid references or tender ids. Same effect as Portal URLs.

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

Free users: limited to 10 items (preview). Paid users: up to 1,000,000. Call summary rows, if enabled, are extra and do not count against this number.

## `opportunityTypes` (type: `array`):

Which parts of the portal to scrape. Empty means all four.

## `opportunityStatus` (type: `array`):

Empty means any status. Open for submission returns 1,865 records today, forthcoming 1,107, closed 41,188.

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

EU framework programme, for example Horizon Europe or Erasmus+. The number in brackets is how many opportunities carry that programme today.

## `programmePeriod` (type: `string`):

Multiannual financial framework the opportunity belongs to.

## `callIdentifier` (type: `string`):

Exact call identifier, for example HORIZON-CL5-2026-09. Returns every topic under that call.

## `crossCuttingPriorities` (type: `array`):

Horizon policy priorities such as Artificial Intelligence or Clean Energy.

## `contractTypes` (type: `array`):

Services, supplies, works, grants or twinning. Applies mostly to tenders and external action calls.

## `procedureTypes` (type: `array`):

Procurement procedure, for example open procedure or competitive procedure with negotiation.

## `awardMethods` (type: `array`):

How the tender is awarded: best price-quality ratio, lowest price and so on.

## `focusAreas` (type: `array`):

Horizon 2020 focus areas.

## `missions` (type: `array`):

Horizon Europe mission the topic belongs to.

## `missionGroups` (type: `array`):

Parent mission grouping, broader than the mission itself.

## `specificObjectives` (type: `array`):

Digital Europe specific objectives such as artificial intelligence or cybersecurity.

## `destinationGroups` (type: `array`):

Horizon Europe work programme destination, the thematic block a topic sits in.

## `geographicalZones` (type: `array`):

Country or region the opportunity targets. Mostly populated on tenders and external action calls.

## `prospectRegions` (type: `array`):

EuropeAid geographic instrument, for example Neighbourhood or Instrument for Pre-accession Assistance.

## `cpvCodes` (type: `array`):

Common Procurement Vocabulary codes for tenders, for example 73000000 for research and development services. 2,794 codes are indexed, so they are typed rather than picked from a list.

## `placesOfPerformance` (type: `array`):

Where the contract is delivered or performed.

## `onlyFutureDeadlines` (type: `boolean`):

The portal leaves 1,161 of its 1,865 "open for submission" records flagged open after their deadline has passed. Tick this to keep only opportunities whose next deadline is still in the future (704 of the 1,865 today).

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

Only opportunities with a submission deadline on or after this date. Format YYYY-MM-DD.

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

Only opportunities with a submission deadline on or before this date. Format YYYY-MM-DD.

## `publishedFrom` (type: `string`):

Only opportunities published (opening date) on or after this date. Format YYYY-MM-DD.

## `publishedTo` (type: `string`):

Only opportunities published (opening date) on or before this date. Format YYYY-MM-DD.

## `sortBy` (type: `string`):

Only these five fields actually reorder the API response; anything else is silently ignored upstream.

## `sortOrder` (type: `string`):

Ascending puts the nearest deadline first.

## `includeFullDescription` (type: `boolean`):

The complete topic or tender description as HTML plus a plain text version. Grant topics carry the expected outcome and scope sections here.

## `includeTopicConditions` (type: `boolean`):

Admissibility, eligibility, financial capacity and award criteria, roughly 10 KB of structured HTML per grant topic. Needs the heavier fetch path.

## `includeBudgetBreakdown` (type: `boolean`):

Budget per year and per action, expected number of grants, and the minimum and maximum EU contribution per project.

## `includeActionTypes` (type: `boolean`):

Types of action, grant agreement types and the direct electronic submission URL with its opening and closing timestamps. Needs the heavier fetch path.

## `includeDocuments` (type: `boolean`):

Every published document with its name, format, language, publication date and download URL.

## `includeTenderLots` (type: `boolean`):

Lot breakdown for procurement notices, including the raw lot object from the eForms notice.

## `includeLatestUpdates` (type: `boolean`):

The portal change log for the call: what changed and when. Needs the heavier fetch path.

## `includeSupportInfo` (type: `boolean`):

Helpdesk links, online manual references and the submission service instructions. Needs the heavier fetch path.

## `includeDestinationDetails` (type: `boolean`):

The full work programme destination text explaining the expected impact the topic contributes to.

## `includeCpvCodes` (type: `boolean`):

All Common Procurement Vocabulary codes on the notice, each resolved to its English label.

## `includeGeoZones` (type: `boolean`):

Geographical zones and places of performance resolved to names, plus the EuropeAid region.

## `includeContractingAuthority` (type: `boolean`):

Lead contracting authority name and URL, buyer profile, legal entity ids and the beneficiary administration.

## `includeTenderTerms` (type: `boolean`):

Submission method, whether submissions and questions are still open, timezone, TED notice number, OJS issue and the estimated procedure value.

## `includeCorrigenda` (type: `boolean`):

Corrections published against the tender after it went live.

## `includeProgrammeStructure` (type: `boolean`):

Programme divisions, focus areas, missions, specific objectives and topic tags, each resolved to its label.

## `includeRawMetadata` (type: `boolean`):

The complete untouched upstream metadata object for the record. Forces the heavier fetch path and adds roughly 30 KB per row.

## `includeCallSummary` (type: `boolean`):

Adds one extra row per distinct call in the result set, aggregating its topics, statuses, deadlines and types of action. These rows do not count against Max Items.

## Actor input object example

```json
{
  "startUrls": [],
  "opportunityIds": [],
  "maxItems": 10,
  "opportunityTypes": [],
  "opportunityStatus": [
    "open"
  ],
  "programmes": [],
  "programmePeriod": "any",
  "crossCuttingPriorities": [],
  "contractTypes": [],
  "procedureTypes": [],
  "awardMethods": [],
  "focusAreas": [],
  "missions": [],
  "missionGroups": [],
  "specificObjectives": [],
  "destinationGroups": [],
  "geographicalZones": [],
  "prospectRegions": [],
  "cpvCodes": [],
  "placesOfPerformance": [],
  "onlyFutureDeadlines": true,
  "sortBy": "deadline",
  "sortOrder": "ASC",
  "includeFullDescription": false,
  "includeTopicConditions": false,
  "includeBudgetBreakdown": false,
  "includeActionTypes": false,
  "includeDocuments": false,
  "includeTenderLots": false,
  "includeLatestUpdates": false,
  "includeSupportInfo": false,
  "includeDestinationDetails": false,
  "includeCpvCodes": false,
  "includeGeoZones": false,
  "includeContractingAuthority": false,
  "includeTenderTerms": false,
  "includeCorrigenda": false,
  "includeProgrammeStructure": false,
  "includeRawMetadata": false,
  "includeCallSummary": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `csv` (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 = {
    "startUrls": [],
    "opportunityIds": [],
    "maxItems": 10,
    "opportunityTypes": [],
    "opportunityStatus": [
        "open"
    ],
    "programmes": [],
    "crossCuttingPriorities": [],
    "contractTypes": [],
    "procedureTypes": [],
    "awardMethods": [],
    "focusAreas": [],
    "missions": [],
    "missionGroups": [],
    "specificObjectives": [],
    "destinationGroups": [],
    "geographicalZones": [],
    "prospectRegions": [],
    "cpvCodes": [],
    "placesOfPerformance": [],
    "onlyFutureDeadlines": true,
    "sortBy": "deadline",
    "sortOrder": "ASC"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/eu-funding-tenders-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 = {
    "startUrls": [],
    "opportunityIds": [],
    "maxItems": 10,
    "opportunityTypes": [],
    "opportunityStatus": ["open"],
    "programmes": [],
    "crossCuttingPriorities": [],
    "contractTypes": [],
    "procedureTypes": [],
    "awardMethods": [],
    "focusAreas": [],
    "missions": [],
    "missionGroups": [],
    "specificObjectives": [],
    "destinationGroups": [],
    "geographicalZones": [],
    "prospectRegions": [],
    "cpvCodes": [],
    "placesOfPerformance": [],
    "onlyFutureDeadlines": True,
    "sortBy": "deadline",
    "sortOrder": "ASC",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/eu-funding-tenders-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 '{
  "startUrls": [],
  "opportunityIds": [],
  "maxItems": 10,
  "opportunityTypes": [],
  "opportunityStatus": [
    "open"
  ],
  "programmes": [],
  "crossCuttingPriorities": [],
  "contractTypes": [],
  "procedureTypes": [],
  "awardMethods": [],
  "focusAreas": [],
  "missions": [],
  "missionGroups": [],
  "specificObjectives": [],
  "destinationGroups": [],
  "geographicalZones": [],
  "prospectRegions": [],
  "cpvCodes": [],
  "placesOfPerformance": [],
  "onlyFutureDeadlines": true,
  "sortBy": "deadline",
  "sortOrder": "ASC"
}' |
apify call parseforge/eu-funding-tenders-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/eu-funding-tenders-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/zdQlB8OsCcB8Vk2PX/builds/2kKY5rV1HvtTdHvqD/openapi.json