# UK & Australia Tenders: Contracts Finder + AusTender API (`wrtcom/gov-tenders-uk-au`) Actor

Public tenders and contract awards from UK Contracts Finder and AusTender (official OCDS APIs), with the winning supplier. Filter by keyword, value and date; daily new-only mode. $5 per 1,000 notices. No personal data.

- **URL**: https://apify.com/wrtcom/gov-tenders-uk-au.md
- **Developed by:** [WRTLabs](https://apify.com/wrtcom) (community)
- **Categories:** Lead generation, Business
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 tender notices

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 & Australia Tenders: Contracts Finder + AusTender API

Get public-sector tenders and contract notices from **UK Contracts Finder** and **AusTender**
in **one clean, unified format**, including **who won the contract** (supplier company, UK Companies
House number or Australian ABN). Filter by date, keywords and value, or run it daily and get
**only the new notices**.

Data comes from the official open-data APIs (OCDS) of both governments. We don't scrape
web pages and don't use logins, and the output contains **no contact details**: winning suppliers are shown only when they are a
company or public body.

### What you get

One row per notice, with the same fields for both countries:

| Field | Example |
|---|---|
| `country` | `UK` / `AU` |
| `notice_id` | `7917ed39-076b-…` (UK) / `CN4285896` (AU) |
| `published` | `2026-10-29T22:46:38Z` |
| `stage` | `tender`, `award`, `contract`, `planning` … |
| `title`, `description` | `Co-Sourced Internal Audit Service` |
| `buyer` | `ORBIT GROUP LIMITED` |
| `value`, `currency` | `840000`, `GBP` |
| `category`, `cpv_or_unspsc` | `services`, `79212000` |
| `deadline` | response deadline (UK open tenders) |
| `contract_start`, `contract_end` | contract period (AU) |
| `award_date`, `award_value` | for awarded contracts |
| `suppliers` | winning suppliers that are companies or public bodies: `name`, `company_number` (UK Companies House), `abn` (AU), `scale` (UK: `sme` / `large`) |
| `suppliers_withheld` | number of winners not shown because they may be individuals (sole traders, named partners) |
| `url` | link to the notice page on the official site (Contracts Finder `/Notice/…`, AusTender `/Cn/Show/…`) |
| `id` | unique record id (= `release_id`); used by "only new" mode |
| `ocid`, `release_id` | OCDS identifiers for joining with other data |
| `licence`, `licence_url`, `attribution` | source licence, kept on every row |

#### Example record

```json
{
  "id": "prod-2be96201192c44fda8188d1767a75650-5a519c064248358c89eb3cac35e33505",
  "country": "AU",
  "notice_id": "CN4287053",
  "published": "2026-11-05T06:19:48Z",
  "stage": "contract",
  "title": "Concur Licensing",
  "description": "Concur Licensing",
  "buyer": "Digital Transformation Agency",
  "value": 207837.43,
  "currency": "AUD",
  "category": null,
  "cpv_or_unspsc": "81162000",
  "deadline": null,
  "contract_start": "2026-10-28T13:00:00Z",
  "contract_end": "2029-10-27T13:00:00Z",
  "award_date": "2026-10-28T13:00:00Z",
  "award_value": 207837.43,
  "suppliers": [{"name": "Example Software Pty Ltd", "company_number": null, "abn": "11222333444", "scale": null}],
  "suppliers_withheld": 0,
  "url": "https://www.tenders.gov.au/Cn/Show/3d59bcdc-91b3-4aaf-9585-f844982a37d5",
  "ocid": "prod-2be96201192c44fda8188d1767a75650",
  "release_id": "prod-2be96201192c44fda8188d1767a75650-5a519c064248358c89eb3cac35e33505",
  "licence": "CC-BY-3.0-AU",
  "licence_url": "https://creativecommons.org/licenses/by/3.0/au/",
  "attribution": "AusTender materials are released by the Department of Finance. ..."
}
```

(Real record from a test run on 2026-11-05; attribution shortened here, full text in the data. The supplier and award fields were added on 2026-11-06 and are shown with a made-up supplier.)

Download the dataset as JSON, CSV, Excel or XML, or read it through the Apify API.

Each run also saves a **run report** (`RUN_REPORT` in the key-value store, linked on the Output tab):
per source, pages fetched, records delivered, block rate, invalid records, and whether the date range was
collected completely (if a run stops at its request limit, the status message says the results may be incomplete).

**Coverage note:** AusTender's API publishes **awarded contract notices (CNs)**, not open
tender opportunities. UK Contracts Finder covers tenders, awards and updates.

### Input

| Option | Default | |
|---|---|---|
| Countries | UK + AU | `uk`, `au` |
| Published from / to | last 7 days | `YYYY-MM-DD` |
| Keywords | (all) | matches title or description, any word |
| UK: awarded contracts only | off | UK award notices only (with the winner); AU is always awarded contracts |
| Minimum value | (none) | in the notice's currency (GBP/AUD); notices without a value are dropped |
| Max results | 1000 (form starts at 50 for a quick test) | hard stop, so you control cost |
| Only new since last run | off | turn on and schedule daily to get a fresh feed |

### Daily tender alert in 3 steps

1. Set **Keywords** for your sector (e.g. `software`, `cloud`, `cleaning`) and, if you like, a **Minimum value**.
2. Turn on **Only new since last run**.
3. Add a daily **Schedule** in Apify Console. Each run delivers only notices you have not seen yet.
   Send them on with an Apify integration (e.g. email, Slack, Google Sheets, Make, Zapier) or a webhook.

### Typical uses

- Daily alert of new public contracts in your sector (keywords + schedule + "only new").
- Market sizing: who buys what, for how much, in UK and Australia.
- Competitor and pipeline tracking for bid teams: who wins which contracts, for how much.

### Pricing

Pay per result: **$0.005 per notice** delivered to your dataset, plus a tiny start fee per run
(see the Pricing tab). Examples: 50 notices = $0.25; 1,000 notices = $5.
Notices dropped by your filters are free. *Max results* and the maximum cost per run cap what you pay.

### How it behaves

- Polite by design: obeys robots.txt, one request at a time per site, slows down automatically
  if a source rate-limits.
- Contact names, emails and phones are removed. Winning suppliers are shown only when they are clearly
  an organisation (the name ends in a legal form such as Ltd / Pty Ltd / LLP / PLC, or it is a public body
  such as a university or council, with no trading-as or personal part);
  possible individuals are withheld and only counted. Emails/phone numbers inside descriptions are masked.

### FAQ

**Which UK service is covered?** UK Contracts Finder only (open tenders, awards, updates).
Find a Tender (FTS) is not included.

**Does AusTender include open tenders?** No. The AusTender open-data API publishes awarded
contract notices (CNs). Open approaches to market (ATMs) are not in the API.

**How fresh is the data?** Each run reads the official APIs live, so it is as fresh as the
sources at run time.

**How long does a run take?** A quick test (form defaults, 50 results) takes about 20 seconds.
A week of both countries with keyword filters took about 2 minutes in our tests. UK Contracts
Finder limits request rates, so large date ranges take longer.

**Can I use it from code or an AI agent?** Yes: through the Apify API and client libraries
(Python, JavaScript), or as a tool for AI agents through the Apify MCP server.

**Is it legal to use the data?** Both sources are official open data (OGL v3 for the UK,
CC BY 3.0 AU for Australia). Keep the attribution in each row when you re-publish.

### Data licence and attribution

Re-use of the output must keep the attribution in each row:

- UK: *Contains public sector information licensed under the
  [Open Government Licence v3.0](https://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/).*
  Source: Contracts Finder, Cabinet Office.
- Australia (wording required by the [AusTender Terms of Use](https://help.tenders.gov.au/terms-of-use/), clause 6.1):
  *AusTender materials are released by the Department of Finance. AusTender materials are subject to
  change and should be verified on the AusTender website to ensure the information is up to date and
  correct: www.tenders.gov.au.* Licensed under
  [CC BY 3.0 AU](https://creativecommons.org/licenses/by/3.0/au/). Data filtered and reformatted.
  Only contract notice data is included; Approach to Market (ATM) documents are copyright and are never collected.

This Actor is not affiliated with or endorsed by the UK or Australian governments.

# Actor input Schema

## `countries` (type: `array`):

Sources to search: uk = UK Contracts Finder, au = AusTender.

## `dateFrom` (type: `string`):

First publication date (YYYY-MM-DD). Default: 7 days before 'Published to'.

## `dateTo` (type: `string`):

Last publication date (YYYY-MM-DD). Default: today.

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

Keep only notices whose title or description contains any of these words (case-insensitive), e.g. software, cloud, cleaning. Empty = all.

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

Keep only notices with a value at least this amount, in the notice's own currency (GBP or AUD). Notices without a value are dropped when set.

## `awardsOnly` (type: `boolean`):

UK: return only contract award notices (with the winning supplier). Australia (AusTender) results are always awarded contracts.

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

Stop after this many results in total (you pay per result). The form starts at 50 for a quick test; default without a value is 1000.

## `onlyNew` (type: `boolean`):

Skip notices already returned by earlier runs on your account. Use with a daily schedule.

## Actor input object example

```json
{
  "countries": [
    "uk",
    "au"
  ],
  "awardsOnly": false,
  "maxItems": 50,
  "onlyNew": false
}
```

# Actor output Schema

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

One row per notice: country, notice_id, url, published, stage, title, description, buyer, value, currency, category, cpv_or_unspsc, deadline, contract dates, OCDS ids, licence and attribution.

## `allFields` (type: `string`):

Same notices with every field.

## `runReport` (type: `string`):

JSON report per source: pages fetched, records scanned and delivered, success/block rate, whether the date range was collected completely.

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

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

# Run the Actor and wait for it to finish
run = client.actor("wrtcom/gov-tenders-uk-au").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": 50
}' |
apify call wrtcom/gov-tenders-uk-au --silent --output-dataset

```

## MCP server setup

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

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/OMgL5vdYsnoc3rRBj/builds/g7SQzKX9QzePxqsoY/openapi.json