# Canada Corporations Search Scraper (`automation-lab/canada-corporations-search-scraper`) Actor

Search the official Corporations Canada federal registry by company name, corporation number, or profile URL. Extract status, BN, office, directors, filings, and profile links.

- **URL**: https://apify.com/automation-lab/canada-corporations-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business, 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Canada Corporations Search Scraper

Extract official federal corporation records from Corporations Canada.

### What does Canada Corporations Search Scraper do?

Canada Corporations Search Scraper searches the public Corporations Canada registry.

It collects company names, corporation numbers, business numbers, statuses, governing legislation, registered office addresses, directors, annual filings, and profile URLs.

Use it for due diligence, enrichment, compliance checks, lead research, and registry monitoring.

### Who is it for?

Compliance teams use it to verify Canadian federal corporate status.

Due diligence analysts use it to enrich counterparty files.

B2B data providers use it to seed Canadian company datasets.

Sales operations teams use it to validate business entities.

Researchers use it to collect public registry facts at scale.

### Why use this actor?

It uses the official federal source.

It supports broad company-name searches.

It supports exact corporation-number lookups.

It can open profile pages for richer records.

It returns clean structured JSON rows.

It runs without login credentials.

### Data source

The actor reads public pages from Corporations Canada on ised-isde.canada.ca.

The source is a Canadian government registry.

The actor does not bypass authentication.

The actor does not collect private account data.

### Data fields

| Field | Description |
| --- | --- |
| corporateName | Main corporation name |
| alternateNames | Additional English/French names when listed |
| corporationNumber | Federal corporation number |
| businessNumber | Business number when shown |
| status | Active, dissolved, amalgamated, or other public status |
| governingLegislation | Federal act and legislation label |
| governingLegislationDate | Date shown beside legislation |
| registeredOfficeAddress | Public registered office address |
| directors | Public director entries from the profile page |
| annualFilings | Public annual filing entries |
| profileUrl | Official Corporations Canada profile URL |
| sourceUrl | Search page URL used for extraction |
| query | Search term or corporation number submitted |
| scrapedAt | Extraction timestamp |

### How much does it cost to scrape Corporations Canada?

This actor uses pay-per-event pricing.

There is a small run start event.

Each saved corporation record is charged as one item event.

Use a low `maxItems` value for test runs.

Use larger limits only after confirming the input matches your workflow.

### Input options

`searchTerms` accepts company-name keywords.

`corporationNumbers` accepts exact federal corporation numbers.

`startUrls` accepts Corporations Canada search or profile URLs.

`maxItems` caps total saved records.

`includeDetails` controls whether profile pages are opened.

`delayMs` adds a polite delay between requests.

`status`, `province`, and `act` are advanced source-code filters.

### Quick start

Open the actor input page.

Enter one or more company-name search terms.

Set `maxItems` to the number of records you need.

Keep `includeDetails` enabled for registered office and directors.

Run the actor.

Export the dataset as JSON, CSV, Excel, XML, or through the API.

### Example input

```json
{
  "searchTerms": ["canada"],
  "maxItems": 100,
  "includeDetails": true,
  "delayMs": 250
}
````

### Example output

```json
{
  "corporateName": "Accreditation Canada",
  "corporationNumber": "034564-4",
  "businessNumber": "125594697RC0001",
  "status": "Active",
  "governingLegislation": "Canada Not-for-profit Corporations Act",
  "registeredOfficeAddress": "1150 CYRVILLE ROAD OTTAWA ON K1J 7S9 Canada",
  "profileUrl": "https://ised-isde.canada.ca/cc/lgcy/fdrlCrpDtls.html?..."
}
```

### Search by company name

Use company names when you need discovery.

Short broad words return many records.

Specific legal names return fewer records.

The actor paginates through search results until `maxItems` is reached.

### Search by corporation number

Use `corporationNumbers` when you already know the federal number.

This mode is useful for verification workflows.

It can be combined with name searches.

### Use start URLs

Paste a Corporations Canada search result URL to resume a known search.

Paste a profile URL to extract one specific entity.

Start URLs are useful when analysts share official links internally.

### Detail enrichment

When `includeDetails` is true, the actor opens each profile page.

This adds registered office address.

This adds governing legislation.

This adds public directors when visible.

This adds annual filings when visible.

Disable details for faster low-cost discovery runs.

### Tips for better results

Use several targeted search terms instead of one very broad term.

Set `maxItems` high enough for your expected volume.

Keep the default delay for large searches.

Use corporation-number mode for exact checks.

Review output samples before scheduling recurring runs.

### Integrations

Send results to Google Sheets for analyst review.

Load CSV exports into CRM enrichment pipelines.

Use webhooks to trigger compliance workflows after a run finishes.

Use Apify API clients to run recurring registry checks.

Join records with internal counterparty IDs by corporation number.

### 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/canada-corporations-search-scraper').call({
  searchTerms: ['canada'],
  maxItems: 100,
  includeDetails: true
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/canada-corporations-search-scraper').call(run_input={
    'searchTerms': ['canada'],
    'maxItems': 100,
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~canada-corporations-search-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["canada"],"maxItems":100,"includeDetails":true}'
```

### MCP usage

Use the Apify MCP server with Claude Code or Claude Desktop.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/canada-corporations-search-scraper`

Add it in Claude Code:

```bash
claude mcp add apify-canada-corporations https://mcp.apify.com/?tools=automation-lab/canada-corporations-search-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-canada-corporations": {
      "url": "https://mcp.apify.com/?tools=automation-lab/canada-corporations-search-scraper"
    }
  }
}
```

Example prompt:

"Run the Canada Corporations Search Scraper for the term holdings and summarize active corporations."

Another prompt:

"Look up corporation number 034564-4 and return status, registered office, and directors."

### Scheduling

Create an Apify task with your standard search terms.

Schedule it weekly or monthly.

Compare new exports with previous datasets.

Flag status changes for review.

### Monitoring workflows

Monitor important counterparties by corporation number.

Monitor target industries with keyword searches.

Monitor dissolved or non-compliant statuses.

Monitor registered office changes when profile data is available.

### Limitations

The actor returns what the public registry displays.

Some fields may be missing for some corporations.

Advanced source filters require registry-specific codes.

Very broad searches can return many pages.

The actor is not a legal opinion.

### Legality

This actor extracts public registry information.

You are responsible for using the data lawfully.

Respect applicable privacy, database, and compliance rules.

Do not use the output for unlawful profiling or harassment.

### FAQ

#### Can I search by corporation number?

Yes. Use `corporationNumbers` for exact registry lookups such as `034564-4`.

#### Can I collect directors and registered offices?

Yes. Keep `includeDetails` enabled so the actor opens each public corporation profile.

#### Does this require a Corporations Canada account?

No. The actor uses public registry pages and does not require login credentials.

#### Why are some fields empty?

Some corporations do not display every field publicly. The actor preserves missing values as null or empty arrays.

### Troubleshooting

If you get no results, try a shorter company-name keyword.

If profile fields are empty, confirm `includeDetails` is enabled.

If a broad run is slow, lower `maxItems` or increase `delayMs`.

If exact number lookup fails, verify the hyphenated corporation number format.

### Related scrapers

Explore related automation-lab company and registry scrapers on Apify.

Use them for other jurisdictions or complementary B2B enrichment.

### Support

If the public registry changes layout, open an Apify issue with your run ID.

Include the input you used.

Include the fields you expected.

We will review the extractor.

### Changelog

Initial version extracts search results and optional profile details.

### Dataset export formats

JSON is best for APIs.

CSV is best for spreadsheets.

Excel is best for analyst handoff.

XML is available for legacy systems.

RSS is not recommended for full registry records.

### Quality notes

Records are parsed from official HTML pages.

URLs are preserved for auditability.

Timestamps are included for freshness tracking.

Duplicate profile URLs are skipped within a run.

### Performance notes

HTTP extraction is lightweight.

No browser is launched.

Profile enrichment adds one request per corporation.

Search result pages usually contain twenty records.

### Responsible use

Keep delays reasonable.

Avoid unnecessary repeat runs.

Cache outputs when building internal dashboards.

Use exact lookups for routine monitoring.

# Actor input Schema

## `searchTerms` (type: `array`):

One or more corporate-name keywords to search on the public Corporations Canada federal registry.

## `corporationNumbers` (type: `array`):

Optional exact federal corporation numbers, for example 034564-4. These are searched in addition to company-name terms.

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

Optional search-result or corporation-profile URLs from ised-isde.canada.ca/cc/lgcy/.

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

Maximum number of corporation records to save across all searches.

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

Fetch each profile page to add governing legislation, registered office address, directors, and annual filing information when public.

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

Optional Corporations Canada status code. Leave empty for all statuses unless you know the registry code to use.

## `province` (type: `string`):

Optional Corporations Canada province/territory code. Leave empty for all registered office locations.

## `act` (type: `string`):

Optional Corporations Canada act code. Leave empty for all federal acts.

## `delayMs` (type: `integer`):

Polite delay between registry page requests. Increase for large searches.

## Actor input object example

```json
{
  "searchTerms": [
    "canada"
  ],
  "corporationNumbers": [],
  "startUrls": [],
  "maxItems": 20,
  "includeDetails": true,
  "delayMs": 250
}
```

# 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 = {
    "searchTerms": [
        "canada"
    ],
    "corporationNumbers": [],
    "startUrls": [],
    "maxItems": 20,
    "includeDetails": true,
    "status": "",
    "province": "",
    "act": "",
    "delayMs": 250
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/canada-corporations-search-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 = {
    "searchTerms": ["canada"],
    "corporationNumbers": [],
    "startUrls": [],
    "maxItems": 20,
    "includeDetails": True,
    "status": "",
    "province": "",
    "act": "",
    "delayMs": 250,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/canada-corporations-search-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 '{
  "searchTerms": [
    "canada"
  ],
  "corporationNumbers": [],
  "startUrls": [],
  "maxItems": 20,
  "includeDetails": true,
  "status": "",
  "province": "",
  "act": "",
  "delayMs": 250
}' |
apify call automation-lab/canada-corporations-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Canada Corporations Search Scraper",
        "description": "Search the official Corporations Canada federal registry by company name, corporation number, or profile URL. Extract status, BN, office, directors, filings, and profile links.",
        "version": "0.1",
        "x-build-id": "O4KHRy1EediEOILDc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~canada-corporations-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-canada-corporations-search-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~canada-corporations-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-canada-corporations-search-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~canada-corporations-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-canada-corporations-search-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",
                "required": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Company name search terms",
                        "type": "array",
                        "description": "One or more corporate-name keywords to search on the public Corporations Canada federal registry.",
                        "default": [
                            "canada"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "corporationNumbers": {
                        "title": "Corporation numbers",
                        "type": "array",
                        "description": "Optional exact federal corporation numbers, for example 034564-4. These are searched in addition to company-name terms.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Corporations Canada URLs",
                        "type": "array",
                        "description": "Optional search-result or corporation-profile URLs from ised-isde.canada.ca/cc/lgcy/.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum corporations",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of corporation records to save across all searches.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Open corporation profile pages",
                        "type": "boolean",
                        "description": "Fetch each profile page to add governing legislation, registered office address, directors, and annual filing information when public.",
                        "default": true
                    },
                    "status": {
                        "title": "Status filter code",
                        "type": "string",
                        "description": "Optional Corporations Canada status code. Leave empty for all statuses unless you know the registry code to use."
                    },
                    "province": {
                        "title": "Province filter code",
                        "type": "string",
                        "description": "Optional Corporations Canada province/territory code. Leave empty for all registered office locations."
                    },
                    "act": {
                        "title": "Governing act filter code",
                        "type": "string",
                        "description": "Optional Corporations Canada act code. Leave empty for all federal acts."
                    },
                    "delayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite delay between registry page requests. Increase for large searches.",
                        "default": 250
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
