# AusTender Contract Awards Scraper (`automation-lab/austender-contract-awards-scraper`) Actor

Extract Australian Government contract awards with buyers, suppliers, ABNs, values, dates, contacts, and UNSPSC codes. Export clean data or schedule recurring monitoring—no AusTender API key required.

- **URL**: https://apify.com/automation-lab/austender-contract-awards-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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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 Contract Awards Scraper

Extract **Australian Government contract awards** from the official AusTender OCDS API.
Get buyer and supplier names, ABNs, award values, contract periods, contacts, UNSPSC codes, and source identifiers in clean JSON, CSV, Excel, or XML.

The **AusTender Contract Awards Scraper** supports exact Contract Notice lookups and repeatable date-range monitoring.
It requires no AusTender login, browser, proxy, or external API key.

### What does AusTender Contract Awards Scraper do?

This Actor turns nested [AusTender](https://www.tenders.gov.au/) Open Contracting Data Standard releases into one flat row per federal contract award.
Use it to:

- 🎯 look up one or many known Contract Notice IDs such as `CN4256428`;
- 📅 find awards by publication or last-modified date;
- ⏳ find contracts by start or end date for pipeline and recompete research;
- 🏢 connect Australian Government buyers with awarded suppliers and ABNs;
- 💰 analyze contract values, currencies, periods, and UNSPSC categories;
- 🔄 schedule a daily extraction without maintaining API pagination code.

The Actor calls the official anonymous JSON API directly and automatically splits date windows when the source reaches its response cap.

### Who is this AusTender scraper for?

**Government suppliers and business development teams**

- Monitor competitor wins by supplier and agency.
- Find expiring incumbent contracts before a likely recompete.
- Enrich CRM accounts with Contract Notice IDs, ABNs, values, and dates.

**Procurement and category analysts**

- Build agency-spend and supplier-concentration dashboards.
- Group awards by UNSPSC category or procurement method.
- Refresh a warehouse from publication or modification windows.

**Journalists and researchers**

- Trace public spending to named suppliers.
- Preserve release IDs and official source URLs for reproducible analysis.
- Compare contract periods, values, and purchasing entities over time.

**Consultants and data teams**

- Feed Australian procurement intelligence into Sheets, BigQuery, Snowflake, or a client portal.
- Trigger alerts when a chosen date window produces new awards.
- Use exact lookups as a dependable enrichment step in automated workflows.

### Why use this Australian Government contracts scraper?

- ✅ **Official source** — data comes from the Australian Department of Finance AusTender OCDS API.
- ✅ **No credentials** — no AusTender account or third-party API subscription is needed.
- ✅ **Award-focused** — output centers on signed and awarded contracts, not only open opportunities.
- ✅ **Normalized rows** — nested OCDS parties, awards, and contracts become export-friendly columns.
- ✅ **Cap-aware extraction** — full 100-release windows are automatically subdivided.
- ✅ **Low overhead** — direct HTTP extraction runs with 256 MB memory and no browser.
- ✅ **Repeatable automation** — run from the Console, API, scheduler, webhook, Make, Zapier, or MCP.

### What AusTender contract data can you extract?

| Category | Fields |
|---|---|
| Source identity | `ocid`, `releaseId`, `releaseDate`, `releaseTags`, `contractNoticeId`, `sourceUrl` |
| Award | `awardId`, `awardStatus`, `awardDate` |
| Contract | `contractStatus`, `dateSigned`, `title`, `description` |
| Buyer | `buyerName`, `buyerAbn`, `buyerContactName`, `buyerContactEmail` |
| Supplier | `supplierName`, `supplierAbn`, locality, region, postcode, country, contact name, email |
| Classification | `unspscCode`, `procurementMethod`, `procurementMethodDetails` |
| Commercial terms | `contractStartDate`, `contractEndDate`, `amount`, `currency` |
| Extraction | `scrapedAt` |

Fields absent from an upstream OCDS release are omitted rather than replaced with invented values.
Amounts are returned as numbers so they can be summed immediately.

### How much does it cost to scrape AusTender contract awards?

This Actor uses pay-per-event pricing.
A small start fee covers initialization, followed by a charge for each contract award saved.
All Apify platform costs are included.

| Event | Free | Starter | Scale | Business |
|---|---:|---:|---:|---:|
| Run started | $0.005 | $0.005 | $0.005 | $0.005 |
| Contract award | $0.0005276 | $0.00045878 | $0.00035785 | $0.00027527 |

Higher plans receive additional volume discounts.
For example, 100 contract awards cost about $0.058 on the Free plan or $0.051 on Starter, including the start fee.
The Apify Free plan's included credits are enough for many small lookups and monitoring tests.

Prices are formula-derived from a representative 256 MB cloud run and include the fixed start charge.

### How to scrape AusTender contract awards

1. Open [AusTender Contract Awards Scraper](https://apify.com/automation-lab/austender-contract-awards-scraper).
2. Add one or more Contract Notice IDs, or enter both ends of a date range.
3. Choose the date field: publication, last modification, contract start, or contract end.
4. Set a practical maximum number of contract awards.
5. Click **Start**.
6. Review the Contract awards dataset view.
7. Export the results as JSON, CSV, Excel, XML, or connect them to another app.

Start with the prefilled exact lookup for a fast, inexpensive first run.

### Input parameters

| Parameter | Type | Default | Purpose |
|---|---|---|---|
| `noticeIds` | string array | `[]` | Exact AusTender IDs such as `CN4256428` |
| `dateType` | string | `contractPublished` | Date dimension used by the range search |
| `fromDate` | ISO date string | none | Inclusive beginning of the date range |
| `toDate` | ISO date string | none | End of the date range |
| `maxItems` | integer | `100` | Maximum normalized contract rows to save |
| `windowHours` | integer | `24` | Initial API date-window size before automatic splitting |

Provide at least one Contract Notice ID or both `fromDate` and `toDate`.
Date ranges may span up to 366 days per run.

### Input examples

**Look up exact Contract Notices**

```json
{
  "noticeIds": ["CN4256428", "CN4256861"],
  "maxItems": 10
}
````

**Monitor newly published awards**

```json
{
  "dateType": "contractPublished",
  "fromDate": "2026-07-01T00:00:00Z",
  "toDate": "2026-07-02T00:00:00Z",
  "maxItems": 1000,
  "windowHours": 2
}
```

**Find contracts approaching their end date**

```json
{
  "dateType": "contractEnd",
  "fromDate": "2027-01-01T00:00:00Z",
  "toDate": "2027-01-08T00:00:00Z",
  "maxItems": 2000,
  "windowHours": 24
}
```

### Output example

```json
{
  "ocid": "prod-6527ed2fd89c42f28d153544d3492b1d",
  "releaseId": "prod-6527ed2fd89c42f28d153544d3492b1d-be5e877d0a98326594417ad1dca7bf93",
  "releaseDate": "2026-07-01T00:54:05Z",
  "releaseTags": ["contract"],
  "contractNoticeId": "CN4256428",
  "awardStatus": "active",
  "contractStatus": "active",
  "title": "C00359",
  "description": "IMT VSA6 items MS",
  "buyerName": "Australian Institute of Family Studies",
  "buyerAbn": "64001053079",
  "supplierName": "Data#3 Limited",
  "supplierAbn": "31010545267",
  "supplierLocality": "Brisbane",
  "supplierRegion": "QLD",
  "unspscCode": "43200000",
  "procurementMethod": "open",
  "contractStartDate": "2026-06-30T14:00:00Z",
  "contractEndDate": "2031-06-29T14:00:00Z",
  "amount": 743033.67,
  "currency": "AUD",
  "sourceUrl": "https://api.tenders.gov.au/ocds/findById/CN4256428"
}
```

### Date search modes

Use `contractPublished` for daily new-award ingestion.
Use `contractLastModified` to refresh records that AusTender changed after publication.
Use `contractStart` to analyze contracts beginning in a future delivery period.
Use `contractEnd` to identify expiring contracts and potential recompete windows.

Date timestamps must use ISO-8601, ideally UTC with a trailing `Z`.
The Actor preserves the official release date separately from contract start, end, award, and signature dates.

### Exact Contract Notice lookups

Exact lookup is the fastest route when you already have `CN` identifiers.
The Actor validates IDs before requesting the source and fails closed on malformed values.
Duplicate IDs are removed from the input.
When IDs and a date range are combined, exact lookups run first and duplicates are suppressed across both routes.

### Handling AusTender API response limits

The official API can return 100 releases for a date query.
A full response may indicate that more records exist inside the requested interval.
The Actor therefore bisects capped windows repeatedly, down to one minute.

If 100 releases still occupy a one-minute window, the run logs a warning because the public endpoint exposes no cursor for that unusually dense interval.
Choose a lower `windowHours` setting for easier log inspection; automatic splitting works regardless of the initial value.

### Tips for best results

- 🚀 Start with one known Contract Notice ID to validate your workflow.
- 🕐 Schedule publication-date jobs shortly after the period you want to ingest.
- 🔁 Use last-modified searches to keep a warehouse synchronized.
- 📉 Keep `maxItems` low during workflow development.
- 🧩 Join records on `contractNoticeId`, and retain `releaseId` to distinguish revisions.
- 🏷️ Group by `unspscCode` for category intelligence.
- 📆 Search contract end dates months ahead for recompete planning.
- 🔒 Treat contact details responsibly and comply with applicable privacy and outreach rules.

### Integrations and procurement workflows

**AusTender → Google Sheets**

Schedule a daily run and append contract awards to a shared supplier-intelligence sheet.
Use buyer, supplier, amount, and end date columns for team review.

**AusTender → Slack or Microsoft Teams**

Trigger a webhook when a run completes, filter new rows by agency or UNSPSC, and alert the relevant account owner.

**AusTender → BigQuery or Snowflake**

Load normalized rows into an analytics warehouse.
Use `releaseId` for idempotency and `contractNoticeId` for contract-level reporting.

**AusTender → Make or Zapier**

Create CRM opportunities for high-value or soon-expiring contracts and attach the official source URL.

**AusTender → scheduled recompete monitor**

Run `contractEnd` searches weekly, compare against prior results, and notify business development teams about incumbent contracts entering a target horizon.

### Using the AusTender scraper API with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/austender-contract-awards-scraper').call({
  noticeIds: ['CN4256428'],
  maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Using the AusTender scraper API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/austender-contract-awards-scraper').call(run_input={
    'noticeIds': ['CN4256428'],
    'maxItems': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Using the AusTender scraper API with cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~austender-contract-awards-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"noticeIds":["CN4256428"],"maxItems":10}'
```

Poll the returned run ID, then download items from its `defaultDatasetId`.
Do not place long-lived tokens in shared scripts or source control.

### Use with AI agents via MCP

AusTender Contract Awards Scraper can be used by AI assistants through the [Model Context Protocol](https://docs.apify.com/platform/integrations/mcp).

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/austender-contract-awards-scraper"
```

For Claude Desktop, Cursor, or VS Code, add:

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

Example prompts:

- “Use `automation-lab/austender-contract-awards-scraper` to look up CN4256428 and summarize the buyer, supplier, value, and contract period.”
- “Find Australian Government contracts ending next quarter and group them by supplier ABN.”
- “Extract yesterday's newly published AusTender awards and identify the five largest values.”

Authentication uses your Apify account on first connection.

### Scheduling a daily AusTender monitor

Create an Apify schedule with a publication window matching the period since the prior run.
Store the last successful timestamp in your downstream system, or use fixed non-overlapping UTC windows.
Deduplicate downstream on `contractNoticeId` plus `releaseId`.

For updates to previously published records, add a separate `contractLastModified` schedule.
A webhook can start data loading or alerting as soon as each run finishes.

### Data quality and missing fields

AusTender publishes OCDS records with optional nested fields.
Some contracts may omit a contact name, address component, title, classification, or procurement-method detail.
The Actor does not guess missing data.

Supplier references are matched to release parties by ID, with the OCDS supplier role as a fallback.
Awards are matched to contracts through `awardID` where available.
Always retain source identifiers when merging this dataset with another system.

### Is it legal to scrape AusTender?

AusTender contract data is public government procurement information exposed through an official anonymous API.
The API package identifies the Department of Finance as publisher and uses an open-data license.

You are responsible for your use of the results.
Follow the source terms, avoid excessive request rates, respect privacy obligations, and do not use contact information for unlawful or misleading outreach.
This Actor uses conservative direct requests and bounded retries.

### FAQ

**How fast is the AusTender Contract Awards Scraper?**

Exact lookups commonly finish in seconds.
Date runs depend on interval density because full source responses are split to avoid missing records.

**Does it need an AusTender API key or login?**

No.
The official OCDS endpoints used by this Actor are publicly accessible without credentials.

**What is the difference between this Actor and the AusTender website?**

The website is designed for interactive procurement browsing.
This Actor provides normalized rows, output limits, scheduled runs, API access, exports, retries, cap handling, and integrations.

**Why did my date search return no results?**

Confirm that both dates are valid ISO-8601 values, the start precedes the end, and the selected date dimension matches your intent.
A contract may have a publication date but no start or end date inside the same period.

**Why are some supplier or contact fields missing?**

Those fields are optional in upstream OCDS releases.
The Actor omits unavailable values rather than fabricating them.

**Can I search more than one year?**

Each run accepts at most 366 days to keep request volume controlled.
Create several adjacent runs or schedules for longer historical backfills.

**Can I monitor contract changes?**

Yes.
Use `contractLastModified` with recurring non-overlapping date windows and retain the release ID for revision-aware processing.

**Will I receive duplicate contracts?**

The Actor deduplicates the same Contract Notice and release within a run.
A later modified release can correctly have a different release ID; handle that as an update downstream.

### Other government procurement scrapers

- [Contracts Finder UK Procurement Scraper](https://apify.com/automation-lab/contracts-finder-uk-procurement-scraper) — UK contract notices in OCDS.
- [SAM.gov Opportunities Scraper](https://apify.com/automation-lab/sam-gov-opportunities-scraper) — US federal opportunities.
- [USAspending Awards Scraper](https://apify.com/automation-lab/usaspending-awards-scraper) — US federal award intelligence.
- [UK Find a Tender Scraper](https://apify.com/automation-lab/uk-find-a-tender-scraper) — higher-value UK procurement notices.
- [World Bank Procurement Notices Scraper](https://apify.com/automation-lab/world-bank-procurement-notices-scraper) — international development procurement.

Use these actors together to build a multi-country public procurement feed while preserving each source's native identifiers.

### Support

If a run fails, include the run URL, input route, date type, and redacted input in an Apify issue.
For empty results, first test one known Contract Notice ID and inspect the selected date dimension.
Source-side outages and throttling are retried conservatively; persistent API errors remain visible as failed runs instead of silent empty datasets.

# Actor input Schema

## `noticeIds` (type: `array`):

Add AusTender Contract Notice identifiers such as CN4256428. Exact lookups run before an optional date search.

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

Choose whether the range applies to publication, latest modification, contract start, or contract end dates.

## `fromDate` (type: `string`):

Enter the inclusive start of the search window as ISO-8601, for example 2026-07-01T00:00:00Z.

## `toDate` (type: `string`):

Enter the end of the search window as ISO-8601. It must be later than the start and at most 366 days away.

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

Stop after saving this many normalized contract-award rows across ID and date routes.

## `windowHours` (type: `integer`):

Split date searches into windows of this size. Capped 100-release responses are bisected automatically.

## Actor input object example

```json
{
  "noticeIds": [
    "CN4256428"
  ],
  "dateType": "contractPublished",
  "maxItems": 10,
  "windowHours": 24
}
```

# Actor output Schema

## `overview` (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 = {
    "noticeIds": [
        "CN4256428"
    ],
    "dateType": "contractPublished",
    "maxItems": 10,
    "windowHours": 24
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/austender-contract-awards-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 = {
    "noticeIds": ["CN4256428"],
    "dateType": "contractPublished",
    "maxItems": 10,
    "windowHours": 24,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/austender-contract-awards-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 '{
  "noticeIds": [
    "CN4256428"
  ],
  "dateType": "contractPublished",
  "maxItems": 10,
  "windowHours": 24
}' |
apify call automation-lab/austender-contract-awards-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AusTender Contract Awards Scraper",
        "description": "Extract Australian Government contract awards with buyers, suppliers, ABNs, values, dates, contacts, and UNSPSC codes. Export clean data or schedule recurring monitoring—no AusTender API key required.",
        "version": "0.1",
        "x-build-id": "qubfafzObT66PSnJp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~austender-contract-awards-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-austender-contract-awards-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-contract-awards-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-austender-contract-awards-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-contract-awards-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-austender-contract-awards-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": {
                    "noticeIds": {
                        "title": "Contract Notice IDs",
                        "type": "array",
                        "description": "Add AusTender Contract Notice identifiers such as CN4256428. Exact lookups run before an optional date search.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "dateType": {
                        "title": "Date field",
                        "enum": [
                            "contractPublished",
                            "contractLastModified",
                            "contractStart",
                            "contractEnd"
                        ],
                        "type": "string",
                        "description": "Choose whether the range applies to publication, latest modification, contract start, or contract end dates.",
                        "default": "contractPublished"
                    },
                    "fromDate": {
                        "title": "From date/time",
                        "type": "string",
                        "description": "Enter the inclusive start of the search window as ISO-8601, for example 2026-07-01T00:00:00Z."
                    },
                    "toDate": {
                        "title": "To date/time",
                        "type": "string",
                        "description": "Enter the end of the search window as ISO-8601. It must be later than the start and at most 366 days away."
                    },
                    "maxItems": {
                        "title": "Maximum contract awards",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Stop after saving this many normalized contract-award rows across ID and date routes.",
                        "default": 100
                    },
                    "windowHours": {
                        "title": "Initial date window size (hours)",
                        "minimum": 1,
                        "maximum": 168,
                        "type": "integer",
                        "description": "Split date searches into windows of this size. Capped 100-release responses are bisected automatically.",
                        "default": 24
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```