# Contracts Finder UK Tenders Scraper (`parseforge/contractsfinder-uk-tenders-scraper`) Actor

Find public records from Contractsfinder Uk Tenders with identifiers, dates, parties, descriptions, status flags and direct links to source filings. Designed for compliance, government affairs, due diligence and policy research. Run on demand or on a recurring schedule and feed every row into you.

- **URL**: https://apify.com/parseforge/contractsfinder-uk-tenders-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Other, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏛 Contracts Finder UK Tenders Scraper

> 🚀 **Get UK public sector tenders and contract awards in seconds.** Title, CPV classification, value, status, buyer, dates and delivery region from the official Contracts Finder OCDS API.

> 🕒 **Last updated** 2026-05-27 · **📊 28 fields** per record · **All UK central + local government** · **Full OCDS schema**

The UK's Cabinet Office publishes every public-sector tender on Contracts Finder under the Open Contracting Data Standard (OCDS). This scraper wraps the live OCDS endpoint and returns clean, structured records ready for Power BI, Tableau or your own procurement intelligence platform.

Every record carries the tender title, CPV procurement code, value, currency, buyer organisation, tender and contract periods, delivery region and award metadata. Filter by published date range to keep your dataset incremental.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| UK govtech vendors | Track upcoming tenders by CPV code |
| Procurement consultants | Build comparable-deal tables for clients |
| Civic-tech researchers | Map public spending by buyer and category |
| Compliance teams | Audit framework call-offs and award timing |
| Data engineers | Pipe OCDS data into your procurement warehouse |

### 📋 What the Contracts Finder UK Tenders Scraper does

- Calls the official OCDS `/Published/Notices/OCDS/Search` endpoint
- Handles cursor pagination automatically
- Returns full tender object: title, value, CPV, dates, buyer, delivery region, awards
- Filters by `publishedFrom` and `publishedTo` for incremental pulls
- Streams to data / data / data / data

> 💡 **Why it matters:** OCDS is the gold-standard procurement output. Pulling it daily gives you a real-time view of every UK public-sector opportunity worth competing for.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Description</th></tr>
<tr><td>maxItems</td><td>integer</td><td>Cap on records returned (free plan: 10)</td></tr>
<tr><td>publishedFrom</td><td>string</td><td>ISO date YYYY-MM-DD</td></tr>
<tr><td>publishedTo</td><td>string</td><td>ISO date YYYY-MM-DD</td></tr>
</table>

````

{ "maxItems": 50 }

```
```

{ "publishedFrom": "2026-05-01", "publishedTo": "2026-05-26", "maxItems": 500 }

````

> ⚠️ **Good to Know:** the OCDS API paginates at 100 per page via cursor URLs. The actor handles cursors transparently.

### 📊 Output

<table>
<tr><th>Field</th><th>Description</th></tr>
<tr><td>📛 title / description / status</td><td>Tender headline</td></tr>
<tr><td>🆔 tenderId / ocid / releaseId</td><td>Identifiers</td></tr>
<tr><td>🏷 tags</td><td>OCDS release tags (tender, award, contract)</td></tr>
<tr><td>💰 value / currency</td><td>Tender value</td></tr>
<tr><td>📂 cpvCode / cpvDescription</td><td>CPV classification</td></tr>
<tr><td>🛠 procurementMethod / procurementMethodDetails / suitability</td><td>Method metadata</td></tr>
<tr><td>📅 tenderStart / tenderEnd / contractStart / contractEnd</td><td>Date periods</td></tr>
<tr><td>📍 deliveryRegion / deliveryPostalCode / deliveryCountry</td><td>Where work is delivered</td></tr>
<tr><td>🏢 buyerName / buyerId</td><td>Procuring organisation</td></tr>
<tr><td>🏆 awardValue / awardDate</td><td>Award metadata if released</td></tr>
<tr><td>📅 publishedDate</td><td>OCDS publication date</td></tr>
<tr><td>🔗 sourceUrl</td><td>Contracts Finder public notice URL</td></tr>
<tr><td>🕒 scrapedAt</td><td>ISO timestamp</td></tr>
</table>

### ✨ Why choose this Actor

- 🆓 UK govt open data, no auth required
- 📡 Direct hit on the OCDS endpoint, OCDS 1.1 compliant
- 🧭 Cursor pagination handled automatically
- 📑 Includes CPV codes for procurement segmentation
- 📦 Get as data

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Setup time |
|---|---|---|---|
| Daily data downloads from gov.uk | Free | Bulk only | Hours |
| Direct OCDS API integration | Free | Full | Code required |
| ParseForge Contracts Finder Scraper | Pay-per-result | Full + structured | Minutes |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 credit).
2. Open the Contracts Finder UK Tenders Scraper.
3. Set `publishedFrom` / `publishedTo` and `maxItems`.
4. Click **Start** and access data / data / data / data.
5. Schedule daily for an incremental feed.

### 💼 Business use cases

**Bid scouting** - alert your sales team when a CPV-coded tender matches your portfolio.

**Procurement analytics** - chart UK public spending by buyer or category.

**Compliance monitoring** - track framework call-offs and verify timing requirements.

**Market intelligence** - benchmark competitors' winning bid sizes.

### 🔌 Automating Contracts Finder UK Tenders Scraper

Hook into Make, Zapier, n8n, Airbyte, Pipedream, Slack, Google Drive, GitHub Actions or any HTTP webhook.

### 🌟 Beyond business use cases

- **Research:** academic analysis of UK procurement policy.
- **Personal:** track which buyers fund local civic projects.
- **Non-profit:** support transparency and open-government initiatives.
- **Experimentation:** train NLP on tender descriptions for opportunity matching.

### 🤖 Ask an AI assistant about this scraper

Ask ChatGPT, Claude, Perplexity or Copilot: "How do I pull every UK tender published this month with the ParseForge Apify actor?"

### ❓ Frequently Asked Questions

**Is Contracts Finder data public?**
Yes, under the UK Open Government Licence v3.

**What's OCDS?**
Open Contracting Data Standard - a data schema for procurement transparency.

**Does the actor handle pagination?**
Yes, via OCDS cursor URLs.

**Can I filter by CPV code?**
The OCDS search API doesn't support CPV filtering server-side. Filter client-side on the output.

**Does the actor include awards?**
Awards are returned in the `awards` array of each release.

**How current is the data?**
Contracts Finder is updated continuously; the actor returns whatever the API serves at run time.

**Can I get historical data?**
Set `publishedFrom` to capture any historical window.

**Are local authorities included?**
Yes - Contracts Finder covers central and local UK government.

**Are EU tenders covered?**
EU procurement is on TED. This actor focuses on UK Contracts Finder.

**Is there a daily access cap?**
No formal cap; OCDS expects polite usage.

### 🔌 Integrate with any app

Apify, Make, Zapier, n8n, Pipedream, Slack, Airbyte, GitHub, Google Drive, Power Automate, AWS Lambda, REST webhook.

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [EU Clinical Trials Register Scraper](https://apify.com/parseforge/eu-clinical-trials-register-scraper) | EU CTIS clinical trials |
| [OpenAlex Institutions Scraper](https://apify.com/parseforge/openalex-institutions-scraper) | Global research institutions |
| [OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more government and open-data scrapers.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with the UK Cabinet Office or Contracts Finder. Only publicly available open data is collected.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000
## `publishedFrom` (type: `string`):

Only return notices published on or after this date (YYYY-MM-DD). Leave blank for any.
## `publishedTo` (type: `string`):

Only return notices published on or before this date (YYYY-MM-DD). Leave blank for any.

## Actor input object example

```json
{
  "maxItems": 10,
  "publishedFrom": "",
  "publishedTo": ""
}
````

# 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": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/contractsfinder-uk-tenders-scraper").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": 10 }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/contractsfinder-uk-tenders-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Contracts Finder UK Tenders Scraper",
        "description": "Find public records from Contractsfinder Uk Tenders with identifiers, dates, parties, descriptions, status flags and direct links to source filings. Designed for compliance, government affairs, due diligence and policy research. Run on demand or on a recurring schedule and feed every row into you.",
        "version": "0.1",
        "x-build-id": "2iBVfE2eJSieqeCI5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~contractsfinder-uk-tenders-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-contractsfinder-uk-tenders-scraper",
                "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/parseforge~contractsfinder-uk-tenders-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-contractsfinder-uk-tenders-scraper",
                "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/parseforge~contractsfinder-uk-tenders-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-contractsfinder-uk-tenders-scraper",
                "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",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "publishedFrom": {
                        "title": "Published from (ISO date)",
                        "type": "string",
                        "description": "Only return notices published on or after this date (YYYY-MM-DD). Leave blank for any.",
                        "default": ""
                    },
                    "publishedTo": {
                        "title": "Published to (ISO date)",
                        "type": "string",
                        "description": "Only return notices published on or before this date (YYYY-MM-DD). Leave blank for any.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```