# EU TED Tenders — Public Procurement Notice Scraper (`foxlabs/ted-tenders`) Actor

Fetches structured public procurement notices from the official EU TED (Tenders Electronic Daily) API. Filter by country, CPV code, date, value, and notice type. Free, unauthenticated API; clean JSON output ready for CRM/dashboard ingestion.

- **URL**: https://apify.com/foxlabs/ted-tenders.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $4.00 / 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.

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

## EU TED Tenders — Public Procurement Notice Scraper

### What does EU TED Tenders do?

**EU TED Tenders** fetches structured public procurement notices from the official **TED (Tenders Electronic Daily)** API run by the European Union Publications Office. It outputs clean JSON rows for every notice matching your filters — country, CPV code, date range, notice type, value — ready to be loaded into a CRM, dashboard, or Slack alert.

TED is the single source of truth for public contracts published by EU member states above the EU thresholds. Every business that sells to government in the EU needs this data; this Actor turns the official but gnarly XML/JSON API into a flat dataset you can ingest in seconds. Try it from the [Apify Console](https://console.apify.com), schedule daily runs, hit the API, or pipe into Make/Zapier/n8n.

### Why use EU TED Tenders?

- **Sales pipelines** — bid teams chasing public contracts get every relevant tender published in the last 24 hours, filtered to their CPV codes.
- **Market intelligence** — track competitor wins via contract award notices (CAN), aggregate by buyer or sector.
- **Compliance & monitoring** — watch buyer behaviour across member states; build alerts on procurement irregularities.
- **Research** — feed TED data into LLMs or BI dashboards without writing your own EU-procurement parser.

### How to use EU TED Tenders

1. Open the Actor's **Input** tab in the Apify Console.
2. Either paste a native TED expert query (e.g. `publication-date>=20260101 AND buyer-country=DEU`) into the **TED Expert Search Query** field, or fill in the structured filters (date, countries, CPV codes, notice types).
3. Pick your preferred output language (defaults to English).
4. Click **Start**. The dataset will populate in real time.
5. Download as JSON, CSV, or Excel from the **Dataset** tab.

### Input

The Actor accepts either:

- A raw **TED expert query** string (full power of TED's query DSL), or
- Structured filters: date range, ISO-3 country codes, CPV codes, notice types.

Plus output controls: language, max results, page size.

```json
{
  "publicationDateFrom": "20260420",
  "countries": ["DEU", "FRA"],
  "cpvCodes": ["72000000"],
  "noticeTypes": ["cn"],
  "language": "ENG",
  "maxResults": 500
}
````

### Output

Each dataset row represents one published notice:

```json
{
  "publicationNumber": "265768-2026",
  "publicationDate": "2026-04-20",
  "title": "Supply of cloud infrastructure services",
  "noticeType": "cn",
  "procedureType": "open",
  "buyerName": "Bundesministerium für Digitales",
  "buyerCountry": "DEU",
  "buyerCity": "Berlin",
  "buyerEmail": "vergabe@bmdv.bund.de",
  "buyerUrl": "https://www.bmdv.bund.de",
  "totalValue": 2400000,
  "totalValueCurrency": "EUR",
  "cpvCodes": ["72000000", "72200000"],
  "deadlineDate": "2026-05-20",
  "description": "Multi-year framework for IaaS provision...",
  "placeOfPerformanceCountry": "DEU",
  "placeOfPerformanceCity": "Berlin",
  "detailUrl": "https://ted.europa.eu/en/notice/-/detail/265768-2026",
  "xmlUrl": "https://ted.europa.eu/en/notice/265768-2026/xml",
  "scrapedAt": "2026-04-24T08:00:00.000Z"
}
```

You can download the dataset in JSON, CSV, Excel, HTML, RSS, or XML formats.

### Data table

| Field | Description |
|---|---|
| `publicationNumber` | TED canonical notice ID (e.g. `265768-2026`) |
| `publicationDate` | Date the notice was published in TED |
| `title` | Notice title in the requested language |
| `noticeType` / `noticeSubtype` | TED notice classification (cn, can-standard, pin-only, ...) |
| `procedureType` | open, restricted, negotiated, ... |
| `buyerName` / `buyerCountry` / `buyerCity` | Contracting authority |
| `buyerEmail` / `buyerUrl` | Contact channels |
| `totalValue` / `totalValueCurrency` | Estimated or awarded value |
| `cpvCodes` | Common Procurement Vocabulary classifications |
| `deadlineDate` | Deadline for tender submission (when present) |
| `description` | Free-text description from the lot or procedure |
| `placeOfPerformance*` | Where the contract is to be executed |
| `detailUrl` / `xmlUrl` | Links to the official TED notice page and XML |

### Pricing / Cost estimation

This Actor uses **pay-per-result pricing: $4 per 1,000 notices** (≈ $0.004 per notice). TED's underlying API is free, so there are no third-party fees on top.

Apify's free tier includes $5/month of platform credits, which covers roughly **1,250 notices/month** free of charge before you pay anything. Beyond that you only pay for what you fetch — there is no monthly minimum or seat fee.

Typical runs:

- **Daily incremental ingest** (one day of EU-wide notices ≈ 1,500–3,000 rows): $6–$12/month at daily cadence.
- **Targeted niche** (one CPV code in one country, daily): often under $1/month.
- **Initial backfill** (a month of EU-wide notices ≈ 50,000–80,000 rows): one-off $200–$320, then daily increments are cheap.

### Tips

- **Schedule daily runs** with a `publication-date` filter equal to today's date for incremental ingestion.
- **Use `maxResults`** when exploring — TED can return tens of thousands of notices for broad queries.
- **Native query syntax** is the most flexible; the structured filters are convenience wrappers.
- **Multilingual fields** — `title`, `description`, `buyerName` come in many EU languages; the Actor picks your `language` and falls back to English.

### FAQ

**Is TED data free to use?** Yes — TED notices are official EU publications under [Decision (EU) 2017/1873](https://eur-lex.europa.eu/eli/dec/2017/1873/oj). Standard attribution and ToS apply for commercial reuse.

**Why are some fields missing?** TED notices vary by type — a planning notice (PIN) won't have an awarded value; a contract award (CAN) won't have a tender deadline. Empty fields are returned as `null`.

**Can I get notice details beyond the search API?** v0.1 returns search-API fields and links to the full XML/HTML. A future version may parse the XML for full lot-level detail.

For feedback and feature requests, open an issue in the Actor's Issues tab.

# Actor input Schema

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

Native TED expert query. Examples: 'publication-date>=20260101', 'place-of-performance-country=DEU AND classification-cpv=72000000', 'notice-type=cn'. The default ('publication-date>=20200101') matches every notice since 2020 — newest first, so a 'pull recent' default. Leave empty to fall back to the structured filters below.

## `publicationDateFrom` (type: `string`):

Only used if 'query' is empty. Format: 20260101.

## `publicationDateTo` (type: `string`):

Only used if 'query' is empty.

## `countries` (type: `array`):

Filter by buyer country. Use ISO 3166-1 alpha-3 codes: DEU, FRA, ITA, ESP, POL, etc. Only used if 'query' is empty.

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

Filter by CPV code (Common Procurement Vocabulary). Examples: 72000000 (IT services), 45000000 (construction). Only used if 'query' is empty.

## `noticeTypes` (type: `array`):

TED notice type codes. Common: cn (contract notice), can-standard (contract award), pin-only (prior info). Only used if 'query' is empty.

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

Language code for localized fields like title and description.

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

Hard cap on dataset rows. 0 = no limit.

## `pageSize` (type: `integer`):

Notices per API call. TED max is 250.

## Actor input object example

```json
{
  "query": "publication-date>=20200101",
  "countries": [],
  "cpvCodes": [],
  "noticeTypes": [],
  "language": "ENG",
  "maxResults": 1000,
  "pageSize": 100
}
```

# Actor output Schema

## `dataset` (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>=20200101"
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/ted-tenders").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>=20200101" }

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/ted-tenders").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": "publication-date>=20200101"
}' |
apify call foxlabs/ted-tenders --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=foxlabs/ted-tenders",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EU TED Tenders — Public Procurement Notice Scraper",
        "description": "Fetches structured public procurement notices from the official EU TED (Tenders Electronic Daily) API. Filter by country, CPV code, date, value, and notice type. Free, unauthenticated API; clean JSON output ready for CRM/dashboard ingestion.",
        "version": "0.4",
        "x-build-id": "zChWjWM2qsgr2JBYC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/foxlabs~ted-tenders/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-foxlabs-ted-tenders",
                "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/foxlabs~ted-tenders/runs": {
            "post": {
                "operationId": "runs-sync-foxlabs-ted-tenders",
                "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/foxlabs~ted-tenders/run-sync": {
            "post": {
                "operationId": "run-sync-foxlabs-ted-tenders",
                "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": "TED Expert Search Query",
                        "type": "string",
                        "description": "Native TED expert query. Examples: 'publication-date>=20260101', 'place-of-performance-country=DEU AND classification-cpv=72000000', 'notice-type=cn'. The default ('publication-date>=20200101') matches every notice since 2020 — newest first, so a 'pull recent' default. Leave empty to fall back to the structured filters below.",
                        "default": "publication-date>=20200101"
                    },
                    "publicationDateFrom": {
                        "title": "Publication date from (YYYYMMDD)",
                        "pattern": "^[0-9]{8}$",
                        "type": "string",
                        "description": "Only used if 'query' is empty. Format: 20260101."
                    },
                    "publicationDateTo": {
                        "title": "Publication date to (YYYYMMDD)",
                        "pattern": "^[0-9]{8}$",
                        "type": "string",
                        "description": "Only used if 'query' is empty."
                    },
                    "countries": {
                        "title": "Buyer countries (ISO 3-letter)",
                        "type": "array",
                        "description": "Filter by buyer country. Use ISO 3166-1 alpha-3 codes: DEU, FRA, ITA, ESP, POL, etc. Only used if 'query' is empty.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "cpvCodes": {
                        "title": "CPV classification codes",
                        "type": "array",
                        "description": "Filter by CPV code (Common Procurement Vocabulary). Examples: 72000000 (IT services), 45000000 (construction). Only used if 'query' is empty.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "noticeTypes": {
                        "title": "Notice types",
                        "type": "array",
                        "description": "TED notice type codes. Common: cn (contract notice), can-standard (contract award), pin-only (prior info). Only used if 'query' is empty.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Preferred output language",
                        "enum": [
                            "ENG",
                            "DEU",
                            "FRA",
                            "ITA",
                            "ESP",
                            "POL",
                            "NLD",
                            "POR",
                            "SWE",
                            "DAN",
                            "FIN",
                            "CES",
                            "ELL",
                            "HUN",
                            "RON",
                            "SLK",
                            "SLV",
                            "BUL",
                            "HRV",
                            "EST",
                            "LAV",
                            "LIT",
                            "GLE",
                            "MLT"
                        ],
                        "type": "string",
                        "description": "Language code for localized fields like title and description.",
                        "default": "ENG"
                    },
                    "maxResults": {
                        "title": "Max notices",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on dataset rows. 0 = no limit.",
                        "default": 1000
                    },
                    "pageSize": {
                        "title": "API page size",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Notices per API call. TED max is 250.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```