# EU TED Tenders Monitor: Public Procurement Search + Alerts (`transparent_meteorite/eu-ted-tenders-monitor`) Actor

Search EU public procurement notices on TED by keyword, CPV code, country, buyer, date and value: deadline, estimated value, award winners, plus a new-notices-since-last-run monitor. Beta.

- **URL**: https://apify.com/transparent_meteorite/eu-ted-tenders-monitor.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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

## EU TED Tenders Monitor: Public Procurement Search + New-Notice Alerts

Use this to find EU public tenders on TED by keyword, CPV code, country and value, and monitor for newly published notices.

**Beta.** Verify any tender you bid on in the linked official TED notice. Built on the official TED open API, local unit tests with fixtures copied from real responses, and a live check against the API before release. Open an issue on the Issues tab if a field looks wrong and we fix it fast.

### What it does

Search public procurement notices published on **TED (Tenders Electronic Daily)**, the official EU journal for public tenders, and monitor for new ones. No login, no scraping: it uses the anonymous TED Search API v3.

- **Find tenders.** Filter by keyword, CPV code, buyer country, buyer name, publication date and value. Optionally keep only tenders whose submission deadline has not passed.
- **See the money and the date.** Contract notices return the submission deadline and estimated value (lots summed, currency kept).
- **See who won.** Award notices return winner names, winner countries and the awarded value.
- **Monitor mode.** With "Only new since last run" on, each run delivers only notices not seen before (state kept in a named key-value store). A repeat run with nothing new delivers and charges nothing. Schedule it daily for alerts.

### Use cases

- Bid teams and consultancies: a daily feed of new open tenders in your CPV codes and countries.
- Sales intelligence: who wins public contracts in a sector, for how much, and which buyers keep issuing them.
- Market research: tender volume and value by country, buyer and category.

### Example input

Open IT tenders from German buyers, new since last run:

```json
{ "keywords": ["software"], "cpvCodes": ["72"], "countries": ["DE"], "noticeKind": "contracts", "onlyOpenForBids": true, "daysBack": 7, "maxItems": 100 }
```

Recent awards in France above 1 million EUR:

```json
{ "countries": ["FR"], "noticeKind": "awards", "minValue": 1000000, "currency": "EUR", "onlyNewSinceLastRun": false }
```

### Output fields

noticeId, noticeKind (contract or award), noticeType, title (English when available), publicationDate, buyerName, buyerCountry (ISO 3), buyerCity, cpvCodes, contractNature, procedureType, lotCount, deadline (earliest lot deadline), deadlineOpen, estimatedValue and estimatedValueCurrency (contract notices), winners, winnerCountries, awardedValue and awardedValueCurrency (award notices), noticeUrl, pdfUrl, source, scrapedAt.

### Pricing

Pay per event: $0.004 per notice returned (about $4 per 1,000). Actor start $0.00005. Filtered rows and already-seen notices are free. Set Maximum cost per run to cap spend.

### Data source, licence and limits

Data comes from the Publications Office of the European Union (TED). The TED API documentation states that searching published notices is anonymous and that the Search API exists for reuse and analysis of published notices. Reuse of TED notice data is permitted under the European Commission reuse policy (Decision 2011/833/EU) with the source acknowledged, which every row does in its `source` and `noticeUrl` fields. This actor is not affiliated with or endorsed by the European Union.

- Value filters compare the numbers published in the notice. Values can be in different currencies; set a currency to avoid mixing them. Many notices publish no value, and those are dropped when a value filter is set.
- TED can lag the real publication by hours to days, and notices come in many languages; the actor prefers the English title.
- The actor makes serial, polite requests with backoff.

### Output sample

Each result is one dataset item (JSON, CSV, Excel or via API). Shape taken from the actor's dataset schema; field names and meanings below, not live data:

| Field | Meaning |
|---|---|
| `publicationDate` |  |
| `noticeKind` |  |
| `title` |  |
| `buyerName` |  |
| `buyerCountry` |  |
| `deadline` |  |
| `estimatedValue` |  |
| `estimatedValueCurrency` |  |
| `winners` |  |
| `awardedValue` |  |
| `noticeUrl` |  |

### FAQ

**How do I try it quickly?** Press Start with the prefilled input; it is a small run.

**How is it priced?** Pay per event; see the Pricing section above or the Pricing tab. A small run costs very little.

**Is this a one-off or can it run on a schedule?** Both. Use Apify schedules or the API to run it repeatedly.

**What if the source is slow or fails?** Failed or rate-limited requests (HTTP 429 or 5xx, network errors) are retried up to 4 attempts with growing waits; if a source stays unavailable the run records a warning instead of returning invented results.

**Is the data legal to use?** The actor reads public data. You are responsible for using the results in line with applicable law and the source's terms.

### Alternatives to EU TED Tenders Monitor

Other ways to get similar data, so you can choose what fits:

- **the TED website saved searches and email alerts**: official, free
- **the TED API directly**: free, you write the code

This actor's edge is pay-per-result pricing, no login and ready-to-use structured output. Compare on a small test run before you commit.

### Changelog

- **0.2** (2026-10-28): listing refresh (title, description, README sections, console prefills). No change to output fields.
- Earlier: initial release.

# Actor input Schema

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

Full-text search over notice text. Any keyword matches (OR). Leave empty to filter only by the fields below.

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

Common Procurement Vocabulary codes. A short code is a prefix: 72 or 72000000 matches all IT services. Any code matches (OR).

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

Country of the contracting authority, ISO 2-letter (DE, FR, PL) or 3-letter (DEU) codes. Empty = all EU/EEA.

## `buyerName` (type: `string`):

Contracting authority name, e.g. Bundesamt or Ministry of Health.

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

Contract notices carry deadline and estimated value. Award notices carry winners and awarded value.

## `daysBack` (type: `integer`):

Publication-date window (1 to 365).

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

Cap on notices delivered (and charged) this run.

## `onlyNewSinceLastRun` (type: `boolean`):

Skip notices delivered in a previous run (tracked in a named key-value store). A repeat run with no new notices delivers 0 rows and charges 0 events.

## `onlyOpenForBids` (type: `boolean`):

Contract notices only: keep notices whose submission deadline has not passed.

## `minValue` (type: `integer`):

Minimum estimated value (contract notices) or awarded value (award notices), in the notice currency. Notices without a published value are dropped when a value filter is set.

## `maxValue` (type: `integer`):

Maximum estimated or awarded value.

## `currency` (type: `string`):

Optional ISO currency code (EUR, PLN, SEK). When set, only notices valued in that currency pass the value filter.

## `stateStoreName` (type: `string`):

Named key-value store that remembers delivered notices. Change it to keep separate monitors or reset dedupe.

## Actor input object example

```json
{
  "keywords": [
    "software"
  ],
  "countries": [
    "DE"
  ],
  "noticeKind": "contracts",
  "daysBack": 3,
  "maxItems": 5,
  "onlyNewSinceLastRun": true,
  "onlyOpenForBids": false,
  "stateStoreName": "eu-ted-seen"
}
```

# Actor output Schema

## `overview` (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 = {
    "keywords": [
        "software"
    ],
    "countries": [
        "DE"
    ],
    "daysBack": 3,
    "maxItems": 5,
    "onlyNewSinceLastRun": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/eu-ted-tenders-monitor").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": ["software"],
    "countries": ["DE"],
    "daysBack": 3,
    "maxItems": 5,
    "onlyNewSinceLastRun": False,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/eu-ted-tenders-monitor").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 '{
  "keywords": [
    "software"
  ],
  "countries": [
    "DE"
  ],
  "daysBack": 3,
  "maxItems": 5,
  "onlyNewSinceLastRun": false
}' |
apify call transparent_meteorite/eu-ted-tenders-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/eu-ted-tenders-monitor"
        }
    }
}
```

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/0jfsHV6JKU3CM21Vn/builds/PnFK1K09IkS2f2hP7/openapi.json