# UK Government Tenders & Contracts Finder API (`toby_richmond/uk-contracts-finder-feed`) Actor

Search UK public-sector tenders and awards from Contracts Finder, and track what changes over time: deadline changes, new awards, added notices. Clean JSON + MCP tools for AI agents, grouped by OCID. Buyer organisation only, no PII. OGL v3.0 data. Free during early access.

- **URL**: https://apify.com/toby\_richmond/uk-contracts-finder-feed.md
- **Developed by:** [Toby Richmond](https://apify.com/toby_richmond) (community)
- **Categories:** Developer tools, Lead generation, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## UK Government Tenders & Contracts Finder API — with Change Tracking

**Search UK public-sector tenders and awards from Contracts Finder — and get the one
thing the portal won't push you: what CHANGED.** Deadline changes, new awards, and added
notices, as a structured API and MCP tools for AI agents.

> Looking for: UK government tenders API · Contracts Finder API · UK public sector contracts ·
> OCDS tender data · government procurement / bids data · RFP / ITT tracking · tender alerts.
> This Actor delivers it as clean JSON, grouped by procurement (OCID).

### The problem this solves
UK Contracts Finder lists current tenders and awards — but it **doesn't proactively tell
you when a deadline moves, when something is awarded, or when a new notice lands** on a
procurement you're watching. For suppliers and bid teams, a missed deadline change or a
missed award is lost business. This feed **tracks every notice over time** and exposes
those change events directly.

### What you can do
- **Search UK government tenders** by category (CPV), keyword, status, and dates.
- **Get a full notice** by ID (OCID), including document links and the live notice URL.
- **Track what changed** — deadline changes, new awards, added documents — grouped by the
  procurement's stable **OCID** so a tender and its later award line up. *The differentiator.*

### MCP tools (for AI agents / Claude / agent builders)
Exposes Model Context Protocol tools so an agent can query UK procurement directly:
- `search_opportunities(category, keyword, status, posted_after, due_after, due_before)`
- `get_opportunity(solicitation_id)`  *(solicitation_id = OCID)*
- `list_recent_changes(since)` — the change feed

### Example input
```json
{ "tool": "search_opportunities", "status": "Open", "keyword": "facilities", "limit": 5 }
````

### Example output (one record)

```json
{
  "solicitation_id": "ocds-b5fd17-8718ec9a-...",
  "title": "FM Procurement Consultancy Support",
  "agency": "Watford Borough Council",
  "category": "Procurement consultancy services",
  "status": "Awarded",
  "estimated_value": 50000,
  "value_currency": "GBP",
  "due_date": "2026-03-02T00:00:00+00:00",
  "source_url": "https://www.contractsfinder.service.gov.uk/notice/336cb675-1fe7-452f-b23d-2f87addeeec1"
}
```

### Example change event (`list_recent_changes`)

```json
{ "event": "deadline_changed", "solicitation_id": "ocds-b5fd17-8718ec9a-...",
  "old_due_date": "2026-02-23T00:00:00+00:00", "new_due_date": "2026-03-02T00:00:00+00:00" }
```

### Data schema (per tender)

`solicitation_id` (OCID), `title`, `agency` (**buyer organisation only**), `category`
(CPV description), `posted_date` / `due_date` (ISO-8601 with explicit timezone),
`status` (Open / Closed / Awarded), `estimated_value` (**present for most UK notices**, GBP),
`document_links`, `source` / `source_url` (the live notice page).

**No personal data.** Buyer **contact** names/emails/phones are **stripped at ingestion**
and re-checked at storage; the free-text `description` (which can contain emails) is
**dropped**. Only the buying **organisation name** and solicitation data are served.

### Coverage & freshness

Official **UK Contracts Finder** OCDS API (Cabinet Office) — central government, local
councils, NHS, education and other public bodies. **National, high volume.** Refreshed
daily; history accumulates as it runs (early-access window of recent notices).

### Access

**Free during early access (beta).** Usage limits or pricing may be introduced later, with
notice. (Not "free forever," just free for now.)

### Reliability

A built-in monitor watches for upstream breakage and PII drift; if something looks wrong it
**stops serving and returns "temporarily unavailable" rather than serve stale or wrong data.**

### Licence / attribution

Contains public sector information from UK **Contracts Finder**, © Crown copyright, licensed
under the **Open Government Licence v3.0** (commercial reuse permitted).
http://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/

***

*Keywords: UK government tenders API, Contracts Finder API, UK public sector contracts, OCDS
data, procurement data, government bids, ITT / RFP / RFQ tracking, tender alerts, GovTech.*

# Actor input Schema

## `tool` (type: `string`):

Which operation to run: search opportunities, get one by id, or list recent changes.

## `status` (type: `string`):

Solicitation status to filter by (search\_opportunities).

## `category` (type: `string`):

Procurement category substring, e.g. 'INFORMATION TECHNOLOGY'.

## `keyword` (type: `string`):

Keyword to match in the solicitation title or category.

## `due_after` (type: `string`):

Only solicitations with a due date on/after this date.

## `due_before` (type: `string`):

Only solicitations with a due date on/before this date.

## `solicitation_id` (type: `string`):

Bid number to fetch (used by get\_opportunity).

## `since` (type: `string`):

For list\_recent\_changes: only changes at/after this timestamp.

## `limit` (type: `integer`):

Maximum number of records to return.

## Actor input object example

```json
{
  "tool": "search_opportunities",
  "status": "Open",
  "limit": 50
}
```

# Actor output Schema

## `solicitations` (type: `string`):

The returned records (solicitations, or change events for list\_recent\_changes).

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("toby_richmond/uk-contracts-finder-feed").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("toby_richmond/uk-contracts-finder-feed").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call toby_richmond/uk-contracts-finder-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=toby_richmond/uk-contracts-finder-feed",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UK Government Tenders & Contracts Finder API",
        "description": "Search UK public-sector tenders and awards from Contracts Finder, and track what changes over time: deadline changes, new awards, added notices. Clean JSON + MCP tools for AI agents, grouped by OCID. Buyer organisation only, no PII. OGL v3.0 data. Free during early access.",
        "version": "0.1",
        "x-build-id": "qi0W46PjSCvsSyCls"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/toby_richmond~uk-contracts-finder-feed/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-toby_richmond-uk-contracts-finder-feed",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/toby_richmond~uk-contracts-finder-feed/runs": {
            "post": {
                "operationId": "runs-sync-toby_richmond-uk-contracts-finder-feed",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/toby_richmond~uk-contracts-finder-feed/run-sync": {
            "post": {
                "operationId": "run-sync-toby_richmond-uk-contracts-finder-feed",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "tool"
                ],
                "properties": {
                    "tool": {
                        "title": "Tool",
                        "enum": [
                            "search_opportunities",
                            "get_opportunity",
                            "list_recent_changes"
                        ],
                        "type": "string",
                        "description": "Which operation to run: search opportunities, get one by id, or list recent changes.",
                        "default": "search_opportunities"
                    },
                    "status": {
                        "title": "Status",
                        "enum": [
                            "Open",
                            "Closed",
                            "Awarded",
                            "Archived"
                        ],
                        "type": "string",
                        "description": "Solicitation status to filter by (search_opportunities).",
                        "default": "Open"
                    },
                    "category": {
                        "title": "Category contains",
                        "type": "string",
                        "description": "Procurement category substring, e.g. 'INFORMATION TECHNOLOGY'."
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Keyword to match in the solicitation title or category."
                    },
                    "due_after": {
                        "title": "Due after (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only solicitations with a due date on/after this date."
                    },
                    "due_before": {
                        "title": "Due before (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only solicitations with a due date on/before this date."
                    },
                    "solicitation_id": {
                        "title": "Solicitation ID",
                        "type": "string",
                        "description": "Bid number to fetch (used by get_opportunity)."
                    },
                    "since": {
                        "title": "Changes since (ISO-8601)",
                        "type": "string",
                        "description": "For list_recent_changes: only changes at/after this timestamp."
                    },
                    "limit": {
                        "title": "Max results",
                        "type": "integer",
                        "description": "Maximum number of records to return.",
                        "default": 50
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```