# Australian Tender Intelligence API (`s1syphus9/australian-tender-intelligence`) Actor

Find and score Australian Government tender opportunities from AusTender using supplier-profile matching, deadline risk, and transparent match reasons.

- **URL**: https://apify.com/s1syphus9/australian-tender-intelligence.md
- **Developed by:** [Wesley Luong](https://apify.com/s1syphus9) (community)
- **Categories:** Lead generation, Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 matched australian tenders

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

### Australian Tender Intelligence API

Find and score Australian Government tender opportunities from AusTender using supplier-profile matching, deadline risk, and transparent match reasons. The Actor returns clean, structured tender records that can be used for lead generation, bid/no-bid triage, sales monitoring, CRM enrichment, spreadsheets, dashboards, alerts, and automated procurement workflows.

It is currently tuned for Australian Defence, infrastructure, engineering, construction, maintenance, renewable energy, and related supplier opportunities. You can change the keywords, agencies, categories, locations, and supplier profile to monitor other Australian Government tender niches.

### What this Actor does

Australian Tender Intelligence API collects current public AusTender Approaches to Market and turns them into scored opportunity records. Instead of only extracting tender pages, it helps answer the practical question: "Is this tender worth reviewing?"

For each matched tender, the Actor returns:

- normalized tender metadata;
- source, document, and lodgement links;
- public contact email where available;
- supplier-profile fit score from 0 to 100;
- deadline risk;
- match reasons and concerns;
- recommended next action.

### Who it is for

Use this Actor if you monitor Australian Government opportunities for:

- Defence and infrastructure suppliers;
- engineering consultants;
- builders and refurbishment contractors;
- facilities maintenance providers;
- renewable energy and microgrid consultants;
- bid writers and tender consultants;
- sales teams selling into Australian public-sector buyers;
- procurement intelligence and market research workflows.

### Data source

This Actor uses publicly accessible AusTender current ATM data:

- Current ATMs: `https://www.tenders.gov.au/atm`
- Current ATM RSS feed: `https://www.tenders.gov.au/public_data/rss/rss.xml`
- Public ATM detail pages: `https://www.tenders.gov.au/Atm/Show/<id>`

AusTender describes an Approach to Market as a notice inviting potential suppliers to participate in procurement. This can include tenders, requests for quote, expressions of interest, requests for information, and requests for proposal.

### Input

You can search broadly or target a specific supplier profile. The default input is tuned for Defence and infrastructure opportunities:

```json
{
  "keywords": [],
  "categories": ["Engineering", "Building construction", "Events management"],
  "agencies": ["Defence"],
  "locations": ["ACT", "NSW", "VIC", "QLD", "NT", "WA", "SA", "TAS"],
  "supplierProfile": {
    "businessSize": "SME",
    "capabilities": ["engineering", "design services", "communications", "event management", "maintenance", "renewable energy"],
    "statesServed": ["ACT", "NSW", "VIC", "QLD", "NT", "WA", "SA", "TAS"],
    "industries": ["government", "defence", "infrastructure"]
  },
  "maxResults": 10,
  "minFitScore": 30,
  "maxDetailPages": 100
}
````

#### Input fields

| Field | Description |
| --- | --- |
| `keywords` | Optional capability or opportunity terms to search for. Leave empty to rely on category, agency, location, and supplier-profile scoring. |
| `categories` | Optional AusTender category text filters, such as Building construction, Engineering, Events management, or Information Technology. |
| `agencies` | Optional buyer-agency filters, such as Defence, ATO, Services Australia, or DFAT. |
| `locations` | Australian states and territories the supplier can service. |
| `supplierProfile.capabilities` | Supplier capabilities used for fit scoring and match explanations. |
| `supplierProfile.statesServed` | Service areas used for location scoring. |
| `maxResults` | Maximum number of matched tender records to return. |
| `minFitScore` | Minimum score required for a tender to be included. |
| `maxDetailPages` | Maximum number of current AusTender detail pages to inspect from the live feed. |

#### Suggested input presets

Use the default input for Defence and infrastructure opportunities. The repository also includes three tested starter presets you can copy into the Apify input editor or use through the API:

| Preset | File | Best for |
| --- | --- | --- |
| Defence / infrastructure | `presets/defence-infrastructure.json` | Defence construction, facilities, maintenance, engineering, and infrastructure suppliers. |
| Cyber / IT services | `presets/cyber-it-services.json` | Cyber security, cloud, managed IT, software, and digital services suppliers. |
| Renewable energy / engineering | `presets/renewable-energy-engineering.json` | Solar, BESS, microgrid, electrical engineering, and clean-energy infrastructure suppliers. |

The default profile is intentionally narrow so the first run returns useful examples. To monitor another niche, change the keywords, categories, agencies, locations, and supplier capabilities.

### Output

Each dataset item contains fields such as:

```json
{
  "atmId": "DCET2026-01A",
  "title": "EST10003 RAAF Base Tindal Renewable Energy Microgrid – Design Services",
  "agency": "Department of Defence - DSRG",
  "category": "Building construction and support and maintenance and repair services",
  "closeDate": "15-Jul-2026 12:00 pm (ACT Local Time)",
  "location": "ACT",
  "atmType": "Request for Tender",
  "contactEmail": "EST10003@aurecongroup.com",
  "sourceUrl": "https://www.tenders.gov.au/Atm/Show/9493839c-93f9-4cb4-bf82-17949c5c8654",
  "documentsUrl": "https://www.tenders.gov.au/Atm/ViewDocuments/9493839c-93f9-4cb4-bf82-17949c5c8654",
  "source": "AusTender",
  "intelligence": {
    "fitScore": 100,
    "deadlineRisk": "near",
    "daysUntilClose": 11,
    "matchReasons": [
      "Supplier capability match: engineering, design services, communications, maintenance, renewable energy",
      "Category match: Building construction",
      "Agency match: Defence",
      "Location match: ACT"
    ],
    "concerns": [],
    "recommendedNextStep": "Download ATM documents and start bid/no-bid review."
  }
}
```

### Fit scoring

The score is intentionally transparent. It uses:

- keyword and capability matches across title, category, agency, description, ATM type, and location;
- supplier capability matches;
- category match;
- agency match;
- location/service-area match;
- ATM type;
- deadline risk;
- document-link availability;
- public contact-email availability.

A high score does not mean you should automatically bid. It means the tender is likely worth human review.

### Pricing

This Actor uses pay-per-event pricing.

- Primary event: `tender-matched`
- Charged when: one normalized and scored AusTender opportunity is pushed to the default dataset.
- Launch price: $0.02 per matched tender, displayed by Apify as $20.00 per 1,000 matched tenders.

Empty searches and records filtered out before being returned are not charged as matched tenders.

The Actor also uses Apify's standard low-cost Actor start event. Users can set a maximum run cost in Apify before starting a run.

### How to use the results

You can export the dataset as JSON, CSV, Excel, RSS, or HTML from Apify. You can also use the Apify API to run the Actor on a schedule and send matched tenders into your CRM, spreadsheet, Slack/Discord channel, webhook, database, or internal procurement dashboard.

Common workflows:

- daily or weekly tender monitoring;
- Defence infrastructure opportunity alerts;
- bid/no-bid triage;
- sales prospecting for government suppliers;
- procurement market research;
- competitor and agency pipeline tracking.

### Limitations

- This Actor uses public AusTender current ATM pages and RSS data.
- It does not guarantee that every possible tender document, addendum, or attachment is parsed.
- It does not submit tenders or replace AusTender account workflows.
- It does not provide legal, procurement, financial, or bid advice.
- Source pages can change, which may require maintenance.

### FAQ

#### Is this an official AusTender or Australian Government service?

No. This Actor is independently maintained and uses publicly accessible AusTender pages. Always verify important details on the official AusTender source page.

#### Why did my run return zero results?

Usually because the input filters are too narrow for the current live AusTender feed. Try lowering `minFitScore`, increasing `maxDetailPages`, removing an agency filter, or broadening keywords/categories.

#### Does the Actor submit tender responses?

No. It only finds, normalizes, and scores public opportunity records. Lodgement must still be completed through AusTender or the official lodgement instructions.

#### What does the fit score mean?

The fit score is a triage signal, not a bid recommendation. It estimates how strongly the opportunity matches the supplied profile based on capability, category, agency, location, deadline, documents, and contact availability.

#### Can this monitor non-Defence tenders?

Yes. The default is tuned for Defence/infrastructure because that niche currently produces strong live examples. You can change the filters and supplier profile for cyber, ICT, energy, professional services, facilities, or other Australian Government opportunity niches.

#### Can I schedule this Actor?

Yes. Use Apify schedules to run it daily or weekly, then export results to CSV/Excel, call it through the API, or connect the dataset to webhooks and downstream workflows.

### Disclaimer

This Actor is not affiliated with, endorsed by, or operated by the Australian Government or AusTender. It uses publicly accessible AusTender pages and is intended for opportunity research and workflow automation only. Always verify tender requirements, closing dates, lodgement rules, eligibility, and documents on the official AusTender source page before acting.

# Actor input Schema

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

Opportunity keywords or capability terms to search and score against.

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

Optional AusTender category text filters, e.g. Building construction, Engineering, Events management, or Information Technology.

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

Optional agency filters, e.g. Defence, ATO, DFAT.

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

State/territory service areas such as ACT, NSW, VIC, QLD, WA, SA, NT, TAS.

## `supplierProfile` (type: `object`):

Profile used for scoring. Suggested keys: businessSize, capabilities, statesServed, industries.

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

Maximum matched tenders returned after filtering and scoring.

## `minFitScore` (type: `integer`):

Only return tenders with this score or higher.

## `maxDetailPages` (type: `integer`):

Maximum current AusTender ATM detail pages to inspect from the RSS feed.

## Actor input object example

```json
{
  "keywords": [],
  "categories": [
    "Engineering",
    "Building construction",
    "Events management"
  ],
  "agencies": [
    "Defence"
  ],
  "locations": [
    "ACT",
    "NSW",
    "VIC",
    "QLD",
    "NT",
    "WA",
    "SA",
    "TAS"
  ],
  "supplierProfile": {
    "businessSize": "SME",
    "capabilities": [
      "engineering",
      "design services",
      "communications",
      "event management",
      "maintenance",
      "renewable energy"
    ],
    "statesServed": [
      "ACT",
      "NSW",
      "VIC",
      "QLD",
      "NT",
      "WA",
      "SA",
      "TAS"
    ],
    "industries": [
      "government",
      "defence",
      "infrastructure"
    ]
  },
  "maxResults": 10,
  "minFitScore": 30,
  "maxDetailPages": 100
}
```

# Actor output Schema

## `matchedTenders` (type: `string`):

Dataset items returned by the Actor. Each item is one matched AusTender opportunity with fit score, deadline risk, match reasons, and source links.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("s1syphus9/australian-tender-intelligence").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("s1syphus9/australian-tender-intelligence").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 '{}' |
apify call s1syphus9/australian-tender-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=s1syphus9/australian-tender-intelligence",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Australian Tender Intelligence API",
        "description": "Find and score Australian Government tender opportunities from AusTender using supplier-profile matching, deadline risk, and transparent match reasons.",
        "version": "0.1",
        "x-build-id": "q43h2Cnpdvk4FHLn3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/s1syphus9~australian-tender-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-s1syphus9-australian-tender-intelligence",
                "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/s1syphus9~australian-tender-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-s1syphus9-australian-tender-intelligence",
                "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/s1syphus9~australian-tender-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-s1syphus9-australian-tender-intelligence",
                "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": [
                    "maxResults",
                    "minFitScore",
                    "maxDetailPages"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Opportunity keywords or capability terms to search and score against.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Optional AusTender category text filters, e.g. Building construction, Engineering, Events management, or Information Technology.",
                        "default": [
                            "Engineering",
                            "Building construction",
                            "Events management"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "agencies": {
                        "title": "Agencies",
                        "type": "array",
                        "description": "Optional agency filters, e.g. Defence, ATO, DFAT.",
                        "default": [
                            "Defence"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "State/territory service areas such as ACT, NSW, VIC, QLD, WA, SA, NT, TAS.",
                        "default": [
                            "ACT",
                            "NSW",
                            "VIC",
                            "QLD",
                            "NT",
                            "WA",
                            "SA",
                            "TAS"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "supplierProfile": {
                        "title": "Supplier profile",
                        "type": "object",
                        "description": "Profile used for scoring. Suggested keys: businessSize, capabilities, statesServed, industries.",
                        "default": {
                            "businessSize": "SME",
                            "capabilities": [
                                "engineering",
                                "design services",
                                "communications",
                                "event management",
                                "maintenance",
                                "renewable energy"
                            ],
                            "statesServed": [
                                "ACT",
                                "NSW",
                                "VIC",
                                "QLD",
                                "NT",
                                "WA",
                                "SA",
                                "TAS"
                            ],
                            "industries": [
                                "government",
                                "defence",
                                "infrastructure"
                            ]
                        }
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum matched tenders returned after filtering and scoring.",
                        "default": 10
                    },
                    "minFitScore": {
                        "title": "Minimum fit score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only return tenders with this score or higher.",
                        "default": 30
                    },
                    "maxDetailPages": {
                        "title": "Maximum detail pages",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum current AusTender ATM detail pages to inspect from the RSS feed.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
