# EU TED Tenders Scraper — New Tender & Award Alerts (`magnova/eu-ted-tenders-scraper`) Actor

Scrape EU public tenders from TED via the official TED API — buyer, title, CPV codes, submission deadline, estimated value, award winners. Monitoring mode delivers only new tenders, award notices and change notices. $0.005 per notice, no start fee.

- **URL**: https://apify.com/magnova/eu-ted-tenders-scraper.md
- **Developed by:** [Magnova](https://apify.com/magnova) (community)
- **Categories:** Automation, Lead generation
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 tender notices

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## EU TED Tenders Scraper — New Tender & Award Alerts

**Every EU public tender, award and change notice from TED — the EU's official procurement journal — as clean structured records, with a monitoring mode that delivers only what's new.**

TED (Tenders Electronic Daily) publishes 600,000+ above-threshold public procurement notices a year: roughly 3,700 on a working day. Buried in that firehose are the contracts your business bids on — and the deadlines that decide whether you can. This Actor reads TED through the Publications Office's **official Search API v3** (keyless — no API key, no login, no scraping) and turns it into flat, analysis-ready records: buyer, title, CPV codes, place of performance, the submission deadline, estimated value, and — on award notices — who won and for how much.

It is built scraper-first, with monitoring as a mode: your first run pulls the current corpus for your slice (a country, a CPV family, a keyword), and scheduled runs after that deliver **only the notices you haven't seen** — new tenders, award notices, and the change notices (corrigenda, deadline-moving updates, cancellations) that snapshot tools never show you.

### What you get

Each delivered record (`recordType: "NOTICE"`, charged) carries:

| Field | What it is |
|---|---|
| `publicationNumber` | TED's stable notice ID (e.g. `737937-2025`) — the dedupe key |
| `publicationDate` | Official Journal publication date (day-granular) |
| `noticeType` / `noticeTypeLabel` | TED's type code (`cn-standard`, `can-standard`, …) and its human name |
| `eventType` | `NEW`, `AWARD` or `CHANGE` (see Event types below) |
| `noticeTitle` / `titleLanguage` / `titleByLanguage` | The notice title — English where TED provides it, else the buyer's language — plus the full per-language map |
| `noticeDescription` | The notice's short description (first lot) |
| `buyerName` / `buyerNames` / `buyerCountry` | The contracting authority (organisation names and country codes) |
| `placeOfPerformanceCountries` / `placeOfPerformanceNuts` | Where the work happens — countries and NUTS regions |
| `cpvCodes` | CPV classification codes, deduplicated across lots |
| `contractNature` | `works`, `supplies` or `services` |
| `submissionDeadline` / `submissionDeadlines` | The earliest, and all, submission deadlines — a full datetime when TED publishes a time, a plain date when it doesn't |
| `estimatedValue` / `estimatedValueCurrency` | The buyer's estimated contract value, where published |
| `awardedValue` / `awardedValueCurrency` / `winnerName` / `winnerNames` | Award notices: the awarded value and the winning business(es) |
| `changeReasonCode` / `changeReasonLabel` / `changedNoticeNumber` | Change notices: why the notice changed, and the publication number it changes (where TED references it by number) |
| `noticeUrl` / `noticeXmlUrl` / `noticePdfUrl` / `apiUrl` | The notice on TED: web page, full XML, PDF, and the notice in TED's API (links shipped as data) |

Every run ends with one `SUMMARY` record (never charged): how many notices matched, how many were fetched, delivered, skipped as duplicates or filtered out, and whether the run stopped at a cap. If the TED API cannot be read, the run writes one `ERROR` record plus the summary instead of pretending there were no new tenders — and in monitoring mode the state is not advanced, so the next run catches up.

**What is never in a record:** contact data. TED's source contains buyer and winner contact touchpoints — emails, phone numbers, contact-point names. This Actor does not request those fields from the API at all, so they can never appear in your dataset. And if a buyer writes an email address into a notice's own text, or one turns up inside a name field, it is stripped before the record ships. Buyer and winner **organisation names** are public procurement facts and are included.

### Three ways to run it

**1. Corpus (default).** A run delivers the matching notices for its publication window — the last `backfillDays` complete publication days (default 7), or an explicit `dateFrom`/`dateTo` range (up to 366 days). This is the first-run sale: pull a quarter of German construction awards, a month of EU IT tenders, and analyse them offline.

**2. Monitoring mode.** Select one of your key-value stores in the *Monitor state store* input and schedule the run (daily is the natural cadence — TED publishes on working days). The first run delivers the window's notices as a charged baseline; every later run delivers only notices the store hasn't seen. Set *Start monitoring silently* (`monitorOnlyNew`) to skip the baseline: the first run just remembers the current notices, and you receive only what appears afterwards. Notices a run couldn't deliver (cap reached, timeout) stay unseen and are delivered by the next run.

**3. Cursor mode.** Hold your own state in Make, Zapier or your scheduler: pass `publishedSince` (an ISO date) and each run delivers notices published on or after that date — stateless incremental, no store needed. TED publication dates are day-granular, so the cursor compares by day, boundary-inclusive.

### Event types — including the changes nobody else sells

- **NEW** — a newly published notice: contract notices, prior information notices, qualification systems, transparency notices.
- **AWARD** — a contract award notice: who won, and the awarded value where published.
- **CHANGE** — a notice that changes an earlier one. TED marks these with change metadata; on a typical day about 1 in 6 notices is a change. This Actor classifies a notice as CHANGE when it carries TED change metadata (reason codes `cor-buy`/`cor-pub`/`cor-esen` corrections, `update-add`/`info-release` updates, `cancel`/`cancel-intent` cancellations, `susp-review`), or when it is a `can-modif` contract modification notice. A changed award notice is classified CHANGE — the change is the event — while its `noticeType` still shows it is an award notice.

One honesty note about changes: TED's change metadata names *which lot or section* changed, never *which field*. A deadline change therefore cannot be separated from a text correction in the source data — so CHANGE is one event, and its record always carries the notice's **current** submission deadline. If a deadline moved, the change record shows the new one.

### Inputs

| Input | What it does |
|---|---|
| `backfillDays` | Publication days back from yesterday (default 7, max 92) |
| `dateFrom` / `dateTo` | Explicit window (overrides `backfillDays`; max 366 days) |
| `buyerCountries` | Buyer country filter, ISO alpha-3 (`DEU`, `FRA`, `POL`, …) |
| `cpvPrefixes` | CPV prefix filter (`45` construction, `72` IT services, `79` business services…) |
| `keywords` | TED full-text search terms (OR), matched against the notice's full text |
| `eventTypes` | `NEW`, `AWARD`, `CHANGE` — leave empty for all |
| `minEstimatedValue` | Only notices at or above this value (award notices compare on awarded value; notices with no published value are excluded) |
| `publishedSince` | Stateless cursor: notices published on/after this date |
| `monitorStore` | Your key-value store for only-new delivery |
| `monitorOnlyNew` | Skip the charged baseline; start silently |
| `maxResults` | Cap on delivered (charged) notices per run (default prefilled 500, max 15,000) |
| `maxTotalChargeUsd` | Hard stop for the run's charges |

Buyer country, CPV and keywords are applied inside the TED query itself; event types and minimum value are applied by the Actor while streaming results (TED's query language cannot express "has change metadata"), and only delivered notices are ever charged.

### Use it as an API (Server Actor)

This actor also runs as a **server**: send one HTTP request and get the notices back in the response — no run to start, no dataset to poll.

```
POST https://magnova--eu-ted-tenders-scraper.apify.actor
Authorization: Bearer <YOUR_APIFY_TOKEN>
Content-Type: application/json

{"buyerCountries": ["DEU"], "backfillDays": 7, "maxResults": 25}
```

The body takes the same fields as the normal input below. The response is `{"records": [...], "summary": {...}}`. Server mode is a snapshot lookup — the monitor state store stays a scheduled/batch-run feature — and one request returns at most 100 notices. You are charged the same $0.005 per delivered notice as a normal run (tiered by your Apify plan), billed to your own Apify account; error rows are never charged.

### Pricing

**$0.005 per notice delivered** (SILVER $0.00425, GOLD+ $0.0035), **no start fee**. Duplicates, filtered-out notices, silently seeded notices, ERROR records and the SUMMARY are never charged. A scheduled monitoring run on a day with no new matching notices costs nothing. The corpus is the cheap part: a 1,000-notice backfill is $5 at the standard tier.

### Examples

German construction tenders from the last 7 days (a typical corpus pull):

```json
{ "buyerCountries": ["DEU"], "cpvPrefixes": ["45"], "backfillDays": 7, "maxResults": 500 }
```

Daily monitoring of EU IT-services awards, started silently, with your store attached:

```json
{ "cpvPrefixes": ["72"], "eventTypes": ["AWARD"], "backfillDays": 3, "monitorOnlyNew": true, "monitorStore": "<your key-value store>" }
```

A sample delivered record (shortened):

```json
{
  "recordType": "NOTICE",
  "publicationNumber": "775131-2026",
  "publicationDate": "2026-11-06",
  "noticeType": "cn-standard",
  "noticeTypeLabel": "Contract notice",
  "eventType": "NEW",
  "noticeTitle": "Germany – Plastering work – Leuschnerstraße 13 - Estrich",
  "titleLanguage": "eng",
  "buyerName": "SBH | Schulbau Hamburg",
  "buyerCountry": ["DEU"],
  "placeOfPerformanceCountries": ["DEU"],
  "placeOfPerformanceNuts": ["DE600"],
  "cpvCodes": ["45410000"],
  "contractNature": "works",
  "submissionDeadline": "2026-12-08T10:00:00+01:00",
  "estimatedValue": 35400000,
  "estimatedValueCurrency": "EUR",
  "noticeUrl": "https://ted.europa.eu/en/notice/-/detail/775131-2026",
  "apiUrl": "https://api.ted.europa.eu/v3/notices/775131-2026"
}
```

### EU TED Tenders API

This Actor is the no-code way to use the official TED Search API: it handles the expert-query syntax, iteration pagination, the 1,800-field catalogue, multilingual title flattening, per-lot deadline assembly and cross-run dedupe for you. Compared with snapshot scrapers of the TED website, you get the same official data the Publications Office itself serves — plus the delta: only-new delivery and change events the website tools don't offer.

### Use cases

- **Bid teams:** never miss a tender in your countries × CPVs — and never miss the corrigendum that moves its deadline.
- **Bid consultants & tender-alert services:** build client feeds on the monitoring mode instead of re-pulling the whole corpus daily.
- **Market intelligence:** award corpora by CPV and country — who wins, at what values, how often.
- **AI agents:** structured, deduped tender data with stable IDs, ready for pipelines and RAG — call it via the Apify API or MCP like any other Actor.

### Using this Actor with AI agents (MCP)

The Actor is agent-ready: every input and output field is described, the example input runs as-is, and a single call with `{}`-plus-prefill works zero-shot. Typical agent flow: run once with your filters for the corpus, then schedule daily runs with a monitor store and consume only the new NOTICE records; stop conditions are explicit (`stoppedByMaxCharge`, `stoppedByResultCap`, `streamComplete` in the SUMMARY).

### FAQ

**Is this official EU data?** Yes — TED is the EU's official procurement journal, and this Actor reads it through the Publications Office's own Search API v3. The Actor is an independent tool, not affiliated with or endorsed by the European Union.

**Does it need an API key or account?** No. The TED Search API for published notices is keyless, and the Actor needs no TED account, login or key — and neither do you.

**What's not covered?** TED carries above-EU-threshold procurement. Below-threshold national tenders are published on national portals, not TED. The full legal text of a notice lives in its XML (linked in every record); the Actor ships the structured fields, not the full text.

**Why did my first monitoring run deliver so much?** That's the baseline: the current window delivered once, so later runs can deliver only what's new. Prefer to start from zero? Turn on *Start monitoring silently*.

**Why is a notice's estimated value missing?** Because the buyer didn't publish one — roughly half of contract notices carry no procedure-level estimate in TED. Award notices carry the awarded value instead, where published.

**Can it alert me the same day?** TED publishes each Official Journal once a day, in the morning. A daily scheduled run shortly after publication is the freshest cadence the source supports.

### Legal and data

All data comes from TED (Tenders Electronic Daily), the official EU procurement journal, via the official TED Search API v3 published by the Publications Office of the European Union for exactly this kind of reuse. TED data is © European Union and may be reused, including commercially, with attribution (Commission Decision 2011/833/EU and the TED legal notice): **Source: TED — Tenders Electronic Daily, © European Union, https://ted.europa.eu**. This Actor uses the API the Publications Office recommends for technical users instead of scraping the website, honours TED's fair-usage expectations (gentle paged requests), and never fetches the TED website itself — notice links are shipped as data. Records contain business data only (buyer organisations, contract details, winning businesses as published by law); personal contact data present in the source is excluded by design — those fields are never requested from the API. No login, no API key, no CAPTCHA bypass, no personal data.

# Actor input Schema

## `backfillDays` (type: `integer`):

How many publication days back the run covers, counting back from yesterday (the last complete Official Journal day). TED publishes on working days; 7 days covers a full week. The window is ignored when Date from / Date to are set. Scheduled monitoring runs typically use 2-3 days of lookback plus a monitor store, so a missed day never loses notices.

## `buyerCountries` (type: `array`):

Optional filter: only notices whose BUYER (the contracting authority) is in one of these countries. ISO 3166 alpha-3 codes, e.g. DEU, FRA, POL, ESP. Leave empty for all countries. This is the buyer's country, not the place of performance.

## `cpvPrefixes` (type: `array`):

Optional filter: only notices carrying at least one CPV code that starts with one of these prefixes. CPV is the EU's procurement vocabulary: "45" = construction work, "72" = IT services, "79" = business services, "48" = software packages. Give 2-8 digits; a full 8-digit code matches exactly. Leave empty for all CPV codes.

## `dateFrom` (type: `string`):

Optional explicit window start (ISO date, e.g. "2026-10-01"). Must be given together with Date to, and overrides Publication days back. Useful for one-off corpus pulls (e.g. a quarter of award history).

## `dateTo` (type: `string`):

Optional explicit window end (ISO date, e.g. "2026-10-31"). Must be given together with Date from. Maximum window: 366 days.

## `eventTypes` (type: `array`):

Optional filter on the kind of event each notice represents. NEW = a newly published notice (new tender, prior information notice, qualification system, ...). AWARD = a contract award notice (who won, and for how much). CHANGE = a notice that changes an earlier one — a corrigendum, an update, a cancellation, or a contract modification notice (can-modif); a change record always carries the notice's CURRENT submission deadline. Leave empty for all event types.

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

Optional keyword filter using TED's own full-text search: a notice is delivered when TED's index matches one of your keywords or phrases anywhere in the notice's full text (title, description, buyer, and the rest of the notice body — the full text lives in the notice XML; this Actor ships the main fields only). Up to 20 keywords, combined with OR. Note the difference from a title filter: a keyword can match text a delivered record does not itself contain, and the record's matchedKeywords field lists only the keywords that literally appear in its title, description or buyer name.

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

Hard cap on notices delivered (and charged) in one run. Notices are delivered newest first (highest publication number), so a capped run delivers the most recent matches; capped-out notices stay unseen in monitoring mode and are delivered by the next run if they still fall in its window. Leave at 1000 unless you are pulling a large corpus.

## `maxTotalChargeUsd` (type: `number`):

Optional hard stop for this run's charges: delivery stops as soon as the charged notices reach this amount (checked conservatively at the highest per-notice price, so the run may stop slightly early on discounted tiers), and the SUMMARY record reports stoppedByMaxCharge. Undelivered new notices stay unseen, so the next run delivers them. Leave empty for no cap. The run-level maximum charge in the run options is also honoured exactly.

## `minEstimatedValue` (type: `number`):

Optional: only deliver notices whose estimated value is at least this amount (compared in the notice's own currency — TED values are overwhelmingly in EUR; award notices are compared on their awarded value). Notices that publish no value at all are excluded while this is set.

## `monitorOnlyNew` (type: `boolean`):

Off (default): the first run delivers the window's current notices as a baseline batch (charged), later runs deliver only new ones. On: the first run silently remembers the current notices without delivering or charging anything, and only notices published afterwards are ever delivered. Only applies when a monitor store is selected; without a store every run is a baseline run.

## `monitorStore` (type: `string`):

A key-value store this Actor may read and write to remember which notices it has already seen — this is what makes only-new delivery work across runs. Pick any store you own; the Actor keeps one small state record in it. Without a store, every run delivers the window's notices as a baseline and remembers nothing. If the store is missing or cannot be opened, the run continues in baseline mode and the SUMMARY record says so — it never crashes. The Actor remembers every notice it processed (including ones your filters excluded), so widening the filters later does not re-deliver old notices.

## `publishedSince` (type: `string`):

Optional stateless cursor for workflow tools (Make, Zapier, your own scheduler) that hold state themselves: only notices published on this ISO date or later are delivered — for example "2026-11-01" or "2026-11-01T00:00:00Z". TED publication dates are day-granular, so the cursor compares by day, boundary-inclusive. The cursor raises the window start; it does not extend the window end. Leave empty for the normal window behavior.

## Actor input object example

```json
{
  "backfillDays": 7,
  "buyerCountries": [
    "DEU",
    "FRA"
  ],
  "cpvPrefixes": [
    "45",
    "72"
  ],
  "dateFrom": "2026-10-01",
  "dateTo": "2026-10-31",
  "eventTypes": [
    "NEW",
    "AWARD"
  ],
  "keywords": [
    "software",
    "road construction"
  ],
  "maxResults": 1000,
  "maxTotalChargeUsd": 1,
  "minEstimatedValue": 100000,
  "monitorOnlyNew": false,
  "publishedSince": "2026-11-01"
}
```

# 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 = {
    "backfillDays": 7,
    "maxResults": 500,
    "monitorOnlyNew": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("magnova/eu-ted-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 = {
    "backfillDays": 7,
    "maxResults": 500,
    "monitorOnlyNew": False,
}

# Run the Actor and wait for it to finish
run = client.actor("magnova/eu-ted-tenders-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "backfillDays": 7,
  "maxResults": 500,
  "monitorOnlyNew": false
}' |
apify call magnova/eu-ted-tenders-scraper --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/D5tpIvav2CZBEB1gz/builds/alf5ui9BIJcQKBaYx/openapi.json
