# UK Public Tenders (`avorelis/uk-public-tenders`) Actor

Find open UK public sector tenders and upcoming contracts from the official Contracts Finder API. Filter by keyword, CPV, region, value and SME suitability.

- **URL**: https://apify.com/avorelis/uk-public-tenders.md
- **Developed by:** [Patrick Karban](https://apify.com/avorelis) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 tender delivereds

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

### What does UK Public Tenders do?

**UK Public Tenders** finds open UK public sector tenders and upcoming pipeline contracts from **Contracts Finder**, the official procurement service of the UK government, and returns them as clean, structured data: title, buyer, CPV industry codes, region, bid deadline, contract value range, SME suitability and a direct link to the notice.

The data comes from the official Contracts Finder API, no scraping of web pages. Notices are published under the Open Government Licence v3.0. Contact names, e-mail addresses, phone numbers and award data are not included.

Typical uses:

- **Daily or weekly tender alerts** for your industry and region, e.g. all new IT, cleaning or construction tenders in London
- **Bid pipelines for SMEs**: tenders marked as suitable for small businesses within your contract size
- **Early preparation** with pipeline notices of contracts buyers plan to tender in the coming months
- **Market research** on public sector demand by region, CPV category and buyer
- **Automations and AI agents** that screen new tenders and draft bid/no-bid decisions

### How to use UK Public Tenders

1. Choose filters: keywords, CPV codes (industry), regions, contract value or SME suitability. All are optional.
2. Set **Published within the last days** to `1` for a daily alert or `7` for a weekly monitor, or leave it empty to get every tender that is still open.
3. Set **Maximum results** to cap the number of tenders and the cost, click **Start**, then export as JSON, CSV or Excel, or schedule the run.

### Input

| Field | Required | Example | Description |
|---|---|---|---|
| `keywords` | no | `software` | Words that must all appear in title, description or buyer name |
| `cpvCodes` | no | `["72"]` | CPV codes, shorter codes include all sub-categories (`72` = IT services, `45` = construction, `90910000` = cleaning) |
| `regions` | no | `["London"]` | UK regions where the contract is delivered |
| `includeNationwide` | no | `true` | With regions selected, also return tenders open to any region (default `true`) |
| `noticeTypes` | no | `["open", "pipeline"]` | `open` = live opportunities (default), `pipeline` = planned contracts |
| `minValue` | no | `100000` | Minimum estimated contract value in GBP |
| `maxValue` | no | `250000` | Maximum estimated contract value in GBP |
| `smeSuitableOnly` | no | `true` | Only tenders marked as suitable for SMEs |
| `publishedWithinDays` | no | `7` | Only tenders published in the last N days |
| `maxItems` | no | `100` | Maximum number of tenders, caps the cost |

Example input for a weekly IT monitor in London:

```json
{
    "cpvCodes": ["72"],
    "regions": ["London"],
    "publishedWithinDays": 7,
    "maxItems": 200
}
```

### Output example

A real record from a test run:

```json
{
    "noticeId": "b0472684-2784-4d0f-855b-ccc800bd6d67",
    "title": "T0222 - Provision of Replacement Heating System at Evesham Hospital",
    "description": "Tenders are invited to bid for Provision of Replacement Heating System at Evesham Community Hospital (Physio & Training Block) for Herefordshire & Worcestershire Health & Care NHS Trust",
    "buyerName": "Herefordshire and Worcestershire Health and Care NHS Trust",
    "noticeType": "open",
    "publishedDate": "2026-09-21T07:22:45.000Z",
    "deadline": "2026-10-16T11:00:00.000Z",
    "approachMarketDate": null,
    "contractStart": "2026-12-01",
    "contractEnd": "2027-03-30",
    "valueLow": 450000,
    "valueHigh": 450000,
    "currency": "GBP",
    "mainCpv": "45210000",
    "cpvCodes": ["45210000"],
    "cpvDescription": "Building construction work",
    "regions": ["West Midlands"],
    "nationwide": false,
    "postcode": "WR5 1JR",
    "latitude": 52.166284,
    "longitude": -2.188162,
    "suitableForSme": true,
    "suitableForVcse": false,
    "noticeUrl": "https://www.contractsfinder.service.gov.uk/Notice/b0472684-2784-4d0f-855b-ccc800bd6d67",
    "source": "Contracts Finder, UK Government. Contains public sector information licensed under the Open Government Licence v3.0."
}
```

#### Output fields

| Field | Description |
|---|---|
| `noticeId` | Contracts Finder notice ID, stable across runs, use it to detect new tenders |
| `title` | Title of the tender |
| `description` | Description, max. 1,500 characters, HTML and contact details removed |
| `buyerName` | Contracting authority, e.g. a council, NHS trust or department |
| `noticeType` | `open` or `pipeline` |
| `publishedDate` | Publication date and time (UTC) |
| `deadline` | Bid deadline (UTC), empty for pipeline notices |
| `approachMarketDate` | Pipeline notices: planned date to go to market |
| `contractStart` | Planned contract start |
| `contractEnd` | Planned contract end |
| `valueLow` | Lower end of the estimated value in GBP |
| `valueHigh` | Upper end of the estimated value in GBP, often empty |
| `currency` | Always GBP when a value is published |
| `mainCpv` | First CPV industry code |
| `cpvCodes` | All CPV industry codes |
| `cpvDescription` | Plain-text name of the CPV codes |
| `regions` | Regions where the contract is delivered |
| `nationwide` | True if open to any region |
| `postcode` | Place of delivery, published for about a third of tenders |
| `latitude` | Latitude of the place of delivery, when known |
| `longitude` | Longitude of the place of delivery, when known |
| `suitableForSme` | Marked as suitable for small and medium-sized enterprises |
| `suitableForVcse` | Marked as suitable for voluntary, community and social enterprises |
| `noticeUrl` | Full notice on Contracts Finder with documents and how to apply |
| `source` | Source and licence attribution |

### How much does it cost?

You pay per delivered tender. The price per 1,000 tenders is shown on the **Pricing** tab. Platform usage is included. Runs that find nothing cost nothing for results, and **Maximum results** plus your own spending limit always cap the cost.

### FAQ

#### Where does the data come from, and may I reuse it?

From the official Contracts Finder API of the UK government. Contracts Finder publishes notices under the Open Government Licence v3.0, which allows commercial reuse with attribution. Keep the `source` field when you republish the data. The Actor uses the official API only, respects its limits and returns no personal contact data.

#### Which tenders are covered?

All open opportunities and pipeline notices on Contracts Finder, mainly contracts from public bodies in England and UK-wide buyers, including many above the procurement thresholds. Scotland and Wales publish most of their tenders on their own portals (Public Contracts Scotland, Sell2Wales), and some above-threshold notices appear only on Find a Tender. Those are not included yet.

#### Why are value and postcode sometimes empty?

Buyers do not always publish them. The Actor returns what Contracts Finder publishes and leaves the field empty otherwise.

#### Why did my run stop early?

Either **Maximum results** or your spending limit was reached. The status message of the run tells you which one.

#### Can I use it through the API or with AI agents?

Yes. Every input field is documented for API and MCP use. Call the Actor with a JSON input like `{"cpvCodes": ["72"], "regions": ["London"]}`.

#### Do you have tenders from other countries?

Yes, [German Public Tenders](https://apify.com/avorelis/german-public-tenders) covers Germany, Austria and other EU countries from the official EU database TED.

#### I found a problem or need another field

Please open an issue on the **Issues** tab. Issues are answered in writing.

# Actor input Schema

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

Words that must all appear in the tender title, description or buyer name, case-insensitive. Example: "cleaning services" or "software". Leave empty for all tenders.

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

CPV industry codes with 2 to 8 digits. Shorter codes include all sub-categories: "72" = IT services, "45" = construction work, "90910000" = cleaning. A tender matches if any of its CPV codes starts with one of yours.

## `regions` (type: `array`):

UK regions where the contract is delivered, for example London or Scotland. Leave empty for the whole UK. Tenders marked as open to any region are included unless you switch off the next option.

## `includeNationwide` (type: `boolean`):

When regions are selected, also return tenders the buyer marked as deliverable in any region. Has no effect when no region is selected.

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

"open" = live opportunities you can bid on now. "pipeline" = contracts the buyer plans to tender soon, useful for early preparation. Default: open only.

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

Only tenders whose estimated value reaches at least this amount in pounds. Tenders without a published value are excluded when this filter is set.

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

Only tenders whose estimated value starts at or below this amount in pounds. Useful for small businesses. Tenders without a published value are excluded when set.

## `smeSuitableOnly` (type: `boolean`):

Return only tenders the buyer marked as suitable for small and medium-sized enterprises.

## `publishedWithinDays` (type: `integer`):

Only tenders published in the last N days, for example 1 for a daily alert or 7 for a weekly monitor. Leave empty for all open tenders.

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

Stop after this many tenders. Each delivered tender is charged once, so this also caps the cost of a run.

## Actor input object example

```json
{
  "keywords": "software",
  "cpvCodes": [
    "72"
  ],
  "regions": [
    "London"
  ],
  "includeNationwide": true,
  "noticeTypes": [
    "open"
  ],
  "minValue": 100000,
  "maxValue": 250000,
  "smeSuitableOnly": false,
  "publishedWithinDays": 7,
  "maxItems": 100
}
```

# 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 = {
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("avorelis/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 = { "maxItems": 100 }

# Run the Actor and wait for it to finish
run = client.actor("avorelis/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 '{
  "maxItems": 100
}' |
apify call avorelis/uk-public-tenders --silent --output-dataset

```

## MCP server setup

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