# AusTender Scraper: Australian Government Contracts (`agents001/australia-gov-contracts-feed`) Actor

Scrape AusTender contract notices for Australian government contracts: winning supplier, ABN, state, agency, value in AUD, UNSPSC category, description, contract dates and procurement method. Filter by agency, category, keyword, value or ABN, and get only new notices on a schedule.

- **URL**: https://apify.com/agents001/australia-gov-contracts-feed.md
- **Developed by:** [Mike Ross](https://apify.com/agents001) (community)
- **Categories:** Lead generation, Business
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 contract notices

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?

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

## AusTender Scraper: Australian Government Contracts

Scrape AusTender contract notices and get the companies that just won Australian Government contracts, as clean structured data: **one record per AusTender contract notice** with the winning supplier's name, ABN, suburb, state and postcode, the buying agency, the contract value in AUD, the UNSPSC category, the description, contract start and end dates, the procurement method, the CN id and a link to the official notice.

Under the Commonwealth Procurement Rules, federal agencies must publish a contract notice on AusTender within 42 days of entering into any contract worth AUD 10,000 or more. That makes AusTender the most complete public list of who is selling to the Australian Government, and around 1,000 new notices appear every week. Schedule this Actor daily with `onlyNew` switched on and you get a fresh list of companies with new government revenue, new projects to staff and supply, and a reason to call.

Use it to:

- Build a weekly list of companies that just won Australian Government contracts in your category, state and value range.
- Find prime contractors to partner with or subcontract to.
- Get a record every time a competitor's ABN wins a contract.
- Spot contracts about to expire, using contract end dates, before the work goes back to market.
- Track government spending by agency, supplier or category.

### What you get

| Field | Example |
|---|---|
| `supplierName`, `supplierAbn` | `Technology One Limited`, `84010487180` |
| `supplierSuburb`, `supplierState`, `supplierPostcode`, `supplierCountry` | `FORTITUDE VALLEY`, `QLD`, `4006`, `Australia` |
| `agency`, `agencyAbn` | `National Indigenous Australians Agency`, `30429895164` |
| `valueAud` | `1211087.14` (including GST; for amendments, the amended total) |
| `unspscCode` | `81162000` |
| `description`, `agencyReference` | `Software`, `NCD11771` |
| `contractStart`, `contractEnd`, `contractMonths` | `2026-08-24`, `2027-08-30`, `12.2` |
| `publishedAt` | `2026-10-21T02:33:50Z` |
| `procurementMethod`, `procurementMethodDetails` | `open`, `Open tender` (also `limited` or `prequalified`) |
| `limitedTenderReason`, `exemption` | Why a limited tender or exemption was used, when published |
| `cnId`, `isAmendment`, `amendmentId` | `CN4283814`, `true`, `CN4283814-A1` |
| `cnUrl`, `apiUrl` | The notice on tenders.gov.au and the same record in the AusTender API |
| `isNew` | Whether the notice is new since the previous run with the same filters |

The Output tab has three views: **Contracts**, **Supplier leads** and **Amendments**.

### Who it is for

- **Sales and business development teams**: a company that just won a AUD 2 million Defence software contract is hiring, buying and subcontracting. Filter by category, value and state to build a weekly target list.
- **Subcontractors and partners** looking for prime contractors in their field.
- **Competitor watchers**: list your competitors' ABNs and get a note every time they win.
- **Analysts and journalists** tracking government spending by agency, supplier or category.

### Quick start

1. Click **Start** with no input. You get the contract notices published in the last 7 days.
2. Add filters, for example agency `Defence`, UNSPSC code `43000000` (all IT), minimum value `100000`, supplier state `VIC`.
3. Schedule it daily with **Last N days** set to `3` and **Only notices not seen in previous runs** switched on. Connect the dataset to email, Slack, Google Sheets or your CRM with an Apify integration or webhook.

### Input

| Field | What it does | Default |
|---|---|---|
| `daysBack` | Window of days up to now | 7 |
| `dateFrom`, `dateTo` | A fixed window instead, as Canberra dates (`2026-10-01`). The end date is included | none |
| `dateType` | `published` (new notices), `contractStart`, `contractEnd` (contracts about to expire; future windows work) or `lastModified` | `published` |
| `agencies` | Agency name contains any of these words, or agency ABN | all |
| `unspscCodes` | Category codes. Trailing zeros widen the match: `43000000` is a whole segment, `8111` a family | all |
| `keywords` | Description, supplier, agency or agency reference contains any of these words | all |
| `minValueAud` | Only contracts worth at least this much | none |
| `supplierAbns` | Only these suppliers (11-digit ABNs) | all |
| `supplierStates` | `ACT`, `NSW`, `NT`, `QLD`, `SA`, `TAS`, `VIC`, `WA` or `Outside Australia` | all |
| `includeAmendments` | Also return amendment notices | true |
| `onlyNew` | Only notices not returned by a previous run with the same filters | false |
| `maxItems` | At most this many records, newest first. `0` means no limit | 1000 |

Example input for a daily IT sales feed:

```json
{
  "daysBack": 3,
  "unspscCodes": ["43000000", "81110000"],
  "minValueAud": 250000,
  "supplierStates": ["NSW", "ACT", "VIC"],
  "onlyNew": true
}
```

Example input for contracts ending in the next quarter (renewal and replacement opportunities):

```json
{
  "dateType": "contractEnd",
  "dateFrom": "2026-11-01",
  "dateTo": "2027-01-31",
  "minValueAud": 1000000
}
```

### Output example

```json
{
  "cnId": "CN4283814",
  "amendmentId": "CN4283814-A1",
  "isAmendment": true,
  "supplierName": "Technology One Limited",
  "supplierAbn": "84010487180",
  "supplierSuburb": "FORTITUDE VALLEY",
  "supplierState": "QLD",
  "supplierPostcode": "4006",
  "supplierCountry": "Australia",
  "agency": "National Indigenous Australians Agency",
  "agencyAbn": "30429895164",
  "valueAud": 1211087.14,
  "unspscCode": "81162000",
  "description": "Software",
  "agencyReference": "NCD11771",
  "contractStart": "2026-08-24",
  "contractEnd": "2027-08-30",
  "contractMonths": 12.2,
  "publishedAt": "2026-10-21T02:33:50Z",
  "procurementMethod": "open",
  "procurementMethodDetails": "Open tender",
  "limitedTenderReason": null,
  "exemption": null,
  "contractStatus": "active",
  "cnUrl": "https://www.tenders.gov.au/Cn/Show/3178fd14-ea3d-48bb-b980-ceabc38fecf8",
  "apiUrl": "https://api.tenders.gov.au/ocds/findById/CN4283814",
  "releaseId": "prod-38d7191152074b71868180192d2e0e8e-193a23db7b713b78b3cffa172154fef8",
  "ocid": "prod-38d7191152074b71868180192d2e0e8e",
  "isNew": true,
  "source": "AusTender (Australian Government Department of Finance), CC BY 3.0 AU",
  "recordType": "contractNotice",
  "scrapedAt": "2026-10-23T08:00:00Z",
  "schemaVersion": 1
}
```

A run report is saved in the key-value store as `RUN_SUMMARY`: records returned, notices scanned, sole-trader notices skipped, total value returned, and the licence attribution text.

### Pricing

This Actor uses **pay per event** pricing, with platform usage included:

- **$2.50 per 1,000 contract notices** (`contract-notice` event, $0.0025 each), with lower rates on higher Apify plans.

You only pay for records saved to your dataset, so filters, `onlyNew` and `maxItems` keep costs down. A daily `onlyNew` run with no filters returns roughly 200 notices on a weekday, about $0.50. A filtered run (one category, a minimum value) usually returns a few dozen. Set a maximum cost per run in the run options and the Actor stops cleanly when it is reached.

### How "only new notices" works

When `onlyNew` is on, the Actor remembers which notices it has already returned for this set of filters in a key-value store in your account called `agents001-australia-gov-contracts-feed-state`. The next run only returns notices that are not on that list. The date window is not part of the history key, so a rolling "last 3 days" schedule keeps one history. Changing the filters starts a fresh history. The store holds notice ids and publish times only.

With `onlyNew` off, the Actor does not open or update this store, so every record has `isNew` set to true. If a run stops with a message that it cannot open the store (for example because another Actor in your account already uses that name), enter a different name in **State store name** and run again.

Amendments are separate notices with their own id, so an amended contract comes through again with `isAmendment: true`. Switch off **Include amendments** if you only want original awards.

### Good to know

- Agencies have up to 42 days to publish a notice, so the publish date is often weeks after the contract start date. Use `dateType: published` for "just announced".
- No notices are published on weekends, so a Saturday or Sunday window is empty.
- Values include GST and are the total expected value over the life of the contract.
- AusTender publishes the supplier's legal name. For sole traders that is a person's name, so those notices are skipped by default to keep the output company-level. The run report counts them.
- Agency contact officers' names, emails and phone numbers, and supplier street addresses, are never output.
- UNSPSC codes are returned as codes. The UNSPSC code list is published by GS1 US at unspsc.org.

### Data source, licence and attribution

All data comes from the official [AusTender OCDS API](https://github.com/austender/austender-ocds-api) (`api.tenders.gov.au`) published by the Australian Government Department of Finance. Under the [AusTender terms of use](https://www.tenders.gov.au/infolinks/termsofuse), contract notice data is licensed under the [Creative Commons Attribution 3.0 Australia licence (CC BY 3.0 AU)](https://creativecommons.org/licenses/by/3.0/au/), which allows commercial reuse with attribution. The Actor reformats the data (field names, dates in Canberra time, contact details removed). When you pass the data on, include this attribution, which the terms require:

> 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.

Every record also carries a `source` field and a `cnUrl` link to the official notice. The Actor reads contract notices only and does not collect Approach to Market (tender) documents, which the terms exclude from the licence.

### FAQ

**How fresh is the data?**
Each run reads the AusTender API live, so a notice appears as soon as the agency publishes it. Agencies have up to 42 days after signing to publish, and no notices are published on weekends.

**How much does a typical run cost?**
$2.50 per 1,000 contract notices, with lower rates on higher Apify plans. A daily `onlyNew` run with no filters returns roughly 200 notices on a weekday, about $0.50. A filtered run usually returns a few dozen.

**Can I schedule it and get only new notices?**
Yes. Schedule it daily with **Only notices not seen in previous runs** switched on. See How "only new notices" works above.

**Does it need a login or API key?**
No. The AusTender OCDS API is public and needs no login. You only need your Apify account.

**What formats can I export?**
JSON, CSV or Excel from the Output tab, or read the dataset through the Apify API.

**Is it legal to use this data? Where does it come from?**
The data comes from the official AusTender OCDS API published by the Department of Finance, under the CC BY 3.0 AU licence, which allows commercial reuse with attribution. See Data source, licence and attribution above for the required wording.

**Why is `supplierAbn` empty for some notices?**
Most overseas suppliers have no ABN. A few Australian notices also lack one.

**Why are suburb and postcode empty for overseas suppliers?**
AusTender stores placeholder values for overseas addresses, so the Actor returns only the country and `Outside Australia` as the state.

**How far back can I go?**
To 1 January 2013. Large windows take longer: the API returns 100 notices per page, about 1.5 seconds each, so a month takes about a minute and a year about 15 minutes. Use `maxItems` or filters for quick tests.

**What exactly is a contract notice?**
A record of a contract that has already been signed, with the supplier who won it. Open tenders (Approach to Market notices) are a different AusTender notice type and are not included.

**Something looks wrong. What should I do?**
Open an issue on the Actor's Issues tab with the run link and the CN id.

### Disclaimer

This Actor is independent and is not affiliated with, endorsed by or sponsored by AusTender, the Department of Finance or the Australian Government. Contract data belongs to its publishers; check the official notice on www.tenders.gov.au before acting on it.

# Actor input Schema

## `daysBack` (type: `integer`):

Window of days up to now. Used when no start or end date is given, and as the window length when only an end date is given.

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

First day of the window, read in Canberra time. Overrides 'Last N days'. Example: 2026-10-01.

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

Last day of the window, included, read in Canberra time. Leave empty for today.

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

Published date finds newly announced contracts (best for buying signals). Contract end date finds contracts about to expire, so a future window works too.

## `agencies` (type: `array`):

Only contracts from agencies whose name contains any of these words, or whose ABN matches. Examples: 'Defence', 'Services Australia', 'Taxation'. Case-insensitive.

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

Only contracts in these categories. Trailing zeros widen the match: 43000000 is all IT and telecoms, 8111 is all computer services, 81111500 is software engineering.

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

Only contracts whose description, supplier name, agency or agency reference contains any of these words or phrases. Case-insensitive.

## `minValueAud` (type: `integer`):

Only contracts worth at least this much, including GST. AusTender publishes contracts from AUD 10,000.

## `supplierAbns` (type: `array`):

Only contracts won by these suppliers. 11-digit ABNs; spaces are ignored. Use this to watch competitors or accounts.

## `supplierStates` (type: `array`):

Only suppliers based in these states or territories: ACT, NSW, NT, QLD, SA, TAS, VIC, WA or 'Outside Australia'.

## `includeAmendments` (type: `boolean`):

Also return amendment notices (for example a contract extended or its value changed). They carry isAmendment true and the amended total value.

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

Remember which notices were already returned for these filters and only return new ones. The first run returns everything in the window. Ideal for a daily schedule with 'Last N days' set to 2 or 3.

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

Stop after this many contract notices, newest first. 0 means no limit. You pay per record returned.

## `stateStoreName` (type: `string`):

Only used when 'Only notices not seen in previous runs' is on. Name of the key-value store in your account that remembers notices already returned. Each set of filters gets its own record inside it. Change it only to keep separate histories. If a run reports that it cannot open the store, enter a different name here.

## `requestDelaySecs` (type: `number`):

Minimum seconds between requests to the AusTender API. Keep this polite.

## Actor input object example

```json
{
  "daysBack": 7,
  "dateType": "published",
  "includeAmendments": true,
  "onlyNew": false,
  "maxItems": 1000,
  "stateStoreName": "agents001-australia-gov-contracts-feed-state",
  "requestDelaySecs": 0.3
}
```

# Actor output Schema

## `contracts` (type: `string`):

No description

## `suppliers` (type: `string`):

No description

## `runSummary` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("agents001/australia-gov-contracts-feed").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("agents001/australia-gov-contracts-feed").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 '{}' |
apify call agents001/australia-gov-contracts-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,agents001/australia-gov-contracts-feed"
        }
    }
}
```

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/6YPYyN0TUjEoONmK1/builds/VXKJWIvIS8MbWlgbD/openapi.json