# EU Tenders Scraper - TED Public Procurement Notices (`alex_r_ai/ted-eu-tenders-scraper`) Actor

Scrape EU public procurement tenders from the official TED (Tenders Electronic Daily) API. Filter by keyword, CPV, country and date. Free official data, clean JSON.

- **URL**: https://apify.com/alex\_r\_ai/ted-eu-tenders-scraper.md
- **Developed by:** [Alex R](https://apify.com/alex_r_ai) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 tenders

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 Tenders Scraper — TED Public Procurement Notices

Scrape **EU public procurement tenders** from the official **TED (Tenders Electronic Daily)** database — covering 27 EU member states plus EEA countries and hundreds of billions of euros in annual contract opportunities. Filter by keyword, CPV code, country and publication date, and get clean JSON, CSV or Excel ready for your CRM, dashboard or AI agent.

> **Quick start:** Just press **Start**. With no filters the Actor returns **open tenders** (still accepting bids) published in the **last 7 days**. Then add a country, CPV code, or keyword to focus on what you sell.

### Why this Actor

- **Official, free source** — pulls directly from the TED v3 API. No scraping of fragile HTML, no API key, no breakage.
- **Real filters** — keyword, CPV classification, buyer country, and publication date range.
- **Clean, normalised output** — TED's raw multilingual/array fields are flattened into tidy columns (title, buyer, country, deadline, value, CPV, links).
- **Bulk-ready** — iterates through large result sets while respecting your `maxItems` cap.

### Example input

```json
{
  "keywords": "software",
  "cpvCodes": ["72000000", "48000000"],
  "countries": ["LU", "DE", "FR"],
  "publishedAfter": "2026-01-01",
  "scope": "ACTIVE",
  "maxItems": 500
}
````

Advanced — raw TED expert query (overrides the filters):

```json
{ "query": "classification-cpv=72000000 AND buyer-country=DEU AND publication-date>=20260101" }
```

### Example output (one tender)

```json
{
  "publicationNumber": "323-2025",
  "title": "Provision of cloud hosting services",
  "noticeType": "cn-standard",
  "buyerName": "Lietuvos bankas",
  "buyerCountry": "LTU",
  "placeOfPerformance": ["LT011", "LTU"],
  "cpvCodes": ["72318000"],
  "contractNature": "services",
  "publicationDate": "2025-01-02",
  "submissionDeadline": "2025-01-13",
  "totalValue": null,
  "currency": null,
  "tedUrl": "https://ted.europa.eu/en/notice/323-2025",
  "pdfUrlEn": "https://ted.europa.eu/en/notice/323-2025/pdf"
}
```

### Use cases

- **Public-sector B2B sales** — monitor live tenders in your category and country, feed them to your pipeline.
- **Bid/no-bid intelligence** — track buyers, contract values, and deadlines.
- **Market research** — analyse procurement trends by CPV, country, or buyer.
- **Agent workflows** — give an AI assistant live access to EU tender opportunities via the Apify MCP server.

### Filters

| Field | Meaning |
|-------|---------|
| `noticeKind` | **Open calls** (default, still biddable), **awards** (who won + value), or **all** |
| `keywords` | Words to match in the notice title |
| `cpvCodes` | Common Procurement Vocabulary codes (e.g. 72000000 = IT services) |
| `countries` | Buyer country — 2- or 3-letter ISO codes both accepted |
| `publishedAfter` / `publishedBefore` | Publication date range |
| `scope` | `ACTIVE` (open for submission), `LATEST`, or `ALL` |
| `maxItems` | Cap on results saved |
| `query` | Advanced raw TED expert query (overrides everything else) |

Helpful CPV divisions: `72000000` IT services · `48000000` software · `45000000` construction · `79000000` business services · `85000000` health & social · `71000000` architecture & engineering.

### Pricing (pay per event)

| Event | What it covers |
|-------|----------------|
| `tender` | Each tender notice saved to the dataset |

The free synthetic `apify-actor-start` event covers run startup. Set `maxItems` to keep spend predictable.

### Notes

- Data comes from the official EU TED Search API, which is open and requires no authentication.
- Very large pulls: narrow with a date range or country to stay within TED's paging limits.
- Run on a schedule to get a daily feed of new tenders in your category.

# Actor input Schema

## `noticeKind` (type: `string`):

Open calls = tenders still open for bidding (recommended for finding opportunities). Awards = already-awarded contracts (market intelligence: who won, for how much). All = both.

## `keywords` (type: `string`):

Free-text words to match in the notice title, e.g. 'software development' or 'cloud hosting'.

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

Common Procurement Vocabulary codes to filter by, e.g. 72000000 (IT services), 48000000 (software). Multiple codes are OR-matched.

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

Country of the buyer. 2-letter (LU, DE) or 3-letter (LUX, DEU) ISO codes both work. Multiple countries are OR-matched.

## `publishedAfter` (type: `string`):

Only notices published on or after this date.

## `publishedBefore` (type: `string`):

Only notices published on or before this date.

## `scope` (type: `string`):

ACTIVE = notices still open for submission. LATEST = latest version of each. ALL = everything matching.

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

Stop after saving this many tenders. Keeps your cost predictable.

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

Power users only. A raw TED expert search query, e.g. classification-cpv=72000000 AND buyer-country=DEU AND publication-date>=20250101. If set, this overrides all the filters above.

## Actor input object example

```json
{
  "noticeKind": "open",
  "cpvCodes": [
    "72000000"
  ],
  "countries": [
    "LU",
    "DE"
  ],
  "scope": "ACTIVE",
  "maxItems": 200
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keywords": "",
    "cpvCodes": [
        "72000000"
    ],
    "countries": [
        "LU",
        "DE"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("alex_r_ai/ted-eu-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 = {
    "keywords": "",
    "cpvCodes": ["72000000"],
    "countries": [
        "LU",
        "DE",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("alex_r_ai/ted-eu-tenders-scraper").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 '{
  "keywords": "",
  "cpvCodes": [
    "72000000"
  ],
  "countries": [
    "LU",
    "DE"
  ]
}' |
apify call alex_r_ai/ted-eu-tenders-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EU Tenders Scraper - TED Public Procurement Notices",
        "description": "Scrape EU public procurement tenders from the official TED (Tenders Electronic Daily) API. Filter by keyword, CPV, country and date. Free official data, clean JSON.",
        "version": "0.0",
        "x-build-id": "5qIe1cnOgq7JRxcbQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/alex_r_ai~ted-eu-tenders-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-alex_r_ai-ted-eu-tenders-scraper",
                "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/alex_r_ai~ted-eu-tenders-scraper/runs": {
            "post": {
                "operationId": "runs-sync-alex_r_ai-ted-eu-tenders-scraper",
                "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/alex_r_ai~ted-eu-tenders-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-alex_r_ai-ted-eu-tenders-scraper",
                "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": {
                    "noticeKind": {
                        "title": "Notice kind",
                        "enum": [
                            "open",
                            "awards",
                            "all"
                        ],
                        "type": "string",
                        "description": "Open calls = tenders still open for bidding (recommended for finding opportunities). Awards = already-awarded contracts (market intelligence: who won, for how much). All = both.",
                        "default": "open"
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Free-text words to match in the notice title, e.g. 'software development' or 'cloud hosting'."
                    },
                    "cpvCodes": {
                        "title": "CPV codes",
                        "type": "array",
                        "description": "Common Procurement Vocabulary codes to filter by, e.g. 72000000 (IT services), 48000000 (software). Multiple codes are OR-matched.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Buyer countries",
                        "type": "array",
                        "description": "Country of the buyer. 2-letter (LU, DE) or 3-letter (LUX, DEU) ISO codes both work. Multiple countries are OR-matched.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "publishedAfter": {
                        "title": "Published after",
                        "type": "string",
                        "description": "Only notices published on or after this date."
                    },
                    "publishedBefore": {
                        "title": "Published before",
                        "type": "string",
                        "description": "Only notices published on or before this date."
                    },
                    "scope": {
                        "title": "Scope",
                        "enum": [
                            "ACTIVE",
                            "LATEST",
                            "ALL"
                        ],
                        "type": "string",
                        "description": "ACTIVE = notices still open for submission. LATEST = latest version of each. ALL = everything matching.",
                        "default": "ACTIVE"
                    },
                    "maxItems": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Stop after saving this many tenders. Keeps your cost predictable.",
                        "default": 200
                    },
                    "query": {
                        "title": "Advanced: raw TED expert query",
                        "type": "string",
                        "description": "Power users only. A raw TED expert search query, e.g. classification-cpv=72000000 AND buyer-country=DEU AND publication-date>=20250101. If set, this overrides all the filters above."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
