# EU Contract Award Lookup - Who Won the Tender (TED) (`fabriken2026/eu-contract-award-lookup`) Actor

Find who won an EU public tender: buyer, winning supplier, contract value and CPV code. Official TED award data - never scraped.

- **URL**: https://apify.com/fabriken2026/eu-contract-award-lookup.md
- **Developed by:** [David](https://apify.com/fabriken2026) (community)
- **Categories:** Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$400.00 / 1,000 award search (up to 50 results)s

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Contract Award Lookup - Who Won the Tender (TED)

**Verified official source - never hallucinated.** This Actor answers
"who won that contract" questions with award data fetched from **TED
(Tenders Electronic Daily)**, the EU's official public procurement
database, at lookup time - not with an AI model's guess and not with a
scraped snapshot of somebody's website.

### Why this Actor?

Sales teams want to know which contracts their competitors just won.
Bid consultants want to know what winning bids tend to cost in a CPV
category. Market researchers want to track which suppliers dominate a
sector. LLMs will happily invent all three answers. This Actor gives
your agent (or workflow) a deterministic lookup of **contract award
notices** in TED via its official open Search API.

- **No AI in the loop.** Pure, predictable data lookup. Same input,
  same output, every time.
- **No scraping.** Official API only - stable fields, no broken
  selectors, no terms-of-service grey zones.
- **Fresh at the source.** Award data at lookup time, not
  training-data time.
- **Live from day one.** TED's Search API requires no API key at all.
- **Honest about gaps.** Winner or value not published in the notice?
  You get an explicit note - never a guess.

### Features

- **Find who won a public contract** in any EU/EEA country, filtered
  by CPV code, free-text keywords and a date range.
- **See the contract value and currency** when the buyer chose to
  publish it (not every notice includes a value).
- **Get the contracting authority** (buyer) for every award.
- **Country selectable, Sweden by default** - any EU/EEA two-letter
  country code works.
- **Direct link to the official TED notice** on every result, so a
  human can always verify the source.
- **Official TED award data** - no scraping, no third-party databases,
  no AI in the loop. Same input, same output, every time.
- **GDPR-safe by design** - organisation names only (see below).

### Use cases

- **Competitive intelligence:** track which public contracts a named
  competitor has won recently, in which countries and CPV categories.
- **AI agents that must not hallucinate:** give Claude, ChatGPT or any
  MCP/tool-calling agent a grounded source for "who won this tender"
  questions instead of a guess.
- **Sales trigger events:** a fresh contract award is a classic
  outreach signal - target the winner (new budget, new project) or the
  runner-up (still shopping for alternatives).
- **Bid benchmarking:** see what winning bids in a CPV category tend to
  cost before pricing your own tender response.
- **Pairs with company lookups:** combine with our Swedish, Norwegian
  and Finnish Company Lookup Actors to verify that a winner is an
  active company in good standing before you act on the result.
- **Market research:** map which suppliers dominate a sector or country
  over a chosen period.

### Input

```json
{
    "country": "SE",
    "cpvCode": "72",
    "keywords": "cloud",
    "dateFrom": "2026-06-01",
    "dateTo": "2026-07-10",
    "maxResults": 20
}
````

All filters are optional - country alone works ("show me all fresh
awards in Sweden"). Country defaults to Sweden (`SE`); any EU/EEA
two-letter code is accepted. Results come newest first.

### Output (dataset items)

```json
{
    "title": "Sverige - Servrar - IT-utrustning för datacenter",
    "buyer": "Ängelholms kommun",
    "winners": ["Atea Sverige AB"],
    "contractValue": 40000000,
    "contractCurrency": "SEK",
    "cpvCodes": ["48820000", "72000000"],
    "published": "2026-07-09",
    "tedUrl": "https://ted.europa.eu/..."
}
```

Some notices do not publish a winner or a value - those fields come
back explicitly absent with a note, rather than a guessed figure. The
run still succeeds either way, so your pipeline never breaks on an
incomplete notice.

### Pricing (pay-per-event)

| Event | Price | When |
|---|---|---|
| `award-search` | $0.40 | Per successful search (up to 50 awards), regardless of hit count |

Invalid searches are free. No subscription, no minimum. One search
answers questions like "which IT contracts did competitor X win this
year?" that would otherwise take an afternoon of manual digging on
ted.europa.eu.

### FAQ

**Is there a free API for EU procurement awards?**
TED's Search API is free at the source, but you still need query
building (CPV/date/keyword logic), notice-type filtering (awards vs.
open calls) and result parsing. This Actor packages all of that into
one call at $0.40 per search.

**How do I find out who won a specific tender?**
Search by CPV code, keyword or buyer name and date range; each result
includes `winners`, `buyer`, `contractValue` (when published) and a
direct `tedUrl` to the official notice for verification.

**Why is `winners` sometimes missing?**
Not every EU country and buyer publishes the winner's name in the
award notice itself - some only publish the buyer, value and CPV code.
This Actor never guesses a winner; it reports exactly what TED
published.

**Does this cover Sweden only?**
No - Sweden is just the default. Pass any EU/EEA two-letter country
code (e.g. `DE`, `FR`, `FI`, `NO`) to search awards there instead.

**Can my AI agent use this?**
Yes - that is the primary design goal. Call it from any agent
framework via the Apify API or via MCP. The output is small, flat JSON
that fits comfortably in an agent's context window.

**How fresh is the data?**
Every search goes to TED's Search API at run time. You get what TED
has published as of now, not what a model memorised during training.

**Why should I trust these results over an AI web search?**
Because nothing here is generated. Every field is copied from the
official award notice and every result carries a `tedUrl` back to that
notice, so the answer is auditable.

### GDPR & privacy

This Actor handles **organisation-level data only**: winners and
buyers are organisation names exactly as published by the EU in the
official notice. Contact persons and their email addresses, which
exist in TED's underlying data, are **never requested from the source
and never returned**.

### Permissions & security

This Actor runs with Apify's **limited permissions** model: it reads
its own input, writes to its own default dataset and calls TED's
official Search API over HTTPS - nothing else. It requests no access
to your other Actors, storages or account data. No API key or login is
needed anywhere in the chain.

### Data source & license

Data comes from **TED (Tenders Electronic Daily)**, the official EU
public procurement database, via its open Search API. Procurement
notices can be freely reused, for commercial or non-commercial
purposes, under Commission Decision 2011/833/EU; metadata is CC0 1.0.
TED is acknowledged as the source in every result. This Actor is
independent and not affiliated with or endorsed by the European Union
or the Publications Office. Notices cover procurement **above EU
thresholds** (plus voluntary publications); smaller national awards may
be absent. Winner and value are not always published in the notice.

### Terms of use

- **Business use only.** This Actor is intended exclusively for use in
  the course of business (B2B). By using it you confirm you are acting
  as a business, not a consumer.
- **As is.** The service and all data are provided "as is", without
  warranties of any kind - no guarantee of accuracy, completeness,
  timeliness or availability. Always verify details in the official
  notice (the `tedUrl` in every result) before acting on them.
- **Liability cap.** Total aggregate liability for all claims in any
  12-month period is limited to the amount you paid for the service in
  that period. No liability for indirect or consequential damages, lost
  profits, lost business opportunities or lost data. Nothing in these
  terms limits liability that cannot lawfully be limited.
- **Fair use.** No bulk re-selling of raw data, no circumventing rate
  limits, no use that violates TED's terms.

### Versioning & support

Versions are locked - the Actor never silently changes behaviour under
you. Changes are released as new versions with a changelog entry.

Part of the **Nordic Data Tools** family: Swedish company lookup,
company financials, new company registrations, procurement search,
official statistics, Norwegian company lookup and Finnish company
lookup - all built on official Nordic and EU data sources.

#### Changelog

- **0.1** - initial release: contract award search by country (EU/EEA),
  CPV, keywords and date range; winners, buyer, value and official
  link. Pay-per-event pricing.

# Actor input Schema

## `country` (type: `string`):

Buyer country as a two-letter EU/EEA code: <code>SE</code> Sweden (default), <code>FI</code> Finland, <code>DK</code> Denmark, <code>DE</code> Germany, etc.

## `cpvCode` (type: `string`):

EU procurement category code, 2-8 digits. Shorter codes match whole categories: <code>72</code> = IT services, <code>45</code> = construction, <code>90</code> = environmental services.

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

Free-text search in the notices, e.g. a competitor's name or <code>cloud</code>. Letters, digits, spaces and hyphens only - other characters are stripped for safety.

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

Only award notices published on or after this date.

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

Only award notices published on or before this date.

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

How many awards to return (1-50), newest first.

## Actor input object example

```json
{
  "country": "SE",
  "cpvCode": "72",
  "maxResults": 20
}
```

# 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 = {
    "cpvCode": "72"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabriken2026/eu-contract-award-lookup").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 = { "cpvCode": "72" }

# Run the Actor and wait for it to finish
run = client.actor("fabriken2026/eu-contract-award-lookup").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 '{
  "cpvCode": "72"
}' |
apify call fabriken2026/eu-contract-award-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fabriken2026/eu-contract-award-lookup",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EU Contract Award Lookup - Who Won the Tender (TED)",
        "description": "Find who won an EU public tender: buyer, winning supplier, contract value and CPV code. Official TED award data - never scraped.",
        "version": "0.1",
        "x-build-id": "nYgzhM36gTqaaZHhi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fabriken2026~eu-contract-award-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fabriken2026-eu-contract-award-lookup",
                "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/fabriken2026~eu-contract-award-lookup/runs": {
            "post": {
                "operationId": "runs-sync-fabriken2026-eu-contract-award-lookup",
                "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/fabriken2026~eu-contract-award-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-fabriken2026-eu-contract-award-lookup",
                "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": {
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Buyer country as a two-letter EU/EEA code: <code>SE</code> Sweden (default), <code>FI</code> Finland, <code>DK</code> Denmark, <code>DE</code> Germany, etc.",
                        "default": "SE"
                    },
                    "cpvCode": {
                        "title": "CPV code",
                        "type": "string",
                        "description": "EU procurement category code, 2-8 digits. Shorter codes match whole categories: <code>72</code> = IT services, <code>45</code> = construction, <code>90</code> = environmental services."
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Free-text search in the notices, e.g. a competitor's name or <code>cloud</code>. Letters, digits, spaces and hyphens only - other characters are stripped for safety."
                    },
                    "dateFrom": {
                        "title": "Published from (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only award notices published on or after this date."
                    },
                    "dateTo": {
                        "title": "Published to (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only award notices published on or before this date."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many awards to return (1-50), newest first.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
