# Rumble Category Scraper (`tarasenkofedor/rumble-category-scraper`) Actor

Walks /category/{slug}/videos pages and extracts unique channel URLs until target volume is hit, the pagination 404s, or a safety cap on pages is reached.

- **URL**: https://apify.com/tarasenkofedor/rumble-category-scraper.md
- **Developed by:** [Fiodar Tarasenka](https://apify.com/tarasenkofedor) (community)
- **Categories:** Automation, Developer tools, Social media
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## infla/rumble-category-scraper

Walks `https://rumble.com/category/{slug}/videos` paginated listing
pages and extracts unique channel URLs. Powers Infla's
`rumble_category` job type (PLAN-009).

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `category` | string (required) | — | Rumble category slug (`crypto`, `news`, `finance`, …). |
| `mode` | enum (`channels` \| `videos`) | `channels` | Output shape. See [Videos mode (PLAN-011)](#videos-mode-plan-011) below. |
| `targetUniqueCreators` | integer | 100 | Stop after this many unique channels. In videos mode this caps the number of distinct creators emitted. |
| `maxVideosPerCreator` | integer | 5 | Videos-mode only: cap on videos emitted per creator. Range 1-50. Ignored in channels mode. |
| `maxPages` | integer | 50 | Safety cap on pagination depth. |

### Output

#### Channels mode (default)

One dataset item per unique channel:

```json
{
    "mode": "channels",
    "channelHandle": "russellbrand",
    "channelURL": "https://rumble.com/c/RussellBrand",
    "page": 1,
    "position": 3
}
````

`channelHandle` is lowercased so callers can dedupe across runs
without re-normalising. `page` + `position` preserve discovery order.

### Videos mode (PLAN-011)

When `mode: "videos"`, the actor emits **one dataset item per video
card** instead of per channel, with the parent channel handle attached
so the Go side can group by handle downstream. This is how Infla's
PLAN-011 door-knock + content-only outreach pipelines get pre-fetched
video context without an extra per-creator round-trip to Rumble.

Use channels mode when you only need a list of creators to enrich
later via a separate per-channel scrape. Use videos mode when you
want the listing-page video data inline — saves one round-trip per
creator and is the default for Infla's `rumble_category` jobs after
PLAN-011.

Per-item shape in videos mode:

```json
{
    "mode": "videos",
    "channelHandle": "philgodlewski",
    "channelURL": "https://rumble.com/c/philgodlewski",
    "videoURL": "https://rumble.com/v123-some-slug.html",
    "videoExternalID": "v123",
    "title": "Title from the listing card",
    "durationSeconds": 1234,
    "publishedAt": "2026-05-30T00:00:00Z",
    "viewCount": 1234,
    "thumbnailURL": "https://.../thumbnail.jpg",
    "isShort": false,
    "isLive": false,
    "page": 1,
    "position": 7
}
```

Field notes:

- `videoExternalID` is the Rumble permalink slug (e.g. `v123` from
  `/v123-some-slug.html`). Stable across the site and usable as a
  primary key on the Go side.
- `durationSeconds` parses both `mm:ss` and `hh:mm:ss` card text.
  `0` when the card doesn't expose a duration (e.g. live streams).
- `viewCount` handles `1.2K` / `3M` / `4.5B` abbreviations. `0`
  on parse failure.
- `publishedAt` converts relative dates ("2 days ago", "3 hours ago",
  "1 month ago") to ISO 8601 UTC at midnight. `null` when the card
  has no date or it's in an unrecognised shape — listing cards
  don't carry sub-day precision so midnight is the honest anchor.
- `isShort` / `isLive` are best-effort badge detection. Default
  `false` when the badge isn't present.

Stop semantics in videos mode: the crawl halts when the number of
**distinct creators** reaches `targetUniqueCreators` (matching
channels-mode "unique creators reached"), or pagination 4xx, or
`maxPages`. Per-creator cap is enforced by `maxVideosPerCreator`
but does NOT contribute to the stop condition.

### Termination

The actor stops on the first of:

- `targetUniqueCreators` unique handles collected
- Next page returns a non-2xx response (pagination exhausted)
- `maxPages` reached

### Local development

```bash
cd apify-actors/rumble-category-scraper
npm install
## npm install runs `playwright install chromium` via postinstall;
## if the postinstall step is skipped (e.g. CI), run it manually:
##   npx playwright install chromium

mkdir -p .actor
echo '{"category":"crypto","targetUniqueCreators":20,"maxPages":3}' > .actor/INPUT.json
apify run --input-file=.actor/INPUT.json --purge
```

`apify run --purge` (Apify CLI v0.x+) wipes the local key-value
store and dataset between runs so each invocation starts clean.

#### Cloudflare on Rumble category pages

Rumble protects category listing pages with Cloudflare's JS
challenge — every raw HTTP fetch is met with HTTP 403 from CF's
edge. The actor uses **PlaywrightCrawler** with a real headless
Chromium so the challenge resolves automatically. CheerioCrawler
(raw HTTP) was tried first and confirmed not viable for this
target.

Local runs without an Apify token use direct connections — your
laptop's IP solves the challenge once and Chromium reuses the
clearance cookie across pages. If your IP has been flagged by CF
for any reason, you'll see persistent 403s; either rotate IPs or
test on the cloud (`apify push` + run from the console).

On Apify cloud, `Actor.createProxyConfiguration({groups:['RESIDENTIAL']})`
is requested. RESIDENTIAL requires a paid Apify plan; on free tier
the call falls back to datacenter proxy, which is sufficient for
most CF challenges on listing pages.

### Deploy

Requires the [Apify CLI](https://docs.apify.com/cli/) (`npm i -g apify-cli`)
and an Apify account with `apify login` completed.

```bash
cd apify-actors/rumble-category-scraper
apify push
```

`apify push` reads `.actor/actor.json`, builds the image
remotely, and publishes a new actor version under your account.
The actor will appear in the Apify Console with the technical
name from `actor.json` (`rumble-category-scraper`). The full
ID is `<your-username>/rumble-category-scraper`.

After deploy:

1. Open the actor in the Apify Console and copy its ID
   (`username/rumble-category-scraper`).
2. Set `APIFY_ACTOR_RUMBLE_CATEGORY=<your-username>/rumble-category-scraper`
   in Infla's `.env.production` (and reload the app container).
3. Infla's discovery worker reads `cfg.ApifyActorRumbleCategory`
   when dispatching a `rumble_category` job.

### Design notes

- **PlaywrightCrawler over CheerioCrawler.** Rumble's category
  pages are gated by Cloudflare's JS challenge. A real Chromium
  resolves the challenge transparently; raw HTTP (CheerioCrawler)
  is met with 403 on every request. Cost: a Playwright run is
  \~3-5x the compute units of a Cheerio run, but at one actor run
  per discovery job this is still <$0.50 of operator-visible cost.
- **`maxConcurrency: 1`.** Sequential pagination keeps the
  per-page log line meaningful and avoids saturating Rumble's
  anti-bot. The expected target is 100-300 creators which finishes
  in well under a minute even sequentially.
- **No retries on 404.** Rumble's pagination doesn't expose a
  total-pages count; the canonical "you've reached the end" signal
  is a 404 on the next page request. The actor treats failed
  requests as the stop signal and exits cleanly.
- **Conservative selectors.** Match `a[href^="/c/"]`, `/user/`, and
  `/channel/`. Three prefixes cover every Rumble channel-URL
  scheme observed during PLAN-009 research. New schemes (if
  Rumble adds any) would need a code change here; the conservative
  approach beats a regex that might catch outbound advertising
  links.
- **`useFingerprints: true`.** Apify's browser pool rotates user-
  agent + canvas/font fingerprints across sessions, which combined
  with the Playwright JS-challenge solver is the canonical CF
  bypass recipe documented by Apify itself.

### Schema version

This actor's output JSON is consumed by
`internal/services/discovery/rumble_category.go` (PLAN-009 C10).
Any output-field rename requires a coordinated change there.

# Actor input Schema

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

The slug component of the Rumble category URL — the part after /category/ and before /videos. Example: 'crypto', 'news', 'finance', 'gaming'.

## `mode` (type: `string`):

channels = one dataset item per unique channel (PLAN-009 legacy). videos = one dataset item per video card with the parent channel handle attached (PLAN-011 default for Infla's rumble\_category jobs).

## `targetUniqueCreators` (type: `integer`):

Stop crawling once this many unique channels have been collected. The actor walks pages sequentially and dedupes by channel handle in-process. In videos mode this caps the number of distinct creators we emit videos for.

## `maxVideosPerCreator` (type: `integer`):

Videos-mode only: cap the number of videos emitted per channel. Ignored in channels mode. Typical values 3-10; defaults to 5 to keep dataset size reasonable.

## `maxPages` (type: `integer`):

Per-round page budget — the actor walks at most this many sequential pages from startPage before stopping. NOT an absolute upper bound: combined with startPage, the run terminates at page startPage + maxPages - 1. Rumble category pages typically expose ~30-50 pages before pagination ends.

## `startPage` (type: `integer`):

First page in the round walk. Defaults to 1 (full back-compat with v2.6 callers). The Go discoverer bumps this on each extension round so the actor picks up where the previous round left off instead of re-walking the same pages.

## `cookies` (type: `string`):

Optional JSON-stringified array of Playwright-format cookie objects ({name, value, domain, path, secure?, httpOnly?, sameSite?, expires?}). When set, the actor injects them into the browser context before the first navigation, which makes us look like a returning visitor and unlocks the inline grid JSON Rumble strips from anonymous direct-hits. Capture via Chrome DevTools > Application > Cookies > rumble.com, or any cookie-export extension. Leave empty to rely on the warm-up hop (v2.5 default) instead.

## `proxyCountryCode` (type: `string`):

ISO 3166 alpha-2 country code (e.g. 'US', 'GB', 'DE') for the Apify residential proxy. Empty = any country. Default 'US' because Rumble's category content is US-dominant and geo-experimental layouts there are less likely. Operators outside the US who want a local proxy can override.

## Actor input object example

```json
{
  "category": "crypto",
  "mode": "channels",
  "targetUniqueCreators": 100,
  "maxVideosPerCreator": 5,
  "maxPages": 50,
  "startPage": 1,
  "cookies": "",
  "proxyCountryCode": "US"
}
```

# 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 = {
    "category": "crypto"
};

// Run the Actor and wait for it to finish
const run = await client.actor("tarasenkofedor/rumble-category-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 = { "category": "crypto" }

# Run the Actor and wait for it to finish
run = client.actor("tarasenkofedor/rumble-category-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 '{
  "category": "crypto"
}' |
apify call tarasenkofedor/rumble-category-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rumble Category Scraper",
        "description": "Walks /category/{slug}/videos pages and extracts unique channel URLs until target volume is hit, the pagination 404s, or a safety cap on pages is reached.",
        "version": "2.7",
        "x-build-id": "9JEh55WxgNHI1vGxA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tarasenkofedor~rumble-category-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tarasenkofedor-rumble-category-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/tarasenkofedor~rumble-category-scraper/runs": {
            "post": {
                "operationId": "runs-sync-tarasenkofedor-rumble-category-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/tarasenkofedor~rumble-category-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-tarasenkofedor-rumble-category-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": [
                    "category",
                    "targetUniqueCreators"
                ],
                "properties": {
                    "category": {
                        "title": "Rumble category slug",
                        "type": "string",
                        "description": "The slug component of the Rumble category URL — the part after /category/ and before /videos. Example: 'crypto', 'news', 'finance', 'gaming'."
                    },
                    "mode": {
                        "title": "Crawl mode",
                        "enum": [
                            "channels",
                            "videos"
                        ],
                        "type": "string",
                        "description": "channels = one dataset item per unique channel (PLAN-009 legacy). videos = one dataset item per video card with the parent channel handle attached (PLAN-011 default for Infla's rumble_category jobs).",
                        "default": "channels"
                    },
                    "targetUniqueCreators": {
                        "title": "Target unique creators",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop crawling once this many unique channels have been collected. The actor walks pages sequentially and dedupes by channel handle in-process. In videos mode this caps the number of distinct creators we emit videos for.",
                        "default": 100
                    },
                    "maxVideosPerCreator": {
                        "title": "Max videos per creator (videos mode)",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Videos-mode only: cap the number of videos emitted per channel. Ignored in channels mode. Typical values 3-10; defaults to 5 to keep dataset size reasonable.",
                        "default": 5
                    },
                    "maxPages": {
                        "title": "Max pages (this round)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Per-round page budget — the actor walks at most this many sequential pages from startPage before stopping. NOT an absolute upper bound: combined with startPage, the run terminates at page startPage + maxPages - 1. Rumble category pages typically expose ~30-50 pages before pagination ends.",
                        "default": 50
                    },
                    "startPage": {
                        "title": "Start page (v2.7 PLAN-028)",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "First page in the round walk. Defaults to 1 (full back-compat with v2.6 callers). The Go discoverer bumps this on each extension round so the actor picks up where the previous round left off instead of re-walking the same pages.",
                        "default": 1
                    },
                    "cookies": {
                        "title": "Cookies (optional, v2.5)",
                        "type": "string",
                        "description": "Optional JSON-stringified array of Playwright-format cookie objects ({name, value, domain, path, secure?, httpOnly?, sameSite?, expires?}). When set, the actor injects them into the browser context before the first navigation, which makes us look like a returning visitor and unlocks the inline grid JSON Rumble strips from anonymous direct-hits. Capture via Chrome DevTools > Application > Cookies > rumble.com, or any cookie-export extension. Leave empty to rely on the warm-up hop (v2.5 default) instead.",
                        "default": ""
                    },
                    "proxyCountryCode": {
                        "title": "Proxy country code (optional, v2.5)",
                        "type": "string",
                        "description": "ISO 3166 alpha-2 country code (e.g. 'US', 'GB', 'DE') for the Apify residential proxy. Empty = any country. Default 'US' because Rumble's category content is US-dominant and geo-experimental layouts there are less likely. Operators outside the US who want a local proxy can override.",
                        "default": "US"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```