# ToDoCanada Events Scraper (`automation-lab/todocanada-events-scraper`) Actor

🇨🇦 Extract Canadian events, schedules, venues, prices, organizers, images, and ticket links from ToDoCanada city guides and event pages.

- **URL**: https://apify.com/automation-lab/todocanada-events-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **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

## ToDoCanada Events Scraper

Extract structured Canadian event data from ToDoCanada city guides, discovery pages, and individual event listings.

Turn public event pages into a clean dataset of schedules, venues, prices, organizers, images, and registration links. Run it once for research or schedule it to maintain a current local events feed.

### What does ToDoCanada Events Scraper do?

The Actor accepts one or more `todocanada.ca` URLs and discovers event records embedded in their public pages.

It supports:

- City and weekend guides
- Category and editorial discovery pages
- Individual event URLs
- Multiple source URLs in one run
- Canonical URL deduplication
- Optional detail-page enrichment
- JSON, CSV, Excel, XML, and RSS exports through Apify

Each dataset row represents one event. No account or ToDoCanada credentials are required.

### Who is it for?

#### Tourism publishers

Build city calendars and destination guides from normalized event listings.

#### Event calendar operators

Discover new listings and refresh dates, venues, and registration links on a schedule.

#### Travel applications

Add local activities to trip-planning and recommendation workflows.

#### Venue and entertainment marketers

Research event timing, categories, organizers, and local competition.

#### Data teams

Feed Canadian event records into warehouses, dashboards, and enrichment pipelines.

### Why use this event scraper?

- **Structured output:** avoid copying inconsistent editorial pages by hand.
- **Repeatable monitoring:** rerun the same sources daily or weekly.
- **Flexible inputs:** combine broad guides with specific event URLs.
- **Useful provenance:** every row preserves its discovery source and canonical event link.
- **Efficient extraction:** HTTP and embedded structured data avoid browser overhead.
- **Safe limits:** `maxItems` controls dataset size and run cost.

### What data can you extract?

| Field | Type | Description |
|---|---|---|
| `title` | string | Event title |
| `description` | string | Public event summary |
| `startDate` | string | Start date or date-time from the source |
| `endDate` | string | End date or date-time when available |
| `venueName` | string | Venue or location name |
| `address` | object | Street, city, province, postal code, and country |
| `price` | string | Published price information |
| `isFree` | boolean | Whether structured data identifies a free event |
| `organizer` | string | Organizer name when published |
| `categories` | array | Event keywords or categories |
| `imageUrl` | string | Main event image |
| `eventUrl` | string | Canonical ToDoCanada event URL |
| `ticketUrl` | string | Ticket or registration URL |
| `sourceUrl` | string | Discovery URL supplied in the input |
| `scrapedAt` | string | UTC extraction timestamp |

Optional source fields may be absent when ToDoCanada does not publish them.

### How to scrape ToDoCanada events

1. Open the Actor input page.
2. Add a city guide, category page, search page, or event URL.
3. Set the maximum number of events.
4. Enable detail pages if richer records justify extra requests.
5. Start the run.
6. Preview the Events dataset.
7. Export or connect the dataset to your workflow.

For a cheap first run, keep detail enrichment disabled and request 20 events.

### Input

```json
{
  "startUrls": [
    { "url": "https://www.todocanada.ca/things-to-do-in-toronto-this-weekend/" }
  ],
  "maxItems": 100,
  "includeDetails": false,
  "deduplicate": true
}
````

#### `startUrls`

A list of public ToDoCanada URLs. Use discovery pages for broad collection and explicit event pages for focused extraction.

#### `maxItems`

Maximum unique events emitted across all sources. Allowed range: 1 to 10,000.

#### `includeDetails`

When enabled, the Actor visits discovered event pages and merges richer structured fields. This increases run time and requests.

#### `deduplicate`

When enabled, repeated canonical event URLs are emitted only once.

### Output example

```json
{
  "title": "Toronto International Harp Festival 2026",
  "description": "A global gathering of harpists, educators, and music lovers.",
  "startDate": "2026-07-06",
  "endDate": "2026-07-12",
  "venueName": "Various Locations",
  "address": {
    "city": "Toronto",
    "province": "ON"
  },
  "isFree": false,
  "eventUrl": "https://www.todocanada.ca/city/toronto/event/toronto-international-harp-festival-2026/",
  "sourceUrl": "https://www.todocanada.ca/things-to-do-in-toronto-this-weekend/",
  "scrapedAt": "2026-07-12T00:00:00.000Z"
}
```

### How much does it cost to scrape ToDoCanada events?

This Actor uses pay-per-event pricing: a small run-start charge plus a charge for each dataset item. Apify plan tiers receive volume discounts.

Use `maxItems` to set a predictable upper bound. HTTP extraction keeps compute usage low. Enabling detail pages adds one request per discovered event but does not create duplicate output charges.

Check the live Actor pricing panel for exact tier prices before starting a run.

### Event discovery and deduplication

Discovery pages often repeat an event in several editorial sections. The Actor uses the canonical ToDoCanada event URL as its primary identity.

When multiple input pages contain the same event, deduplication keeps the first record and preserves that source URL. Disable deduplication only when source-page membership itself matters to your analysis.

### Detail-page enrichment

Leave `includeDetails` off when listing-page fields are sufficient or speed is the priority.

Enable it when you need the best available description, organizer, categories, image, price, venue, or registration link. A failed detail request does not discard a usable discovery record.

### Scheduling and event monitoring

Create an Apify schedule to run the same city pages daily or weekly.

A typical monitoring workflow is:

1. Run this Actor on selected city sources.
2. Export the current dataset.
3. Compare `eventUrl`, `startDate`, `endDate`, and `price` with the prior run.
4. Notify your team about new or changed events.
5. Remove expired records according to your own retention policy.

### Integrations

#### Google Sheets

Use the Google Sheets integration to maintain an editorial event calendar.

#### Webhooks

Send a run-finished webhook to an API, automation platform, or serverless function.

#### Zapier and Make

Trigger downstream publishing, review, enrichment, or notification steps.

#### Data warehouses

Load dataset exports into BigQuery, Snowflake, PostgreSQL, or your object store.

#### Slack and email

Notify curators when a monitored city produces new event URLs.

### API usage

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/todocanada-events-scraper').call({
  startUrls: [{ url: 'https://www.todocanada.ca/things-to-do-in-toronto-this-weekend/' }],
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/todocanada-events-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.todocanada.ca/things-to-do-in-toronto-this-weekend/'}],
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~todocanada-events-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.todocanada.ca/things-to-do-in-toronto-this-weekend/"}],"maxItems":100}'
```

### Use with Apify MCP

Connect through `https://mcp.apify.com?tools=automation-lab/todocanada-events-scraper` from Claude Code, Claude Desktop, or another MCP client.

Example prompts:

- “Extract up to 100 events from this ToDoCanada Toronto guide.”
- “Collect these Vancouver and Calgary event pages and return venue addresses.”
- “Run my saved Canadian events monitor and summarize newly discovered URLs.”

MCP is useful when an agent should collect current event data before drafting content or planning a trip.

### Tips for better results

- Prefer stable ToDoCanada discovery URLs over copied tracking links.
- Combine several sources in one run to deduplicate across pages.
- Keep detail enrichment off for fast discovery scans.
- Enable detail enrichment for publication-ready records.
- Schedule collection frequently enough for your editorial cycle.
- Use `eventUrl` as the durable external key in downstream systems.
- Preserve `sourceUrl` when auditing where an event was discovered.
- Treat missing optional fields as “not published,” not as extraction errors.

### Data quality notes

ToDoCanada controls source availability and structured-data quality. Date formats can represent dates or full date-times. Recurring and multi-day events may be modeled differently by individual pages.

The Actor preserves source date values rather than guessing unavailable times. Address country codes and external ticket links are also preserved as published.

### Troubleshooting

#### Why did the run find no events?

Confirm the URL is public, belongs to `todocanada.ca`, and currently contains event structured data. Editorial pages without event listings cannot produce records.

#### Why are some fields missing?

Fields are optional when the source does not publish them. Try `includeDetails: true` to inspect the canonical event page.

#### Why did I receive fewer events than expected?

Canonical deduplication may merge events repeated across sources. The page may also contain fewer structured events than visible editorial links.

#### Why is the run slower with detail pages?

Detail enrichment performs an additional HTTP request for each event.

### Legality

This Actor extracts publicly available pages. You are responsible for complying with applicable laws, ToDoCanada terms, database rights, copyright, privacy requirements, and your intended use.

Avoid collecting personal data unnecessarily. Respect reasonable request volumes and do not republish protected descriptions or images without appropriate rights.

### Responsible use

- Collect only data needed for a legitimate purpose.
- Keep schedules proportionate to how often event pages change.
- Attribute or link to original event pages where appropriate.
- Verify critical dates and ticket details before publication.
- Honor takedown, correction, and rights-holder requests.

### FAQ

#### Does it require a ToDoCanada account?

No. It reads public pages.

#### Can it scrape several Canadian cities?

Yes. Add multiple city or discovery URLs to `startUrls`.

#### Can it scrape an individual event?

Yes. Supply the canonical ToDoCanada event URL.

#### Does it download images?

It returns image URLs when published; it does not download binary image files.

#### Can it detect free events?

It returns `isFree` from structured source signals and explicit zero/free price values.

#### Can I export CSV or Excel?

Yes. Use the dataset export controls or API.

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

Yes. Use Apify schedules and optionally webhooks.

#### Does it remove expired events later?

Each run reflects its current input pages. Handle historical retention and deletion in your downstream system.

### Related scrapers and workflows

Explore other public web data tools from [automation-lab](https://apify.com/automation-lab). Combine event extraction with travel, venue, maps, or content workflows when those Actors fit your use case.

### Support

If a valid public ToDoCanada page produces no events, open an Actor issue and include:

- The input URL
- Approximate run time
- Run ID
- Expected event example
- Whether detail enrichment was enabled

That evidence helps reproduce source changes without exposing private downstream data.

# Actor input Schema

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

City guides, category/search pages, or explicit event URLs.

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

Stop after this many unique events.

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

Fetch each event page for richer structured data. Slower but more complete.

## `deduplicate` (type: `boolean`):

Remove duplicate canonical event URLs across source pages.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.todocanada.ca/things-to-do-in-toronto-this-weekend/"
    }
  ],
  "maxItems": 20,
  "includeDetails": false,
  "deduplicate": true
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.todocanada.ca/things-to-do-in-toronto-this-weekend/"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/todocanada-events-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 = {
    "startUrls": [{ "url": "https://www.todocanada.ca/things-to-do-in-toronto-this-weekend/" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/todocanada-events-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 '{
  "startUrls": [
    {
      "url": "https://www.todocanada.ca/things-to-do-in-toronto-this-weekend/"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/todocanada-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ToDoCanada Events Scraper",
        "description": "🇨🇦 Extract Canadian events, schedules, venues, prices, organizers, images, and ticket links from ToDoCanada city guides and event pages.",
        "version": "0.1",
        "x-build-id": "ME9jgqSXmrUwv68ar"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~todocanada-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-todocanada-events-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~todocanada-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-todocanada-events-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~todocanada-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-todocanada-events-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": {
                    "startUrls": {
                        "title": "📍 ToDoCanada URLs",
                        "type": "array",
                        "description": "City guides, category/search pages, or explicit event URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum events",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many unique events.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Visit event detail pages",
                        "type": "boolean",
                        "description": "Fetch each event page for richer structured data. Slower but more complete.",
                        "default": false
                    },
                    "deduplicate": {
                        "title": "Deduplicate events",
                        "type": "boolean",
                        "description": "Remove duplicate canonical event URLs across source pages.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
