# Public Tenders API: EU TED & UK Find a Tender, No Login (`conserving_celerytop/eu-uk-public-tenders`) Actor

Search public tenders from TED (EU) and Find a Tender (UK) by keyword, CPV code, country, value and date. $4.00 per 1,000 notices. One row per notice with buyer, CPV codes, deadline and estimated value. New-notice mode, Slack or webhook alerts. MCP-ready, no login or API key.

- **URL**: https://apify.com/conserving\_celerytop/eu-uk-public-tenders.md
- **Developed by:** [Don Mangu](https://apify.com/conserving_celerytop) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 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.
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

## Public Tenders API: EU TED & UK Find a Tender, No Login

This public tenders API searches tender notices from three official sources in one run: **TED** (Tenders Electronic Daily, the EU's Official Journal S), **Find a Tender** (the UK's public procurement notice service) and **Contracts Finder** (UK contracts in England, mostly the smaller ones below the Find a Tender value thresholds). You filter by keywords, CPV codes, buyer country, notice type, estimated value and publication date. It needs no login, no API key and no account on TED, Find a Tender or Contracts Finder.

You get one row per notice: title, short description, buyer organisation and country, CPV codes, procedure type, deadline, estimated value and currency, number of lots, place of performance, whether the buyer marked it suitable for SMEs, and a link to the official notice. Contact persons, e-mail addresses and phone numbers are removed from every row. The price is $4.00 per 1,000 notices.

### Daily tender alerts from TED and Find a Tender

Turn on **Only new notices**, give the search a **monitor name**, schedule it once a day, and each run returns only the notices it has not returned before. Add a Slack webhook or your own webhook URL to get the new notices posted where your bid team works. Small businesses bidding for UK public sector work should add **Contracts Finder** under Sources, because it lists many council, school and NHS contracts that are not published on Find a Tender.

### How to search EU and UK public tenders, step by step

1. Open the Actor and enter one or more **Keywords**, for example `software` or `road maintenance`. A notice matches when it contains any of them.
2. Optionally add **CPV codes** (8 digits, such as `72000000` for IT services) and **Buyer countries** (ISO codes such as `DE`, `FR`, `IE`, `GB`).
3. Keep **Notice types** on Contract notices to get open calls for tenders, or add prior information, award, design contest or modification notices.
4. Set **Published in the last (days)**, for example 1 for a daily alert or 30 for a first market scan.
5. Set **Maximum notices per source** to cap the run and the cost.
6. Click **Start**. Results appear in the Notices table and can be downloaded as JSON, CSV or Excel.
7. For alerts: open **Monitoring and alerts**, turn on **Only new notices**, choose a **Monitor name**, add a Slack or webhook URL if you want pushes, then create a daily schedule for the Actor with this input.

Small businesses bidding for UK public sector work should add **Contracts Finder** under Sources, because it lists many council, school and NHS contracts that are not published on Find a Tender.

### How much does it cost to search public tenders?

The Actor uses pay-per-event pricing: you pay for each notice row delivered, plus the standard Actor start event. Notices that are filtered out, notices already seen by a monitor, and failed requests are not charged.

The price is $4.00 per 1,000 notices ($0.004 per notice) on every plan. Worked example: a daily monitor that returns 25 new notices a day costs 25 x $0.004 = $0.10 per day, about $3.00 per month. A one-off scan of 2,000 contract notices from the last 30 days costs about $8.00. Set a spending limit on the run and the Actor stops cleanly when it is reached.

### Input example for a public tenders search

```json
{
    "keywords": ["software", "cloud hosting"],
    "cpvCodes": ["72000000"],
    "countries": ["DE", "IE", "GB"],
    "noticeTypes": ["contract"],
    "publishedSinceDays": 7,
    "sources": ["ted", "find-a-tender", "contracts-finder"],
    "maxResults": 100,
    "onlyNew": true,
    "monitorName": "it-tenders"
}
```

All input fields:

| Field | Console name | What it does |
|---|---|---|
| `keywords` | Keywords | Words or phrases; a notice matches any one |
| `cpvCodes` | CPV codes | 8-digit CPV codes; children are included |
| `countries` | Buyer countries | Buyer country codes such as DE or GB |
| `noticeTypes` | Notice types | contract, prior, award, contest, modification |
| `publishedSinceDays` | Published in the last (days) | 1 to 365 |
| `sources` | Sources | ted, find-a-tender, contracts-finder (default: ted and find-a-tender) |
| `maxResults` | Maximum notices per source | Per source, up to 10,000 |
| `onlyNew` | Only new notices | Return only notices this monitor has not returned before |
| `monitorName` | Monitor name | Name of the saved search for Only new notices |
| `slackWebhookUrl` | Slack webhook URL | Slack incoming webhook for alerts |
| `webhookUrl` | Webhook URL | Your https endpoint for alerts |
| `valueMin` | Minimum estimated value | Lowest estimated value, notice currency |
| `valueMax` | Maximum estimated value | Highest estimated value, notice currency |

### Output example: one public tender notice

```json
{
    "source": "find-a-tender",
    "noticeId": "040001-2026",
    "url": "https://www.find-tender.service.gov.uk/Notice/040001-2026",
    "title": "Software framework",
    "description": "Framework for software licences. Contact procurement on [phone removed].",
    "buyerName": "Example NHS Trust",
    "buyerCountry": "GBR",
    "cpvCodes": ["72212000"],
    "procedureType": "open: Open procedure",
    "noticeType": "tender",
    "publicationDate": "2026-09-25",
    "deadline": "2026-10-17T12:00:00Z",
    "estimatedValue": 240000,
    "currency": "GBP",
    "lotsCount": 1,
    "placeOfPerformance": "UKE42, United Kingdom",
    "suitableForSme": null,
    "sourceAttribution": "Source: Find a Tender, https://www.find-tender.service.gov.uk. Contains public sector information licensed under the Open Government Licence v3.0."
}
```

| Field | Meaning |
| --- | --- |
| source | `ted`, `find-a-tender` or `contracts-finder` |
| noticeId | Publication number (TED), notice ID (Find a Tender) or notice GUID (Contracts Finder) |
| url | Link to the official notice |
| title, description | Notice title and a short description (up to 500 characters) |
| buyerName, buyerCountry | Buying organisation and its country (ISO 3166 alpha-3 code, such as `DEU` or `GBR`) |
| cpvCodes | CPV codes listed in the notice |
| procedureType, noticeType | Procedure (open, restricted, ...) and notice kind |
| publicationDate, deadline | Publication day, and the earliest deadline for tenders as date and time (for restricted procedures without one, the deadline for requests to participate) |
| estimatedValue, currency | Estimated value as published, in the notice currency (empty when the notice gives none; about half of TED contract notices do not) |
| lotsCount | Number of lots |
| placeOfPerformance | Region or country where the work is done |
| suitableForSme | `true` when the buyer marked the contract as suitable for small and medium-sized enterprises, `false` when not, empty when the notice does not say (always empty for TED) |
| sourceAttribution | Source and licence line for the row |

A `STATS` record in the key-value store lists notices delivered and scanned per source, requests, retries, failed requests, charges and warnings.

### Attribution for TED, Find a Tender and Contracts Finder data

- TED data: Source: TED, Tenders Electronic Daily, (c) European Union, https://ted.europa.eu. Reused under the TED legal notice.
- Find a Tender data: Contains public sector information licensed under the Open Government Licence v3.0.
- Contracts Finder data: Contains public sector information licensed under the Open Government Licence v3.0.

Each row carries the matching line in `sourceAttribution`.

### Related Actors

- [Company Registry Search](https://apify.com/conserving_celerytop/open-company-registries): Use it to look up company records in the GLEIF, Norwegian (Brreg) and Finnish (PRH) registers.
- [Company Name to Domain](https://apify.com/conserving_celerytop/company-name-to-domain): Use it to turn a list of company names into official website domains.
- [Form D Funding Rounds](https://apify.com/conserving_celerytop/form-d-funding-rounds): Use it to find startup and fund raises from SEC Form D filings.
- [Crossref Works Search](https://apify.com/conserving_celerytop/crossref-works-search): Use it to search scholarly works, DOIs and citations on Crossref.

### FAQ about EU and UK public tenders

**Is it legal to use this tender data?** The TED legal notice says notices "can be freely reused, for commercial or non-commercial purposes" (https://ted.europa.eu/en/legal-notice). Find a Tender says "Notice data is available under the Open Government Licence" (https://www.find-tender.service.gov.uk/Developer/Documentation). Every Contracts Finder API answer carries the Open Government Licence v3 as its licence. Rows carry the attribution these terms ask for. This Actor is not affiliated with the Publications Office of the European Union, the UK Cabinet Office or any government body.

**Does it return personal data?** No. Contact persons, e-mail addresses and phone numbers are dropped, and e-mail addresses or phone numbers inside descriptions are replaced with `[email removed]` or `[phone removed]`.

**What are the limits?** Up to 10,000 notices per source per run. Estimated values are shown in the notice currency without conversion; notices without a stated value are left out when you set a value range. Find a Tender and Contracts Finder cover UK notices only, so they are skipped when your countries do not include GB. Some larger UK contracts appear on both Find a Tender and Contracts Finder under different notice IDs, so choose one of the two if you do not want both copies. A Find a Tender search takes about 20 seconds per week of notices searched and looks back at most about 100 days.

**How do CPV codes match?** On all three sources a code covers its children: 72000000 also returns notices listed under 72321000 or 72267200.

**How do keywords match?** On TED, keywords match the full text of the notice in every language it is published in. A phrase such as `cloud hosting` must appear as written. On Find a Tender and Contracts Finder, keywords are matched in the title and description.

**Why did I get zero results?** Widen the keywords, remove a CPV code or a country, or raise the number of days. With Only new notices on, zero means nothing new was published since the last run of that monitor.

**What if a source is slow or refuses requests?** The Actor paces its reads, tries again a few times and waits when a source asks it to. If a source keeps refusing, the Actor stops reading it and says so in the status message and the `STATS` record, and the other sources still run. Contracts Finder asks callers to wait 5 minutes after a refusal, so the Actor stops that source at the first refusal and you can run again later.

# Actor input Schema

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

Enter words or phrases to find in the notice. A notice matches when it contains any one of them. Leave empty to get every notice that passes the other filters.

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

Enter Common Procurement Vocabulary codes, 8 digits, for example 72000000 (IT services) or 45000000 (construction work). A notice matches when it lists any one of them.

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

Enter ISO country codes of the buying organisation, for example DE, FR, IE or GB. Leave empty for all countries. Find a Tender and Contracts Finder are read only when this is empty or includes GB.

## `noticeTypes` (type: `array`):

Choose the kinds of notice to return. Contract notices are open calls for tenders.

## `publishedSinceDays` (type: `integer`):

Return notices published in this many past days.

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

Choose the notice sources to search. Contracts Finder lists UK contracts in England, mostly below the Find a Tender value thresholds.

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

Stop each source after this many notices. Each notice returned is one charged result.

## `onlyNew` (type: `boolean`):

Return only notices this monitor has not returned before. Use it on a daily schedule to get alerts for new tenders.

## `monitorName` (type: `string`):

Name the list of seen notices. Use a different name for each saved search you schedule. Letters, digits and hyphens.

## `slackWebhookUrl` (type: `string`):

Paste a Slack incoming webhook URL to post the notices of each run to a channel.

## `webhookUrl` (type: `string`):

Enter an https URL to receive the notices of each run as JSON (POST, up to 100 notices per call).

## `valueMin` (type: `integer`):

Return notices with an estimated value of at least this amount, in the notice currency (no conversion). Notices without a stated value are left out when you set a value range.

## `valueMax` (type: `integer`):

Return notices with an estimated value of at most this amount, in the notice currency.

## Actor input object example

```json
{
  "keywords": [
    "software"
  ],
  "noticeTypes": [
    "contract"
  ],
  "publishedSinceDays": 3,
  "sources": [
    "ted",
    "find-a-tender",
    "contracts-finder"
  ],
  "maxResults": 10,
  "onlyNew": false,
  "monitorName": "default"
}
```

# Actor output Schema

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

Dataset items, one per notice: source, noticeId, url, title, description, buyerName, buyerCountry, cpvCodes, procedureType, noticeType, publicationDate, deadline, estimatedValue, currency, lotsCount, placeOfPerformance, suitableForSme and sourceAttribution.

## `stats` (type: `string`):

JSON record with notices delivered and scanned per source, requests, retries, failed requests, charges, alerts sent, warnings and errors.

# 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"
    ],
    "noticeTypes": [
        "contract"
    ],
    "publishedSinceDays": 3,
    "sources": [
        "ted",
        "find-a-tender",
        "contracts-finder"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("conserving_celerytop/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 = {
    "keywords": ["software"],
    "noticeTypes": ["contract"],
    "publishedSinceDays": 3,
    "sources": [
        "ted",
        "find-a-tender",
        "contracts-finder",
    ],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("conserving_celerytop/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 '{
  "keywords": [
    "software"
  ],
  "noticeTypes": [
    "contract"
  ],
  "publishedSinceDays": 3,
  "sources": [
    "ted",
    "find-a-tender",
    "contracts-finder"
  ],
  "maxResults": 10
}' |
apify call conserving_celerytop/eu-uk-public-tenders --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,conserving_celerytop/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/pCCvFAySFmSxbl0B4/builds/AOozu9O3jv3Dfb4x1/openapi.json