# CanadaBuys Tender Opportunities Scraper (`automation-lab/canadabuys-tender-opportunities-scraper`) Actor

Scrape public CanadaBuys tender opportunities with title, buyer, category, closing date, status, source link, and optional detail text.

- **URL**: https://apify.com/automation-lab/canadabuys-tender-opportunities-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **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.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

## CanadaBuys Tender Opportunities Scraper

Extract public Canadian federal procurement opportunities from CanadaBuys into clean Apify datasets.

Use this actor to monitor open opportunities, build bid-intelligence feeds, enrich CRM records, or export tender rows for analysis.

### What does CanadaBuys Tender Opportunities Scraper do?

CanadaBuys Tender Opportunities Scraper collects tender notices from the public CanadaBuys tender opportunities index.

It reads the server-rendered CanadaBuys listing pages and saves one structured dataset item per notice.

The actor is designed for repeatable procurement monitoring rather than manual copy and paste.

It can search by keyword, filter open opportunities, and optionally keep only specific organizations, categories, regions, or dates.

### Who is it for?

Capture teams use it to find new Canadian federal bid leads.

Suppliers use it to monitor relevant opportunities by category or keyword.

Consultants use it to track demand signals across government buyers.

Procurement data platforms use it to ingest CanadaBuys notices into downstream databases.

Sales teams use it to enrich CRM accounts with active public-sector buying intent.

### Why use this scraper?

CanadaBuys is a high-value public procurement source.

Manual monitoring is slow and easy to miss.

This actor turns public tender pages into stable JSON, CSV, Excel, or API output.

It is HTTP-first, lightweight, and suited for scheduled monitoring runs.

### What data can it extract?

The actor extracts the core fields shown on CanadaBuys tender listings.

Optional detail-page enrichment is available when CanadaBuys permits direct detail access.

Listing records are always saved even if a detail page blocks repeated direct requests.

### Data fields

| Field | Description |
| --- | --- |
| `title` | Tender/opportunity title |
| `tenderId` | ID parsed from the CanadaBuys detail URL |
| `solicitationNumber` | Solicitation number when available from detail pages |
| `status` | Tender status when available |
| `category` | Category such as goods, services, or construction |
| `organization` | Buyer or issuing organization |
| `region` | Region/location when available |
| `openDate` | Open or amendment date from the listing |
| `closingDate` | Closing date |
| `closingTime` | Closing time when available |
| `publicationDate` | Publication date when available |
| `detailUrl` | CanadaBuys tender notice URL |
| `sourceUrl` | Search/listing URL used for the record |
| `searchKeyword` | Keyword supplied in the input |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape CanadaBuys tender opportunities?

This actor uses pay-per-event pricing.

There is a small run-start charge and a per-item charge for each saved tender opportunity.

Final Store pricing is calculated from cloud test costs before publication.

Use a small `maxItems` value for smoke tests and a larger value for scheduled monitoring.

### Input options

`keywords` searches CanadaBuys for a procurement keyword or phrase.

`startUrls` accepts CanadaBuys search URLs or direct tender notice URLs.

`openOnly` requests open CanadaBuys opportunity filters by default.

`statuses` lets you keep specific status labels after extraction.

`organization` filters buyer names after extraction.

`category` filters tender categories after extraction.

`region` filters enriched region/location fields when present.

`dateFrom` and `dateTo` filter against closing, publication, or open dates.

`maxItems` controls the number of saved records.

`includeDetails` opens tender notice pages for additional metadata when available.

`requestDelayMs` adds polite delay between requests.

### Example input

```json
{
  "keywords": "construction",
  "openOnly": true,
  "maxItems": 50,
  "includeDetails": false
}
````

### Example output

```json
{
  "title": "Construction of 6 New Buildings",
  "tenderId": "mx-444049429558",
  "category": "Construction",
  "organization": "Construction de Défense Canada - Région…",
  "openDate": "2026/06/29",
  "closingDate": "2026/07/15",
  "detailUrl": "https://canadabuys.canada.ca/en/tender-opportunities/tender-notice/mx-444049429558",
  "searchKeyword": "construction",
  "scrapedAt": "2026-07-07T03:11:37.402Z"
}
```

### How to scrape CanadaBuys tenders

1. Open the actor on Apify.

2. Enter a keyword such as `construction`, `software`, or `professional services`.

3. Keep `Open opportunities only` enabled for active bid monitoring.

4. Set `Maximum opportunities` to your desired export size.

5. Run the actor.

6. Download results from the dataset as JSON, CSV, Excel, XML, RSS, or HTML.

### Monitoring workflow

Schedule the actor daily or weekly.

Use stable keywords that match your sales or bid strategy.

Export new records into your CRM, data warehouse, or notification workflow.

Use `detailUrl` as the persistent source link for deduplication.

### Bid intelligence workflow

Combine this actor with CRM enrichment.

Match `organization` to account records.

Use `category`, `title`, and `closingDate` to prioritize opportunities.

Route promising records to capture managers.

### Integrations

Send results to Google Sheets for a shared bid tracker.

Use webhooks to notify Slack when new opportunities appear.

Use the Apify API to load records into Snowflake, BigQuery, Airtable, or HubSpot.

Use dataset exports for BI dashboards.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/canadabuys-tender-opportunities-scraper').call({
  keywords: 'construction',
  openOnly: true,
  maxItems: 50,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/canadabuys-tender-opportunities-scraper').call(run_input={
    'keywords': 'construction',
    'openOnly': True,
    'maxItems': 50,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~canadabuys-tender-opportunities-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":"construction","openOnly":true,"maxItems":50}'
```

### MCP usage

Use the actor from Claude Desktop or Claude Code through Apify MCP.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/canadabuys-tender-opportunities-scraper
```

#### Claude Code

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

#### Claude Desktop

Add this server to your Claude Desktop JSON config:

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

#### Cursor

Open **Settings → Tools & MCP → Add custom MCP** and use the MCP server URL above.

#### VS Code

Open the Command Palette, choose **MCP: Add Server**, select **HTTP**, and use the MCP server URL above.

Example prompts:

- "Find recent CanadaBuys construction opportunities and summarize closing dates."

- "Extract CanadaBuys software tenders and group them by buyer organization."

- "Build a shortlist of open Canadian procurement leads for professional services."

### Tips for better results

Use broad keywords first, then filter by organization or category.

Use `maxItems` 20-50 for testing.

Use `maxItems` 100+ for realistic monitoring runs.

Disable detail enrichment when you only need listing fields.

Enable detail enrichment only for smaller high-value runs.

### Troubleshooting

If a detail page is not enriched, the actor still saves the listing record.

CanadaBuys may reject repeated direct detail-page requests with HTTP 403.

If you receive fewer records than expected, broaden the keyword or remove post-extraction filters.

If dates look unusual, check the original `detailUrl`; some legacy notices contain placeholder dates.

### Legality

### Is it legal to scrape CanadaBuys?

This actor extracts publicly available tender opportunity pages.

You should use the data responsibly and comply with CanadaBuys terms, Apify terms, and applicable laws.

Do not use the actor to overload the website.

Respect source links and verify critical procurement details on CanadaBuys before bidding.

### Related scrapers

- https://apify.com/automation-lab/samgov-government-contracts-scraper

- https://apify.com/automation-lab/uk-find-a-tender-scraper

- https://apify.com/automation-lab/singapore-gebiz-tender-opportunities-scraper

- https://apify.com/automation-lab/boamp-public-tenders-scraper

### FAQ

#### Can I scrape only open CanadaBuys tenders?

Yes. Keep `openOnly` enabled, which is the default.

#### Can I monitor one department?

Yes. Use a broad keyword and set `organization` to part of the department name.

#### Can I export to Excel?

Yes. Apify datasets support Excel, CSV, JSON, XML, RSS, and HTML exports.

#### Does the actor use a browser?

No. It uses lightweight HTTP and Cheerio parsing for the public listing page.

#### Why are some detail fields empty?

Some CanadaBuys notice detail pages can reject repeated direct requests. Listing fields are still extracted reliably.

#### Can I run it on a schedule?

Yes. Use Apify schedules and webhooks to create an automated procurement monitor.

### Support

If you need a new field, open an issue on the actor page.

Include the CanadaBuys URL and a sample expected output field.

### Changelog

Initial version extracts public CanadaBuys tender opportunity listing rows with optional detail-page enrichment.

# Actor input Schema

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

Keyword or phrase to search in CanadaBuys tender opportunities. Leave empty to collect the latest public tender opportunities.

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

Optional CanadaBuys tender-opportunities search/listing URLs or direct tender notice URLs. If provided, these override the generated keyword search URL.

## `openOnly` (type: `boolean`):

When enabled, request CanadaBuys Open status filters before scraping. Disable to include other statuses such as awarded, expired, or cancelled.

## `statuses` (type: `array`):

Optional post-extraction status labels to keep, for example Open, Awarded, Expired, or Cancelled. Leave empty to keep all records returned by the search.

## `organization` (type: `string`):

Keep only opportunities whose buyer/organization contains this text after extraction.

## `category` (type: `string`):

Keep only opportunities whose category contains this text, such as construction, goods, or services.

## `region` (type: `string`):

Keep only enriched opportunities whose region/location text contains this value. Best used with Open detail pages enabled.

## `dateFrom` (type: `string`):

Optional earliest closing/publication date in YYYY-MM-DD or YYYY/MM/DD form.

## `dateTo` (type: `string`):

Optional latest closing/publication date in YYYY-MM-DD or YYYY/MM/DD form.

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

Maximum tender opportunity records to save. Use 10-50 for quick tests and 100+ for monitoring feeds.

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

Open each tender notice page to extract solicitation number, buyer/contact details, summary text, amendment hints, and attachment links. Slower but richer.

## `requestDelayMs` (type: `integer`):

Polite delay between CanadaBuys HTTP requests. Increase for large monitoring runs.

## Actor input object example

```json
{
  "keywords": "construction",
  "startUrls": [],
  "openOnly": true,
  "statuses": [],
  "organization": "",
  "category": "",
  "region": "",
  "dateFrom": "",
  "dateTo": "",
  "maxItems": 20,
  "includeDetails": false,
  "requestDelayMs": 300
}
```

# 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 = {
    "keywords": "construction",
    "startUrls": [],
    "openOnly": true,
    "statuses": [],
    "organization": "",
    "category": "",
    "region": "",
    "dateFrom": "",
    "dateTo": "",
    "maxItems": 20,
    "includeDetails": false,
    "requestDelayMs": 300
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/canadabuys-tender-opportunities-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "keywords": "construction",
    "startUrls": [],
    "openOnly": True,
    "statuses": [],
    "organization": "",
    "category": "",
    "region": "",
    "dateFrom": "",
    "dateTo": "",
    "maxItems": 20,
    "includeDetails": False,
    "requestDelayMs": 300,
}

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

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

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

```

## CLI example

```bash
echo '{
  "keywords": "construction",
  "startUrls": [],
  "openOnly": true,
  "statuses": [],
  "organization": "",
  "category": "",
  "region": "",
  "dateFrom": "",
  "dateTo": "",
  "maxItems": 20,
  "includeDetails": false,
  "requestDelayMs": 300
}' |
apify call automation-lab/canadabuys-tender-opportunities-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CanadaBuys Tender Opportunities Scraper",
        "description": "Scrape public CanadaBuys tender opportunities with title, buyer, category, closing date, status, source link, and optional detail text.",
        "version": "0.1",
        "x-build-id": "A92dkwgynbl2EOHXa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~canadabuys-tender-opportunities-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-canadabuys-tender-opportunities-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~canadabuys-tender-opportunities-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-canadabuys-tender-opportunities-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~canadabuys-tender-opportunities-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-canadabuys-tender-opportunities-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Keyword or phrase to search in CanadaBuys tender opportunities. Leave empty to collect the latest public tender opportunities."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional CanadaBuys tender-opportunities search/listing URLs or direct tender notice URLs. If provided, these override the generated keyword search URL.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "openOnly": {
                        "title": "Open opportunities only",
                        "type": "boolean",
                        "description": "When enabled, request CanadaBuys Open status filters before scraping. Disable to include other statuses such as awarded, expired, or cancelled.",
                        "default": true
                    },
                    "statuses": {
                        "title": "Status labels to keep",
                        "type": "array",
                        "description": "Optional post-extraction status labels to keep, for example Open, Awarded, Expired, or Cancelled. Leave empty to keep all records returned by the search.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "organization": {
                        "title": "Organization contains",
                        "type": "string",
                        "description": "Keep only opportunities whose buyer/organization contains this text after extraction.",
                        "default": ""
                    },
                    "category": {
                        "title": "Category contains",
                        "type": "string",
                        "description": "Keep only opportunities whose category contains this text, such as construction, goods, or services.",
                        "default": ""
                    },
                    "region": {
                        "title": "Region or location contains",
                        "type": "string",
                        "description": "Keep only enriched opportunities whose region/location text contains this value. Best used with Open detail pages enabled.",
                        "default": ""
                    },
                    "dateFrom": {
                        "title": "Date from",
                        "type": "string",
                        "description": "Optional earliest closing/publication date in YYYY-MM-DD or YYYY/MM/DD form.",
                        "default": ""
                    },
                    "dateTo": {
                        "title": "Date to",
                        "type": "string",
                        "description": "Optional latest closing/publication date in YYYY-MM-DD or YYYY/MM/DD form.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Maximum opportunities",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum tender opportunity records to save. Use 10-50 for quick tests and 100+ for monitoring feeds.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Open detail pages",
                        "type": "boolean",
                        "description": "Open each tender notice page to extract solicitation number, buyer/contact details, summary text, amendment hints, and attachment links. Slower but richer.",
                        "default": false
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Polite delay between CanadaBuys HTTP requests. Increase for large monitoring runs.",
                        "default": 300
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```