# Queensland Forward Procurement Pipeline Monitor (`fixmyerrorcode/queensland-forward-procurement-monitor`) Actor

Find planned Queensland Government purchases before tenders are released, filter the official forward pipeline, and monitor additions, changes, and removals.

- **URL**: https://apify.com/fixmyerrorcode/queensland-forward-procurement-monitor.md
- **Developed by:** [UpsideRadar](https://apify.com/fixmyerrorcode) (community)
- **Categories:** Automation, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 opportunity records

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

Find planned Queensland Government purchases before tenders are released and monitor changes automatically.

This Actor turns the official Forward procurement pipeline into structured, filterable opportunity records for suppliers, business-development teams, procurement advisers, market researchers, and automation workflows.

*Built by UpsideRadar from authoritative public data.*

> **Most important limitation:** a pipeline entry is an indicative purchasing plan, not a live tender, confirmed budget, award, or guarantee that procurement will proceed. Verify material details at the official source.

### Best for

- suppliers looking for earlier visibility into planned Queensland Government purchasing;
- business-development and bid teams prioritising agencies, categories, regions, timing, and spend ranges;
- procurement advisers and market researchers comparing pipeline activity;
- recurring Apify Tasks that should report additions, changes, and removals.

### Why use this instead of downloading the source?

The Actor reads the official machine-readable API and adds:

- normalized agency, category, region, timing, spend, method, and funding fields;
- parsed planned-release dates and numeric AUD spend-range bounds;
- deterministic filtering, ordering, deduplication, and change detection;
- customer-scoped monitoring baselines that advance only after complete output and charging;
- source attribution, stable-looking IDs, fingerprints, warnings, and run summaries;
- dataset views and schemas ready for Apify API, Make, Zapier, n8n, and AI agents.

The source contact-email column is deliberately excluded.

### Typical price

Current pay-per-event prices before any Apify Store discount:

| Result | Approximate price |
|---|---:|
| 25 opportunity records | **about US$0.10** (US$0.101) |
| 100 opportunity records | **about US$0.40** (US$0.401) |
| 500 opportunity records | **about US$2.00** (US$2.001) |
| Successful no-change monitor comparison | **about US$0.006** |

These examples use the live event configuration: US$0.001 start, US$0.005 successful monitor check, and US$0.004 per valid opportunity record written.

### Three-step quick start

1. Choose **Find planned opportunities**, **Monitor changes**, or **Market summary**.
2. Add optional filters. Start broad if you do not know the source’s exact vocabulary.
3. Set **Maximum records** and run. Review the `opportunities` dataset view and the run summary before automating.

Safe 25-record preview:

```json
{
  "customerGoal": "search",
  "includePast": false,
  "maxItems": 25
}
````

### Practical use cases

#### Find high-value planned procurement

Use `minSpendAud` to find records whose published spend range may reach a threshold. A parsed bound is not an exact or confirmed budget.

```json
{
  "customerGoal": "search",
  "minSpendAud": 10000000,
  "includePast": false,
  "maxItems": 25
}
```

#### Monitor ICT or construction plans

Save the filters as an Apify Task, run it once to create a baseline, then schedule the same Task for later comparisons.

```json
{
  "customerGoal": "monitor",
  "categoryGroups": ["Information and communication technology"],
  "monitoringStateKey": "ict-plans",
  "includeUnchanged": false,
  "maxItems": 25
}
```

#### Preview a selected Queensland region

```json
{
  "customerGoal": "search",
  "regions": ["Cairns"],
  "includePast": true,
  "maxItems": 25
}
```

### Customer goals

#### Find planned opportunities

Return records matching keywords, agencies, category groups, categories, regions, procurement methods, funding status, spend bounds, release dates, or the source’s Brisbane 2032 classification.

#### Monitor changes

The first automatic monitor run:

- creates the private baseline successfully;
- emits no opportunity records because no changes are expected yet;
- writes a non-opportunity `MONITORING_CHECK` receipt with a clear message and next steps;
- confirms that the same Task, filters, and monitoring state name should be scheduled again.

Subsequent successful runs return `new`, `changed`, and `removed` records. Leave **Include unchanged records** off for low-cost scheduled monitoring.

A removal means only that a record is absent from the current comparable filtered snapshot. It does not mean the procurement was cancelled, awarded, or completed.

#### Market summary

Return matching opportunity records and write deterministic aggregates to the run’s `SUMMARY` record. Aggregates cover agencies, category groups, regions, procurement methods, funding, timing status, spend-range medians, and change counts. No LLM is used.

### Filters

Filters are optional and combine across fields. List filters use case-insensitive matching, but source wording still matters.

Useful starting examples:

- agency: `Queensland Health`;
- category group: `Information and communication technology`;
- region: `Cairns`;
- procurement method: `Open tender`;
- funding status: `Funded`;
- keywords: `software`, `digital`, `construction`, or `medical`.

If an exact field is unfamiliar, start with a keyword and inspect returned source values before tightening the filter.

### Brisbane 2032-related purchasing plans

The official pipeline contains a field named `Brisbane 2032 related`. Set `brisbane2032Only` to `true` to return records carrying that source-published classification.

This Actor does not independently classify records as Games-related. It is not affiliated with, sponsored by, or endorsed by Brisbane 2032, the Australian Olympic Committee, the International Olympic Committee, Paralympics Australia, or the International Paralympic Committee. No protected emblems are used.

### Output

The default table puts decision-friendly fields first:

1. change type and program description;
2. agency, category group, and category;
3. planned-release window and spend range;
4. procurement method and funding status;
5. region, Brisbane 2032 indicator, and related public URL.

Full JSON retains source identifiers, normalized date and spend bounds, deterministic identity and scope fingerprints, timestamps, completeness, warnings, and official-source attribution.

Example:

```json
{
  "schemaVersion": "1.0.0",
  "recordType": "queensland_forward_procurement_opportunity",
  "agency": "CS Energy Ltd",
  "categoryGroup": "General goods and services",
  "programDescription": "Services and management of oil fluid power",
  "estimatedReleaseWindow": "Jul - Sep 26",
  "estimatedReleaseStart": "2026-07-01",
  "estimatedReleaseEnd": "2026-09-30",
  "procurementMethod": "Open tender",
  "spendRange": "$5M - $10M",
  "spendMinAud": 5000000,
  "spendMaxAud": 10000000,
  "fundingStatus": "Funded",
  "region": "Multiple",
  "changeType": "current",
  "sourceAttribution": {
    "publisher": "Queensland Government — Housing and Public Works",
    "license": "Creative Commons Attribution 4.0"
  }
}
```

### API and automation

New integrations should use `customerGoal`. Existing API clients and saved Tasks may continue sending supported legacy `mode` values. Hidden reliability, debug, and previous-dataset fields remain API-compatible.

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor(
  'fixmyerrorcode/queensland-forward-procurement-monitor'
).call({
  customerGoal: 'search',
  categoryGroups: ['Information and communication technology'],
  includePast: false,
  maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor(
    "fixmyerrorcode/queensland-forward-procurement-monitor"
).call(run_input={
    "customerGoal": "search",
    "brisbane2032Only": True,
    "includePast": True,
    "maxItems": 100,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### CLI

```text
apify call fixmyerrorcode/queensland-forward-procurement-monitor \
  --input '{"customerGoal":"search","regions":["Cairns"],"includePast":true,"maxItems":25}'
```

#### HTTP

```text
curl -X POST \
  "https://api.apify.com/v2/acts/fixmyerrorcode~queensland-forward-procurement-monitor/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"customerGoal":"search","minSpendAud":10000000,"includePast":true,"maxItems":25}'
```

Use environment variables or a secret manager for tokens.

### Pricing details

- synthetic `apify-actor-start`: **US$0.001** per run;
- `monitor-check`: **US$0.005** per successful automatic baseline creation or comparison;
- `opportunity-record`: **US$0.004** per valid, deduplicated dataset item;
- platform usage included.

The first automatic monitor run costs approximately US$0.006 and emits no paid opportunity records. Duplicates, discarded rows, failed requests, and records withheld by the maximum charge are not charged as opportunity records.

For a scheduled monitor, set the run maximum to at least **US$0.006 + US$0.004 for each change you want returned**. Monitoring state advances only after complete output and charging, so a charge-limited run can safely retry unsaved changes.

### What this does not tell you

- whether a live tender has been released;
- whether a published spend range is an exact or confirmed budget;
- whether funding, timing, scope, or procurement method will remain unchanged;
- whether a pipeline item will proceed, be awarded, or produce a contract;
- who to contact, how to bid, or whether your organization is eligible;
- whether a removed monitoring record was cancelled or awarded.

Results do not include tender documents, bids, awards, personal contacts, or procurement advice.

### Source and independence

Source: Queensland Government, Housing and Public Works, **Forward procurement pipeline**, licensed under [Creative Commons Attribution 4.0](https://creativecommons.org/licenses/by/4.0/).

The Actor uses the official machine-readable Queensland open-data API and fails closed if the expected licence, resource, or datastore contract changes.

This is an independent product. It is not affiliated with, endorsed by, or operated by the Queensland Government, QTenders, or the Australian Government. Verify material information at the authoritative source before acting.

### Support and troubleshooting

- **Empty search:** remove optional filters, set `includePast` to `true`, and inspect broad results for current source vocabulary.
- **First monitor run returned no opportunities:** this is expected. Open the `MONITORING_CHECK` result to confirm baseline creation, then schedule the same Task and filters.
- **Later monitor run returned no changes:** check the receipt; a successful no-change comparison is a valid result.
- **Maximum charge reached:** increase the run limit only if you want more records. The Actor does not advance monitoring state after incomplete output.
- **`SourceContractError`:** the official licence, resource shape, or datastore contract may have changed. This deliberate fail-closed behavior protects provenance.
- **Other failure:** report the run ID and a non-sensitive log excerpt through the Actor’s Issues tab.

Do not include API tokens, private dataset contents, personal information, or source contact-email values in a public issue.

# Actor input Schema

## `customerGoal` (type: `string`):

Choose the customer outcome. Existing API clients can continue sending the hidden legacy mode field.

## `mode` (type: `string`):

Hidden API compatibility field. Ordinary customers should use Customer goal.

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

Return records containing any keyword in the program, agency, category, region, or procurement method.

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

Case-insensitive agency-name filters. Use source wording such as Queensland Health; matching is not case-sensitive.

## `categoryGroups` (type: `array`):

Filter broad spend groups such as Information and communication technology.

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

Case-insensitive source-category filters. Start with a keyword if you do not know the exact source vocabulary.

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

Case-insensitive Queensland SA4 or agency-region filters, such as Cairns or Multiple.

## `procurementMethods` (type: `array`):

Filter values such as Open tender or Open offer method.

## `fundingStatuses` (type: `array`):

Filter values published by the source, such as Funded.

## `minSpendAud` (type: `integer`):

Keep records whose published spend range may reach at least this amount.

## `maxSpendAud` (type: `integer`):

Keep records whose published spend range may include an amount at or below this value.

## `releaseFrom` (type: `string`):

Optional inclusive YYYY-MM-DD lower bound applied to parsed planned-release windows.

## `releaseTo` (type: `string`):

Optional inclusive YYYY-MM-DD upper bound applied to parsed planned-release windows.

## `includePast` (type: `boolean`):

Include records whose published planned-release window has already ended.

## `brisbane2032Only` (type: `boolean`):

Return only records carrying the official source's published Brisbane 2032 related classification.

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

Maximum dataset items. Billing stops with this limit or the run's maximum charge, whichever comes first.

## `previousDatasetId` (type: `string`):

Hidden API-compatible override for older workflows. Automatic customer-scoped monitoring is recommended.

## `monitoringStateKey` (type: `string`):

Optional name used to keep separate automatic baselines for the same filters.

## `includeUnchanged` (type: `boolean`):

In monitor mode, also output and charge for records that have not changed. Leave off for low-cost scheduled monitoring.

## `maxRequestRetries` (type: `integer`):

Hidden API-compatible reliability control. Conservative defaults protect the official source.

## `requestDelayMillis` (type: `integer`):

Hidden API-compatible delay between official-source requests.

## `debugMode` (type: `boolean`):

Hidden API-compatible diagnostic control; never logs source contact-email values.

## Actor input object example

```json
{
  "customerGoal": "search",
  "keywords": [
    "software",
    "digital"
  ],
  "agencies": [
    "Queensland Health"
  ],
  "categoryGroups": [
    "Information and communication technology"
  ],
  "categories": [
    "Software"
  ],
  "regions": [
    "Cairns"
  ],
  "procurementMethods": [
    "Open tender"
  ],
  "fundingStatuses": [
    "Funded"
  ],
  "includePast": false,
  "brisbane2032Only": false,
  "maxItems": 25,
  "monitoringStateKey": "default",
  "includeUnchanged": false,
  "maxRequestRetries": 3,
  "requestDelayMillis": 250,
  "debugMode": false
}
```

# Actor output Schema

## `records` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

## `marketSummary` (type: `string`):

No description

## `monitoringCheck` (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 = {
    "customerGoal": "search",
    "maxItems": 25,
    "monitoringStateKey": "default"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fixmyerrorcode/queensland-forward-procurement-monitor").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 = {
    "customerGoal": "search",
    "maxItems": 25,
    "monitoringStateKey": "default",
}

# Run the Actor and wait for it to finish
run = client.actor("fixmyerrorcode/queensland-forward-procurement-monitor").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 '{
  "customerGoal": "search",
  "maxItems": 25,
  "monitoringStateKey": "default"
}' |
apify call fixmyerrorcode/queensland-forward-procurement-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fixmyerrorcode/queensland-forward-procurement-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Queensland Forward Procurement Pipeline Monitor",
        "description": "Find planned Queensland Government purchases before tenders are released, filter the official forward pipeline, and monitor additions, changes, and removals.",
        "version": "0.2",
        "x-build-id": "VYdcgNchNhEzL5qHf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fixmyerrorcode~queensland-forward-procurement-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fixmyerrorcode-queensland-forward-procurement-monitor",
                "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/fixmyerrorcode~queensland-forward-procurement-monitor/runs": {
            "post": {
                "operationId": "runs-sync-fixmyerrorcode-queensland-forward-procurement-monitor",
                "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/fixmyerrorcode~queensland-forward-procurement-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-fixmyerrorcode-queensland-forward-procurement-monitor",
                "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",
                "required": [
                    "maxItems"
                ],
                "properties": {
                    "customerGoal": {
                        "title": "Customer goal",
                        "enum": [
                            "search",
                            "monitor",
                            "market_summary"
                        ],
                        "type": "string",
                        "description": "Choose the customer outcome. Existing API clients can continue sending the hidden legacy mode field.",
                        "default": "search"
                    },
                    "mode": {
                        "title": "Legacy API mode",
                        "type": "string",
                        "description": "Hidden API compatibility field. Ordinary customers should use Customer goal."
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Return records containing any keyword in the program, agency, category, region, or procurement method.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "agencies": {
                        "title": "Agencies",
                        "type": "array",
                        "description": "Case-insensitive agency-name filters. Use source wording such as Queensland Health; matching is not case-sensitive.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryGroups": {
                        "title": "Category groups",
                        "type": "array",
                        "description": "Filter broad spend groups such as Information and communication technology.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Case-insensitive source-category filters. Start with a keyword if you do not know the exact source vocabulary.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "regions": {
                        "title": "Regions",
                        "type": "array",
                        "description": "Case-insensitive Queensland SA4 or agency-region filters, such as Cairns or Multiple.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "procurementMethods": {
                        "title": "Procurement methods",
                        "type": "array",
                        "description": "Filter values such as Open tender or Open offer method.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "fundingStatuses": {
                        "title": "Funding statuses",
                        "type": "array",
                        "description": "Filter values published by the source, such as Funded.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "minSpendAud": {
                        "title": "Minimum spend (AUD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep records whose published spend range may reach at least this amount."
                    },
                    "maxSpendAud": {
                        "title": "Maximum spend (AUD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep records whose published spend range may include an amount at or below this value."
                    },
                    "releaseFrom": {
                        "title": "Planned release from",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional inclusive YYYY-MM-DD lower bound applied to parsed planned-release windows."
                    },
                    "releaseTo": {
                        "title": "Planned release to",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional inclusive YYYY-MM-DD upper bound applied to parsed planned-release windows."
                    },
                    "includePast": {
                        "title": "Include past planned windows",
                        "type": "boolean",
                        "description": "Include records whose published planned-release window has already ended.",
                        "default": false
                    },
                    "brisbane2032Only": {
                        "title": "Brisbane 2032 only",
                        "type": "boolean",
                        "description": "Return only records carrying the official source's published Brisbane 2032 related classification.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum dataset items. Billing stops with this limit or the run's maximum charge, whichever comes first.",
                        "default": 25
                    },
                    "previousDatasetId": {
                        "title": "Legacy previous dataset ID",
                        "pattern": "^[A-Za-z0-9_-]+$",
                        "minLength": 1,
                        "maxLength": 128,
                        "type": "string",
                        "description": "Hidden API-compatible override for older workflows. Automatic customer-scoped monitoring is recommended."
                    },
                    "monitoringStateKey": {
                        "title": "Monitoring state name",
                        "pattern": "^[A-Za-z0-9_-]+$",
                        "minLength": 1,
                        "maxLength": 48,
                        "type": "string",
                        "description": "Optional name used to keep separate automatic baselines for the same filters.",
                        "default": "default"
                    },
                    "includeUnchanged": {
                        "title": "Include unchanged records",
                        "type": "boolean",
                        "description": "In monitor mode, also output and charge for records that have not changed. Leave off for low-cost scheduled monitoring.",
                        "default": false
                    },
                    "maxRequestRetries": {
                        "title": "Maximum API retries",
                        "minimum": 0,
                        "maximum": 6,
                        "type": "integer",
                        "description": "Hidden API-compatible reliability control. Conservative defaults protect the official source.",
                        "default": 3
                    },
                    "requestDelayMillis": {
                        "title": "Request delay (milliseconds)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hidden API-compatible delay between official-source requests.",
                        "default": 250
                    },
                    "debugMode": {
                        "title": "Debug logging",
                        "type": "boolean",
                        "description": "Hidden API-compatible diagnostic control; never logs source contact-email values.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
