# Public Webinar Event Finder (`automation-lab/public-webinar-event-finder`) Actor

Find public webinars, demos, workshops, speakers, dates, topics, and registration URLs from company event pages.

- **URL**: https://apify.com/automation-lab/public-webinar-event-finder.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

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

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

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

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

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

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

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

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


# README

## Public Webinar Event Finder

Find public webinars, demos, workshops, virtual events, speakers, topics, dates, and registration URLs from company marketing pages.

Use this actor to monitor target accounts, competitors, partners, vendors, and category leaders for upcoming public event signals without logging in or scraping attendee data.

### What does Public Webinar Event Finder do?

Public Webinar Event Finder crawls public company webinar and event pages and turns messy marketing pages into structured records.

It looks for JSON-LD Event schema, visible event cards, webinar links, demo CTAs, workshop pages, dates, and registration URLs.

Each dataset item is a single webinar/event lead with the source URL, event title, registration URL, detected date, topics, host company, description, confidence score, and dedupe hash.

### Who is it for?

- 🧲 Demand generation teams tracking competitor webinars and topic trends.
- 💬 Sales and SDR teams looking for timely outreach triggers at target accounts.
- 🧭 Competitive intelligence teams monitoring product launches, partner events, and workshops.
- 🤝 Partnership teams finding co-marketing events and integration webinars.
- 📊 Data teams building enrichment pipelines for CRM, spreadsheets, BI tools, or alerts.

### Why use this actor?

Company event pages are inconsistent. Some expose structured schema, some use card grids, and some hide the useful registration link behind generic buttons.

This actor standardizes those pages into exportable rows so teams can search, filter, deduplicate, and automate next actions.

### What data can you extract?

| Field | Description |
| --- | --- |
| `title` | Webinar, workshop, demo, or event title. |
| `sourceUrl` | Page where the event signal was detected. |
| `registrationUrl` | Registration, detail, or CTA destination when available. |
| `ctaText` | Visible button/link text such as Register or Watch now. |
| `startDate` | Detected start date from schema or visible text. |
| `endDate` | Detected end date when schema provides it. |
| `timezone` | Timezone when schema provides it. |
| `status` | Event status when schema provides it. |
| `speakers` | Speaker or performer names when available. |
| `hostCompany` | Organizer/site name or source domain. |
| `topics` | Matched webinar/event keywords. |
| `description` | Short visible or schema description. |
| `detectedFrom` | `json-ld` or `visible-html`. |
| `confidence` | Heuristic confidence from 0 to 1. |
| `contentHash` | Stable hash for deduplication. |
| `scrapedAt` | ISO timestamp of extraction. |

### How much does it cost to find public webinars?

The actor uses pay-per-event pricing.

- Start event: $0.005 per run.
- Webinar/event record: tiered per saved dataset item.
- Current BRONZE tier price is $0.000033342 per item.
- FREE tier price is $0.000038344 per item, with lower prices for SILVER, GOLD, PLATINUM, and DIAMOND tiers.

Pricing was calculated from cloud validation cost before QA handoff.

### Quick start

1. Open the actor on Apify.
2. Add one or more public company webinar/event URLs.
3. Keep `maxItems` small for the first run.
4. Run the actor.
5. Export the dataset as CSV, JSON, Excel, or connect it to your workflow.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.salesforce.com/resources/webinars/" }
  ],
  "maxItems": 50,
  "maxPagesPerDomain": 20,
  "crawlDepth": 1,
  "sameDomainOnly": true,
  "includePastEvents": false,
  "keywords": ["webinar", "demo", "workshop", "virtual event", "summit"]
}
````

### Input options

- `startUrls` — public event, webinar, resource, or marketing pages.
- `maxItems` — maximum dataset rows to save.
- `maxPagesPerDomain` — safety cap for each company domain.
- `crawlDepth` — how many levels of relevant links to follow.
- `sameDomainOnly` — prevents uncontrolled cross-domain crawling.
- `includePastEvents` — keeps past/cancelled/postponed items when the source marks them.
- `keywords` — extra event terms used for matching and topic labels.

### Output example

```json
{
  "title": "Agentforce Webinar",
  "sourceUrl": "https://www.example.com/resources/webinars/",
  "registrationUrl": "https://www.example.com/events/agentforce-webinar/",
  "ctaText": "Register now",
  "startDate": "September 15",
  "hostCompany": "Example",
  "topics": ["webinar", "register"],
  "description": "Join our experts for a product webinar...",
  "detectedFrom": "visible-html",
  "confidence": 0.9,
  "contentHash": "...",
  "scrapedAt": "2026-06-24T00:00:00.000Z"
}
```

### Common workflows

- 🧾 Export upcoming webinars into a spreadsheet for sales research.
- 🔔 Run daily and send new webinar rows to Slack or email.
- 🧠 Feed public event signals into a competitive-intelligence database.
- 🧩 Enrich account lists with recent and upcoming event topics.
- 🗓️ Build a calendar of competitor product demos and workshops.

### Tips for best results

Start with pages that are already focused on webinars, events, resources, or demos.

Use `sameDomainOnly: true` for predictable crawling and clean source attribution.

Increase `maxPagesPerDomain` gradually when a site has many paginated event pages.

Add custom keywords such as `summit`, `training`, `roadshow`, or your product category.

### Integrations

You can connect results to:

- Google Sheets exports for research teams.
- Airtable bases for competitive-intel trackers.
- CRM enrichment workflows via Apify integrations.
- Slack alerts when new rows appear.
- BI dashboards for category event trend analysis.

### 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/public-webinar-event-finder').call({
  startUrls: [{ url: 'https://www.salesforce.com/resources/webinars/' }],
  maxItems: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('APIFY_TOKEN')
run = client.actor('automation-lab/public-webinar-event-finder').call(run_input={
    'startUrls': [{'url': 'https://www.salesforce.com/resources/webinars/'}],
    'maxItems': 50,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~public-webinar-event-finder/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.salesforce.com/resources/webinars/"}],"maxItems":50}'
```

### MCP usage

Use the Apify MCP server with this actor enabled:

```bash
claude mcp add apify-webinars https://mcp.apify.com/?tools=automation-lab/public-webinar-event-finder
```

For Claude Desktop or another MCP client, add a server entry like this:

```json
{
  "mcpServers": {
    "apify-webinars": {
      "url": "https://mcp.apify.com/?tools=automation-lab/public-webinar-event-finder"
    }
  }
}
```

Example prompts:

- "Find public webinars from these five competitor event pages and summarize upcoming AI topics."
- "Run the public webinar extractor weekly and flag new registration URLs."
- "Compare webinar topics across these partner websites."

### Data quality notes

The actor reports a confidence score because public marketing pages vary widely.

JSON-LD Event schema usually receives the highest confidence.

Visible HTML detections score higher when a card includes a registration CTA, event URL, and date-like text.

### Limitations

The actor only reads public pages.

It does not register for events, bypass login walls, collect attendees, or scrape private webinar platforms.

Some sites render all content client-side; those may require a future Playwright fallback if the HTML has no usable signals.

### Troubleshooting

If you get zero results, verify the page is public and contains event/webinar text in the HTML.

If results are too broad, lower `crawlDepth`, keep `sameDomainOnly` enabled, or use narrower custom keywords.

If a site has many archive pages, increase `maxPagesPerDomain` and `maxItems` slowly.

### Legality and compliance

This actor is designed for public marketing/event pages.

Always ensure your use complies with applicable laws, website terms, and internal data policies.

Do not use it to collect private attendee information or access gated webinar rooms.

### Related scrapers

Related Automation Labs actors can support adjacent workflows:

- Website content crawlers for full-page text extraction.
- URL status checkers for monitoring registration links.
- Company enrichment actors for account-level research.

Use Public Webinar Event Finder when you need event-specific structure rather than generic page text.

### FAQ

#### Can this monitor competitors?

Yes. Provide public competitor event or webinar pages and run on a schedule.

#### Does it require a browser?

No for the current MVP. It uses HTTP and Cheerio because many event pages expose usable HTML and JSON-LD.

#### Can it find past webinars?

Yes. Set `includePastEvents` to true and point it at archive pages.

#### Does it scrape Zoom webinar attendee data?

No. It only extracts public marketing/event page signals and registration URLs.

### Changelog

- v0.1 — Initial HTTP/Cheerio implementation for public webinar and event discovery.

# Actor input Schema

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

Public company webinar, event, resource, or marketing pages to crawl. The actor follows relevant same-domain webinar/event links.

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

Stop after this many unique webinar/event records are saved.

## `maxPagesPerDomain` (type: `integer`):

Upper limit for relevant pages fetched from each company domain.

## `crawlDepth` (type: `integer`):

How many levels of webinar/event links to follow from each start URL.

## `sameDomainOnly` (type: `boolean`):

Only follow discovered links on the same company domain as the start URL. Registration links can still be captured in output.

## `includePastEvents` (type: `boolean`):

Keep events marked as past, cancelled, or postponed when the source exposes status metadata.

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

Additional words used to prioritize links and topics, e.g. product demo, summit, partner workshop.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.salesforce.com/resources/webinars/"
    }
  ],
  "maxItems": 20,
  "maxPagesPerDomain": 20,
  "crawlDepth": 1,
  "sameDomainOnly": true,
  "includePastEvents": false,
  "keywords": [
    "webinar",
    "demo",
    "workshop",
    "virtual event",
    "register"
  ]
}
```

# 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.salesforce.com/resources/webinars/"
        }
    ],
    "maxItems": 20,
    "maxPagesPerDomain": 20,
    "crawlDepth": 1,
    "sameDomainOnly": true,
    "includePastEvents": false,
    "keywords": [
        "webinar",
        "demo",
        "workshop",
        "virtual event",
        "register"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/public-webinar-event-finder").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.salesforce.com/resources/webinars/" }],
    "maxItems": 20,
    "maxPagesPerDomain": 20,
    "crawlDepth": 1,
    "sameDomainOnly": True,
    "includePastEvents": False,
    "keywords": [
        "webinar",
        "demo",
        "workshop",
        "virtual event",
        "register",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/public-webinar-event-finder").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.salesforce.com/resources/webinars/"
    }
  ],
  "maxItems": 20,
  "maxPagesPerDomain": 20,
  "crawlDepth": 1,
  "sameDomainOnly": true,
  "includePastEvents": false,
  "keywords": [
    "webinar",
    "demo",
    "workshop",
    "virtual event",
    "register"
  ]
}' |
apify call automation-lab/public-webinar-event-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Public Webinar Event Finder",
        "description": "Find public webinars, demos, workshops, speakers, dates, topics, and registration URLs from company event pages.",
        "version": "0.1",
        "x-build-id": "3iI8sXRQS6u6mnCmA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~public-webinar-event-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-public-webinar-event-finder",
                "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~public-webinar-event-finder/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-public-webinar-event-finder",
                "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~public-webinar-event-finder/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-public-webinar-event-finder",
                "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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Public company webinar, event, resource, or marketing pages to crawl. The actor follows relevant same-domain webinar/event links.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum webinar/event records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many unique webinar/event records are saved.",
                        "default": 100
                    },
                    "maxPagesPerDomain": {
                        "title": "Maximum pages per domain",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Upper limit for relevant pages fetched from each company domain.",
                        "default": 25
                    },
                    "crawlDepth": {
                        "title": "Crawl depth",
                        "minimum": 0,
                        "maximum": 3,
                        "type": "integer",
                        "description": "How many levels of webinar/event links to follow from each start URL.",
                        "default": 1
                    },
                    "sameDomainOnly": {
                        "title": "Stay on the same domain",
                        "type": "boolean",
                        "description": "Only follow discovered links on the same company domain as the start URL. Registration links can still be captured in output.",
                        "default": true
                    },
                    "includePastEvents": {
                        "title": "Include past/cancelled events",
                        "type": "boolean",
                        "description": "Keep events marked as past, cancelled, or postponed when the source exposes status metadata.",
                        "default": false
                    },
                    "keywords": {
                        "title": "Custom event keywords",
                        "type": "array",
                        "description": "Additional words used to prioritize links and topics, e.g. product demo, summit, partner workshop.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "webinar",
                            "demo",
                            "workshop",
                            "virtual event",
                            "register"
                        ]
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
