# UK Tender Monitor (`arched_friend/uk-tender-monitor`) Actor

Find UK public sector tenders on Contracts Finder by keyword, region, value or CPV code. Returns buyer, value, deadline and days left to bid, SME suitability, and the winning supplier and price once awarded. Flags new tenders and fresh awards.

- **URL**: https://apify.com/arched\_friend/uk-tender-monitor.md
- **Developed by:** [Peach O](https://apify.com/arched_friend) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 notice returneds

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 Tender Monitor: Public Sector Contracts to Bid On, and Who Won the Rest

Find UK public sector tenders on Contracts Finder by keyword, region, value or CPV code. You get the buyer, the estimated value, the bid deadline and the days left, and whether the buyer marked it suitable for SMEs. Once a contract is awarded, you also get the winning supplier and the price. After the first run, it flags new tenders, fresh awards and moved deadlines.

Built for bid teams and small suppliers who want the right UK tenders in their inbox instead of refreshing Contracts Finder every morning.

### How it works

```mermaid
flowchart LR
    A["What you sell,<br/>region, value"] --> B["Contracts Finder API"]
    B --> C["Open tenders:<br/>deadline, value, SME"]
    B --> D["Awarded notices:<br/>winner and price"]
    C --> E["One row per notice,<br/>soonest deadline first"]
    D --> E
    E --> F{"Since last run?"}
    F -->|not seen| G["new-notice"]
    F -->|contract let| H["awarded"]
    F -->|date moved| I["deadline-changed"]
```

It doesn't scrape and doesn't need an API key. It reads the UK government's own Contracts Finder API. That API returns at most 1,000 notices per call and has no paging, so the Actor splits a busy date range into smaller windows and reads each one instead of quietly stopping at 1,000.

### Built for

- **SME suppliers** who can't afford a bid team watching portals all day
- **Bid and proposal managers** building a pipeline of qualified tenders
- **Sales teams selling to councils, NHS trusts and schools**
- **Competitor analysts** tracking who wins which contracts, at what price
- **Consultants** who find public sector work for clients

### Input

```json
{
  "keywords": ["cyber security", "penetration testing"],
  "statuses": ["Open"],
  "regions": ["London", "South East"],
  "minValue": 50000,
  "smeOnly": true,
  "onlyChanged": true
}
```

| Setting | What it does |
| --- | --- |
| `keywords` | What you sell. Each keyword runs its own search |
| `statuses` | `Open` to bid now, `Awarded` to see winners, or both |
| `lastDays` | How far back to look, by publish or update date |
| `regions` | UK regions. Notices open to any region are always kept |
| `minValue` | Skip contracts too small to be worth bidding on |
| `smeOnly` | Drop notices the buyer marked unsuitable for SMEs |
| `cpvPrefixes` | CPV codes, for example `72` for IT services |
| `buyers` | Only buyers whose name contains, for example, `NHS` |
| `closingWithinDays` | Only deadlines in the next N days |
| `onlyChanged` | Return nothing on a quiet run |

### Output

```json
{
  "title": "RFQ2026/37 - Specialist Consultancy Team for a new Theatre and Conference facility in Newry City",
  "buyer": "Newry, Mourne and Down District Council (NMD)",
  "status": "Open",
  "valueHigh": 29000,
  "publishedDate": "2026-09-22",
  "deadlineDate": "2026-10-07",
  "daysUntilDeadline": 14,
  "contractStart": "2026-10-28",
  "contractEnd": "2027-01-28",
  "suitableForSme": true,
  "regions": ["Any region"],
  "postcode": "BT34 2QU",
  "cpvCodes": ["79411000", "79411100", "73220000"],
  "cpvDescription": "General management consultancy services and Business development consultancy services",
  "awardedSupplier": null,
  "url": "https://www.contractsfinder.service.gov.uk/Notice/dcd45ad1-0712-46b9-a2d0-cff416b72f09",
  "changeType": "new-notice",
  "checkedAt": "2026-09-23T18:17:34.886Z"
}
```

An awarded notice fills in the winner:

```json
{
  "title": "Hillingdon PS HQ - M&E Works",
  "buyer": "METROPOLITAN POLICE SERVICE",
  "status": "Awarded",
  "awardedSupplier": "Overbury PLC",
  "awardedValue": 710527.65,
  "awardedDate": "2026-08-20"
}
```

### Two ways to use it

**Find work to bid on.** Keep `statuses` on `Open`, add your keywords and schedule it daily with `onlyChanged` on. The first run records what's already open. Every run after that returns only new tenders and moved deadlines.

**Watch the competition.** Set `statuses` to `Awarded` and search your service line to see who's winning, which buyers they win with and at what price. Include both `Open` and `Awarded` to follow a tender from publication through to the award. It comes back as `awarded` the day the winner is published.

### Run it as an API

```bash
curl -X POST "https://api.apify.com/v2/acts/arched_friend~uk-tender-monitor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["cleaning"],
    "statuses": ["Open"],
    "closingWithinDays": 21
  }'
```

### Pricing

You pay $0.002 for each notice returned. A quiet run with `onlyChanged` on costs nothing.

| Watching UK tenders daily | Monthly cost |
| --- | --- |
| Checking Contracts Finder by hand | 20 to 30 minutes every day |
| Tender alert subscriptions | roughly £50 to £300 per month |
| This Actor | under $1 per month for most searches |

### Common questions

**Does this cover Find a Tender?** No. It covers Contracts Finder, the UK government's register for public contracts, which is strongest on lower value English contracts. Some larger tenders appear only on the separate Find a Tender service, and this Actor doesn't search it.

**Why is a value null?** The buyer didn't publish one. Contracts Finder stores a missing value as 0 and some buyers type £1 as a placeholder, so both come back as null rather than a fake price. `minValue` keeps those notices rather than hiding them.

**Why do some results have an old publish date?** The date window matches notices published *or updated* in the period, so an older tender that has just been awarded shows up. That's usually the update you want.

**Do I need an API key?** No. Contracts Finder's API is public.

### Related products

- **EU Tender Monitor** for public contracts across the EU on TED
- **Federal Contract Finder** for US federal awards
- **Grant Opportunity Finder** for US federal grants
- **Company Hiring Monitor** to see which of your competitors are hiring after a big win

# Actor input Schema

## `keywords` (type: `array`):

What you sell, one per line, for example cleaning, cyber security or software. Each keyword runs its own search and the results are merged. Leave empty to see everything in the period.

## `statuses` (type: `array`):

Open tenders are taking bids now. Awarded notices show who won and for how much.

## `lastDays` (type: `integer`):

How far back to search. Keep it short for a scheduled run.

## `regions` (type: `array`):

Only notices for these regions. Notices open to any region are always kept. Leave empty for all.

## `minValue` (type: `integer`):

Drop notices worth less than this. Notices with no published value are kept.

## `smeOnly` (type: `boolean`):

Drop notices the buyer has marked as not suitable for small and medium businesses.

## `cpvPrefixes` (type: `array`):

Optional. Keep notices whose CPV codes start with any of these, one per line, for example 72 for IT services or 90910 for cleaning.

## `buyers` (type: `array`):

Optional. Keep notices from buyers whose name contains any of these, one per line, for example NHS or Council.

## `excludeTerms` (type: `array`):

Drop notices whose title, buyer or description contains any of these, one per line.

## `closingWithinDays` (type: `integer`):

Only notices whose bid deadline falls in the next N days. 0 keeps everything.

## `onlyChanged` (type: `boolean`):

Return nothing on a quiet run. Turn this on for a scheduled search so you only hear about new tenders, fresh awards and moved deadlines.

## `maxResults` (type: `integer`):

The most notices to read for each keyword.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for one answer from Contracts Finder before giving up on it.

## `timeBudgetSecs` (type: `integer`):

How long the run may spend before it returns what it has.

## Actor input object example

```json
{
  "keywords": [
    "software"
  ],
  "statuses": [
    "Open"
  ],
  "lastDays": 30,
  "regions": [],
  "minValue": 0,
  "smeOnly": false,
  "closingWithinDays": 0,
  "onlyChanged": false,
  "maxResults": 500,
  "requestTimeoutSecs": 45,
  "timeBudgetSecs": 150
}
```

# Actor output Schema

## `notices` (type: `string`):

One row per notice with buyer, value, deadline, SME suitability and any winning supplier, soonest deadline first.

## `runSummary` (type: `string`):

Counts of open and awarded notices, new ones, fresh awards and the total open value.

# 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 = {
    "keywords": [
        "software"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arched_friend/uk-tender-monitor").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 = { "keywords": ["software"] }

# Run the Actor and wait for it to finish
run = client.actor("arched_friend/uk-tender-monitor").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 '{
  "keywords": [
    "software"
  ]
}' |
apify call arched_friend/uk-tender-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arched_friend/uk-tender-monitor"
        }
    }
}
```

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/lI23Gf08mbZePwNgT/builds/FlS7mu87aF1DFekrY/openapi.json