# Canada and Australia Tenders: CanadaBuys and AusTender (`nightwave-owner/canada-australia-tenders`) Actor

Returns Canadian federal tenders and awards from CanadaBuys and Australian Government contract notices from AusTender, one row per notice with buyer, category, value, deadline, supplier and link. Filter by keyword, UNSPSC code, stage, value and date. onlyNew for daily alerts.

- **URL**: https://apify.com/nightwave-owner/canada-australia-tenders.md
- **Developed by:** [Viktor Wiberg](https://apify.com/nightwave-owner) (community)
- **Categories:** Lead generation, Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 tenders

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

## Canada and Australia Tenders: CanadaBuys and AusTender

Canadian federal tenders and award notices from CanadaBuys, and Australian Government contract notices from AusTender, read from the official open data of both governments. You get one clean row per notice with title, short description, buyer, region, UNSPSC or GSIN category, value, publication date, closing date, winning supplier (for awards) and a link to the full notice.

Use it for a daily alert on new Canadian tenders in your field, to see which federal departments in Canada and Australia buy what you sell, or to follow who wins contracts and for how much. Schedule a run with the dates left empty and `onlyNew: true` for a simple tender alert.

### What is covered

| Country | Source | Stages | Notes |
|---|---|---|---|
| Canada (`ca`) | CanadaBuys open data files (tender notices and award notices) | `tender`, `award` | Federal government buyers on CanadaBuys, from 2022-08-08. Open tenders and the closed, expired and cancelled ones of the current fiscal year. |
| Australia (`au`) | AusTender OCDS API (contract notices) | `award` | Commonwealth contracts worth 10 000 AUD or more, published by agencies on AusTender. |

**Why Australia has no open tenders.** AusTender publishes contract notices through an open API under a Creative Commons licence, and that is what this actor uses. Open approaches to market (current tenders) are only shown as web pages on tenders.gov.au, and there is no open dataset or API with a stated licence for reuse. They are therefore left out. A run with `stages: ["tender"]` only returns Canadian notices.

For scale: in the seven days from 28 September to 4 October 2026 the default run matched 1 061 notices: 128 Canadian tenders, 112 Canadian awards and 821 Australian contract notices.

Not included: provincial and municipal portals (for example MERX-only notices, SEAO in Quebec, state tender sites in Australia) and AusTender standing offer notices.

### Example from a real run

Input: notices that mention "software" in both countries, published from 27 September to 3 October 2026 (run `2ririrPRAvaqkncal`).

```json
{
  "keywords": "software",
  "publishedFrom": "2026-09-27",
  "publishedTo": "2026-10-03",
  "maxResults": 20
}
```

The run read 9 230 notices, returned 20 and took about 13 seconds. Two of the rows (Canadian award and Australian contract notice):

```json
{
  "noticeId": "CW2354439",
  "country": "CA",
  "title": "Battle Management Software for the Department of National Defence",
  "buyer": "Department of Public Works and Government Services (PSPC)",
  "buyerRegion": "Quebec",
  "description": "The Department of National Defence has a requirement for a Battle Management Software - SitWare Software Licenses and Maintenance and Support Services.",
  "category": "Software",
  "categoryCode": "43230000",
  "categoryCodes": ["43230000"],
  "stage": "award",
  "publishedAt": "2026-10-01",
  "deadline": null,
  "valueAmount": 24613583.86,
  "currency": "CAD",
  "supplierName": "Systematic Canada, Inc",
  "url": "https://canadabuys.canada.ca/en/tender-opportunities/award-notice/cw2354439",
  "source": "CanadaBuys open data, Public Services and Procurement Canada",
  "license": "Open Government Licence - Canada",
  "retrievedAt": "2026-10-04T06:20:43.285Z"
}
```

```json
{
  "noticeId": "CN4280091",
  "country": "AU",
  "title": "ArcGIS software",
  "buyer": "Department of Climate Change, Energy, the Environment and Water",
  "buyerRegion": null,
  "description": null,
  "category": null,
  "categoryCode": "43230000",
  "categoryCodes": ["43230000"],
  "stage": "award",
  "publishedAt": "2026-10-01T02:12:18Z",
  "deadline": null,
  "valueAmount": 336970,
  "currency": "AUD",
  "supplierName": "ESRI-AUSTRALIA PTY LTD",
  "url": "https://www.tenders.gov.au/Cn/Show/a1c69596-2f15-4afa-a5ea-d390f14a7b1f",
  "source": "AusTender OCDS API, Australian Government Department of Finance",
  "license": "Creative Commons Attribution 3.0 Australia (CC BY 3.0 AU)",
  "retrievedAt": "2026-10-04T06:20:43.339Z"
}
```

Other rows in the same run: "Online Questionnaire Management Platform" (open tender, Administrative Tribunals Support Service of Canada), "IT Software Procurement" (Department of Home Affairs, 739 200 AUD, Amazon Web Services Australia) and "Licenses of Maestro and Licenses of Impresario by Tacteris" (Canadian award, 1 724 625 CAD, Tacteris Systems Inc.).

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `countries` | array | `["ca", "au"]` | `ca` for CanadaBuys, `au` for AusTender. |
| `keywords` | string | empty | Words that must all appear in the title, description, buyer name or category, in any order and any case. Example: `"cleaning services"`. |
| `categories` | array | empty | UNSPSC codes (both countries) or GSIN codes (older Canadian notices). Trailing `00` pairs match the whole group, so `43200000` also matches `43211503`. GSIN codes such as `N7030` match by prefix. |
| `stages` | array | `["tender", "award"]` | `tender` (Canada only) and/or `award`. |
| `publishedFrom` | string | 6 days before `publishedTo` | First publication date, `YYYY-MM-DD`. Earliest 2022-08-08. |
| `publishedTo` | string | today (UTC) | Last publication date (inclusive). At most 31 days per run. |
| `valueMin` | integer | empty | Minimum value in the notice's own currency (CAD or AUD). Notices without a value are left out when set, which includes all Canadian tender notices. |
| `maxResults` | integer | `50` | Maximum number of notices to return, newest first. |
| `onlyNew` | boolean | `false` | Return only notices that earlier runs with the same input did not deliver. See "Monitoring and scheduling". |

A run with empty input returns the 50 newest notices from both countries in the last seven days.

Example input: open Canadian IT tenders.

```json
{
  "countries": ["ca"],
  "stages": ["tender"],
  "categories": ["43200000", "81110000"],
  "maxResults": 200
}
```

Example input: Australian contracts of at least 1 million AUD in September 2026.

```json
{
  "countries": ["au"],
  "publishedFrom": "2026-09-01",
  "publishedTo": "2026-09-30",
  "valueMin": 1000000,
  "maxResults": 1000
}
```

### Output

One row per notice. The dataset view "Tenders" shows the most important columns.

| Field | Description |
|---|---|
| `noticeId` | CanadaBuys reference number (for example `cb-213-8386093` or `CW2354439`) or AusTender contract notice id (for example `CN4280217`) |
| `country` | `CA` or `AU` |
| `title` | Title of the notice. For AusTender, the contract description |
| `buyer`, `buyerRegion` | Contracting organisation and its province or state |
| `description` | Short description in plain text, at most 500 characters (Canada only; AusTender contract notices have no separate description) |
| `category`, `categoryCode`, `categoryCodes` | Name and code of the first category, and all UNSPSC or GSIN codes in the notice |
| `stage` | `tender` or `award` |
| `publishedAt` | Publication date (Canada) or exact publication time in UTC (Australia) |
| `deadline` | Closing date and time of a Canadian tender, as published |
| `valueAmount`, `currency` | Total contract value of an award or contract. Empty for tenders and for values published as 0.00 |
| `supplierName` | Winning supplier, only when the name is clearly an organisation (see below) |
| `url` | Link to the notice on CanadaBuys or AusTender |
| `source`, `license` | Source and licence, for attribution |
| `retrievedAt` | When the run read the data |

### Monitoring and scheduling

Set `onlyNew` to `true` to use the actor for recurring monitoring. The actor then remembers which notices it has delivered for the same input, in a named key-value store in your Apify account (`nightwave-state-canada-australia-tenders`, one record per input). Each run returns and charges only notices that earlier runs did not deliver. The first run returns everything in the selection. A run without news finishes successfully with 0 rows.

A notice is identified by country, stage and notice id. Leave the dates empty: the default range is the last seven days, so a daily run looks at a week of notices and returns the ones it has not delivered before. Set `maxResults` above the number of notices your search normally gets in a week.

`onlyNew` and `maxResults` are not part of the remembered input, so you can change them without starting over. Changing any other field starts a fresh state. To start over with the same input, delete the record in the key-value store.

Example: a daily run at 08:00 Ottawa time that returns new Canadian tenders. In Apify Console, open **Schedules**, create a schedule with the cron expression `0 8 * * *` and the time zone America/Toronto, and add this actor with the input below.

```json
{
  "countries": ["ca"],
  "stages": ["tender"],
  "onlyNew": true,
  "maxResults": 200
}
```

The same schedule through the Apify API:

```sh
curl -X POST "https://api.apify.com/v2/schedules?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"name": "daily-canada-tenders", "cronExpression": "0 8 * * *", "timezone": "America/Toronto", "isEnabled": true, "isExclusive": true,
       "actions": [{"type": "RUN_ACTOR", "actorId": "nightwave-owner~canada-australia-tenders",
                    "runInput": {"contentType": "application/json; charset=utf-8", "body": "<the input above as a JSON string>"}}]}'
```

In a real test, the input above returned 128 notices on the first run and 0 on the second run a minute later.

Connect a webhook or an integration (Slack, e-mail, Google Sheets) to the actor in Apify Console if you want the new rows sent somewhere when the run finishes.

### Limits

- **Personal data is left out.** Contact person names, e-mail addresses and phone numbers in the source data are never read. E-mail addresses and phone numbers written into a title or description are replaced with `[removed]`. A supplier is named only when the name contains a word that marks an organisation (Pty, Ltd, Inc, Corporation, University, Trust and similar), because individuals such as barristers and consultants also win contracts under their own names. For those rows `supplierName` is empty; open the notice link for the full record.
- CanadaBuys updates its open data files once a day, so a Canadian notice shows up the day after it is published at the latest. AusTender's API is live.
- AusTender contract notices cover contracts of 10 000 AUD or more. Dates are filtered in UTC.
- Canadian tender notices carry no estimated value, so `valueMin` leaves them out.
- At most 31 days per run. A run over 31 days reads about 12 500 notices and 43 AusTender pages and takes about a minute; a seven day run takes about 15 seconds.
- The actor never returns more rows than your maximum cost per run allows.
- Requests are retried four times on network errors, rate limits and server errors. A rejected request or a file in an unexpected format stops the run with a clear message instead of storing broken rows.

### Use cases

- A daily alert for new Canadian federal tenders in your UNSPSC codes or keywords, sent to Slack or e-mail with an Apify integration.
- Market research: which departments in Canada and Australia buy software, cleaning, construction or consulting, and for how much.
- Competitor tracking: which companies win contracts in your field, with values and links.
- Feed a bid management tool or CRM with the structured fields and the notice link.

### FAQ

**How often is the data updated?**
Every run reads the sources live. CanadaBuys refreshes its files daily; AusTender publishes contract notices throughout the Australian working day.

**What does 1 000 rows cost?**
4 USD (0.004 USD per notice, event `tender`). Platform usage is included. A test run over 30 days returned 912 notices.

**Can I use the data commercially?**
Yes. Both licences allow commercial reuse with attribution. See below.

### Source and license

**Canada.** The data comes from the CanadaBuys open data files published by Public Services and Procurement Canada on the Open Government Portal: [CanadaBuys tender notices](https://open.canada.ca/data/en/dataset/6abd20d4-7a1c-4b38-baa2-9525d0bb2fd2) and [CanadaBuys award notices](https://open.canada.ca/data/en/dataset/a1acb126-9ce8-40a9-b889-5da2b1dd20cb) (files under `https://canadabuys.canada.ca/opendata/pub/`). Both datasets are published under the [Open Government Licence - Canada](https://open.canada.ca/en/open-government-licence-canada), which says: "You are free to: Copy, modify, publish, translate, adapt, distribute or otherwise use the Information in any medium, mode or format for any lawful purpose." The condition is to acknowledge the source with the attribution statement "Contains information licensed under the Open Government Licence - Canada".

**Australia.** The data comes from the [AusTender OCDS API](https://github.com/austender/austender-ocds-api) run by the Australian Government Department of Finance (`GET https://api.tenders.gov.au/ocds/findByDates/contractPublished/<from>/<to>`), which needs no API key. Every API response states its licence: `"license": "https://creativecommons.org/licenses/by/3.0/au/"`, that is [Creative Commons Attribution 3.0 Australia](https://creativecommons.org/licenses/by/3.0/au/), which allows commercial reuse with attribution. Attribute it as "Source: AusTender, Department of Finance, licensed under CC BY 3.0 AU".

Every row carries `source` and `license` for attribution. The actor reshapes the notices (selected fields, shortened descriptions) but does not change their content. It is not affiliated with or endorsed by the Government of Canada or the Australian Government.

### Pricing

Pay per result: 0.004 USD per row returned (event `tender`), which is 4 USD per 1 000 notices. Platform usage is included, so you pay only per result. `maxResults` caps how many rows a run returns, so you always know the highest possible cost.

Rows are delivered only after they have been charged. If you set a maximum cost per run (maxTotalChargeUsd), the run stops there and its status message says how many rows were delivered.

### Contact

Built and maintained by Nightwave AB. Questions, bugs and feature requests: kontakt@nightwave.se

### På svenska

Actorn hämtar offentliga upphandlingar från Kanada (CanadaBuys, öppna data från den federala regeringen) och Australien (AusTender, kontraktsnotiser via öppet OCDS-API). Varje annons blir en rad med titel, kort beskrivning, köpare, provins eller delstat, UNSPSC- eller GSIN-kod, värde, publiceringsdatum, sista anbudsdag, vinnande leverantör och länk.

- Kanada: pågående och avslutade upphandlingar samt tilldelningar. Australien: bara kontraktsnotiser (tilldelningar), eftersom pågående upphandlingar på tenders.gov.au inte finns som öppna data med licens för vidareanvändning.
- Filtrera på land, sökord, kategorikod, skede, lägsta värde och publiceringsdatum (högst 31 dagar per körning).
- Med `onlyNew: true` lämnar en schemalagd körning bara annonser som inte levererats tidigare, och bara de debiteras.
- Kontaktpersoner tas aldrig med. Leverantörer namnges bara när namnet tydligt är en organisation.
- Källor och licenser: Open Government Licence - Canada och CC BY 3.0 AU, som båda tillåter kommersiell vidareanvändning med källhänvisning.
- Pris: 0,004 USD per annons, 4 USD per 1 000.

# Actor input Schema

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

ca: CanadaBuys (federal tenders and award notices). au: AusTender (Australian Government contract notices, which are awards). For example \["ca"]. Defaults to both.

## `keywords` (type: `string`):

Optional. Words that must all appear in the title, description, buyer name or category, in any order and any case, for example "software" or "cleaning services". Leave empty for all notices.

## `categories` (type: `array`):

Optional. Only notices with at least one of these category codes, for example \["43200000"]. UNSPSC codes are used by both countries; trailing 00 pairs match the whole group, so 43200000 (computer equipment) also matches 43211503. Canadian GSIN codes such as N7030 match by prefix.

## `stages` (type: `array`):

tender: open and recent tender notices (Canada only, AusTender has no open data for open tenders). award: contract award notices (Canada) and contract notices (Australia). For example \["tender"]. Defaults to both.

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

First publication date, YYYY-MM-DD, for example "2026-09-28". Defaults to six days before the end date, so the default run covers the last seven days. Earliest 2022-08-08.

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

Last publication date (inclusive), YYYY-MM-DD, for example "2026-10-03". Defaults to today (UTC). At most 31 days per run.

## `valueMin` (type: `integer`):

Optional. Only notices with a stated value of at least this amount in the notice's own currency (CAD or AUD), for example 100000. Canadian tender notices have no value, so this setting leaves only awards and contracts.

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

Maximum number of notices to return, newest first, for example 50. Each notice is one billable result. Defaults to 50.

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

For scheduled runs. When true, notices that an earlier run with the same input already delivered are skipped and not charged, so a daily run returns only what is new. The first run returns everything. Defaults to false.

## Actor input object example

```json
{
  "countries": [
    "ca"
  ],
  "keywords": "cleaning services",
  "categories": [
    "43200000",
    "81110000"
  ],
  "stages": [
    "tender"
  ],
  "publishedFrom": "2026-09-28",
  "publishedTo": "2026-10-03",
  "valueMin": 100000,
  "maxResults": 50,
  "onlyNew": true
}
```

# Actor output Schema

## `results` (type: `string`):

All rows produced by the run, as JSON. Open in Apify Console or download via the dataset API.

# 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 = {
    "countries": [
        "ca",
        "au"
    ],
    "keywords": "software",
    "stages": [
        "tender",
        "award"
    ],
    "maxResults": 50,
    "onlyNew": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("nightwave-owner/canada-australia-tenders").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 = {
    "countries": [
        "ca",
        "au",
    ],
    "keywords": "software",
    "stages": [
        "tender",
        "award",
    ],
    "maxResults": 50,
    "onlyNew": False,
}

# Run the Actor and wait for it to finish
run = client.actor("nightwave-owner/canada-australia-tenders").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 '{
  "countries": [
    "ca",
    "au"
  ],
  "keywords": "software",
  "stages": [
    "tender",
    "award"
  ],
  "maxResults": 50,
  "onlyNew": false
}' |
apify call nightwave-owner/canada-australia-tenders --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nightwave-owner/canada-australia-tenders"
        }
    }
}
```

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/5C3meLsfJ2N60o8FB/builds/OLbeJgusCCBsxHck4/openapi.json
