# TED Europa Scraper \[Only $3.5💰] | EU Tenders | Awards (`ahmed_jasarevic/ted-europa-eu-scraper`) Actor

Search EU public procurement notices on TED (ted.europa.eu) for tender monitoring and procurement intelligence: titles, buyers, CPV codes, estimated values, deadlines, award criteria, documents and winner info.

- **URL**: https://apify.com/ahmed_jasarevic/ted-europa-eu-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.40 / 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/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

## TED Europa Scraper

Search EU public procurement notices on TED (Tenders Electronic Daily, ted.europa.eu) for tender monitoring and procurement intelligence: notice titles, buyer authorities, countries, CPV codes, estimated values, submission deadlines, award criteria, procurement document links and winner information.

This actor does not use a browser and does not scrape HTML. It calls TED's official, anonymous Search API directly, the same JSON backend the ted.europa.eu website itself queries, so results are clean and structured.

### Main Use Cases

- EU tender monitoring for gov-con and public-sector contractors
- B2B lead generation from open calls, filtered by country and CPV code
- Procurement intelligence and competitor/winner analysis from award notices
- Deadline tracking and opportunity pipelines for bid teams
- Building structured tender databases for procurement SaaS and market research
- Supply-market analysis by CPV sector and buyer country

### How It Works

TED exposes an anonymous, keyless Search API for published notices. The actor calls it directly, so there is no CMS front door, no Cloudflare, no cookies and no JavaScript to render:

| Step | Endpoint | What it does |
| --- | --- | --- |
| Primary | `POST https://api.ted.europa.eu/v3/notices/search` | Return structured notice JSON for a query or filter set. |
| Fallback | `POST https://tedweb.api.ted.europa.eu/v3/notices/search` | Same API, used if the primary host is unavailable. |

The API takes an expert query plus filters, returns up to 250 notices per page, sorts newest first, and includes multilingual titles, CPV arrays, values, deadlines and winner organisations, with per-notice links to the XML, PDF and HTML in all EU languages.

### Extract EU Public Procurement Notices Without Scraping HTML

The TED homepage is a Liferay CMS shell, so notice data is not embedded in the served HTML and there is nothing to parse with CSS selectors; TED also uses no third-party search backend. The official Search API is therefore the cheapest and most reliable surface:

- Filter by buyer country (ISO alpha-3), CPV code prefix and publication date window.
- Choose all notices, only open calls (competition) or only award notices (with winner info).
- Run raw expert queries such as `publication-date >= 20260101 AND buyer-country=DEU`.
- Retrieve up to 15,000 notices per query in page mode (250 per page); narrow the date window for larger sweeps.

### Get Tender Details And Winner Information

Two modes are available. In search mode the filters above drive a newest-first sweep of notices. In detail mode, pass direct notice URLs or publication numbers in `noticeUrls` to fetch each notice in full, ignoring the search filters. Award notices carry the winner name, country and the list of winners, plus the lowest and highest tender values, which is the dataset for competitor and winner analysis.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `query` | string | No | `publication-date >= 20260101` | Raw TED expert query, AND-combined with the filters. |
| `countryCodes` | array | No | `[]` | Buyer country filter (ISO alpha-3, for example DEU, FRA, CZE); OR-combined. |
| `cpvCodes` | array | No | `[]` | CPV code prefix filter (for example 45000000 construction, 48000000 software); OR-combined. |
| `noticeType` | string | No | `all` | `all`, `competition` (open calls) or `award` (award notices). |
| `fromDate` | string | No | `20260101` | Published on or after this date (`YYYYMMDD`). |
| `toDate` | string | No | empty | Published on or before this date (`YYYYMMDD`). |
| `noticeUrls` | array | No | `[]` | Direct notice URLs or publication numbers; detail mode ignores the search filters. |
| `language` | string | No | `en` | Preferred language for titles and names, with fallback. |
| `maxItems` | integer | No | `100` | Maximum notices (1 to 15000). Free users are capped at 20. |
| `proxy` | object | No | Apify Proxy off | Proxy configuration used for the requests. |

### Output Fields

One item per notice:

- `publicationNumber`, `noticeId`, `procedureId`: notice and procedure identifiers.
- `title`, `contractTitle`: notice and contract titles.
- `buyerName`, `buyerCountry`, `buyerCountries`, `buyerCity`, `buyerEmail`: buyer details.
- `cpvCodes`, `cpvMain`: CPV classification.
- `value`, `valueCurrency`, `tenderValueLowest`, `tenderValueHighest`: estimated and awarded values.
- `deadline`, `deadlineDate`, `deadlineTime`: submission deadline.
- `awardCriteriaTypes`, `awardCriteriaNames`: award criteria.
- `documentsLinks`, `pdfUrl`, `xmlUrl`, `url`: procurement documents and notice links.
- `winnerName`, `winnerCountry`, `winners`: winner info (award notices).
- `publicationDate`, `noticeType`, `noticeSubtype`, `formType`: publication metadata.

Dataset view: `overview`.

### Example Input And Output

Example input:

```json
{
  "countryCodes": ["DEU", "FRA"],
  "cpvCodes": ["48000000"],
  "noticeType": "competition",
  "fromDate": "20260101",
  "maxItems": 100
}
```

Example output row:

```json
{
  "publicationNumber": "685618-2026",
  "noticeId": "685618-2026",
  "procedureId": "a1b2c3d4-0001",
  "title": "Supply of enterprise software licences",
  "contractTitle": "Enterprise software licences",
  "buyerName": "Example Federal Agency",
  "buyerCountry": "DEU",
  "buyerCountries": ["DEU"],
  "buyerCity": "Berlin",
  "buyerEmail": "procurement@example.de",
  "cpvCodes": ["48000000"],
  "cpvMain": "48000000",
  "value": "250000",
  "valueCurrency": "EUR",
  "deadlineDate": "2026-11-30",
  "deadlineTime": "12:00",
  "awardCriteriaTypes": ["price"],
  "awardCriteriaNames": ["Lowest price"],
  "documentsLinks": ["https://ted.europa.eu/en/notice/-/detail/685618-2026"],
  "publicationDate": "2026-10-10",
  "noticeType": "competition",
  "formType": "competition",
  "url": "https://ted.europa.eu/en/notice/-/detail/685618-2026",
  "pdfUrl": "https://ted.europa.eu/en/notice/-/detail/685618-2026/pdf",
  "xmlUrl": "https://ted.europa.eu/en/notice/-/detail/685618-2026/xml"
}
```

### Integrations & Automation

Results are written to Apify datasets, so you can export them as JSON, CSV or Excel, read them through the Apify API, or push them onward with webhooks. Connect the actor to Zapier or Make to load rows into a CRM, a bid pipeline, a spreadsheet or a BI tool.

For new-tender alerts, schedule the actor daily (or hourly) with a rolling `fromDate`, so each run returns only the notices published since the last run. A weekly schedule is usually enough for market research. Recurring runs also help the actor surface better in the Apify Store.

### Related Actors

- [foxlabs/ted-tenders](https://apify.com/foxlabs/ted-tenders)
- [artificially/eu-tenders-scraper](https://apify.com/artificially/eu-tenders-scraper)
- [dltik/ted-europa-scraper](https://apify.com/dltik/ted-europa-scraper)
- [memo23/ted-tenders-scraper](https://apify.com/memo23/ted-tenders-scraper)
- [scrapers_lat/eu-ted-tenders-scraper](https://apify.com/scrapers_lat/eu-ted-tenders-scraper)

### FAQ

#### Is there an official TED API?

Yes. TED publishes an anonymous, keyless Search API for published notices (`POST /v3/notices/search`), and it is the same backend the ted.europa.eu website queries. This actor wraps it: it adds filters and pagination and returns a flattened row, so you do not have to build the expert query and field mapping yourself.

#### What are the alternatives to this actor for EU tender data?

Alternatives include calling the official TED Search API directly, third-party providers such as tedapi.pro, paid tender-intelligence platforms, and other Apify Store actors that focus on TED or EU public tenders. This actor returns both open calls and award notices with winner info from a single configuration.

#### Why use this actor instead of calling the TED API myself?

The API is keyless and free, but you have to build the expert query, map around 1,250 available fields to a flat row, and handle pagination and the 15,000-notice page-mode cap. This actor does that mapping and returns one clean JSON row per notice, with the fields most teams need already flattened.

#### Can I get only open calls or only awards?

Yes. Set `noticeType` to `competition` for open calls (contract notices) or `award` for award notices, which include the winner name, country and the list of winners.

#### Does it return winner information?

Yes, on award notices: `winnerName`, `winnerCountry` and the `winners` array, plus `tenderValueLowest` and `tenderValueHighest`.

#### How far back can I search?

The Search API page mode can retrieve at most 15,000 notices per query. Narrow the date window (`fromDate`/`toDate`) to sweep more history in separate runs. With no filters at all, the actor defaults to the last 7 days.

### SEO Keywords

ted europa scraper, ted scraper, eu public procurement data, eu tenders, eu tender monitoring, ted tenders api, public procurement notices, tender intelligence, cpv code search, eu tender leads, government contracts eu, award notices, tender winner data, procurement lead generation, bid opportunity tracking, eu public tenders scraper, ted europa api, tender deadline tracking, procurement market research, govcon leads, eu procurement database, ted notices export, tender data extraction, public sector tenders

### For AI Agents & LLM Apps

Purpose: return EU public procurement notice rows (buyer, CPV, value, deadline, documents, winner) from TED for a query or filter set.

Minimal working input:

```json
{ "countryCodes": ["DEU"] }
```

Variant that fetches award notices with winner info:

```json
{ "noticeType": "award", "cpvCodes": ["45000000"], "fromDate": "20260101", "maxItems": 100 }
```

Output fields: `publicationNumber`, `noticeId`, `procedureId`, `title`, `contractTitle`, `buyerName`, `buyerCountry`, `buyerCountries`, `buyerCity`, `buyerEmail`, `cpvCodes`, `cpvMain`, `value`, `valueCurrency`, `deadline`, `deadlineDate`, `deadlineTime`, `awardCriteriaTypes`, `awardCriteriaNames`, `documentsLinks`, `winnerName`, `winnerCountry`, `winners`, `tenderValueLowest`, `tenderValueHighest`, `publicationDate`, `noticeType`, `noticeSubtype`, `formType`, `url`, `pdfUrl`, `xmlUrl`.

Behaviors an agent should know:

- `query` is AND-combined with `countryCodes`, `cpvCodes`, `noticeType` and the date filters; `countryCodes` and `cpvCodes` are OR-combined within themselves.
- `noticeUrls` switches to detail mode and ignores all search filters.
- With no filters at all, the actor defaults to notices from the last 7 days.
- `maxItems` is capped at 15,000 (the Search API page-mode cap); leaving it unset uses the default of 100. Free users are capped at 20.
- The API is anonymous and unprotected, so no proxy is needed by default.

Billing: pay-per-event. `apify-actor-start` (about $0.00005) and one `apify-default-dataset-item` per notice (about $0.0035, less at higher loyalty tiers).

### Legal & Compliance Disclaimer

This actor is independent and is not affiliated with, endorsed by or sponsored by the Publications Office of the European Union or the TED service. It reads only publicly available data through TED's own anonymous Search API: it does not log in, does not bypass authentication and does not solve CAPTCHAs.

Users are responsible for complying with the terms that apply to TED data and with any applicable rules in their own jurisdiction. Where the output contains buyer contact details such as `buyerEmail`, that data must not be used for unsolicited commercial outreach in violation of applicable law.

# Actor input Schema

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

Raw TED expert search query (e.g. "publication-date >= 20260101 AND buyer-country=DEU"). Combined with the filters below using AND. Leave empty to use only the filters.

## `countryCodes` (type: `array`):

Filter by buyer country (ISO 3166-1 alpha-3, e.g. DEU, FRA, CZE, POL). Multiple codes are OR-combined.

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

Filter by Common Procurement Vocabulary code prefix (e.g. 45000000 for construction, 48000000 for software). Multiple codes are OR-combined.

## `noticeType` (type: `string`):

Competition = open calls for tenders (contract notices). Award = published contract award notices (includes winner info).

## `fromDate` (type: `string`):

Only notices published on or after this date, format YYYYMMDD (e.g. 20260101). Empty = no lower bound (defaults to last 7 days when no other filter is set).

## `toDate` (type: `string`):

Only notices published on or before this date, format YYYYMMDD. Empty = no upper bound.

## `noticeUrls` (type: `array`):

Direct ted.europa.eu notice URLs (e.g. https://ted.europa.eu/en/notice/-/detail/685618-2026) or bare publication numbers. When set, the actor fetches each notice in full and ignores the search filters above.

## `language` (type: `string`):

Preferred language for titles and names (2- or 3-letter code, e.g. en/eng, de/deu, fr/fra). Falls back to any available language when missing.

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

Maximum number of notices to return (1-15000, the Search API page-mode cap). Free users are capped at 20.

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "query": "publication-date >= 20260101",
  "countryCodes": [
    "DEU"
  ],
  "cpvCodes": [
    "45000000"
  ],
  "noticeType": "all",
  "fromDate": "20260101",
  "noticeUrls": [],
  "language": "en",
  "maxItems": 100,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "query": "publication-date >= 20260101",
    "countryCodes": [
        "DEU"
    ],
    "cpvCodes": [
        "45000000"
    ],
    "fromDate": "20260101",
    "toDate": "",
    "noticeUrls": [],
    "language": "en",
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/ted-europa-eu-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": "publication-date >= 20260101",
    "countryCodes": ["DEU"],
    "cpvCodes": ["45000000"],
    "fromDate": "20260101",
    "toDate": "",
    "noticeUrls": [],
    "language": "en",
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/ted-europa-eu-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 '{
  "query": "publication-date >= 20260101",
  "countryCodes": [
    "DEU"
  ],
  "cpvCodes": [
    "45000000"
  ],
  "fromDate": "20260101",
  "toDate": "",
  "noticeUrls": [],
  "language": "en",
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/ted-europa-eu-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/ted-europa-eu-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/9zeXSUaynVvcspdBe/builds/s8D8jAbVnHz5hzmjQ/openapi.json