# AusTender Current Tender Opportunities Scraper (`automation-lab/austender-current-tender-opportunities-scraper`) Actor

Discover and enrich current Australian Government tender opportunities from the official AusTender feed and public ATM pages.

- **URL**: https://apify.com/automation-lab/austender-current-tender-opportunities-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## AusTender Current Tender Opportunities Scraper

Find open Australian Government bid opportunities before they close.

This Actor reads the official AusTender current Approaches to Market (ATM) RSS feed and enriches each opportunity from its public detail page. It returns structured tender references, agencies, categories, dates, locations, descriptions, participation conditions, lodgement instructions, public contacts, and source links.

Use it for daily bid discovery, procurement intelligence, supplier alerts, opportunity qualification, and CRM lead feeds.

### What this Actor does

- Discovers current opportunities from the official AusTender RSS feed.
- Accepts specific public AusTender ATM detail URLs.
- Enriches feed entries with the complete public detail-page fields.
- Normalizes ACT local closing times to ISO 8601 UTC.
- Filters by keyword, agency, location, and closing window.
- Deduplicates opportunities by their stable AusTender detail URL.
- Saves typed records to the run's default dataset.
- Charges only for records actually saved.

The default workflow scans the current feed. No login, API key, browser, or proxy is normally required.

### Who is it for?

#### Government suppliers

Monitor new opportunities relevant to your products and services without repeatedly checking AusTender by hand.

#### Bid and proposal teams

Build a scheduled shortlist with closing dates, conditions, public contacts, and lodgement instructions.

#### Procurement intelligence vendors

Feed normalized current Australian Government opportunities into search, enrichment, alerting, or analytics products.

#### Consultants and business developers

Identify timely public-sector leads by agency, state or territory, category, and keyword.

#### Data and automation teams

Send records to Google Sheets, Airtable, a warehouse, Slack, email, a CRM, or an internal tender portal.

### Why use this Actor

AusTender's RSS feed is excellent for discovery, but it contains only a small subset of each opportunity. This Actor joins feed discovery with public detail-page enrichment.

It is deliberately HTTP-first:

- lower memory than browser automation;
- fast startup and predictable output;
- conservative request concurrency;
- bounded retries for transient upstream failures;
- optional Apify Proxy recovery when direct access is temporarily blocked.

This Actor covers **current opportunities**. For awarded contracts and supplier spend, use our related [AusTender Contract Awards Scraper](https://apify.com/automation-lab/austender-contract-awards-scraper).

### Extracted data

| Field | Meaning |
| --- | --- |
| `atmId` | Official ATM reference |
| `title` | Opportunity title |
| `agency` | Publishing agency |
| `unspscCode` | Eight-digit UNSPSC code |
| `category` | Human-readable UNSPSC category |
| `publishDate` | ISO 8601 publication date |
| `closeDate` | Closing time normalized from ACT local time to UTC |
| `closeDateRaw` | Closing time exactly as represented by the source |
| `closeTimezone` | `Australia/Sydney`, used for normalization |
| `locations` | Listed states, territories, or named locations |
| `atmType` | Request for Tender, Request for Information, and similar type |
| `multiAgencyAccess` | Multi-agency access flag |
| `panelArrangement` | Panel arrangement flag |
| `multiStage` | Multi-stage process flag |
| `description` | Full public description |
| `conditionsForParticipation` | Published supplier conditions |
| `timeframeForDelivery` | Published delivery timeframe |
| `addressForLodgement` | Response lodgement instructions |
| `contactName` | Public contact officer or team |
| `contactEmail` | Public contact email |
| `documentsPageUrl` | AusTender document index URL |
| `addendaUrl` | Linked addenda index URL, when present |
| `lodgementUrl` | AusTender response lodgement page |
| `detailUrl` | Canonical public ATM URL |
| `feedUrl` | Discovery feed URL, or `null` for an explicit detail input |
| `scrapedAt` | Record extraction timestamp |

Fields unavailable on the source are returned as `null` or an empty array.

### How much does it cost to scrape AusTender opportunities?

The Actor uses pay-per-event pricing:

- **$0.005 per run** start fee;
- **$0.000041071 per saved opportunity on the Free tier**, with strictly decreasing volume-tier prices down to $0.00001 on Diamond.

Failed, duplicate, rejected, and filtered-out records are not charged as items.

Example Free-tier prices:

| Saved opportunities | Estimated total |
| ---: | ---: |
| 1 | $0.005041071 |
| 20 | $0.00582142 |
| 100 | $0.00910710 |

Actual current feed size changes over time. Setting `maxItems` controls both output volume and maximum item charges.

### Getting started

1. Open the Actor in Apify Console.
2. Leave `startUrls` empty to use the official current feed.
3. Set `maxItems` to the maximum number of matching opportunities you need.
4. Keep `includeDetails` enabled for complete records.
5. Add optional keywords, agencies, locations, or closing bounds.
6. Click **Start**.
7. Open the **Tender opportunities** dataset view.
8. Export JSON, CSV, Excel, XML, or RSS, or connect an integration.

A useful first run is:

```json
{
  "maxItems": 20,
  "includeDetails": true
}
````

### Input parameters

#### `startUrls`

Optional array of official AusTender URLs.

Supported URL types:

- `https://www.tenders.gov.au/public_data/rss/rss.xml`
- `https://www.tenders.gov.au/Atm/Show/<uuid>`

Leave this empty for current-feed discovery. Unsupported hosts and page types fail closed instead of producing misleading output.

#### `maxItems`

Maximum number of matching records to save.

- default: `100`
- minimum: `1`
- maximum: `10000`

#### `includeDetails`

When `true`, fetch public detail pages and populate all enrichment fields.

When `false`, return fast feed-only records containing ATM ID, title, summary, publication date, and source links. Agency, location, and closing-date filters require detail enrichment, so the Actor rejects those filters unless `includeDetails` is enabled. This fail-closed validation prevents a configuration error from being mistaken for an empty result.

#### `keywords`

Optional case-insensitive OR filter across ATM ID, title, description, and category.

```json
{
  "keywords": ["cloud", "cyber", "software"]
}
```

#### `agencies`

Optional case-insensitive contains filter. An opportunity is retained when at least one value appears in its agency name.

```json
{
  "agencies": ["Defence", "Foreign Affairs"]
}
```

#### `locations`

Optional exact, case-insensitive match against source locations.

```json
{
  "locations": ["NSW", "ACT"]
}
```

#### `closingAfter` and `closingBefore`

Optional ISO 8601 closing-time bounds.

`closingAfter` is inclusive. `closingBefore` is exclusive.

```json
{
  "closingAfter": "2026-07-01T00:00:00.000Z",
  "closingBefore": "2026-08-01T00:00:00.000Z"
}
```

#### `proxyConfiguration`

Optional Apify Proxy configuration for transient access recovery. Direct requests are cheaper and are used by default.

### Output example

This shortened record reflects the Actor's current public-detail behavior:

```json
{
  "atmId": "LCD-26-0030",
  "title": "Army Innovation Day 2026 (AID26)",
  "agency": "Department of Defence - DSRG",
  "unspscCode": "46000000",
  "category": "Defence and Law Enforcement and Security and Safety Equipment and Supplies",
  "publishDate": "2026-07-01T00:00:00.000Z",
  "closeDate": "2026-07-27T00:00:00.000Z",
  "closeDateRaw": "27-Jul-2026 10:00 am (ACT Local Time)",
  "closeTimezone": "Australia/Sydney",
  "locations": ["ACT", "NSW", "VIC", "SA", "WA", "QLD", "NT", "TAS"],
  "atmType": "Request for Information",
  "multiAgencyAccess": false,
  "panelArrangement": false,
  "multiStage": false,
  "contactName": "SO1 Trials & Exploration",
  "contactEmail": "army.innovation.day@defence.gov.au",
  "documentsPageUrl": "https://www.tenders.gov.au/Atm/ViewDocuments/e6ed7412-5777-4aa5-b34f-b790add9146a",
  "detailUrl": "https://www.tenders.gov.au/Atm/Show/e6ed7412-5777-4aa5-b34f-b790add9146a",
  "feedUrl": "https://www.tenders.gov.au/public_data/rss/rss.xml",
  "scrapedAt": "2026-07-25T00:00:00.000Z"
}
```

Descriptions and conditions are omitted above only to keep the example readable.

### Filters and explicit URLs

Explicit ATM URLs do not bypass your filters. They follow the same normalization and qualification path as feed-discovered records.

Examples:

```json
{
  "startUrls": [
    { "url": "https://www.tenders.gov.au/Atm/Show/e6ed7412-5777-4aa5-b34f-b790add9146a" }
  ],
  "keywords": ["autonomous"],
  "maxItems": 1
}
```

```json
{
  "agencies": ["Defence"],
  "locations": ["SA", "WA"],
  "maxItems": 100,
  "includeDetails": true
}
```

### Scheduling a daily lead feed

1. Save a task with your qualification filters.
2. Add a daily schedule in Apify Console.
3. Connect the dataset to your preferred integration.
4. Use `atmId` or `detailUrl` as the stable downstream deduplication key.
5. Alert the bid owner when `closeDate` is inside your review window.

The source feed represents opportunities current at run time. Keep your own historical dataset when you need change tracking or audit history.

### Integration patterns

#### Google Sheets or Excel

Schedule a filtered run and export the default dataset. Use ATM ID as the unique key when merging daily results.

#### Slack or email alerts

Trigger a workflow after each successful run and format title, agency, closing date, and detail URL into an alert.

#### CRM opportunity creation

Map `atmId` to external ID, `agency` to account, `title` to opportunity name, and `closeDate` to the response deadline.

#### Data warehouse

Load JSON records into a tender fact table. Keep `scrapedAt` for observation time and `publishDate`/`closeDate` for source lifecycle time.

#### AI qualification

Pass description, conditions, category, and location into a model that scores fit against your capability statement. Keep a human in the loop for bidding decisions.

### Run with the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~austender-current-tender-opportunities-scraper/runs?token=YOUR_TOKEN&waitForFinish=300" \
  -H "Content-Type: application/json" \
  -d '{"keywords":["cyber"],"maxItems":20,"includeDetails":true}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/austender-current-tender-opportunities-scraper').call({
  agencies: ['Defence'],
  maxItems: 20,
  includeDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/austender-current-tender-opportunities-scraper').call(run_input={
    'keywords': ['cloud', 'software'],
    'maxItems': 20,
    'includeDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/austender-current-tender-opportunities-scraper"
```

#### Claude Desktop

Add this server object to the Claude Desktop MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/austender-current-tender-opportunities-scraper"
    }
  }
}
```

#### Cursor

Add the same `mcpServers.apify` object in Cursor's MCP settings. Use the Actor-specific URL above.

#### VS Code

Add the server URL to your VS Code MCP configuration and authenticate with Apify when prompted.

Example prompts:

- "Find current Defence opportunities in NSW and summarize those closing in the next 30 days."
- "Run the AusTender Actor for cloud, cyber, and software opportunities, then create a qualification table."
- "Fetch this ATM URL and list its participation conditions, public contact, and closing time."

### Limits and source behavior

- The Actor covers opportunities present in the official current ATM feed or supplied as explicit public detail URLs.
- It does not scrape historical closed opportunities from search pages.
- AusTender controls feed volume, fields, markup, and availability.
- Public detail fields vary by opportunity, so some values are nullable.
- Document index pages can require an AusTender login; the Actor returns their URLs but does not bypass authentication or download protected files.
- Lodgement itself may require an account and is not automated.
- The Actor uses at most five concurrent detail requests.
- A changed or unrecognizable upstream response fails rather than being reported as a valid empty dataset.

### Reliability and troubleshooting

Requests use realistic browser headers, content-type checks, bounded retries, and exponential backoff.

#### Why did my run return no records?

The current feed may have no opportunities matching all filters. Check spelling, widen the closing window, remove one filter at a time, and keep `includeDetails` enabled for agency, location, or closing filters.

#### Why did a run fail with HTTP 403 or 429?

AusTender may temporarily restrict traffic. Retry later or enable an Apify Proxy configuration. The Actor does not loop indefinitely on blocked responses.

#### Why are document files not included?

AusTender's document index can require a registered-user login. The Actor returns the official document/addenda URL and does not bypass the login boundary.

#### Why is the normalized closing date different from the displayed hour?

`closeDate` is UTC. `closeDateRaw` preserves the displayed ACT local time, and `closeTimezone` identifies the conversion timezone.

### Is it legal? Responsible use

AusTender publishes the source opportunity and public contact information for procurement participation. Use the data for legitimate tender discovery, analysis, and supplier workflows.

You are responsible for:

- complying with AusTender's current terms and applicable law;
- respecting privacy and anti-spam obligations;
- securing exported contact data;
- verifying critical dates and conditions against the official detail page;
- submitting responses only through authorized channels;
- avoiding misleading, discriminatory, or abusive use.

This Actor is an independent automation tool and is not affiliated with or endorsed by the Australian Government or the Department of Finance.

### FAQ

#### Does the Actor need an AusTender account?

No for the official current feed and public ATM details. Viewing or downloading tender documents can require registration on AusTender.

#### Can I scrape one opportunity?

Yes. Supply its public `/Atm/Show/<uuid>` URL in `startUrls` and set `maxItems` to `1`.

#### Can I monitor only one agency?

Yes. Add one or more partial agency names to `agencies` and keep detail enrichment enabled.

#### Are keyword filters AND or OR?

Values inside `keywords` use OR logic. Different filter groups combine: a record must pass the keyword, agency, location, and date groups you supplied.

#### Does `maxItems` count filtered-out opportunities?

No. It limits saved matching opportunities.

#### Can I access CSV or Excel?

Yes. Use the dataset export controls in Apify Console or the dataset API after the run.

#### Is the output real-time?

It reflects the official source at run time. Schedule regular runs for monitoring; the Actor does not claim instant push updates.

### Related Actors

- [AusTender Contract Awards Scraper](https://apify.com/automation-lab/austender-contract-awards-scraper) — awarded Australian Government contracts, buyers, suppliers, dates, and amounts.
- [Singapore GeBIZ Tender Opportunities Scraper](https://apify.com/automation-lab/singapore-gebiz-tender-opportunities-scraper) — current Singapore public-sector tender opportunities.
- [New Zealand GETS Tender Opportunities Scraper](https://apify.com/automation-lab/new-zealand-gets-tender-opportunities-scraper) — current New Zealand Government Electronic Tenders Service opportunities.

Use the current-opportunities Actor for open Australian bid discovery and the contract-awards Actor for post-award supplier and spend analysis.

### Support

For reproducible issues, include:

- the Actor run URL;
- sanitized input;
- the affected ATM URL or ID;
- expected versus actual behavior;
- whether the same public page loaded in your region.

Do not include Apify tokens, passwords, private tender documents, or confidential bid information.

# Actor input Schema

## `startUrls` (type: `array`):

Optional official current-ATM RSS URL and/or public /Atm/Show/ detail URLs. Leave empty to scan the current feed.

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

Stop after this many matching opportunities are saved.

## `includeDetails` (type: `boolean`):

Fetch each public ATM page for agency, dates, category, locations, conditions, contact, and lodgement fields. Disable for a fast feed-only monitor.

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

Keep opportunities matching at least one case-insensitive term in the ATM ID, title, description, or category.

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

Keep opportunities whose agency contains at least one supplied value. Detail enrichment must be enabled.

## `locations` (type: `array`):

Keep opportunities matching at least one exact state or territory abbreviation, such as NSW, VIC, or ACT. Detail enrichment must be enabled.

## `closingAfter` (type: `string`):

Optional inclusive ISO 8601 lower bound for the normalized closing time.

## `closingBefore` (type: `string`):

Optional exclusive ISO 8601 upper bound for the normalized closing time.

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

Optional Apify Proxy recovery for transient access blocks. Direct requests are used by default.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.tenders.gov.au/public_data/rss/rss.xml"
    }
  ],
  "maxItems": 20,
  "includeDetails": true
}
```

# Actor output Schema

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

Dataset containing discovered and enriched AusTender opportunity records.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.tenders.gov.au/public_data/rss/rss.xml"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/austender-current-tender-opportunities-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 = {
    "startUrls": [{ "url": "https://www.tenders.gov.au/public_data/rss/rss.xml" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/austender-current-tender-opportunities-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.tenders.gov.au/public_data/rss/rss.xml"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/austender-current-tender-opportunities-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/austender-current-tender-opportunities-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AusTender Current Tender Opportunities Scraper",
        "description": "Discover and enrich current Australian Government tender opportunities from the official AusTender feed and public ATM pages.",
        "version": "0.1",
        "x-build-id": "7kNQbK2bQwK3SA4lU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~austender-current-tender-opportunities-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-austender-current-tender-opportunities-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~austender-current-tender-opportunities-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-austender-current-tender-opportunities-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~austender-current-tender-opportunities-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-austender-current-tender-opportunities-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "AusTender URLs",
                        "type": "array",
                        "description": "Optional official current-ATM RSS URL and/or public /Atm/Show/ detail URLs. Leave empty to scan the current feed.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum opportunities",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many matching opportunities are saved.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Enrich tender details",
                        "type": "boolean",
                        "description": "Fetch each public ATM page for agency, dates, category, locations, conditions, contact, and lodgement fields. Disable for a fast feed-only monitor.",
                        "default": true
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Keep opportunities matching at least one case-insensitive term in the ATM ID, title, description, or category.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "agencies": {
                        "title": "Agencies",
                        "type": "array",
                        "description": "Keep opportunities whose agency contains at least one supplied value. Detail enrichment must be enabled.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Keep opportunities matching at least one exact state or territory abbreviation, such as NSW, VIC, or ACT. Detail enrichment must be enabled.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "closingAfter": {
                        "title": "Closing at or after",
                        "type": "string",
                        "description": "Optional inclusive ISO 8601 lower bound for the normalized closing time."
                    },
                    "closingBefore": {
                        "title": "Closing before",
                        "type": "string",
                        "description": "Optional exclusive ISO 8601 upper bound for the normalized closing time."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy recovery for transient access blocks. Direct requests are used by default."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
