# UK & Australia Tenders Scraper - Search Gov Contracts & Awards (`kadi_bence/gov-tenders-scraper`) Actor

Search UK and Australian government tenders and contract awards (Find a Tender, Contracts Finder, AusTender) via OCDS APIs. Input: sources, keywords, CPV/UNSPSC codes, notice types, dates, value range, buyer. Returns per notice: title, buyer, category, value, deadline, URL. Default: 20 notices.

- **URL**: https://apify.com/kadi_bence/gov-tenders-scraper.md
- **Developed by:** [Bence Kadi](https://apify.com/kadi_bence) (community)
- **Categories:** Lead generation, Automation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 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 Scraper: government contracts and awards API

Export **UK and Australian public tenders and contract awards** from **UK Find a Tender**, **UK Contracts Finder** and **AusTender** in one run. One clean row per notice as JSON, CSV or Excel: title, buyer, CPV/UNSPSC category, estimated value, deadline, **winning suppliers and awarded values**, region and link. No API key, no login, no browser.

### What is the UK & Australia Tenders Scraper?

It reads the official OCDS APIs of **Find a Tender** (higher-value UK notices, Procurement Act 2023), **Contracts Finder** (English contracts from about £12k-£30k, mostly awards) and **AusTender** (Australian Government awarded contracts) and returns one flat table. Field names match our **[EU Public Tenders Scraper (TED)](https://apify.com/kadi_bence/ted-tenders-scraper)**, so UK, Australian and EU notices stack in one sheet.

**Who uses it and why:**

- **Bid and tender managers** get a daily list of new UK tenders in their CPV codes, with deadlines, in Sheets, Slack or their CRM.
- **B2G sales teams** find public buyers that purchase what they sell, and see what they paid before.
- **Competitive intelligence analysts** track who wins UK and Australian government contracts, and for how much.
- **Market researchers and consultants** size public-sector demand by category, region and value.
- **Tender portals and AI agents** feed fresh procurement data into their products, together with EU (TED) and US (SAM.gov) data.
- **Journalists and NGOs** follow the spending of one buyer, such as an NHS trust.

#### Data fields

Every notice is one dataset item with these fields. Examples are from real runs on 2026-10-05.

| Field | Description | Example |
|---|---|---|
| `sourceCountry` | Country of the source (2-letter code) | `GB` |
| `source` | Source name | `UK Contracts Finder` |
| `sourceId` | Source ID, as used in the `sources` input | `uk_cf` |
| `publicationNumber` | Notice ID at the source (unique per source) | `093572-2026` |
| `ocid` | OCDS ID of the whole procurement process | `ocds-h6vhtk-078036` |
| `referenceNumber` | The buyer's own reference, when published | `SR3006962870` |
| `title` | Notice title | `Play Ground Refurbishment x 2` |
| `description` | What is being bought (contact data removed). Empty for AusTender | `Ingoldmells Parish Council is seeking ...` |
| `stage` | `planning`, `tender` or `award` | `tender` |
| `noticeType` | Notice type in plain English | `Tender notice` |
| `noticeTypeCode` | Source notice code | `UK4` |
| `isUpdate` | `true` for updated, amended or changed notices | `false` |
| `status` | Status at the source | `active` |
| `contractNature` | Works, goods or services (UK only) | `services` |
| `buyerName` | Contracting authority | `British Council` |
| `buyerCountry` | Buyer country (2-letter code) | `GB` |
| `buyerRegion` | UK ITL/NUTS code or Australian state | `UKI41` |
| `buyerCity` | Buyer city | `London` |
| `categoryScheme` | `CPV` (UK) or `UNSPSC` (Australia) | `CPV` |
| `mainCategory` | Main category code | `79340000` |
| `mainCategoryLabel` | English label of the main code (UK only) | `Advertising and marketing services` |
| `categoryCodes` | All category codes in the notice | `["45300000", "48000000", "32000000"]` |
| `mainCpv` | Main CPV code (UK only, same as TED) | `80000000` |
| `mainCpvLabel` | Label of the main CPV code | `Education and training services` |
| `cpvCodes` | All CPV codes (empty for AusTender) | `["80000000"]` |
| `estimatedValue` | Estimated value (empty if not published) | `75000` |
| `currency` | Currency of `estimatedValue` | `GBP` |
| `awardedValue` | Total value awarded (award notices) | `220591.2` |
| `awardedCurrency` | Currency of `awardedValue` | `AUD` |
| `winners` | Names of the winning suppliers | `["DELOITTE LLP"]` |
| `winnersOmitted` | Winners left out as natural persons | `1` |
| `publicationDate` | Date the source published the notice | `2026-10-04` |
| `deadline` | Deadline for tenders or expressions of interest | `2026-10-16T12:00:00+01:00` |
| `contractStart` | Contract start date | `2026-11-01` |
| `contractEnd` | Contract end date | `2029-10-31` |
| `procedureType` | Procedure, as the source names it | `Call-off from a framework agreement` |
| `placeOfPerformance` | Regions where the contract is performed | `["England"]` |
| `lotsCount` | Number of lots | `2` |
| `url` | Official notice page | `https://www.find-tender.service.gov.uk/Notice/093572-2026` |
| `attribution` | Licence attribution text for this source | `Contains public sector information licensed under ...` |
| `isNew` | Monitoring mode only: notice not seen before | `true` |
| `scrapedAt` | When the Actor saved the item (UTC) | `2026-10-05T04:48:17Z` |

**Use cases:** Generate leads (build B2B prospect lists) · Research markets & competitors (find deals & buy opportunities, build market datasets, track competitors) · Developer tools (extract government & public data, monitor & alert on website changes).

### How to use the UK & Australia tenders scraper

1. Open the Actor and click **Try for free** (you need a free Apify account).
2. Pick the **Sources** (all three by default) and, optionally, **Notice types**: "Tender" = open calls you can still bid on, "Award" = who won and for how much.
3. Set a date window, for example **Published within the last N days** = 3 (the prefill).
4. Optionally add **Keywords**, **Category codes**, a **minimum value**, a **buyer name** or **regions**.
5. Set **Max results** (the prefill is 30, about 15 seconds) and click **Start**.
6. Open the **Output** tab and download the data as CSV, Excel or JSON, or send it to Google Sheets.
7. For alerts, turn on **Only new notices**, then create a daily **Schedule** (see below).

#### Input guide

**Sources.** `uk_fts` (Find a Tender), `uk_cf` (Contracts Finder), `au_austender` (AusTender). AusTender has award notices only, so it is skipped (with a note in `RUN_SUMMARY`) if **Notice types** lacks "Award".

**Keywords.** Searched in title, description, buyer and category label (AusTender: title and buyer only). Several lines = OR. Case and accents do not matter.

- Good: `software`, `cleaning`, `cyber security`.
- Bad: `IT`. Terms also match inside words, so `IT` matches "facilities". Use a CPV code instead.

**Category codes (CPV / UNSPSC).** UK notices use CPV codes, AusTender uses UNSPSC. Sub-categories are included automatically.

- Good: `72000000` (all CPV IT services, including 72220000), `4323` (UNSPSC software, returns 43232300), or a short prefix such as `72`. `72000000-5` also works; the check digit is ignored.
- Warning: codes are checked against every selected source, and UNSPSC codes starting with 72 are building services, not IT. Run CPV searches on the UK sources and UNSPSC searches on AusTender separately.
- Tip: to find your codes, run a keyword search and look at `categoryCodes`.

**Notice types.** `tender` (open opportunities), `award` (winners and values), `planning` (pipeline and market engagement). Leave empty for all.

**Date window.** **Published within the last N days** for rolling searches (`0` = today), **Published from / to** for a fixed period; no dates = last 30 days.

- Warning: "last N days" replaces the from/to dates, so clear the prefilled `3` for a fixed period.

**Submission deadline on or after.** Only tenders you can still bid on. Accepts `2026-11-01`, `today` or `+14 days`. Notices without a deadline (awards, planning, all of AusTender) are excluded.

**Min / max value.** The estimated value, or the awarded value when there is no estimate, in GBP or AUD (no conversion). Notices without a value are excluded.

**Buyer name contains.** For example `NHS`, `County Council` or `Department of Defence`.

**Regions.** Prefix match on buyer region and place of performance: `UKI` (London), `UKM` (Scotland), `England`, or Australian states like `NSW`. Contracts Finder has no buyer region, so `UKI` finds few of its notices.

**Include updates and amendments.** On by default. Changed notices come as separate rows with `isUpdate: true`. Turn it off for first publications only.

**Max results.** Total notices (`0` = no limit), shared fairly: 30 gives 10 per source. Also your cost cap.

**Only new notices (monitoring mode).** Outputs (and charges) only notices not returned by earlier runs with the same filters. Use a different **Monitor name** for each saved search; changing any filter also starts a new list.

#### Input example: open UK IT tenders you can still bid on

```json
{
  "sources": ["uk_fts", "uk_cf"],
  "noticeTypes": ["tender"],
  "categoryCodes": ["72000000", "48000000"],
  "publishedWithinDays": 7,
  "deadlineAfter": "today",
  "minValue": 50000,
  "maxResults": 500,
  "onlyNewNotices": true
}
```

### Output

Each notice is one item in the run's dataset. This is a real Contracts Finder award notice from a run on 2026-10-05:

```json
{
  "sourceCountry": "GB",
  "source": "UK Contracts Finder",
  "sourceId": "uk_cf",
  "publicationNumber": "8ccf33cd-d570-41f3-b423-97f2a7b3bfcd-916399",
  "ocid": "ocds-b5fd17-4310452a-3d86-46ea-b34d-f2f93f29decb",
  "referenceNumber": "SR3006962870",
  "title": "TPC STRATEGIC DELIVERY PARTNER",
  "description": "Tax Profession Capability (TPC) Strategic Delivery Partner\nHM Revenue & Customs (HMRC) is seeking to appoint a Strategic Delivery Partner ...",
  "stage": "award",
  "noticeType": "Awarded contract notice",
  "noticeTypeCode": "award",
  "isUpdate": false,
  "status": "active",
  "contractNature": "services",
  "buyerName": "H M REVENUE & CUSTOMS",
  "buyerCountry": "GB",
  "buyerRegion": null,
  "buyerCity": "TELFORD",
  "categoryScheme": "CPV",
  "mainCategory": "79400000",
  "mainCategoryLabel": "Business and management consultancy and related services",
  "categoryCodes": ["79400000"],
  "mainCpv": "79400000",
  "mainCpvLabel": "Business and management consultancy and related services",
  "cpvCodes": ["79400000"],
  "estimatedValue": 13100000,
  "currency": "GBP",
  "awardedValue": 13100000,
  "awardedCurrency": "GBP",
  "winners": ["DELOITTE LLP"],
  "winnersOmitted": 0,
  "publicationDate": "2026-10-04",
  "deadline": null,
  "contractStart": "2026-10-05",
  "contractEnd": "2029-10-04",
  "procedureType": "Call-off from a framework agreement",
  "placeOfPerformance": ["England"],
  "lotsCount": null,
  "url": "https://www.contractsfinder.service.gov.uk/Notice/8ccf33cd-d570-41f3-b423-97f2a7b3bfcd",
  "attribution": "Contains public sector information licensed under the Open Government Licence v3.0. Source: Contracts Finder, Cabinet Office, https://www.contractsfinder.service.gov.uk",
  "scrapedAt": "2026-10-05T04:48:17Z"
}
```

On tender notices, `deadline` is filled and the winner fields are empty. AusTender rows have `categoryScheme: "UNSPSC"`, values in AUD and empty `cpvCodes`. Fields shared with our TED actor (`buyerName`, `mainCpv`, `estimatedValue`, `winners` ...) have the same name and meaning.

**Fill rates** in a live run of 1,000 notices (last 7 days, 2026-10-05): title, buyer, category code, publication date and link 100% for every source. Find a Tender: tender deadline 90%, estimated value 89%, award winners 99%, awarded value 96%. Contracts Finder: award winners 99%, awarded value 97%, tender deadline 100%. AusTender: awarded value 100%, winners 93% (the rest are individuals, left out for GDPR).

**Dataset views.** The **Output** tab shows three tables:

- **Notices**: date, source, title, type, buyer, category, estimated value, deadline, link. Best for daily review.
- **Awards and winners**: buyer, winners, awarded value, contract dates, link. Best for competitor analysis.
- **Full details**: description, procedure, region, all category codes, contract dates.

**Run summary.** Every run saves `RUN_SUMMARY` in the key-value store: filters used, per-source counts and errors, skipped sources and monitoring skips. The real summary of the prefilled run:

```json
{
  "filters": {"publishedFrom": "2026-10-02", "publishedTo": "2026-10-05", "noticeTypes": [], "keywords": [], "categoryCodes": []},
  "sources": {
    "UK Find a Tender": {"pages": 1, "fetched": 100, "matched": 100, "saved": 10},
    "UK Contracts Finder": {"pages": 1, "fetched": 61, "matched": 61, "saved": 10},
    "AusTender": {"pages": 1, "fetched": 100, "matched": 100, "saved": 10}
  },
  "skippedSources": {},
  "noticesSaved": 30,
  "skippedAlreadySeen": 0,
  "winnersOmittedNaturalPersons": 5,
  "requests": 6
}
```

**Export.** Download any view as JSON, CSV, Excel, XML, HTML or RSS from the Output tab or the API. You can also send results straight to Google Sheets with the Google Sheets integration.

### Pricing

This Actor uses **pay per event**: **$1.50 per 1,000 notices** saved ($0.0015 per notice). Apify also charges a start fee of **$0.00005 per run**. Platform compute is included in the price.

| Typical run | Notices | Cost |
|---|---|---|
| First test with the prefilled input | 30 | about $0.05 |
| Weekly export of UK tenders in a few CPV codes | 1,000 | about $1.50 |
| Daily UK + AU alert, about 100 new notices a day, for 30 days | 3,000 | about $4.50 per month |
| Bulk research export of award notices | 10,000 | about $15 |

**What is free:**

- In monitoring mode, notices already returned in earlier runs are skipped and not charged.
- Notices that do not match your filters are never charged; a search with no matches costs only the start fee.
- Apify's free plan gives you monthly platform credit (see apify.com/pricing), enough for a few thousand notices.

Cap spending with **Max results** or **Max charge per run** in the run options. At the cap, the Actor stops cleanly and keeps what it saved.

### Use it via API

Replace `MY_APIFY_TOKEN` with your token from Apify Console > Settings > API & Integrations.

**JavaScript / Node.js** (`npm install apify-client`):

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });
const run = await client.actor('kadi_bence/gov-tenders-scraper').call({
    sources: ['uk_fts', 'uk_cf'],
    noticeTypes: ['tender'],
    categoryCodes: ['72000000'],
    publishedWithinDays: 7,
    deadlineAfter: 'today',
    maxResults: 500,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0]?.title);
```

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("MY_APIFY_TOKEN")
run = client.actor("kadi_bence/gov-tenders-scraper").call(run_input={
    "sources": ["au_austender"],
    "publishedWithinDays": 30,
    "minValue": 1000000,
    "maxResults": 1000,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["buyerName"], item["winners"], item["awardedValue"], item["awardedCurrency"])
```

**cURL** (runs the Actor and returns the items in one call):

```bash
curl -X POST "https://api.apify.com/v2/acts/kadi_bence~gov-tenders-scraper/run-sync-get-dataset-items?token=MY_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"sources": ["uk_fts"], "noticeTypes": ["award"], "buyerName": "NHS", "publishedWithinDays": 1, "maxResults": 100}'
```

**Apify CLI:**

```bash
apify call kadi_bence/gov-tenders-scraper --input '{"sources": ["uk_fts", "uk_cf"], "keywords": ["cleaning"], "publishedWithinDays": 3, "maxResults": 50}' --output-dataset
```

**MCP (AI agents such as Claude, Cursor or VS Code).** Add this to your MCP client config. The client will ask you to sign in to Apify (or send your token as an `Authorization: Bearer` header):

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com/?actors=kadi_bence/gov-tenders-scraper"}}}
```

Then ask your agent things like "Find open UK cyber security tenders with a deadline after next week".

### Integrations and scheduling

- **Schedules.** In Apify Console, **Schedules > Create new**: pick this Actor or a saved task and a time.
- **Webhooks.** Call your own URL when a run succeeds or fails.
- **Zapier, Make and n8n.** Use the Apify app to run the Actor or react to finished runs, then send rows to your CRM, Slack or e-mail.
- **Google Sheets.** The Google Sheets integration on the **Integrations** tab appends each run's results to a sheet.

**Recipe: new UK tenders every morning.** UK sources, your **Category codes**, Notice types = Tender, last 2 days, deadline on or after `+7 days`, **Only new notices** on. Save as a task, schedule it daily at 07:00 and connect it to Google Sheets or Slack. Each morning you get only unseen notices.

**Recipe: weekly competitor wins.** Notice types = Award, your keywords or codes, last 7 days, weekly schedule, export the **Awards and winners** view to a sheet.

### Related actors by the same developer

- [EU Public Tenders Scraper (TED)](https://apify.com/kadi_bence/ted-tenders-scraper): EU public tenders and contract awards from TED, with the same field names as this Actor.
- [US Federal Contracts Scraper (SAM.gov)](https://apify.com/kadi_bence/sam-gov-scraper): US federal contract opportunities and awards, with NAICS and set-aside filters.

### FAQ

**How does it work, and where does the data come from?**
The Actor reads the official OCDS open-data APIs of the three sources, 100 notices per page, and applies your filters. The data may be re-used, also commercially; keep the `attribution` text of each row when you publish it.

- **Find a Tender and Contracts Finder** (Cabinet Office): [Open Government Licence v3.0](https://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/). Commercial and non-commercial use is allowed if you acknowledge the source: *"Contains public sector information licensed under the Open Government Licence v3.0."*
- **AusTender** (Department of Finance): [Creative Commons Attribution 3.0 Australia](https://creativecommons.org/licenses/by/3.0/au/). Any use, even commercial, if you give credit, link the licence and say if changes were made.

**Is it legal? What about personal data?**
Yes. It is official open data published for re-use, and the Actor respects robots.txt and rate limits. Contact names, e-mails and phone numbers are never output (`[email removed]` / `[phone removed]` in descriptions). Winners that look like natural persons, such as sole traders, are left out and counted in `winnersOmitted`. Descriptions can still mention people, so handle the data according to GDPR and the UK/Australian Privacy Acts.

**Why are there no open tenders from Australia?**
The AusTender API publishes awarded contracts only. Open approaches to market are not in the API, and AusTender's search pages are closed to robots, so we don't scrape them.

**What about Canada (CanadaBuys)?**
Not available. CanadaBuys data is under the Open Government Licence - Canada, but its robots.txt disallows all automated clients, and we follow robots.txt. The parser is ready; we will add Canada once automated access is allowed.

**Are there limits?**
Each source stops after 3,000 API pages (300,000 notices) per run, and monitoring remembers up to 300,000 notices per search. Only dates and notice types go to the APIs; other filters are applied after download, so a narrow search over a long window takes longer, but you pay only for matches.

**How fast is it?**
The prefilled run (30 notices) takes about 15 seconds; 1,000 notices from the three sources took 48 seconds in our test. If a source answers "429 Too Many Requests", the Actor waits and retries.

**How fresh is the data?**
As fresh as the sources: the APIs are read live at run time.

**Why are my results different from the websites?**
Sub-codes are always included, keywords match inside longer words, updates are included by default, natural-person winners are left out, and AusTender uses the Australian calendar day. Find a Tender's API filters by last update, so the Actor re-filters by publication date. `RUN_SUMMARY` shows the exact window and filters.

**Why is the estimated value or the deadline sometimes empty?**
Buyers don't always publish them, and award notices have no deadline. The Actor never invents values: a value of 0 is returned as empty.

**Can I use it from Python or connect it to Google Sheets, Slack or my CRM?**
Yes. See **Use it via API** and **Integrations and scheduling** above.

**How does "Only new notices" work?**
Returned notice IDs are stored in a named key-value store in your account. The next run with the same filters and monitor name outputs only unseen notices, marked `isNew: true`. Notices cut off by **Max results** are not marked as seen, so they come next run.

**What if a run fails or something looks wrong?**
Invalid input stops the run at once with a clear message. If one source is down, the Actor retries, then continues with the others and names the failed source in `RUN_SUMMARY`; the run fails only when every source fails. Open an issue on the **Issues** tab with the run link. Fixes usually land within 24 to 48 hours.

**What changed recently?**
See the changelog below.

### Need a custom version?

I build custom scrapers, scheduled data feeds and integrations (CSV, Excel, Google Sheets, API, MCP for AI agents). Tell me the sites and fields you need:

- Email: bence.kadi@gmail.com
- Apify profile: https://apify.com/kadi_bence

### Related Actors

More low-cost Actors by the same developer, built on official APIs and public data:

- [TED Tenders Scraper](https://apify.com/kadi_bence/ted-tenders-scraper) — EU public tenders and contract award winners
- [SAM.gov Scraper](https://apify.com/kadi_bence/sam-gov-scraper) — US federal contract opportunities and awards
- [Document to Markdown](https://apify.com/kadi_bence/document-to-markdown) — PDF, Word, PowerPoint and Excel to clean Markdown, with OCR
- [SEC Form D Scraper](https://apify.com/kadi_bence/sec-form-d-funding) — new startup funding rounds from SEC EDGAR
- [New Business Filings USA](https://apify.com/kadi_bence/us-new-business-filings) — newly registered LLCs and companies
- [Website Tech Stack Detector](https://apify.com/kadi_bence/tech-stack-detector) — CMS, ecommerce, analytics and frameworks of any website
- [Bulk WHOIS & RDAP Domain Lookup](https://apify.com/kadi_bence/domain-whois-lookup) — registrar, dates and DNS for many domains

All my Actors: [apify.com/kadi_bence](https://apify.com/kadi_bence)

### Changelog

- **1.0 (2026-10-05):** First release. UK Find a Tender, UK Contracts Finder and AusTender via the official OCDS APIs, TED-compatible fields, monitoring mode, CPV/UNSPSC sub-category matching, GDPR filtering of individuals.

# Actor input Schema

## `sources` (type: `array`):

Official procurement services to search. UK Find a Tender = higher-value UK notices (Procurement Act 2023). UK Contracts Finder = English public contracts over £12k-£30k, mostly awards. AusTender = Australian Government contract notices (awarded contracts only).

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

Words or phrases searched in the title, description, buyer name and category label, e.g. 'software', 'cleaning'. Several lines = any of them (OR). Accents and case don't matter, and a term also matches inside longer words, so avoid very short terms like 'IT'. AusTender rows have no description, so there keywords only search title and buyer. Leave empty for all notices.

## `categoryCodes` (type: `array`):

UK notices use CPV codes (e.g. 72000000 IT services, 45000000 construction), AusTender uses UNSPSC (e.g. 43230000 software, 80101500 consulting). Sub-categories are included: 72000000 also matches 72220000. You can type a short prefix like 72. Codes are checked against every selected source, so a CPV code can also match an unrelated UNSPSC code that starts with the same digits. For clean results, run UK (CPV) and AusTender (UNSPSC) searches separately.

## `noticeTypes` (type: `array`):

Leave empty for all. 'Tender' = open calls you can bid on (with deadlines). 'Award' = who won and for how much. 'Planning' = pipeline and pre-market engagement notices. AusTender only has awards.

## `publishedWithinDays` (type: `integer`):

e.g. 3 for the last three days, 0 for today only. When set, it replaces the 'Published from / to' dates below. Leave empty to use the date range below (default: last 30 days).

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

First publication date (YYYY-MM-DD).

## `publishedTo` (type: `string`):

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

## `deadlineAfter` (type: `string`):

Only tenders you can still bid on: deadline on or after this date. Accepts YYYY-MM-DD, 'today' or '+14 days'. Notices without a deadline (awards, planning) are excluded when you set this.

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

Estimated value, or the awarded value when there is no estimate, in the notice's currency (GBP for UK, AUD for Australia). Notices without a value are excluded when you set this.

## `maxValue` (type: `integer`):

Same rule as above.

## `buyerName` (type: `string`):

Words in the buyer's name, e.g. 'NHS', 'County Council' or 'Department of Defence'.

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

Buyer region or place of performance, prefix match. UK: ITL/NUTS codes like UKI (London), UKM (Scotland), UKL (Wales) or names like 'England'. Australia: ACT, NSW, VIC, QLD ...

## `includeUpdates` (type: `boolean`):

Also return changed or corrected notices (tender updates, award updates, contract changes). Turn off to get first publications only.

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

Stop after this many notices in total (shared fairly across the sources). 0 = no limit. The default without input (API, MCP and AI-agent calls) is 20.

## `onlyNewNotices` (type: `boolean`):

Remember returned notices and output only NEW ones on the next runs with the same search. Ideal for a daily schedule: you only pay for new notices.

## `monitorName` (type: `string`):

Keeps separate 'already seen' lists for different schedules. Changing any filter also starts a new list.

## `proxyConfiguration` (type: `object`):

Not needed: all sources are official open-data APIs.

## Actor input object example

```json
{
  "sources": [
    "uk_fts",
    "uk_cf",
    "au_austender"
  ],
  "publishedWithinDays": 3,
  "includeUpdates": true,
  "maxResults": 30,
  "onlyNewNotices": false,
  "monitorName": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All scraped notices (table view).

## `awards` (type: `string`):

Award notices with winning suppliers and awarded values.

## `noticesFull` (type: `string`):

All scraped notices with every field.

## `summary` (type: `string`):

Per-source pages, matches and notices saved, plus any problems.

# 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 = {
    "sources": [
        "uk_fts",
        "uk_cf",
        "au_austender"
    ],
    "publishedWithinDays": 3,
    "maxResults": 30,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kadi_bence/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 = {
    "sources": [
        "uk_fts",
        "uk_cf",
        "au_austender",
    ],
    "publishedWithinDays": 3,
    "maxResults": 30,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("kadi_bence/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 '{
  "sources": [
    "uk_fts",
    "uk_cf",
    "au_austender"
  ],
  "publishedWithinDays": 3,
  "maxResults": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call kadi_bence/gov-tenders-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kadi_bence/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/FRryAuT0cke7ST5tg/builds/ehGcph5lwDGgVk2TB/openapi.json