# UK Gov Tenders Scraper (`parseforge/uk-gov-tenders-scraper`) Actor

Scrapes UK government tenders from the Contracts Finder OCDS feed. Returns each tender as a flat row with title, buyer, value, stage, dates, and supplier details. Filter by notice stage and published date.

- **URL**: https://apify.com/parseforge/uk-gov-tenders-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Lead generation, Other
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### UK Gov Tenders Scraper

**Scrape UK government tenders from the Contracts Finder OCDS feed, filtered by stage and date.** Every tender comes with its title, buyer, value, deadline, and award details. No API key or registration. Export to CSV, JSON, Excel, or XML.

The UK government publishes thousands of public sector contracts every month, but manually checking the Contracts Finder website is slow and you miss updates. This actor reads the official OCDS feed directly, applies your stage and date filters, and returns each matching tender in a clean, flat row. No browser, no login, no rate-limit headaches.

| Who uses it | What they scrape UK Government Contracts Finder for |
|---|---|
| Bid writers and proposal teams | Find live tenders that match their sector before competitors do |
| Market researchers | Analyse UK public spending patterns by department, value band, or region |
| Sales and business development leads | Build a pipeline of upcoming government contract opportunities |
| Data analysts and journalists | Track awarded contracts to see who is winning public sector work |

### What it does

This Actor collects UK government tenders from the Contracts Finder OCDS feed and returns each one as a flat row with its title, description, buyer, value, stage, dates, and supplier details.

- 📅 **Date filter:** set a published-from date to collect only fresh tenders or backfill a historical range.
- 🏷️ **Stage filter:** choose Tender, Award, Contract, or Planning notices so you see exactly the phase you care about.
- 📦 **Flat output:** every tender is one row, ready for spreadsheets, databases, or BI tools.
- ⚡ **Direct feed access:** reads the official OCDS JSON feed, so results match what is on Contracts Finder in real time.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with UK Government Contracts Finder data

**📬 Build a daily tender alert.**

A bid writer runs the actor each morning with stage set to Tender and published-from set to yesterday, then pushes new matches to a Slack channel or email.

**📊 Analyse departmental spending.**

A researcher collects a year of Award and Contract notices, groups them by buyer name and value band, and identifies which departments spend most on external suppliers.

**🗺️ Map regional contract distribution.**

A data analyst scrapes all tenders with a location field, then plots them on a map to show where public money flows across the UK.

**🏆 Monitor competitor wins.**

A sales lead filters by Award stage, searches for competitor names in the supplier field, and tracks which contracts they have secured.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key needed** | The OCDS feed is public; you start scraping in seconds. |
| **Fixed schema** | Every run returns the same columns, so your pipeline never breaks. |
| **Stage filtering** | Separate live opportunities from awarded contracts in one setting. |
| **Date control** | Pull only the latest notices or backfill months of data. |

### How it compares

No other Store actor targets UK Government Contracts Finder the same way, so the honest comparison is with the alternatives teams actually weigh.

| | UK Gov Tenders Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When UK Government Contracts Finder changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the Actor with a maximum item count, an optional published-from date, and a notice stage. Filters run as each tender is read so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "maxItems": 10
}
```

A larger pull:

```json
{
 "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.021 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $2.10 |
| 1,000 results | $21.00 |
| 10,000 results | $210.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [UK Gov Tenders Scraper](https://apify.com/parseforge/uk-gov-tenders-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to UK Government Contracts Finder through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/uk-gov-tenders-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check your published-from date. If it is set too far in the past or future, the feed may return nothing. Try removing the date filter or setting it to a recent date. Also confirm the stage filter matches the notices you expect.

**The run finished but the dataset is empty.**

The OCDS feed may not have any notices matching your exact stage and date combination. Widen the date range or switch the stage to see if data exists. If the issue persists, run the actor without any filters to confirm the feed is reachable.

**I need more filters, like by region or CPV code.**

The actor currently filters by stage and date only. You can download the full dataset and filter in Excel, Google Sheets, or a database. For programmatic filtering, use Apify's dataset API or an integration to pipe the data into a tool that supports queries.

**The actor is taking a long time to run.**

A high maxItems value combined with a wide date range will pull more data and take longer. Lower the maxItems or narrow the published-from window to speed up the run.

**Some tender fields are empty in the output.**

Not every notice includes all fields. For example, a Tender stage notice will not have an award date or supplier name. Those fields are populated only when the notice reaches the Award or Contract stage.

### FAQ

| Question | Answer |
|---|---|
| What is Contracts Finder? | Contracts Finder is the UK government's official portal for public sector procurement notices. It publishes tenders and contract awards above certain value thresholds using the Open Contracting Data Standard (OCDS). |
| Do I need an API key or login? | No. The actor reads the public OCDS feed directly. You do not need to register, create an app, or manage tokens. |
| How many tenders can I scrape in one run? | You set the maximum in the input. The actor can collect up to a million tenders per run, limited only by what is available in the feed for your chosen filters. |
| What data fields does each tender row include? | Each row includes the tender title, description, buyer name, published date, deadline date, contract value, award date, supplier name, notice stage, and the raw OCDS ID. The exact field list is shown in the sample output on the actor's page. |
| Can I filter by contract value or buyer name? | The input schema provides stage and date filters. For value, buyer, or keyword filtering, you can apply those after the run in your spreadsheet, database, or by post-processing the dataset with another tool. |
| How often is the feed updated? | Contracts Finder publishes new notices throughout the working day. Running the actor on a schedule gives you a fresh snapshot each time. |
| Does this cover devolved administrations like Scotland or Wales? | Contracts Finder covers English central government and wider public sector bodies. Scotland, Wales, and Northern Ireland have their own portals. This actor reads the Contracts Finder OCDS feed specifically. |
| What is the OCDS format? | The Open Contracting Data Standard is a global schema for publishing procurement data. This actor parses the OCDS JSON feed and flattens it into rows, so you do not need to handle nested JSON yourself. |
| Can I get live tender notices only? | Yes. Set the stage filter to 'Tender' and the actor returns only open opportunities. Use 'Award' or 'Contract' for closed and awarded notices. |
| How do I export the results? | After the run completes, you can download the dataset as CSV, JSON, Excel, or XML from the Apify storage tab, or push it to an external service via an integration. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Crown Commercial Service. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

How many tenders to collect per run.

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

YYYY-MM-DD lower bound.

## `stages` (type: `string`):

OCDS notice stage.

## Actor input object example

```json
{
  "maxItems": 10,
  "stages": "tender"
}
```

# 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/uk-gov-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/uk-gov-tenders-scraper").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 '{
  "maxItems": 10
}' |
apify call parseforge/uk-gov-tenders-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/uk-gov-tenders-scraper"
        }
    }
}

```

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/XW6zCvV0fDaqb8aJI/builds/65aTYATo9LAqoP4TX/openapi.json