# UK Public Contract Awards & Suppliers — Contracts Finder (`foxlabs/uk-contracts-finder-supplier-data`) Actor

Search UK public-sector contract awards on Contracts Finder by keyword, buyer or supplier. Returns awarded supplier names and IDs, contract value, buyer organisation, CPV classification, award and contract dates, and the tender description.

- **URL**: https://apify.com/foxlabs/uk-contracts-finder-supplier-data.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 award records

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

## UK Public Contract Awards & Suppliers — Contracts Finder 🏛️

**foXLabs procurement series:** [EU TED](https://apify.com/foxlabs/ted-tenders) · [World Bank](https://apify.com/foxlabs/worldbank-tenders) · [IADB](https://apify.com/foxlabs/iadb-tenders) · [Ukraine Prozorro](https://apify.com/foxlabs/ukraine-prozorro-tenders) · [India](https://apify.com/foxlabs/india-government-tenders) · [US Federal](https://apify.com/foxlabs/usaspending-contract-award-data)

🎉 Find out **which suppliers win UK public money** — company name, contract title, award value, buyer and dates — straight from the official Contracts Finder service, no login and no API key.
Built for sales teams chasing public-sector budget, competitors tracking rivals' wins, and analysts mapping government spend.

### 🔍 What is this Actor — and when should you use it?

Contracts Finder is the UK government's official publication service for public-sector procurement. Every contract award above threshold lands there in OCDS format. This Actor searches it by keyword and returns one clean row per award: the **supplier that won**, what they won, **how much it was worth**, which public body bought it, and when the contract runs.

**Use it when you need:** a list of suppliers already trusted with public money in your sector; the award value a competitor just won; a feed of new awards in a category you sell into; or the buyer-side contact trail (buyer id and source URL) for a bid you plan to chase.

**Use something else when:** you want tenders that are still open for bidding rather than finished awards — switch the `stage` input to `tender` or `planning` in this same Actor. For procurement outside the UK, use the matching Actor in the series above; they share the same core award schema, so outputs concatenate into one table.

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/uk-contracts-finder-supplier-data`.

**Your agent can pay for its own runs.** This Actor is pay-per-event with agentic payments, so an agent can discover it, run it and settle the bill over **x402 (USDC on Base)** or **Skyfire** — no Apify account or API token of its own. Billing is the same either way: per delivered award row.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```
Run the Apify actor foxlabs/uk-contracts-finder-supplier-data with
{"queries":["cyber security"],"stage":"award","maxResultsPerQuery":25}
and give me the suppliers, award values and buyers.
```

### 📋 Overview

| | |
|---|---|
| **Source** | Contracts Finder (UK Government, OCDS search API) |
| **Coverage** | UK-wide public sector — central government, NHS, councils, agencies |
| **Auth needed** | None. No API key, no login, no proxy required |
| **Row** | One contract award (or tender/planning notice, depending on `stage`) |
| **Measured run** | 75 rows in 36 s for 3 keywords (2026-09-19) |
| **Pricing** | $0.004 per delivered row — $4 per 1,000 |

### ✨ Features

- 🏢 **Supplier-first** — every row names the company that won, not just the notice
- 💷 **Award value and currency** on every row, as published
- 🔎 **Keyword search** — search by category ("cyber security"), by service, or by a supplier's own name to see everything they have won
- 🔄 **Three stages** — finished `award`, open `tender`, or upcoming `planning` notices from the same input
- 🧾 **Buyer trail** — buyer id, counterparty name and the official source URL for each notice
- ⚡ **No proxy needed** — the service answers direct requests; proxy is off by default

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~uk-contracts-finder-supplier-data/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["cloud hosting","cyber security"],"stage":"award","maxResultsPerQuery":25}'
```

### 🚀 Getting Started (3 steps)

1. **Pick your keywords.** Put the service, category or supplier name into `queries`. The default run searches `cloud hosting`, `cyber security` and `Capita`.
2. **Choose the stage.** Leave `stage` at `award` for contracts already won; switch to `tender` for live opportunities.
3. **Run it.** Rows arrive in the dataset; export to CSV/JSON/Excel or read them over the API.

### 📥 Input

| Field | Type | Default | Description |
|---|---|---|---|
| `queries` | array | `["cloud hosting","cyber security","Capita"]` | Search terms. A category, a service, or a supplier name |
| `stage` | string | `award` | `award` (won contracts), `tender` (open), `planning` (upcoming) |
| `maxResultsPerQuery` | integer | `25` | Cap on rows returned per search term |
| `maxConcurrency` | integer | `2` | Parallel requests against Contracts Finder |
| `requestDelayMs` | integer | `0` | Optional pause between requests |
| `includeRaw` | boolean | `false` | Attach the untouched source record to each row |
| `proxyConfiguration` | object | proxy off | Contracts Finder answers direct requests; enable only if you need it |

**Example — everything one supplier has won:**

```json
{ "queries": ["Capita"], "stage": "award", "maxResultsPerQuery": 50 }
```

**Example — live opportunities in a category:**

```json
{ "queries": ["software development"], "stage": "tender", "maxResultsPerQuery": 25 }
```

### 📤 Output

One row per notice. From the measured run above (75 rows, 3 keywords, 2026-09-19):

| Field | Type | Fill | Description |
|---|---|---|---|
| `companyName` | string | 100% | Supplier that won the contract |
| `companyId` | string | 100% | Supplier identifier as published |
| `awardId` | string | 100% | OCDS award/notice id |
| `awardTitle` | string | 100% | Contract title |
| `awardType` | string | 100% | Procedure type (e.g. `selective`, `open`) |
| `amount` | number | 100% | Award value |
| `currency` | string | 100% | Currency of `amount` |
| `awardedOn` | string | 100% | Award date (ISO) |
| `startDate` / `endDate` | string | 100% | Contract period |
| `status` | string | 100% | Notice status |
| `counterparty` | string | 100% | Public body on the other side of the contract |
| `buyerId` | string | 100% | Buyer identifier |
| `industryCode` | string | 100% | Classification code for the contract |
| `region` | string | 56% | Region, where the notice carries one |
| `additionalClassifications` | array | 4% | Extra classification codes, rarely published |
| `description` | string | 100% | Notice description |
| `sourceUrl` | string | 100% | Official Contracts Finder URL for the notice |
| `country` / `countryName` / `source` / `query` / `scrapedAt` | string | 100% | Provenance fields |
| `city` | string | **0%** | Contracts Finder does not publish supplier city in these records — the column is present for schema parity with the series and is always empty here |

**A real row from the default run:**

```json
{
  "companyName": "Southampton Marine Services",
  "awardId": "ocds-b5fd17-0db0dcf8-9a57-4c5f-b751-cb43f8227f95",
  "awardTitle": "T0345 - Dry Dock & Repair of Lightvessel 06",
  "awardType": "selective",
  "amount": 408069,
  "currency": "GBP",
  "awardedOn": "2026-07-13",
  "countryName": "United Kingdom"
}
```

### 💼 Use cases

- **Public-sector sales** — build a list of buyers who already spend in your category, with the value they spent
- **Competitive intelligence** — search a rival's name and see every public contract they hold, with values and end dates
- **Renewal timing** — `endDate` tells you when an incumbent's contract runs out, which is when the buyer starts looking
- **Market sizing** — sum award values by category to size the addressable public budget
- **Partner sourcing** — find suppliers already cleared to work with government in a discipline you need

### 🔗 Integration

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/uk-contracts-finder-supplier-data').call({
  queries: ['cyber security'], stage: 'award', maxResultsPerQuery: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("foxlabs/uk-contracts-finder-supplier-data").call(
    run_input={"queries": ["cyber security"], "stage": "award", "maxResultsPerQuery": 25}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

**No-code:** Make, n8n and Zapier all reach this Actor through the Apify app — schedule a run and push new awards straight into a CRM or a sheet.

### 📊 Pricing

Pay-per-event: **`award-record` — $0.004 per delivered row ($4 per 1,000)**. Compute and traffic are included in that price; you pay for rows, not for run time. Rows that carry no supplier and no award id are not charged.

[View current pricing.](https://apify.com/foxlabs/uk-contracts-finder-supplier-data)

### ❓ FAQ

**Do I need an API key for Contracts Finder?** No. The service is public and this Actor needs no key, login or proxy.

**Does it cover Scotland, Wales and Northern Ireland?** Contracts Finder is the UK-wide service and publishes notices from across the UK, but some devolved bodies publish primarily on their own portals. Treat the results as "what Contracts Finder holds", not as a guaranteed census of every UK public contract.

**Can I get contracts that are still open?** Yes — set `stage` to `tender` for live opportunities or `planning` for pipeline notices.

**Why is `city` always empty?** The award records Contracts Finder publishes do not carry supplier city. The column stays in the schema so rows from this Actor line up with the other procurement Actors in the series.

**How fresh is the data?** Every run queries Contracts Finder live; you get what the service holds at that moment.

**Can I search by supplier instead of category?** Yes — put the company name in `queries`, e.g. `["Capita"]`.

### 🐛 Troubleshooting

**A search returns fewer rows than `maxResultsPerQuery`.** That keyword simply has fewer matching notices. Broaden the term or add more entries to `queries`.

**A run returns nothing at all.** Check the keyword spelling and try `stage: "award"` — planning notices are far rarer than awards.

**Rows look truncated.** Raise `maxResultsPerQuery`; the cap applies per search term, not per run.

### ⚠️ Trademark

Contracts Finder is a service of the UK Government. This Actor is an independent tool, is not affiliated with or endorsed by the UK Government or any public body, and reads only publicly published procurement notices.

### ⚖️ Is it legal to scrape this data?

Contracts Finder notices are official public-sector information published for reuse, and the data this Actor returns is the published notice content — supplier names, contract values, buyers and dates. That is business information about public spending, not personal data. Public bodies publish it precisely so suppliers and citizens can see where public money goes. As always, you are responsible for how you use the output.

### 🤝 Support & contact

Questions, a field you need, or a bug: **info@foxlabs.com.tr** — or open an issue on the Actor's Apify page.

### Changelog

#### 0.1

- Contracts Finder search across `award`, `tender` and `planning` stages.
- One row per notice with supplier, value, buyer, dates and source URL.
- Pay-per-event billing on delivered rows (`award-record`).

# Changelog

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

# Actor input Schema

## `queries` (type: `array`):

Free-text searches (`cloud hosting`, `Capita`, `NHS Digital`). Contracts Finder matches across notice titles, descriptions, buyers and suppliers.

## `maxResultsPerQuery` (type: `integer`):

How many rows a single query may produce.

## `maxConcurrency` (type: `integer`):

How many queries to run at the same time. Lower it if the source throttles you.

## `includeRaw` (type: `boolean`):

Attach the source's untouched response under `raw`. Useful when you need a field this actor does not map.

## `requestDelayMs` (type: `integer`):

Politeness delay against a public source. Raise it for large runs.

## `proxyConfiguration` (type: `object`):

Optional. Contracts Finder answers datacenter IPs, though it is slow — allow up to 20 seconds per query.

## `stage` (type: `string`):

Awards carry supplier names; tenders are still open for bids.

## Actor input object example

```json
{
  "queries": [
    "cloud hosting",
    "cyber security",
    "Capita"
  ],
  "maxResultsPerQuery": 25,
  "maxConcurrency": 2,
  "includeRaw": false,
  "requestDelayMs": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "stage": "award"
}
```

# Actor output Schema

## `dataset` (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 = {
    "queries": [
        "cloud hosting",
        "cyber security",
        "Capita"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/uk-contracts-finder-supplier-data").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 = { "queries": [
        "cloud hosting",
        "cyber security",
        "Capita",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/uk-contracts-finder-supplier-data").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 '{
  "queries": [
    "cloud hosting",
    "cyber security",
    "Capita"
  ]
}' |
apify call foxlabs/uk-contracts-finder-supplier-data --silent --output-dataset

```

## MCP server setup

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

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/wPfAhsuscDnEjo9eW/builds/Qs8CWewYRZ5Bp1DP2/openapi.json