# UK Contract Opportunity Records — Contracts Finder OCDS (`nexgensignal/uk-contract-opportunity-records`) Actor

Per-record UK public-sector tenders and awards from Contracts Finder (OCDS). Keyless, org-level, OGL v3.0. No person data.

- **URL**: https://apify.com/nexgensignal/uk-contract-opportunity-records.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, News, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 contract records

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Contract Opportunity Records — Contracts Finder (OCDS)

**Official source. No API key. Pay per record.**

This actor turns the UK government's **Contracts Finder** procurement feed into clean, per-notice records — both open **tender** opportunities and completed contract **awards** — delivered through the official Open Contracting (OCDS) API. Each run reads the live Contracts Finder OCDS Search endpoint and delivers one row per notice: the buyer organisation, the title and description, the CPV classification, the value, the deadline, and — on award notices — the winning supplier organisation and award value. Values are verbatim, licensed under the Open Government Licence v3.0, and **no natural-person contact data is ever emitted**.

### What this is, in one paragraph

Every UK public-sector body above a low threshold must publish its contract opportunities and awards on Contracts Finder. The site exposes this as machine-readable Open Contracting Data Standard (OCDS) releases. This actor reads those releases through the keyless OCDS Search API and flattens each into a single, analysis-ready row: who is buying, what they are buying, how it is classified (CPV), what it is worth, when bids are due, and — for awards — who won and for how much. It paginates the official cursor, paces politely, and stops at the record ceiling you set. You are billed only for records actually delivered.

### Who buys this and for what job

- **Suppliers and bid teams** watching for new opportunities in their CPV categories and tracking who is winning comparable contracts.
- **Market and competitive analysts** building a picture of public-sector spend by buyer, category, and value band.
- **Procurement and consultancy teams** benchmarking award values and framework usage across departments and councils.
- **Data engineers** who want a keyless, one-call UK procurement feed that is already deduplicated to org-level fields.

### Open Government Licence v3.0 (carried on every record)

Contracts Finder data is published by the Crown Commercial Service / Cabinet Office under the **Open Government Licence v3.0**. That licence permits free commercial reuse with attribution, and the OCDS payload itself names the licence on every response. This actor carries the required attribution on every record:

> Contains public sector information licensed under the Open Government Licence v3.0. Source: UK Contracts Finder.

These are decision-records of published procurement notices — point-in-time facts, not a monitoring, alerting, or bid-writing service. Verify against the official notice before acting.

### No person data — by construction

OCDS releases carry a buyer **contact point** (a named official, their email and phone) under `parties[].contactPoint`. This actor **never reads that structure** — it maps only organisation-level fields (buyer name/id, org address locality/region/postcode/country, supplier org name/id). As a second, structural safeguard, every free-text field (title and description) is scrubbed before emit: any known contact string, and any email address or phone-number pattern, is redacted. This is enforced by acceptance tests that feed a notice containing a person's name, email, and phone and assert none of it survives, plus a live leak check against real notices (234 real contact strings across 100 live notices → 0 emitted).

### Pricing

| Event | Free plan | Bronze | Silver | Gold / Platinum / Diamond |
|-------|-----------|--------|--------|---------------------------|
| `contract_record` | $0.05 | $0.045 | $0.04 | $0.0335 |

Delivered before charged. Blocked runs and empty results cost nothing.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `stages` | string list | tender, award | Which OCDS stages to pull: `tender` (open opportunities), `award` (contract awards). |
| `publishedFrom` | string (YYYY-MM-DD) | — | Optional. Keep only notices published on or after this date. |
| `cpvPrefix` | string (2–8 digits) | — | Optional. Keep only notices whose CPV code starts with these digits. Applied to delivered records. |
| `maxRecords` | integer | 500 | Ceiling on records delivered and billed. |

The actor paces requests between pages and follows the official OCDS pagination cursor.

### Output

One JSON object per notice. Real example (award notice, from live data, values verbatim):

```json
{
  "record_id": "ocds-b5fd17-1beb6241-727d-4d4e-a6e0-86ad2cdcec43",
  "ocid": "ocds-b5fd17-1beb6241-727d-4d4e-a6e0-86ad2cdcec43",
  "notice_id": "238f133b-cb67-4695-9e33-af26f18c1413-911210",
  "stage": "award",
  "release_date": "2026-08-18T17:46:56+01:00",
  "title": "ICT Managed Service Provider with Hardware Provision",
  "tender_status": "complete",
  "cpv_code": "72000000",
  "cpv_description": "IT services: consulting, software development, Internet and support",
  "procurement_category": "services",
  "procurement_method": "Call-off from a framework agreement",
  "value_amount": 4559570.55,
  "value_currency": "GBP",
  "deadline": "2026-06-04T14:00:00+01:00",
  "buyer_name": "Golden Lane Housing",
  "buyer_id": "GB-SRS-...",
  "buyer_locality": "Manchester",
  "buyer_postcode": "M14 7HR",
  "buyer_country": "United Kingdom",
  "award_value_amount": 4559570.55,
  "award_value_currency": "GBP",
  "award_date": "2026-08-18T00:00:00+01:00",
  "award_status": "active",
  "supplier_names": ["European Electronique Limited"],
  "supplier_ids": ["GB-COH-01704440"],
  "source": "UK Contracts Finder (OCDS)",
  "source_url": "https://www.contractsfinder.service.gov.uk/Notice/238f133b-cb67-4695-9e33-af26f18c1413-911210",
  "licence": "UK Contracts Finder ... Open Government Licence v3.0 ...",
  "attribution": "Contains public sector information licensed under the Open Government Licence v3.0. Source: UK Contracts Finder.",
  "observed_at": "2026-08-18T23:44:20Z"
}
```

An unbilled `RUN_RECEIPT` records the robots check, the stages pulled, the licence seen, releases seen, records delivered, and whether charged equals delivered.

### Field reference

Every record carries a stable, flat set of fields so it drops straight into a spreadsheet or a warehouse table:

- **Identity:** `record_id` / `ocid` (the OCDS contracting-process id), `notice_id` (the Contracts Finder notice id), `stage` (`tender` or `award`), and `release_date`.
- **What is being bought:** `title`, `description` (both scrubbed of any contact data), `cpv_code` and `cpv_description` (the Common Procurement Vocabulary classification), `procurement_category`, and `procurement_method`.
- **Money and timing:** `value_amount` and `value_currency` for the tender estimate, and `deadline` (the tender-period end date) for open opportunities.
- **Buyer organisation:** `buyer_name`, `buyer_id`, and the organisation's `buyer_locality`, `buyer_region`, `buyer_postcode`, and `buyer_country` — organisation address only, never a named individual.
- **Award detail (award stage):** `award_value_amount`, `award_value_currency`, `award_date`, `award_status`, and the winning `supplier_names` / `supplier_ids` (organisation registrations such as Companies House numbers).
- **Provenance:** `source`, `source_url` (a deep link to the official notice), `licence`, `attribution`, `disclaimer`, and `observed_at` (the UTC retrieval time).

### How a run works

A run first checks the site's robots posture, then walks each requested stage in turn. For each stage it opens the OCDS Search endpoint with your date window, reads a page of releases, builds one org-level record per release, applies your CPV filter, and delivers the record **before** it is charged. It then follows the official pagination cursor (`links.next`) to the next page, pausing briefly between requests to stay well within polite-use limits, and stops as soon as your `maxRecords` ceiling is reached. Because delivery precedes billing, a run that is blocked at the door or that finds nothing costs you nothing, and the `charge_equals_delivered` flag in the run receipt lets you confirm you were billed for exactly what you received.

### Cost guidance

One `contract_record` per delivered notice: cost = notices delivered × your plan's per-record price. 1,000 notices is **$50** (Free) / **$33.50** (Gold). Contracts Finder publishes on the order of hundreds of new notices per day across tender and award stages, so a dated pull (`publishedFrom`) keeps runs bounded and cheap.

### Honest limitations

- **UK only.** This is the UK Contracts Finder feed (central government, councils, NHS, and other public bodies in England — with UK-wide notices). For EU-wide procurement, see the sibling actor below.
- **Point-in-time.** Each record is the notice as published at retrieval; statuses and awards can change. Re-run to refresh.
- **Org-level only.** No buyer contact person, email, or phone is emitted — by design.
- **CPV filter is client-side.** Contracts Finder's OCDS endpoint does not honour a server-side CPV filter, so `cpvPrefix` is applied to delivered records rather than at the source. You are billed only for records that pass the filter and are delivered.
- **Award value fields are populated only on award-stage notices.**

### Differentiation

Distinct from the sibling **EU Tender Bid Signals** (nexgensignal/eu-tender-bid-signals), which reads the **EU's** Tenders Electronic Daily (TED) across all member states. This actor is **UK** procurement specifically, from Contracts Finder, in native OCDS — a different jurisdiction, a different source system, and a different schema. Run both for full UK + EU coverage.

### The NexGen Signal family

Part of the NexGen Signal family of official-source, pay-per-record products:

- [Eurostat House Price Index](https://apify.com/nexgensignal/eurostat-house-price-index)
- [Eurostat Waste Generation](https://apify.com/nexgensignal/eurostat-waste-generation)
- [Eurostat Business & Consumer Confidence](https://apify.com/nexgensignal/eurostat-business-confidence)
- [Eurostat Income Distribution (EU-SILC)](https://apify.com/nexgensignal/eurostat-income-distribution)
- [Eurostat Immigration Statistics](https://apify.com/nexgensignal/eurostat-immigration-statistics)
- [Eurostat Road Freight Transport](https://apify.com/nexgensignal/eurostat-road-freight)
- [Organization Sanctions & LEI Risk](https://apify.com/nexgensignal/organization-sanctions-lei-risk)
- [EU Tender Bid Signals — TED](https://apify.com/nexgensignal/eu-tender-bid-signals)

*Source: UK Contracts Finder (Crown Commercial Service / Cabinet Office) via the OCDS Search API. Contains public sector information licensed under the Open Government Licence v3.0. Reformatted to org-level records; values verbatim; no natural-person contact data emitted.*

# Actor input Schema

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

Which OCDS stages to pull: tender (open opportunities) and/or award (contract awards).

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

Optional. Keep only notices published on or after this date.

## `cpvPrefix` (type: `string`):

Optional. Keep only notices whose CPV classification code starts with these 2-8 digits (applied to delivered records).

## `maxRecords` (type: `integer`):

Maximum records delivered and billed. You are billed only for records delivered.

## Actor input object example

```json
{
  "stages": [
    "tender",
    "award"
  ],
  "maxRecords": 500
}
```

# Actor output Schema

## `results` (type: `string`):

The delivered UK contract opportunity records.

# 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 = {
    "stages": [
        "tender",
        "award"
    ],
    "maxRecords": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/uk-contract-opportunity-records").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 = {
    "stages": [
        "tender",
        "award",
    ],
    "maxRecords": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/uk-contract-opportunity-records").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 '{
  "stages": [
    "tender",
    "award"
  ],
  "maxRecords": 500
}' |
apify call nexgensignal/uk-contract-opportunity-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/uk-contract-opportunity-records"
        }
    }
}

```

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/1ZmPSUbd3nBqDAUmj/builds/uvglaZc1yYsF6DuT9/openapi.json