# EU & UK Tender Scraper: TED, Find a Tender, Contracts Finder (`fecklesspleb/eu-uk-public-tenders`) Actor

Public procurement notices from the official TED (EU), Find a Tender and Contracts Finder (UK) APIs in one schema: title, buyer, CPV, value, deadline, winners. Dedupe, CPV/country/value filters. Ausschreibungen, appels d'offres, licitaciones, gare d'appalto, przetargi, aanbestedingen. Unofficial.

- **URL**: https://apify.com/fecklesspleb/eu-uk-public-tenders.md
- **Developed by:** [Scott Williams](https://apify.com/fecklesspleb) (community)
- **Categories:** Business, Lead generation, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 tender 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 & UK Public Tenders: TED, Find a Tender, Contracts Finder

Get new public procurement notices from three official, keyless government APIs in **one clean schema**:

- **TED** (Tenders Electronic Daily, the EU Official Journal S series): about 2,000 tenders and 1,700 award notices every working day from EU/EEA buyers.
- **Find a Tender** (UK, above-threshold contracts).
- **Contracts Finder** (UK, including lower-value contracts from about £12,000 / £30,000).

Each result tells you **what is being bought, by whom, for how much, by when**, and for award notices **who won and at what value**, with a link to the official notice.

Typical uses: daily bid alerts for a CPV family (e.g. `72` IT services), competitor win tracking, public-sector sales prospecting, market sizing.

**Not affiliated with** or endorsed by the European Union, the Publications Office of the EU, the UK Cabinet Office or Crown Commercial Service. This Actor only reads their published open-data APIs.

### How it works

- Reads the official search APIs for the date window you choose (by default, yesterday and today, UK date).
- Pick the **stages** you want: `tender` (open for bids), `award` (winners) and `planning` (prior information).
- Filters: keywords, CPV prefixes, TED buyer countries, minimum value, open tenders only.
- **Only new notices:** on a daily schedule, every notice is returned once. The Actor remembers up to 100,000 notice ids per `stateKey`.
- **Sources are read side by side**, so TED's volume cannot crowd out the UK sources before `maxItems` is reached.
- **Polite by design:** TED gets 2 requests a second (its fair-use limit is 700 a minute), Find a Tender gets 1 request every 2 seconds, Contracts Finder 1 a second. The Actor backs off on 429 using the Retry-After header (seconds or HTTP date, capped at 5 minutes; 30 s if the header is missing), backs off on 5xx, and honours Contracts Finder's documented 5-minute pause after a 403.

### Input example

```json
{
  "sources": ["ted", "find_a_tender", "contracts_finder"],
  "stages": ["tender"],
  "mode": "latest",
  "lookbackDays": 1,
  "cpvPrefixes": ["72", "48"],
  "keywords": ["software", "cloud"],
  "tedBuyerCountries": ["DEU", "FRA", "IRL"],
  "openOnly": true,
  "maxItems": 100
}
```

**Backfill:** set `"mode": "date_range"` with `startDate` and `endDate` (up to 92 days per run).

### Output example

```json
{
  "source": "find_a_tender",
  "noticeId": "102342-2026",
  "stage": "award",
  "noticeType": "award,contract",
  "title": "Midlands - FRAM lot 9c - Client Support Services",
  "buyerName": "ENVIRONMENT AGENCY",
  "buyerCountry": "GBR",
  "cpvCodes": [
    "72224000"
  ],
  "valueAmount": null,
  "valueIncludesVat": null,
  "deadline": null,
  "publishedDate": "2026-10-29",
  "awardedSuppliers": [
    "Mott MacDonald Limited"
  ],
  "awardValue": 927190.7,
  "awardCurrency": "GBP",
  "noticeUrl": "https://www.find-tender.service.gov.uk/Notice/102342-2026",
  "licence": "Open Government Licence v3.0"
}
```

See `sample_output.json` for full records from a live run.

**Fields:** `source`, `sourceCountry` (EU for TED, GBR for the UK services), `noticeId`, `procedureId`, `noticeVersion`, `stage`, `noticeType`, `title`, `titleTranslated` (TED's label "<Country> – <CPV subject> – <title>" in the preferred language, else English; only the country and subject are translated, the title part stays in the notice's original language), `description` (up to 5,000 characters), `buyerName`, `buyerCountry` (ISO 3166 alpha-3), `buyerCity`, `buyerRegion`, `buyerWebsite`, `cpvCodes`, `mainCpv`, `unspscCodes` (always empty for these sources; kept for a stable schema), `contractNature`, `procedureType`, `valueAmount`, `valueCurrency`, `valueIncludesVat`, `deadline`, `publishedDate`, `placeOfPerformance`, `awardedSuppliers`, `awardValue`, `awardCurrency`, `suitableForSme`, `suitableForVcse` (Contracts Finder), `language`, `noticeUrl`, `dataUrl`, `licence`, `parseError` and `scrapedAt`.

- **Value fields:** `valueAmount` is the buyer's estimated value of the procedure and `awardValue` the awarded/contract value, both in the notice's own currency (`valueCurrency`, `awardCurrency`). `valueIncludesVat` (UK only) is `true` when the notice published only a VAT-inclusive amount (`amountGross`, common on Procurement Act 2023 notices) and `false` for a net amount.
- **Blank values are blank at the source.** Many notices publish no value, and the Actor never imputes one. Checked against the raw APIs on 2026-10-28: Find a Tender award notices put no estimate on the tender (use `awardValue`), some Find a Tender `tenderUpdate` and award releases have no `value` anywhere (tender, lots, awards, contracts), and about half of TED competition notices have no `estimated-value-proc` or lot values. In a 120-notice live run, 63 had `valueAmount` and 74 of 87 awards had `awardValue`. Filter on `minValue` only if you are happy to drop notices with no published value.
- **Supplier privacy (Find a Tender, Contracts Finder):** many UK contracts go to sole traders. A supplier name is shown when it reads as an organisation: any legal form (Ltd, Limited, LLP, LLC, Inc, plc, Corp, Partners, Solicitors, & Co, GmbH ...) is always kept, as are organisation words (University, Council, Services, Joinery, Taxis ...) and a list of known firms whose names carry no such word. For "<name> t/a <business>" only the business name is shown. Other names, family trusts, "& Others" and names with an honorific (Mr, Mrs, Dr ...) are replaced by `[withheld: possible individual]`. In a 3-day live award sample 2 of 253 Find a Tender and 3 of 241 Contracts Finder names were withheld. It is a heuristic: a practice name that itself contains a person's name can still pass. TED winner names are passed through as published.
- **Deadline format:** TED gives a date; the UK sources give a date and time in UTC.
- **Buyer contact:** turn on `includeBuyerContact` to add `buyerContact` with the authority's published email and phone. It is off by default. Person names are never output, and supplier contacts are never collected.

Each run also writes a `RUN_SUMMARY` record with notices read, pushed, filtered out, skipped as already seen and skipped as duplicates, per source, plus a `rateLimited` count of 429 answers.

### Price

**Pay per result:** $0.002 per notice saved ($2 per 1,000). There is no start fee and no charge for the dataset item itself. Set **Max cost per run** in the Apify Console and the Actor stops cleanly when it is reached.

Empty input `{}` and the prefilled input stop at **4 notices** (the **Max notices** default), so they cost at most $0.008. Raise **Max notices** for a fuller feed.

### Use with AI agents / MCP

AI agents can run this Actor as a tool through [Apify's MCP server](https://docs.apify.com/platform/integrations/mcp). Add this server URL to your MCP client (Claude, Cursor, VS Code, OpenAI Agents SDK, LangChain and others) and sign in with OAuth, or send your Apify token as `Authorization: Bearer <token>`:

```text
https://mcp.apify.com?tools=fecklesspleb/eu-uk-public-tenders
```

The tool is named `fecklesspleb--eu-uk-public-tenders`. Agents can also find it with `search-actors` and run it with `call-actor`. The run returns a dataset ID; read the notices with `get-dataset-items`, and pass `fields` (for example `source,sourceCountry,stage,publishedDate,title,buyerName,buyerCountry,mainCpv,valueAmount,valueCurrency,deadline,noticeUrl`) to keep the response small.

Minimal tool input (TED + UK sources, IT/software CPV prefixes, open tenders only, one notice):

```json
{"sources": ["ted", "find_a_tender", "contracts_finder"], "stages": ["tender"], "mode": "latest", "lookbackDays": 1, "cpvPrefixes": ["72", "48"], "openOnly": true, "maxItems": 1}
```

One shortened row from the Actor's bundled `sample_output.json` (live notices scraped 29 October 2026 UTC):

```json
{
  "source": "ted",
  "sourceCountry": "EU",
  "stage": "tender",
  "publishedDate": "2026-10-28",
  "title": "Beschaffung Rugged-Windows-Tablets inkl. Zubehör",
  "buyerName": "Flughafen Wien AG",
  "buyerCountry": "AUT",
  "mainCpv": "30213200",
  "valueAmount": null,
  "valueCurrency": null,
  "deadline": "2026-11-09",
  "noticeUrl": "https://ted.europa.eu/en/notice/-/detail/745241-2026"
}
```

Tips for agents:

- Cost is $0.002 per notice saved (`tender-notice` event). There is no Actor-start fee. Always set `maxItems`, and set `maxTotalChargeUsd` in the run options (`callOptions` in `call-actor`) to cap a run.
- Empty input `{}` and the Console prefills stop at 4 notices ($0.008). Raise `maxItems` only when you need a fuller feed.
- Filter with `stages`, `cpvPrefixes`, `keywords`, `tedBuyerCountries`, `minValue` and `openOnly` so fewer notices are returned and charged.
- Status rows (`recordType: "status"`) are free and uncharged; filter them out when you only want notices.
- Prefer `fields` on `get-dataset-items` so long `description` and nested buyer fields do not fill the context window.

### FAQ and limits

- **Duplicates across OCDS sources:** within a run, each procedure is saved and charged once per stage: Find a Tender and Contracts Finder notices are matched by a source-independent key (OCID, or the notice ID when there is no OCID, plus the stage) before charging. Find a Tender updates (`tenderUpdate`) for a procedure already saved in the same run are skipped too. An amendment published on a later day is a new notice and is returned on that day's run. The first notice seen wins; skipped ones are counted as `duplicates` in `RUN_SUMMARY`. A tender and its later award are different stages and both kept. The two services usually issue different OCID prefixes, so a notice republished on both under different OCIDs is not matched.
- **Updates:** Find a Tender returns every release in the window, including tender updates and cancellations. These map to the `tender` stage; `noticeType` keeps the original tag.
- **Country filter:** `tedBuyerCountries` filters TED on the server. The UK sources are always UK buyers (`GBR`).
- **minValue** compares amounts in each notice's own currency (EUR, GBP); nothing is converted.
- **Language:** TED texts are multilingual. `language` picks your preferred one where present; otherwise the notice's own language is used.
- **Bid documents** are not downloaded; follow `noticeUrl`.
- **Formats differ by source:** TED gives `deadline` as a date (`2026-11-30`) and the notice `language` as an ISO 639-3 code (`DEU`); the UK sources give an ISO datetime (`2026-11-30T12:00:00Z`) and an ISO 639-1 code (`en`).
- **CPV codes:** UK award notices under the Procurement Act 2023 often carry CPV codes only on the awarded items; these are included in `cpvCodes`.
- **Source down:** if one source (or all of them) cannot be reached or answers with errors and no notices were saved, the run still succeeds and the dataset gets one free record (`recordType: "status"`, message starting "Not charged") explaining what failed. `status` is `"error"` when every source failed and `"warning"` when only some did; `failedSources` and `errors` name them. It is not charged. Data records have no `recordType`.
- **Nothing new or nothing matching:** a run that saves no notice still ends with one free record (`recordType: "status"`, `status: "warning"`, not charged). "Not charged: no new items since last run" means every notice in the window was already delivered by an earlier run with the same `stateKey` (set `onlyNewSinceLastRun` to `no` or use another `stateKey` to get them again). "Not charged: no matching notices in the selected window" means the window had nothing that passed your input; `filteredBy` counts what each filter cut, for example the default `stages` (`tender` only). Neither record is written when at least one notice was saved.

### Data licences and attribution

- **TED notices:** © European Union, reused under Commission Decision 2011/833/EU. Acknowledge the source and do not distort the original meaning.
- **Find a Tender and Contracts Finder:** contain public sector information licensed under the Open Government Licence v3.0, © Crown copyright.

# Changelog

This Actor's version history is a separate document: https://apify.com/fecklesspleb/eu-uk-public-tenders/changelog.md

# Actor input Schema

## `sources` (type: `array`):

Which official services to read. They are read side by side (one notice from each in turn) until maxItems is reached.

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

Tender = contract notices you can bid on. Award = award and contract notices with winning suppliers. Planning = prior information and pipeline notices.

## `mode` (type: `string`):

Latest reads today plus the previous lookbackDays days; with 'only new' on (the default here) a daily schedule returns each notice once. Date range reads a fixed window of up to 92 days.

## `lookbackDays` (type: `integer`):

0 = today only. 1 = yesterday and today (recommended for a daily schedule).

## `startDate` (type: `string`):

First publication date (YYYY-MM-DD). Required in date range mode.

## `endDate` (type: `string`):

Last publication date (YYYY-MM-DD). Defaults to today (UK date).

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

Keep notices whose title or description contains any of these words or phrases (case-insensitive). TED titles also carry an English machine-generated title, so English words find most EU notices. Empty = all.

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

Keep notices with any CPV code starting with one of these, e.g. 72 (IT services), 45 (construction), 33 (medical equipment). Empty = all.

## `tedBuyerCountries` (type: `array`):

TED only: 3-letter ISO codes of the buyer's country, e.g. DEU, FRA, IRL, POL. Sent to the TED API as a filter. UK sources are not affected. Empty = all.

## `minValue` (type: `number`):

Keep notices whose published value (award value for award notices) is at least this, in the notice's own currency. Notices with no published value are dropped when this is set. Amounts are not converted: TED is mostly EUR, UK GBP.

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

Keep only tender-stage notices whose submission deadline is today or later.

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

TED texts are multilingual. Values in this language are used when the notice has them; otherwise the notice's own language.

## `includeBuyerContact` (type: `boolean`):

Adds buyerContact {email, telephone} as published by the contracting authority. Off by default. Person names are never output, and supplier contact details are never collected.

## `onlyNewSinceLastRun` (type: `string`):

auto = on in Latest mode, off in Date range mode. Remembers up to 100,000 notice ids per stateKey.

## `stateKey` (type: `string`):

Keeps the 'only new' memory of different schedules apart (letters, digits, - and \_).

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

Stop after saving this many notices (each one is a charged result). Default 4 (at most $0.008). Raise it for a fuller feed.

## `maxPagesPerSource` (type: `integer`):

Safety cap on API pages read from each source (TED pages hold 250 notices, UK pages 100).

## Actor input object example

```json
{
  "sources": [
    "ted",
    "find_a_tender",
    "contracts_finder"
  ],
  "stages": [
    "tender"
  ],
  "mode": "latest",
  "lookbackDays": 1,
  "startDate": "2026-10-01",
  "endDate": "2026-10-27",
  "keywords": [
    "software",
    "cloud",
    "cyber security"
  ],
  "cpvPrefixes": [
    "72",
    "48"
  ],
  "tedBuyerCountries": [
    "DEU",
    "FRA",
    "IRL"
  ],
  "minValue": 100000,
  "openOnly": true,
  "language": "eng",
  "includeBuyerContact": false,
  "onlyNewSinceLastRun": "auto",
  "stateKey": "default",
  "maxItems": 4,
  "maxPagesPerSource": 200
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "sources": [
        "ted",
        "find_a_tender",
        "contracts_finder"
    ],
    "stages": [
        "tender"
    ],
    "mode": "latest",
    "lookbackDays": 1,
    "cpvPrefixes": [
        "72",
        "48"
    ],
    "openOnly": true,
    "maxItems": 4
};

// Run the Actor and wait for it to finish
const run = await client.actor("fecklesspleb/eu-uk-public-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 = {
    "sources": [
        "ted",
        "find_a_tender",
        "contracts_finder",
    ],
    "stages": ["tender"],
    "mode": "latest",
    "lookbackDays": 1,
    "cpvPrefixes": [
        "72",
        "48",
    ],
    "openOnly": True,
    "maxItems": 4,
}

# Run the Actor and wait for it to finish
run = client.actor("fecklesspleb/eu-uk-public-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 '{
  "sources": [
    "ted",
    "find_a_tender",
    "contracts_finder"
  ],
  "stages": [
    "tender"
  ],
  "mode": "latest",
  "lookbackDays": 1,
  "cpvPrefixes": [
    "72",
    "48"
  ],
  "openOnly": true,
  "maxItems": 4
}' |
apify call fecklesspleb/eu-uk-public-tenders --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fecklesspleb/eu-uk-public-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/dyWyCyO3AXL67MAPE/builds/dkxsuszBlGSGtsQLs/openapi.json