# Canada Government IT Tender Monitor (`tenderpilot-data/canada-it-tender-monitor`) Actor

Find and normalize CanadaBuys federal IT tender notices for software, cloud, cybersecurity, data, AI, SaaS, and managed digital services. Includes fit scoring, explanations, deduplication, and company-fit filters.

- **URL**: https://apify.com/tenderpilot-data/canada-it-tender-monitor.md
- **Developed by:** [TenderPilot Data](https://apify.com/tenderpilot-data) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

## Canada Government IT Tender Monitor

Find open Canadian federal IT procurement opportunities from CanadaBuys and export them as clean, structured data.

This Actor helps SaaS, cloud, cybersecurity, data, AI, and IT services vendors monitor public-sector tender opportunities without manually searching CanadaBuys every day.

### What this Actor does

- Downloads official CanadaBuys tender notice CSV data.
- Filters for IT-related opportunities such as software, cloud, cybersecurity, data, AI, TBIPS/SBIPS, database services, and digital services.
- Scores each matching notice with a deterministic `fitScore` from 0 to 100.
- Outputs normalized records with buyer, dates, category, source identifiers, matched keywords, summary, source URL, and contact details.
- Works with Apify datasets, API exports, schedules, webhooks, and downstream AI-agent workflows.

### Best use cases

- Monitor Canada federal IT RFPs and tender opportunities.
- Build a daily watchlist for government sales teams.
- Feed procurement opportunities into CRM, Slack, email, or internal bid pipelines.
- Track cybersecurity, cloud, AI, data, and software-related public-sector opportunities.
- Create a structured procurement intelligence feed for agents and automations.

### Data source

The Actor uses official CanadaBuys open data files published through the Government of Canada open data ecosystem.

Default source:

`https://canadabuys.canada.ca/opendata/pub/openTenderNotice-ouvertAvisAppelOffres.csv`

Important scope note: this first version focuses on CanadaBuys federal tender notice data. It does not claim full coverage of all provincial, municipal, or external procurement portals that can appear in the CanadaBuys web search experience.

### Input

Recommended default input:

```json
{
  "source": "open",
  "status": "open",
  "minScore": 50,
  "maxItems": 100,
  "maxRowsScanned": 0,
  "dropExcluded": true,
  "includePastClosingDates": false
}
````

#### Main input fields

| Field | Type | Description |
|---|---:|---|
| `source` | string | `open`, `new`, or `complete`. Use `open` for current open opportunities. |
| `status` | string | `open`, `expired`, `cancelled`, or `all`. |
| `keywordsInclude` | array | Optional custom IT keywords. Leave empty for the default IT keyword set. |
| `keywordsExclude` | array | Optional custom exclusion keywords. Leave empty for defaults. |
| `dateFrom` | string | Optional publication date lower bound, `YYYY-MM-DD`. |
| `dateTo` | string | Optional publication date upper bound, `YYYY-MM-DD`. |
| `provinces` | array | Optional buyer province filters, for example `Ontario`. |
| `minScore` | integer | Minimum IT-fit score from 0 to 100. Default: `50`. Use `40` for broader recall. |
| `maxItems` | integer | Maximum dataset items to output. Default: `100`. |
| `dropExcluded` | boolean | Drop notices matching exclusion keywords. Default: `true`. |
| `includePastClosingDates` | boolean | Include notices whose closing date is already in the past. Default: `false`. |

### Output

Each dataset item is one normalized tender notice.

Key output fields:

| Field | Description |
|---|---|
| `id` | Stable hash based on source notice, solicitation, and amendment identifiers. |
| `sourceNoticeId` | CanadaBuys/MERX reference number when available. |
| `solicitationNumber` | Solicitation number. |
| `amendmentNumber` | Amendment number. |
| `title` | Tender title. |
| `buyerName` | Contracting entity. |
| `endUserName` | End user entity when available. |
| `status` | Tender status. |
| `publishedDate` | Publication date. |
| `closingDate` | Tender closing deadline. |
| `procurementCategory` | CanadaBuys procurement category codes such as `SRV`, `GD`, or `SRVTGD`. |
| `procurementMethod` | Procurement method. |
| `gsinDescription` | GSIN description when available. |
| `unspscDescription` | UNSPSC description when available. |
| `summary` | Short normalized description snippet. |
| `fitLabel` | `strong_it_fit`, `possible_it_fit`, or `weak_it_fit`. |
| `fitScore` | Deterministic IT relevance score from 0 to 100. |
| `matchedKeywords` | Keywords that matched the tender. |
| `excludedKeywordsMatched` | Exclusion terms that matched, if retained. |
| `sourceUrl` | Original notice URL, or a CanadaBuys tender-notice URL constructed from the source reference number when the CSV URL field is empty. |
| `attachments` | Attachment URLs or names when available. |
| `contact` | Contact name, email, and phone when available. |
| `fetchedAt` | UTC timestamp for this Actor run. |

#### Example output item

```json
{
  "fitScore": 72,
  "fitLabel": "strong_it_fit",
  "title": "APN - CYBERSECURITY ASSESSMENT SOURCE LIST",
  "buyerName": "Defence Construction Canada / Construction de Defense Canada",
  "closingDate": "2026-07-08T14:00:00",
  "matchedKeywords": ["cyber", "cybersecurity", "information technology"],
  "sourceUrl": "https://canadabuys.canada.ca/en/tender-opportunities/tender-notice/cb-951-14703007"
}
```

#### Data source, freshness, and affiliation

Each run downloads the latest available CanadaBuys open tender CSV for the selected source mode.

Current scope:

- CanadaBuys tender notices.
- Primarily Canadian federal open tender data available in the official open-data files.
- Not provincial, municipal, MERX, SEAO, or BC Bid coverage yet.

Affiliation and verification:

- This Actor is not affiliated with CanadaBuys or the Government of Canada.
- Always verify tender details, attachments, deadlines, amendments, and bid instructions on the official source URL before bidding.
- Source update timing depends on the official CanadaBuys data publication process.

### Source modes

#### `open`

Best default. Processes currently open CanadaBuys federal tender notices.

#### `new`

Useful for frequent polling and alert-style workflows. Processes newly published tender notices.

#### `complete`

Useful for historical analysis. Processes the complete CanadaBuys tender notice file from 2022-08-08 onward. This is heavier than `open`.

### Tips

- Use `minScore: 50` for the default cleaner feed.
- Use `minScore: 40` for broader recall.
- Use `minScore: 70` for a stricter high-confidence IT feed.
- By default, past closing date-times are skipped even when the source status is still `Open`.
- Use `source: new` with Apify schedules and webhooks for alerting workflows.
- Add custom `keywordsInclude` for your niche, for example `zero trust`, `SOC`, `SIEM`, `Oracle`, `Salesforce`, `ServiceNow`, or `Microsoft 365`.
- Add custom `keywordsExclude` when a broad keyword creates false positives.

### Limitations

- This Actor is procurement intelligence, not legal or bid advice.
- Source completeness depends on the official CanadaBuys open data files.
- The baseline score is deterministic keyword/classification scoring, not a legal assessment of whether your company should bid.
- Long tender descriptions are truncated only in `summary`; the full normalized description is still available in `description`.
- Attachment parsing and AI summarization are not included in v1. They are planned as future enrichment features.

### Planned improvements

- Saved presets for cybersecurity, cloud/software, TBIPS/SBIPS, and AI/data.
- Better amendment grouping and duplicate handling.
- New-tender alert mode examples.
- Optional AI enrichment for tender summaries and company-fit scoring.
- Attachment parsing.
- Future expansion to SAM.gov and TED/EU using the same normalized schema.

#### Quality controls

- `scoreExplanation` explains why a tender matched, so users can audit `fitScore` instead of trusting a black box.
- `strictMode: true` narrows the feed to opportunities with stronger IT evidence in the title or classification fields.
- `focusArea` lets users quickly narrow the feed to cybersecurity, cloud/SaaS, data/AI, software licensing, IT professional services, or TBIPS/SBIPS opportunities.
- `dedupeMode: latestBySolicitationNumber` keeps the latest record per solicitation number by default. Use `none` if you need every source notice/amendment row.

#### Company-fit matching

Use `companyFitMode` and `companyProfileKeywords` when you want the Actor to score or filter tenders for a specific vendor profile.

Example:

```json
{
  "companyFitMode": "filter",
  "companyProfileKeywords": ["SOC", "penetration testing", "cybersecurity assessment"],
  "focusArea": "cybersecurity",
  "strictMode": true
}
```

- `companyFitMode: score` keeps all normal results and adds company-fit fields.
- `companyFitMode: filter` keeps only results matching at least one company keyword.
- `sortBy: companyFitScore` puts best company-profile matches first.

#### Large source safety

For `source: complete`, the Actor streams the official CSV and applies a default `maxRowsScanned` safety limit of 20000 rows unless you provide a different value. This avoids downloading and scanning the complete historical file blindly during normal runs. Use date filters, stricter filters, and explicit row limits when exploring historical data.

# Actor input Schema

## `source` (type: `string`):

Which CanadaBuys tender notice CSV to process.

## `status` (type: `string`):

Filter by normalized tender status. Use all when processing the complete source.

## `keywordsInclude` (type: `array`):

IT-related keywords used for matching. Leave empty to use the default IT keyword set.

## `keywordsExclude` (type: `array`):

Keywords that indicate non-IT opportunities. Leave empty to use defaults.

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

Optional lower bound for publication date, YYYY-MM-DD.

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

Optional upper bound for publication date, YYYY-MM-DD.

## `provinces` (type: `array`):

Optional exact buyer province filters, for example Ontario or Quebec.

## `minScore` (type: `integer`):

Minimum IT-fit score from 0 to 100. Default 50 keeps the public listing cleaner; use 40 for broader recall.

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

Maximum number of normalized tender notices to output.

## `dropExcluded` (type: `boolean`):

Drop notices that match any exclude keyword.

## `closingDateFrom` (type: `string`):

Optional lower bound for tender closing date, YYYY-MM-DD.

## `closingDateTo` (type: `string`):

Optional upper bound for tender closing date, YYYY-MM-DD.

## `sortBy` (type: `string`):

Sort matching tenders before applying maxItems.

## `includePastClosingDates` (type: `boolean`):

By default, the Actor skips notices whose closing date is earlier than today, even if the source status still says Open. Enable this for historical analysis.

## `strictMode` (type: `boolean`):

Require stronger IT evidence in the title or classification fields. Reduces generic consulting/supply/audit matches.

## `dedupeMode` (type: `string`):

Controls duplicate/amendment handling. Use latestBySolicitationNumber for a cleaner default feed.

## `focusArea` (type: `string`):

Optional buyer preset. Keeps only tenders matching a specific IT opportunity type.

## `companyFitMode` (type: `string`):

Optional company-fit matching. Use score to add company-fit fields, or filter to keep only records matching your company keywords.

## `companyProfileKeywords` (type: `array`):

Optional keywords describing your company offer, such as cloud migration, SOC, penetration testing, Oracle, Salesforce, data warehouse, or Microsoft 365.

## `maxRowsScanned` (type: `integer`):

Safety limit for very large sources. 0 means unlimited except complete source, where default safety limit is 20000 rows.

## Actor input object example

```json
{
  "source": "open",
  "status": "open",
  "keywordsInclude": [
    "cybersecurity",
    "cloud",
    "software"
  ],
  "keywordsExclude": [
    "construction services",
    "roofing"
  ],
  "dateFrom": "2026-06-01",
  "dateTo": "2026-06-30",
  "provinces": [
    "Ontario",
    "Quebec"
  ],
  "minScore": 50,
  "maxItems": 100,
  "dropExcluded": true,
  "closingDateFrom": "2026-07-01",
  "closingDateTo": "2026-12-31",
  "sortBy": "fitScore",
  "includePastClosingDates": false,
  "strictMode": false,
  "dedupeMode": "latestBySolicitationNumber",
  "focusArea": "all",
  "companyFitMode": "off",
  "companyProfileKeywords": [
    "cloud migration",
    "cybersecurity",
    "data analytics"
  ],
  "maxRowsScanned": 0
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (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 = {
    "companyProfileKeywords": [
        "cloud migration",
        "cybersecurity",
        "data analytics"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tenderpilot-data/canada-it-tender-monitor").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "companyProfileKeywords": [
        "cloud migration",
        "cybersecurity",
        "data analytics",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("tenderpilot-data/canada-it-tender-monitor").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "companyProfileKeywords": [
    "cloud migration",
    "cybersecurity",
    "data analytics"
  ]
}' |
apify call tenderpilot-data/canada-it-tender-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=tenderpilot-data/canada-it-tender-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Canada Government IT Tender Monitor",
        "description": "Find and normalize CanadaBuys federal IT tender notices for software, cloud, cybersecurity, data, AI, SaaS, and managed digital services. Includes fit scoring, explanations, deduplication, and company-fit filters.",
        "version": "0.0",
        "x-build-id": "gEAqf0eojIJQxklsV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tenderpilot-data~canada-it-tender-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tenderpilot-data-canada-it-tender-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/tenderpilot-data~canada-it-tender-monitor/runs": {
            "post": {
                "operationId": "runs-sync-tenderpilot-data-canada-it-tender-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/tenderpilot-data~canada-it-tender-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-tenderpilot-data-canada-it-tender-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "source": {
                        "title": "CanadaBuys source file",
                        "enum": [
                            "open",
                            "new",
                            "complete"
                        ],
                        "type": "string",
                        "description": "Which CanadaBuys tender notice CSV to process.",
                        "default": "open"
                    },
                    "status": {
                        "title": "Tender status",
                        "enum": [
                            "open",
                            "expired",
                            "cancelled",
                            "all"
                        ],
                        "type": "string",
                        "description": "Filter by normalized tender status. Use all when processing the complete source.",
                        "default": "open"
                    },
                    "keywordsInclude": {
                        "title": "Include keywords",
                        "type": "array",
                        "description": "IT-related keywords used for matching. Leave empty to use the default IT keyword set.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywordsExclude": {
                        "title": "Exclude keywords",
                        "type": "array",
                        "description": "Keywords that indicate non-IT opportunities. Leave empty to use defaults.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dateFrom": {
                        "title": "Published date from",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional lower bound for publication date, YYYY-MM-DD."
                    },
                    "dateTo": {
                        "title": "Published date to",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional upper bound for publication date, YYYY-MM-DD."
                    },
                    "provinces": {
                        "title": "Buyer provinces",
                        "type": "array",
                        "description": "Optional exact buyer province filters, for example Ontario or Quebec.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minScore": {
                        "title": "Minimum fit score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Minimum IT-fit score from 0 to 100. Default 50 keeps the public listing cleaner; use 40 for broader recall.",
                        "default": 50
                    },
                    "maxItems": {
                        "title": "Maximum items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of normalized tender notices to output.",
                        "default": 100
                    },
                    "dropExcluded": {
                        "title": "Drop excluded matches",
                        "type": "boolean",
                        "description": "Drop notices that match any exclude keyword.",
                        "default": true
                    },
                    "closingDateFrom": {
                        "title": "Closing date from",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional lower bound for tender closing date, YYYY-MM-DD."
                    },
                    "closingDateTo": {
                        "title": "Closing date to",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional upper bound for tender closing date, YYYY-MM-DD."
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "fitScore",
                            "closingDate",
                            "publishedDate",
                            "companyFitScore"
                        ],
                        "type": "string",
                        "description": "Sort matching tenders before applying maxItems.",
                        "default": "fitScore"
                    },
                    "includePastClosingDates": {
                        "title": "Include past closing dates",
                        "type": "boolean",
                        "description": "By default, the Actor skips notices whose closing date is earlier than today, even if the source status still says Open. Enable this for historical analysis.",
                        "default": false
                    },
                    "strictMode": {
                        "title": "Strict mode",
                        "type": "boolean",
                        "description": "Require stronger IT evidence in the title or classification fields. Reduces generic consulting/supply/audit matches.",
                        "default": false
                    },
                    "dedupeMode": {
                        "title": "Deduplication mode",
                        "enum": [
                            "latestBySolicitationNumber",
                            "latestBySourceNoticeId",
                            "none"
                        ],
                        "type": "string",
                        "description": "Controls duplicate/amendment handling. Use latestBySolicitationNumber for a cleaner default feed.",
                        "default": "latestBySolicitationNumber"
                    },
                    "focusArea": {
                        "title": "Focus area",
                        "enum": [
                            "all",
                            "cybersecurity",
                            "cloudSaas",
                            "dataAi",
                            "softwareLicensing",
                            "professionalServices",
                            "tbipsSbips"
                        ],
                        "type": "string",
                        "description": "Optional buyer preset. Keeps only tenders matching a specific IT opportunity type.",
                        "default": "all"
                    },
                    "companyFitMode": {
                        "title": "Company fit mode",
                        "enum": [
                            "off",
                            "score",
                            "filter"
                        ],
                        "type": "string",
                        "description": "Optional company-fit matching. Use score to add company-fit fields, or filter to keep only records matching your company keywords.",
                        "default": "off"
                    },
                    "companyProfileKeywords": {
                        "title": "Company profile keywords",
                        "type": "array",
                        "description": "Optional keywords describing your company offer, such as cloud migration, SOC, penetration testing, Oracle, Salesforce, data warehouse, or Microsoft 365.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxRowsScanned": {
                        "title": "Maximum source rows scanned",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Safety limit for very large sources. 0 means unlimited except complete source, where default safety limit is 20000 rows.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```