# AusTender Scraper — Australian Government Contracts & Expiry (`publicdata/austender-australian-government-contracts`) Actor

Export Australian Government contract notices from the official AusTender OCDS API: supplier, agency, value, UNSPSC category and contract period. Query by contract END date to find the contracts coming up for renewal, or by publish date for new awards. No API key.

- **URL**: https://apify.com/publicdata/austender-australian-government-contracts.md
- **Developed by:** [PublicData](https://apify.com/publicdata) (community)
- **Categories:** Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.25 / 1,000 contracts

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

**See which contracts the Australian Government is about to have to re-award — and who currently holds them, for how much, until exactly when.**

Most tender tools tell you about opportunities once they are announced, which is the moment you are already late. AusTender's own API can be queried by **contract end date**, and this Actor exposes that directly: ask for the contracts finishing in the next 90 days and you get the incumbent, the agency, the value and the expiry date, months before the replacement goes out to market.

It reads the official AusTender OCDS API. No API key, no login, no proxies.

### What you get

One row per contract notice.

**The renewal signal**

- **`contractEnd`** — when the current contract runs out, and `contractStart`
- `contractStatus`, `dateSigned`

**Who holds it**

- **`supplierName`** and **`supplierAbn`** — the ABN joins straight onto Australian company data
- `supplierLocality`, `supplierRegion`, `supplierPostcode`, `supplierCountry`

**Who bought it**

- **`agencyName`** and `agencyAbn`

**Who to talk to about this contract**

- `contractContactEmail`, `contractContactPhone`, `contractContactUnit` — the **buying agency's** contract officer or helpdesk. AusTender files these under the supplier in its OCDS output, but they are the agency's: of 896 populated addresses measured on 2026-08-21, 891 were `*.gov.au` and none belonged to the supplier. Named here for what they actually are. There are no supplier contact details in this feed.

**What and how much**

- `title`, `description`, **`value`** in `currency` (AUD)
- **`unspscCode`** and **`unspscCategory`** — the raw UNSPSC code and a readable category label

**How it was awarded**

- `procurementMethod` and `procurementMethodDetails`
- **`procurementMethod`** — `limited` marks a contract awarded *without* open competition. This is what `limitedTenderOnly` filters on.
- **`limitedTenderExempt`**, `exemptionCode` and `exemption` — the narrower Commonwealth Procurement Rules exemption flag and the justification the agency cited. Measured 2026-08-21 over 600 July contracts: 48 of 366 limited-tender rows (13%) carried a published reason; the rest leave these empty, because the agency filed none.

**Provenance**

- `cnId` (the CN number AusTender itself indexes on), `ocid`, `releaseId`, `publishedDate`, `awardId`, `awardDate`, `awardStatus`, `searchUrl`, `source`, `sourceApi`

### Who uses this

- **Bid teams** — filter on `contractEnd` for the next two quarters in your UNSPSC category, and approach the agency while the re-tender is still being scoped.
- **Sales and account teams** — see every federal contract a competitor holds, its value and its expiry, by putting their name in `supplierName`.
- **Market analysts** — spend by agency, category and year, with the ABN as a join key.
- **Journalists and transparency researchers** — `limitedTenderOnly` isolates contracts awarded without open competition and returns the exemption each agency claimed.
- **Developers and AI agents** — one flat schema over the OCDS feed, callable over the API or as an MCP tool.

### Example output

A contract coming up for renewal — a real record, shortened:

```json
{
  "cnId": "CN4258099",
  "contractStart": "2026-06-15",
  "contractEnd": "2027-03-30",
  "supplierName": "RWM ITALIA SPA",
  "agencyName": "Department of Defence",
  "description": "Ammunitions",
  "value": 4337124.0,
  "currency": "AUD",
  "unspscCode": "46110000",
  "unspscCategory": "Defence and law enforcement and security and safety equipment",
  "procurementMethod": "limited",
  "source": "AusTender (Australian Government), CC BY 3.0 AU"
}
```

Note that this one was awarded by limited tender and files no exemption — which is why `limitedTenderOnly` keys on `procurementMethod`, not on the exemption flag.

Where the agency *did* publish a justification, it comes through in full:

```json
{
  "cnId": "CN4265960",
  "supplierName": "The University of Melbourne",
  "agencyName": "CSIRO",
  "value": 1189177.0,
  "currency": "AUD",
  "procurementMethod": "limited",
  "procurementMethodDetails": "Limited tender",
  "limitedTenderExempt": true,
  "exemptionCode": "GE",
  "exemption": "App A: 2. From another Commonwealth, state, territory or local government entity."
}
```

### Input

| Field | What it does |
|---|---|
| `dateType` | Which date the window filters on. **`contractEnd`** = expiring contracts (the renewal radar). `contractPublished` = new awards. Also `contractStart`, `contractLastModified`. |
| `dateFrom` / `dateTo` | The window, `YYYY-MM-DD`. Left empty it defaults sensibly: the **last 7 days** for new awards, the **next 90 days** for expiring contracts. |
| `query` | Keyword across title, description, supplier and agency. |
| `unspscCodes` | Category prefixes: `43` IT and telecoms, `80` management and consultancy, `72` construction, `85` health, `92` defence and security. |
| `agencyName` | Agency name contains, e.g. `Defence`. |
| `supplierName` | Supplier name contains — track one company's federal book. |
| `minValue` / `maxValue` | Bounds in AUD. Contracts with no published value are excluded when either is set. |
| `limitedTenderOnly` | Keep only contracts awarded without open competition (`procurementMethod` = limited). |
| `maxItems` | Safety cap. `0` = unlimited. |

IT contracts expiring in the first half of 2027 — the ones worth positioning for now:

```json
{ "dateType": "contractEnd", "dateFrom": "2027-01-01", "dateTo": "2027-06-30", "unspscCodes": ["43"], "minValue": 100000 }
```

Everything a competitor has won this year:

```json
{ "dateType": "contractPublished", "dateFrom": "2026-01-01", "dateTo": "2026-08-21", "supplierName": "Accenture", "maxItems": 0 }
```

Defence contracts awarded without open competition last month:

```json
{ "dateType": "contractPublished", "dateFrom": "2026-07-01", "dateTo": "2026-07-31", "agencyName": "Defence", "limitedTenderOnly": true }
```

### Run it on a schedule

Save your filters as a Task and schedule it. For a renewal radar, leave the dates empty with `dateType: "contractEnd"` — every run then covers the next 90 days on a rolling basis. For new awards, leave them empty with `contractPublished` and run daily.

Attach an Apify integration and results land in **Google Sheets**, **Slack**, **e-mail**, a **webhook**, or **Make** and **Zapier**.

Deduplicate on **`releaseId`**, which is unique per publication. Use `cnId` instead if you want one row per contract and are happy for a later amendment to update it — `ocid` groups every release about the same procurement.

### Use it from code or from an AI agent

Start runs and read the dataset over the Apify API or CLI as JSON, CSV, Excel or XML. The Actor is also exposed as an **MCP tool** via the Apify MCP server, so an agent can answer "which Defence IT contracts expire before June?" in a single call.

### Pricing

Pay per event: a small fee per contract exported. API calls only — no browser, no proxy — so platform usage on top is negligible. Use `maxItems` for a hard ceiling.

### Where the data comes from

The official **AusTender** OCDS API (`api.tenders.gov.au/ocds`), published by the Australian Government **Department of Finance** under a **Creative Commons Attribution 3.0 Australia** licence, which permits commercial reuse with attribution. Every row carries the `source` field for exactly that.

**Honest limits**, all measured against the live API on 2026-08-21.

This feed is contract-centric: it covers **awarded contract notices**, not open approaches to market, so it tells you who won and when it ends rather than what you can bid on today. Contracts are reported at or above the A$10,000 reporting threshold for most entities, so smaller spending is not here.

The API accepts only four date types — published, start, end and last-modified — and this Actor exposes all four. There is **no** server-side keyword, value, agency or supplier filter, so those are applied to the records as they are read; that is why a narrow filter over a wide window still costs time even though you are only charged for exported rows.

**No supplier contact details exist in this feed.** The contact block AusTender files under the supplier is the buying agency's — see `contractContactEmail` above.

**No per-notice deep link exists either.** The GUID inside the OCID is not the one the notice page expects, so `searchUrl` opens AusTender's contract-notice search with the CN id already filled in; you press Search to reach the notice.

An exemption reason accompanies about one limited-tender contract in eight (48 of 366 measured over July 2026). The UNSPSC label is the top-level category, not the full eight-digit description.

A single run reads at most **50,000 contracts** — the Actor's own ceiling, which it reports in the log when it hits it. Narrow the date window and run again to go past that.

This Actor is independent and not affiliated with the Australian Government.

### Frequently asked questions

**Can AusTender data be reused commercially?**

Yes. The Australian Government Department of Finance publishes it under a Creative Commons Attribution 3.0 Australia licence, which permits commercial reuse with attribution.

**How do I find contracts about to expire?**

Set `dateType` to `contractEnd`. This is the feature the AusTender Scraper exists for: you see the incumbent supplier, the value and the expiry date months before the replacement goes out to market.

**Does it include tenders I can still bid on?**

No. The AusTender OCDS feed is contract-centric: it covers awarded contract notices. It tells you who won and when it ends, not what is open today.

**Why do most limited-tender rows have no exemption reason?**

Because the agency did not file one. Roughly one limited-tender contract in nine carries a published justification; the rest leave those fields empty.

### Related Actors

Same engine, same official-source approach:

- [**UK Public Tenders**](https://apify.com/publicdata/uk-contracts-finder-find-a-tender) — Contracts Finder and Find a Tender in one run, tenders and awards
- [**EU Tenders (TED)**](https://apify.com/publicdata/ted-tenders-eu-procurement) — European procurement notices and contract awards
- [**Swiss Public Tenders (simap.ch)**](https://apify.com/publicdata/simap-swiss-public-tenders) — tenders and awards with prices, bid counts and weighted criteria
- [**Swiss Commercial Register (SHAB)**](https://apify.com/publicdata/shab-swiss-company-gazette) — new companies, changes, deletions and bankruptcies
- [**France Company Register**](https://apify.com/publicdata/sirene-siren-french-company-search) — SIREN/SIRET, executives, official labels
- [**GLEIF LEI**](https://apify.com/publicdata/gleif-lei-scraper) — LEI lookup, lapsed-LEI screening, parent companies

***

#### Italiano

Esporta gli **appalti del governo australiano** dall'API ufficiale AusTender: fornitore, agenzia, importo, categoria e periodo contrattuale. La funzione distintiva è la ricerca per **data di fine contratto**: si ottengono i contratti in scadenza nei prossimi mesi — con chi li detiene oggi e per quanto — prima che la riassegnazione venga bandita. Il flag `limitedTenderExempt` isola gli affidamenti senza gara, con la motivazione dichiarata dall'agenzia.

#### Deutsch

Exportiert **Aufträge der australischen Bundesregierung** aus der offiziellen AusTender-API: Lieferant, Behörde, Auftragswert, Kategorie und Vertragslaufzeit. Das Alleinstellungsmerkmal ist die Suche nach **Vertragsende**: Sie sehen auslaufende Verträge samt aktuellem Auftragnehmer, lange bevor neu ausgeschrieben wird. `limitedTenderExempt` filtert freihändige Vergaben inklusive der von der Behörde angegebenen Ausnahmebegründung.

#### Français

Exporte les **marchés du gouvernement australien** depuis l'API officielle AusTender : titulaire, agence, montant, catégorie et période contractuelle. La particularité est la recherche par **date de fin de contrat** : vous obtenez les marchés arrivant à échéance, avec leur titulaire actuel, bien avant la remise en concurrence. `limitedTenderExempt` isole les attributions sans mise en concurrence et la justification invoquée.

# Actor input Schema

## `dateType` (type: `string`):

Which date the window below filters on. **contractEnd** finds contracts coming up for renewal — the re-tender radar. contractPublished finds newly awarded contracts.

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

Start of the window (YYYY-MM-DD). Empty = last 7 days, or the next 90 days when dateType is contractEnd.

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

End of the window (YYYY-MM-DD).

## `query` (type: `string`):

Matched against contract title, description, supplier and agency.

## `unspscCodes` (type: `array`):

Code prefixes: `43` IT and telecoms, `80` management and consultancy, `72` construction, `85` health, `92` defence and security.

## `agencyName` (type: `string`):

e.g. `Defence`, `Health`, `Australian Taxation Office`.

## `supplierName` (type: `string`):

Track one company's federal contracts, e.g. `Accenture`.

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

Drop contracts below this amount.

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

Drop contracts above this amount.

## `limitedTenderOnly` (type: `boolean`):

Keep only contracts the agency awarded without open competition (`procurementMethod` = limited). Where the agency published a justification, `exemptionCode` and `exemption` carry it — measured 2026-08-21, 48 of 366 such rows did.

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

Safety cap. 0 = unlimited.

## Actor input object example

```json
{
  "dateType": "contractPublished",
  "unspscCodes": [],
  "limitedTenderOnly": false,
  "maxItems": 500
}
```

# Actor output Schema

## `dataset` (type: `string`):

Australian Government contract notices with supplier, agency, value, UNSPSC category and contract period. Every exported row is one dataset item.

# 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 = {
    "dateType": "contractPublished",
    "query": "",
    "unspscCodes": [],
    "agencyName": "",
    "supplierName": "",
    "maxItems": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("publicdata/austender-australian-government-contracts").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 = {
    "dateType": "contractPublished",
    "query": "",
    "unspscCodes": [],
    "agencyName": "",
    "supplierName": "",
    "maxItems": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("publicdata/austender-australian-government-contracts").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 '{
  "dateType": "contractPublished",
  "query": "",
  "unspscCodes": [],
  "agencyName": "",
  "supplierName": "",
  "maxItems": 500
}' |
apify call publicdata/austender-australian-government-contracts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,publicdata/austender-australian-government-contracts"
        }
    }
}

```

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/ldY6XtpqW5T9bN8wt/builds/Bk6M2xIqvMcGWArEH/openapi.json