# UK Public Contracts & Tenders Finder (`likeable_seal/uk-public-contracts-finder`) Actor

Find UK public sector contract notices worth money. Reads the government's official OCDS feed and returns each notice as a lead: contract value, CPV industry code, buyer organisation, deadline, and the buyer's direct contact details.

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

## Pricing

from $6.00 / 1,000 contract 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

## UK Public Contracts & Tenders Finder

**Get every UK public sector contract notice as a structured, filtered list, with the buyer's
email address attached.**

UK councils, NHS trusts, schools and government agencies publish around **1,800 contract
notices every month**. Each one says what is being bought, what it is worth, when it closes,
and, in every single case, **who to contact about it**.

This Actor reads those notices from the government's own open-data feed and gives you one
clean row per contract, ready to paste into a spreadsheet, a CRM or a bid tracker.

- 🔎 **Filter by what matters**: contract value, industry code (CPV), buyer name, keyword
- 📧 **The buyer's email is included**: every notice measured carried one (696 of 696 over a seven-day pull), plus a phone number on 61%
- 💷 **Real numbers**: median contract value £90,000; 48% are over £100k
- 🏛️ **Every stage**: open tenders, awards, and early planning notices
- 🔗 **The official notice link** on every row, so you can verify anything
- 🆓 **No API key, no browser, no login, no scraping gymnastics**

***

### What can this Actor do?

- **Find contracts to bid on** in your sector and region, with the buyer named and reachable
- **Track a customer's buying activity**: see what an organisation is about to spend on
- **Build a list of public-sector buyers** who are actively spending money
- **Do market research** on public spending by industry, region or buyer type
- **Watch for new opportunities** by scheduling a daily run and diffing what comes back

#### What data can you extract from Contracts Finder?

One row per notice, with:

| | |
|---|---|
| **What is being bought** | title, full description, procurement method, status |
| **What it is worth** | contract value and currency (as published by the buyer) |
| **Who is buying it** | organisation name, unique identifier, full postal address |
| **How to reach them** | contact email, phone number, website |
| **What kind of work it is** | CPV industry code and description, plus all additional codes |
| **When it closes** | bid deadline, and whether it is still open |
| **Where it goes** | delivery postcodes, regions and countries |
| **Whether SMEs can bid** | the buyer's own suitability flag |
| **The proof** | the official Contracts Finder notice URL |

***

### How much does it cost?

**$10 per 1,000 contract notices**, each one carrying the buyer's published contact
details. One price, one event, no surprises.

| Plan | Per notice | Per 1,000 notices |
|---|---|---|
| Free | $0.010 | $10 |
| Bronze | $0.0095 | $9.50 |
| Silver | $0.0090 | $9 |
| Gold | $0.0085 | $8.50 |
| Platinum | $0.0075 | $7.50 |
| Diamond | $0.0060 | $6 |

There is no compute charge to worry about and no proxy costs: this Actor reads a public
JSON API, so the price you see is the price you pay.

For context: the median UK public contract is worth **£90,000**. A full month of the entire
UK feed, every notice published in 30 days, costs about **$18** and tells you every
organisation in the country that is about to spend money.

The free alternatives give you the notices. What they do not give you is the **buyer's email
address**, which is published on every one measured and is the field that turns a list into a list
you can act on.

***

### How to use it

**Every contract over £100k in the last week**

```
minValue: 100000
daysBack: 7
```

**Only construction work, in Yorkshire**

```
cpvCodes: ["45000000", "45260000", "45262000"]
```

**Everything one council is buying**

```
buyerNames: ["Suffolk County Council"]
daysBack: 30
```

**Only what is still open for bids**

```
stages: ["tender"]
```

**Software and IT contracts, over £50k, mentioning "cyber security"**

```
keywords: ["cyber security", "penetration testing"]
minValue: 50000
cpvCodes: ["72000000"]
```

#### Input settings

| Field | Default | What it does |
|---|---|---|
| `daysBack` | 7 | How many days of notices to collect, counting back from today |
| `publishedFrom` | if unset | Start of the window as an ISO date. Overrides `daysBack` |
| `publishedTo` | now | End of the window as an ISO date |
| `minValue` | 0 | Only contracts worth at least this many pounds |
| `cpvCodes` | if unset | UK industry codes to include, e.g. `45262800` |
| `buyerNames` | if unset | Parts of buyer organisation names to include |
| `keywords` | if unset | Words to find in the notice title or description |
| `stages` | all | `tender` (open), `award` (won), `planning` (early) |
| `maxResults` | 1000 | The most notices to return |

***

### What one row looks like

```json
{
  "noticeId": "ocds-b5fd17-c62320ee-3c70-411e-b390-b0d7ffc18f8c",
  "noticeUrl": "https://www.contractsfinder.service.gov.uk/Notice/877f467f-38c2-424d-81d6-c872341c8baa",
  "title": "Accounts Payable Forensics",
  "description": "A forensic tool to identify potential errors in payments before they are made, including duplicate payments, incorrect suppliers and fraud.",
  "status": "complete",
  "stage": "award",
  "noticeType": "award",
  "procurementMethod": "open",
  "value": { "amount": 108360, "currency": "GBP" },
  "cpv": { "code": "48440000", "description": "Financial analysis and accounting software package" },
  "cpvCodes": ["48440000"],
  "buyer": {
    "name": "Bristol City Council",
    "identifier": "GB-CFS-54258",
    "email": "procurement@bristol.gov.uk",
    "phone": "+44 117 903 3318",
    "website": "https://www.bristol.gov.uk",
    "address": "PO Box 68, Bristol, BS1 6DX, United Kingdom"
  },
  "deadline": null,
  "publishedDate": "2026-10-20T09:14:22+01:00",
  "sme": true,
  "deliveryPostcodes": ["BS1 6DX"],
  "deliveryRegions": [],
  "deliveryCountries": ["United Kingdom"]
}
```

***

### Is this legal?

Yes. The Actor reads the **Open Contracting Data Standard (OCDS) API** that UK Contracts
Finder publishes as open government data under the
[Open Government Licence v3](https://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/).
It does not scrape web pages, log in, or bypass anything. Every row links back to the
official notice so you can check it.

You are responsible for how you use the contact details you get back, and for complying with
UK GDPR and the PECR rules on unsolicited contact.

***

### How is this different from other Contracts Finder tools?

| | This Actor | The official site | Search-a-bid-directory tools |
|---|---|---|---|
| **Every notice, no keyword matching** | ✅ | ✅ | ✅ |
| **The buyer's email** | ✅ on every notice measured | on the notice page itself | usually a paid add-on |
| **Filter by contract value** | ✅ | ❌ | varies |
| **Filter by CPV industry code** | ✅ | ❌ | varies |
| **Structured output** | ✅ JSON / CSV / Excel | ❌ copy and paste | ✅ |
| **Runs on a schedule** | ✅ | ❌ | ✅ |
| **Cost for the whole UK, one month** | ~$18 | free | from £49/mo |

The official site lets you search and browse, but it gives no filtered export, and the
contact address sits on the notice rather than in the results. This Actor does the
filtering itself and hands you the contact details with the record.

***

### Frequently asked questions

**Does this cover Scotland, Wales and Northern Ireland?**
Not yet. This Actor reads Contracts Finder, which covers England and some UK-wide
notices. Scotland (Public Contracts Scotland), Wales (Sell2Wales) and Northern Ireland
(eTendersNI) publish separately. Covering them is on the roadmap.

**How fresh is the data?**
It is live. The Actor reads the feed as it stands at the moment you run it. Contracts
Finder publishes continuously, so a daily scheduled run picks up new notices within a day.

**What is a CPV code?**
The Common Procurement Vocabulary, the standard classification the UK uses to say what
kind of work a contract is. 45000000 is construction, 62000000 is IT and software,
72000000 is consulting. Filter by the codes for the work you sell.

**The value field is empty. Why?**
Because the buyer did not publish one. It is never guessed or estimated.

**Can I monitor specific buyers for new opportunities?**
Yes. Filter on `buyerNames` and schedule the Actor to run daily. Each run returns what is
new in the window.

**What happens if my run is interrupted?**
You are charged only for the notices actually written to your dataset, because each notice
is charged as it is saved.

**Can I get the data on a schedule?**
Yes. Apify Schedules run the Actor in the cloud, so it keeps running after you close your
laptop. A run can also be triggered from any other tool over the API.

***

### Still on Apify?

This Actor is one of the most reliable ways to get this data, and it comes with the platform:
scheduling, monitoring, retries, proxy rotation if you ever need it, and export to JSON, CSV
or Excel. If you would rather not work in a developer platform at all, the same feed powers
a simple hosted lookup. Get in touch and we will point you at it.

# Changelog

This Actor's version history is a separate document: https://apify.com/likeable_seal/uk-public-contracts-finder/changelog.md

# Actor input Schema

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

How many days of notices to collect, counting back from today. Ignored when `publishedFrom` is set. With no value, the Actor collects the last 7 days, which is roughly 400 notices.

## `publishedFrom` (type: `string`):

Start of the publication window as an ISO 8601 date or date-time. Leave empty to use `daysBack`.

## `publishedTo` (type: `string`):

End of the publication window as an ISO 8601 date or date-time. Leave empty for 'up to now'.

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

Only return notices whose contract value is at least this many pounds. Notices with no stated value are excluded once this is set.

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

Only return notices classified under any of these UK/CPV codes. A notice matches if any one of its codes matches.

## `buyerNames` (type: `array`):

Only return notices whose buyer organisation name contains any of these strings. Case-insensitive.

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

Only return notices whose title or description contains any of these words. Case-insensitive.

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

Which stage of the procurement to return. Leave empty for all stages.

- `tender`: open and amended tenders you can still bid on
- `award`: contracts that have been awarded, and any later change to one
- `planning`: notices that a buyer is still planning
  Anything else is rejected, rather than being ignored.

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

Stop after this many notices have been returned. This is a cap you set, not a filter: the run ends cleanly once it is reached.

## Actor input object example

```json
{
  "daysBack": 7,
  "publishedFrom": "2026-10-01",
  "publishedTo": "2026-10-21",
  "minValue": 25000,
  "maxResults": 1000
}
```

# Actor output Schema

## `contractLeads` (type: `string`):

One item per notice, in the lead-shaped view: contract value, CPV trade, buyer, deadline and the buyer's contact details.

## `allFields` (type: `string`):

The same notices with every captured field.

## `csvDownload` (type: `string`):

The lead view as CSV: flat columns, ready for a spreadsheet or CRM import, rather than the nested objects the un-viewed export carries.

# 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 = {
    "daysBack": 7,
    "publishedFrom": "",
    "publishedTo": "",
    "minValue": 0,
    "maxResults": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("likeable_seal/uk-public-contracts-finder").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 = {
    "daysBack": 7,
    "publishedFrom": "",
    "publishedTo": "",
    "minValue": 0,
    "maxResults": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("likeable_seal/uk-public-contracts-finder").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 '{
  "daysBack": 7,
  "publishedFrom": "",
  "publishedTo": "",
  "minValue": 0,
  "maxResults": 1000
}' |
apify call likeable_seal/uk-public-contracts-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,likeable_seal/uk-public-contracts-finder"
        }
    }
}
```

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/N9Gp42EphVxIBp3an/builds/kVok9cgCIJsUpf4Ee/openapi.json