# EU Tenders (TED): Contract Notices and Awards API (`studded_lantana/ted-tenders`) Actor

Returns EU public procurement notices from TED as flat JSON: title, buyer, country, CPV codes, estimated value, deadline, open flag, awarded value and winning companies. Filter by country, keyword, CPV, value and date.

- **URL**: https://apify.com/studded_lantana/ted-tenders.md
- **Developed by:** [amit ashkenazi](https://apify.com/studded_lantana) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 notices

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 Tenders (TED): Contract Notices and Awards API

**What it does:** returns European public procurement notices from **TED** (Tenders Electronic Daily, the EU's official journal for public contracts) as flat JSON records: title, an English headline, buyer, buyer country and city, CPV codes, estimated value and currency, tender deadline, whether it is still open, and the official notice link. For contract award notices it also returns the awarded value and the winning companies. Filter by country, full-text keyword, CPV code, value, date and "still open".

Why use it instead of scraping the TED website: it reads the official, documented TED Search API of the EU Publications Office, so there is no HTML parsing to break. TED's raw data uses nested, multilingual fields with one entry per lot; this Actor flattens each notice into one record with one value per field and picks your preferred language.

### Use cases

- **Find EU government contracts to bid on.** Get a daily or weekly list of open calls for tenders in your sector and countries, with deadline, estimated value and buyer.
- **See who won.** Pull contract award notices to track which companies win public contracts in which countries, and for how much.
- **Watch the pipeline.** Prior information notices show what buyers plan to procure before the tender opens.
- **Feed other tools.** Results are plain JSON records, so they drop into a spreadsheet, a CRM, a Slack alert or an AI agent.

### Input

```json
{
  "stages": ["competition"],
  "daysBack": 7,
  "countries": ["DE", "AT"],
  "keywords": ["software", "cloud hosting"],
  "cpvCodes": ["72000000"],
  "minValue": 100000,
  "valueCurrency": "EUR",
  "openOnly": true,
  "language": "eng",
  "maxItems": 200
}
```

- `stages`: `competition` (calls for tenders, default), `planning` (prior information notices), `result` (contract award notices).
- `daysBack` (1–31, default 7), or `dateFrom` / `dateTo` (`YYYY-MM-DD`, inclusive, at most 31 days apart). Dates are TED **publication** dates.
- `countries`: buyer countries as ISO codes, two or three letters (`DE` or `DEU`).
- `keywords`: TED full-text search over the whole notice. A notice matches if any keyword or phrase appears. Notices are in the buyer's language, so add translations as separate entries.
- `cpvCodes`: keeps a notice if any of its CPV codes falls under one of these. Trailing zeros widen the match: `72000000` matches all of 72xxxxxx (IT services) and `45` all construction work.
- `minValue` / `maxValue` with `valueCurrency` (default `EUR`): compared with the estimated value, or with the awarded value when no estimate is published. There is no currency conversion: notices in other currencies, or with no value, are dropped when you set either one.
- `openOnly`: keeps only notices whose tender deadline is still in the future.
- `language`: preferred language for title, description, buyer name and city (3-letter code such as `eng`, `deu`, `fra`). Falls back to English, then to the notice's own language.
- `maxItems` (default 200), `maxPages` (default 20; each page scans up to 100 notices).

### Output

One record per notice. A real example (call for tenders published 2026-10-08, fetched 2026-10-11; description shortened here):

```json
{
  "publication_number": "692801-2026",
  "form_type": "competition",
  "notice_type": "cn-standard",
  "publication_date": "2026-10-08",
  "title": "Request for Tenders for the Provision of an Airlifting Service of Materials at Connemara National Park; Wild Nephin National Park; and Burren National Park",
  "headline_en": "Ireland – Hire of helicopters with crew – Request for Tenders for the Provision of an Airlifting Service of Materials at Connemara National Park; Wild Nephin National Park; and Burren National Park",
  "description": "The National Parks and Wildlife Service (NPWS) intends to engage the professional services of a suitably qualified and experienced supplier to participate in a Single Party Framework Agreement for the...",
  "buyer_name": "Department of Housing Local Government and Heritage",
  "buyer_country": "IRL",
  "buyer_city": "Wexford",
  "cpv_codes": ["60424120", "60400000"],
  "contract_nature": ["services"],
  "procedure_type": "open",
  "place_of_performance": ["IE042", "IRL"],
  "estimated_value": 1500000.0,
  "estimated_value_currency": "EUR",
  "tender_deadline": "2026-11-10T17:00:00+01:00",
  "is_open": true,
  "awarded_value": null,
  "awarded_value_currency": null,
  "winners": [],
  "winner_countries": [],
  "winners_withheld": 0,
  "url": "https://ted.europa.eu/en/notice/-/detail/692801-2026",
  "fetched_at": "2026-10-11T04:27:24Z"
}
```

A contract award notice (`stages: ["result"]`) from the same day has, for example, `"awarded_value": 509561.0`, `"awarded_value_currency": "EUR"`, `"winners": ["Rosenbauer Deutschland GmbH", "Wolfgang Jahn GmbH"]`, `"winner_countries": ["DEU"]`.

| Field | Meaning |
|---|---|
| `publication_number` | TED notice number, e.g. `692801-2026` |
| `form_type`, `notice_type` | Stage (`competition`, `planning`, `result`) and TED notice type (e.g. `cn-standard`, `can-standard`, `pin-only`) |
| `publication_date` | Date the notice was published on TED |
| `title`, `description` | Procedure title and description in your preferred language when available. Descriptions are cut at 3,000 characters; email addresses and phone numbers are replaced with `[email removed]` / `[phone removed]` |
| `headline_en` | TED's English headline: country – main CPV category – title |
| `buyer_name`, `buyer_country`, `buyer_city` | The contracting authority (country as ISO 3-letter code) |
| `cpv_codes` | All CPV codes on the notice and its lots |
| `contract_nature`, `procedure_type` | `works` / `supplies` / `services`; procedure such as `open`, `restricted`, `neg-w-call` |
| `place_of_performance` | NUTS region and country codes where the work is done |
| `estimated_value`, `estimated_value_currency` | Estimated value of the procedure, when the buyer published it |
| `tender_deadline`, `is_open` | Earliest lot deadline for tenders (date-time with the buyer's UTC offset), and whether it is still in the future at fetch time |
| `awarded_value`, `awarded_value_currency` | Award notices: total value of the awarded contracts |
| `winners`, `winner_countries` | Award notices: winning companies that are clearly organisations, and the winners' countries |
| `winners_withheld` | Award notices: how many winners were not named, because they may be individuals (see Limits) |
| `url` | The official TED notice page |

### FAQ

**How do I get EU tenders as JSON or CSV?**
Run the Actor with the filters you want. Results land in an Apify dataset, which you can download as JSON, CSV or Excel, or read through the Apify API.

**What is TED?**
Tenders Electronic Daily is the online version of the Supplement to the Official Journal of the EU. Public buyers in the EU and EEA must publish contracts above the EU thresholds there. This Actor reads it through the official TED Search API.

**How do I get only IT or software tenders in Germany?**
Set `countries` to `["DE"]` and `cpvCodes` to `["72000000", "48000000"]` (IT services and software packages). Add `openOnly: true` to see only tenders you can still bid on.

**Can I see which company won a contract?**
Yes. Set `stages` to `["result"]`. Each record has `awarded_value` and a `winners` list. Winners that may be individuals are counted but not named (see Limits).

**How do I get new EU tenders every day?**
Create an Apify schedule that runs the Actor daily with `daysBack: 2`. `daysBack` counts calendar days in UTC including today, so `1` means today only. With `2` each notice appears on two consecutive runs; use `publication_number` to skip the ones you have already seen.

**Why do keyword searches miss some notices?**
Notices are written in the buyer's language. Add each keyword in the languages you need, e.g. `["software", "Software", "logiciel", "oprogramowanie"]`, or filter by CPV code, which is language-independent.

**Does it return contact details?**
No. Contact names, emails, phone numbers and addresses are never requested from TED. Each record links to the official notice.

### Pricing

Pay per event:

- **$0.005 per run** (start).
- **$0.002 per notice** returned, so $2 per 1,000 notices.

You only pay for notices that match your filters. Notices scanned and filtered out are free. Set a maximum charge per run in Apify to cap spend.

### Limits

- Date range: at most 31 days per run. For longer histories, run once per month.
- A run stops after `maxPages` pages of 100 notices (default 20). TED publishes about 1,900 calls for tenders and 1,400 award notices per working day (Sep–Oct 2026), so wide runs without filters stop early; the log says when.
- Values, deadlines, CPV codes and cities are only present when the buyer published them. Value filters do not convert currencies.
- `tender_deadline` is the earliest deadline across the notice's lots.
- Winner names are returned only when the winner is clearly an organisation: its name carries a legal-entity form (GmbH, AG, S.A., S.p.A., SRL, Sp. z o.o., s.r.o., d.o.o., Ltd, Oy, AB and similar) or it is a public body (university, hospital, municipality...). Other winners may be sole traders or other individuals, so they are counted in `winners_withheld` but not named. Their names are on the official notice (`url`). In 1,000 award notices published 1–9 October 2026, 591 of 1,803 winners (33%) were withheld; companies that omit their legal form from their name are withheld too.
- Partnerships named after their partners (such as German GbR or Polish spółka jawna) are withheld, because their names are people's names.
- Source: TED, © European Union, reused under the TED legal notice. This Actor is not affiliated with or endorsed by the EU Publications Office.

# Actor input Schema

## `stages` (type: `array`):

Which kind of TED notice to return. competition = open calls for tenders you can bid on (default). planning = prior information and pipeline notices, before a tender opens. result = contract award notices with the awarded value and the winning companies; use this to see who won.

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

Notices published on TED in the last N days, including today (UTC). TED publishes on working days: about 1,900 calls for tenders and 1,400 award notices a day (Sep-Oct 2026). For a daily check use 2 and skip notices already seen; use 7 for a weekly one. Maximum 31. Ignored if Date from is set.

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

Optional start of a fixed publication period, as YYYY-MM-DD (e.g. "2026-09-01"). Use it with Date to instead of Days back. The period can be at most 31 days; for a longer history, run once per month.

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

Optional. YYYY-MM-DD, inclusive. Defaults to today (UTC).

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

Keep notices whose buyer is in these countries, as ISO codes, two or three letters, e.g. \["DE", "FR"] or \["DEU", "FRA"]. Covers EU and EEA countries plus others that publish on TED, such as the UK, Switzerland and EU candidate countries. Leave empty for all countries.

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

Full-text search across the whole notice in any language, e.g. \["software", "cloud hosting"]. A notice matches if at least one keyword or phrase appears. Notices are written in the buyer's language, so add translations as separate entries (e.g. "Software", "logiciel"). Letters, digits, spaces and . , & ' - only.

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

Keep notices in these procurement categories (CPV codes). Trailing zeros widen the match, so a division code covers everything under it: "72000000" IT services, "48000000" software packages, "45000000" construction work, "33000000" medical equipment, "79000000" business services. A short prefix such as "45" works too. Leave empty for all categories.

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

Keep notices whose estimated value (awarded value when no estimate is published) is at least this amount in the Value currency, e.g. 100000. Notices without a value, or with a value in another currency, are dropped when this is set, so leave it empty for the fullest list.

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

Keep notices whose estimated value (awarded value when no estimate is published) is at most this amount in the Value currency, e.g. 1000000. Notices without a value, or in another currency, are dropped when this is set.

## `valueCurrency` (type: `string`):

Currency for Minimum and Maximum value, as a 3-letter code, e.g. "EUR", "PLN", "SEK", "CZK". No conversion is done: only notices published in this currency are compared. Default EUR.

## `openOnly` (type: `boolean`):

Set to true to keep only notices whose tender deadline is still in the future, i.e. calls for tenders that can still be bid on. Use it with the competition stage.

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

3-letter code of the language you prefer for title, description, buyer name and city, e.g. "eng", "deu", "fra". When a notice is not published in it, English is used, then the notice's own language. headline_en is always English.

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

Stop after this many matching notices. You are charged per notice returned, so this also caps the cost of the run.

## `maxPages` (type: `integer`):

Advanced; the default is fine for most runs. How many TED result pages (up to 100 notices each) to scan before stopping. Lower it to bound run time on wide date ranges without filters.

## Actor input object example

```json
{
  "stages": [
    "competition"
  ],
  "daysBack": 7,
  "keywords": [
    "software"
  ],
  "valueCurrency": "EUR",
  "openOnly": false,
  "language": "eng",
  "maxItems": 200,
  "maxPages": 20
}
```

# Actor output Schema

## `notices` (type: `string`):

One record per TED notice: buyer, country, CPV codes, estimated value, deadline, awarded value, winning companies and notice URL.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("studded_lantana/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 = { "keywords": ["software"] }

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

```

## MCP server setup

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

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/JrpZIfmbNaPa4Db0x/builds/v3HcdXOZrds7xwD4r/openapi.json