# Rumble Video Downloader (`maximedupre/rumble-video-downloader`) Actor

Download public Rumble videos, Shorts, and embeds. Get direct MP4, WebM, and audio links with titles, channels, thumbnails, durations, file sizes, and saved MP4 files when enabled.

- **URL**: https://apify.com/maximedupre/rumble-video-downloader.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Social media, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.25 / 1,000 downloaded videos

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### 📥 Rumble video downloader for public URLs

Rumble Video Downloader turns public [Rumble](https://rumble.com/) video, Shorts, and embed URLs into direct media links and clean metadata. Paste one or more Rumble links and get an Apify dataset with MP4, WebM, and audio variants when Rumble exposes them, plus titles, channels, thumbnails, durations, publish dates, file sizes, and saved MP4 URLs when file saving is enabled.

Use this Rumble video downloader when you already have Rumble URLs and need repeatable exports for content review, research, moderation queues, archiving, reporting, or an API workflow. The Actor is focused on known public videos. It does not search Rumble, crawl channels, collect comments, scrape playlists, or access private videos.

For a quick first run, keep the prefilled public Rumble Shorts. Leave **Quality to save** at `best` and **Save MP4 files** enabled. Once the output shape fits your workflow, paste your own Rumble URLs or call the Actor through the Apify API.

### ✅ What this Actor does

- Accepts public Rumble video page URLs.
- Accepts public Rumble Shorts URLs.
- Accepts Rumble embed URLs such as `https://rumble.com/embed/v762a76/`.
- Processes batches of submitted URLs.
- Deduplicates URL variants that resolve to the same Rumble video.
- Saves one dataset row per reachable public video or Short.
- Returns source media variants, including MP4, WebM, and AAC audio when Rumble exposes them.
- Saves the selected MP4 file to Apify key-value storage when file saving is enabled.
- Adds source-backed title, channel, duration, publish date, thumbnail, dimensions, file-size hints, canonical URL, and embed URL when available.
- Charges only for successful Rumble videos saved to the dataset.
- Skips invalid, private, removed, unsupported, unavailable, or temporarily unreachable targets without saving failure rows.

You do not need Rumble cookies, a Rumble login, a browser extension, or a Rumble API key. The public form stays focused on URLs, saved-file quality, and whether to save MP4 files.

### 📦 Data you can export

Each output row represents one reachable public Rumble video or Short. Core fields include:

- `videoId` - the source-native Rumble video identifier.
- `sourceUrl` - the canonical public Rumble page.
- `embedUrl` - the Rumble embed URL when available.
- `title`, `description`, `durationSeconds`, and `publishedAt`.
- `thumbnailUrl`, `thumbnailWidth`, and `thumbnailHeight`.
- `channel.id`, `channel.name`, and `channel.url`.
- `engagement.views` and `engagement.likes` as nullable count fields when available in the output.
- `categories` and `tags` when available.
- `media` - all detected media variants with type, format, quality, dimensions, file size, direct media URL, and saved file URL when available.

You can open the dataset in Apify, export it as JSON, CSV, Excel, XML, RSS, or HTML, call it through the Apify API, schedule runs, or connect results to webhooks and integrations. Binary MP4 files are stored separately in the run key-value store and linked from `media[].savedFileUrl`.

### 🚀 How to run it

1. Open the Actor input.
2. Paste one or more public Rumble video, Shorts, or embed URLs in **Rumble video URLs**.
3. Choose **Quality to save** if MP4 file saving is enabled.
4. Keep **Save MP4 files** enabled when you want an Apify storage URL for the selected MP4.
5. Start the Actor.
6. Open the dataset and use `media[].mediaUrl` for direct source links or `media[].savedFileUrl` for saved MP4 files.

Accepted input examples:

```text
https://rumble.com/v2awtm4-dynasty-rookie-mock-draft-with-trades-and-landing-spots.html
https://rumble.com/shorts/v788y7e
https://rumble.com/embed/v762a76/
````

### 🔧 Input options

#### 🔗 Rumble video URLs

Paste public Rumble video, Shorts, or embed URLs. The field uses Apify request-list items with a `url` field, so you can paste many targets in the Console or pass them through the API.

Duplicate URL forms that resolve to the same Rumble video are processed once.

#### 🎞️ Quality to save

Choose the MP4 quality to save when **Save MP4 files** is enabled: `best`, `4320p`, `2160p`, `1440p`, `1080p`, `720p`, `480p`, `360p`, `240p`, `180p`, or `144p`.

This setting chooses the saved MP4 artifact. It does not hide other media. The output still includes every detected media variant.

#### 💾 Save MP4 files

Enable this option to save the selected MP4 file to Apify key-value storage and add its URL to the matching `media` item. Disable it when direct source media links are enough and you want the lightest run.

### 🧾 Output example

```json
{
  "videoId": "v28bdrs",
  "sourceUrl": "https://rumble.com/v2awtm4-dynasty-rookie-mock-draft-with-trades-and-landing-spots.html",
  "embedUrl": "https://rumble.com/embed/v28bdrs/",
  "title": "Dynasty Rookie Mock Draft (With Trades & Landing Spots)",
  "description": null,
  "durationSeconds": 1177,
  "publishedAt": "2023-02-25T16:40:09.000Z",
  "thumbnailUrl": "https://hugh.cdn.rumble.cloud/video/s8/1/S/_/o/t/S_oti.qR4e-small-Dynasty-Rookie-Mock-Draft-W.jpg",
  "thumbnailWidth": 1280,
  "thumbnailHeight": 720,
  "channel": {
    "id": "DynastyFlock",
    "name": "Dynasty Football Flock",
    "url": "https://rumble.com/c/DynastyFlock"
  },
  "engagement": {
    "views": null,
    "likes": null
  },
  "categories": [],
  "tags": [
    "Dynasty",
    "Football",
    "Flock"
  ],
  "media": [
    {
      "type": "video",
      "format": "mp4",
      "quality": "1080p",
      "width": 1920,
      "height": 1080,
      "fileSizeBytes": 398008123,
      "mediaUrl": "https://hugh.cdn.rumble.cloud/video/s8/2/S/_/o/t/S_oti.haa.mp4",
      "savedFileUrl": "https://api.apify.com/v2/key-value-stores/default/records/v28bdrs-1080p.mp4"
    },
    {
      "type": "video",
      "format": "webm",
      "quality": "480p",
      "width": null,
      "height": null,
      "fileSizeBytes": 120390679,
      "mediaUrl": "https://hugh.cdn.rumble.cloud/video/s8/2/S/_/o/t/S_oti.daa.webm",
      "savedFileUrl": null
    }
  ]
}
```

Some values can be `null` when Rumble does not expose them for a public video. Direct source media URLs can change later, so save or process important media soon after the run.

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged only for each reachable public Rumble video or Short saved to the dataset.

- **Downloaded video**: `$0.00225` per saved video, or `$2.25 per 1,000 saved videos`.

Invalid, private, removed, unsupported, unavailable, skipped, or temporarily unreachable targets are not saved as dataset rows and do not create paid video events.

### ⚠️ Limits and caveats

Rumble Video Downloader works with public Rumble videos, Shorts, and embeds that are reachable during the run. It does not use Rumble accounts, cookies, login sessions, or source API keys, and it does not bypass private or removed content.

Some public videos may not expose every metadata field, every quality, audio-only media, WebM media, dimensions, or engagement counts. The Actor still saves the row when it finds at least one usable media variant.

When file saving is enabled, the Actor saves one selected MP4 file per successful video when the source file can be downloaded during the run. If a file cannot be saved, the row can still include direct source media links.

### ❓ FAQ

#### 🔐 Do I need a Rumble account?

No. The Actor is built for public Rumble URLs and does not ask for Rumble cookies, a login, or a source API key.

#### 🎬 Does it support Rumble Shorts?

Yes. You can paste Rumble Shorts URLs. The output includes vertical dimensions and AAC audio when Rumble exposes them.

#### 🧩 Can I use Rumble embed URLs?

Yes. Embed URLs such as `https://rumble.com/embed/v762a76/` are accepted when they point to a public Rumble video.

#### 📁 Does it save files to Apify storage?

Yes, when **Save MP4 files** is enabled. The Actor saves the selected MP4 file and adds the storage URL to `media[].savedFileUrl`. Direct source links are still included in `media[].mediaUrl`.

#### 🔎 Can it find Rumble videos for me?

No. This Actor downloads media from Rumble URLs you provide. Search, channel scraping, playlists, livestream discovery, and comments are outside this Actor's scope.

#### 🔌 Can I run it from code?

Yes. Run the Actor through the Apify API, pass your Rumble URLs in `startUrls`, and read successful downloads from the default dataset.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~rumble-video-downloader/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [YouTube Shorts Downloader ↗](https://apify.com/maximedupre/youtube-shorts-downloader) - Export public YouTube Shorts download links, quality details, thumbnails, and channel data.
- [TikTok Video Downloader ↗](https://apify.com/maximedupre/tiktok-video-downloader) - Download public TikTok video or audio files with source metadata.
- [Facebook Media Downloader ↗](https://apify.com/maximedupre/facebook-media-downloader) - Download public Facebook videos and reels with thumbnails and metadata.
- [Streamable Video Downloader ↗](https://apify.com/maximedupre/streamable-video-downloader) - Extract direct MP4 links and metadata from public Streamable videos.
- [Telegram Media Downloader ↗](https://apify.com/maximedupre/telegram-media-downloader) - Get media URLs and post data from public Telegram posts and channels.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

Paste public Rumble video, Shorts, or embed URLs.

## `preferredQuality` (type: `string`):

Choose which MP4 quality to save when file saving is enabled. Output rows still include every detected media format.

## `saveVideoFiles` (type: `boolean`):

Save the selected MP4 files to Apify storage.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://rumble.com/shorts/vshp03"
    },
    {
      "url": "https://rumble.com/shorts/v22cu1z"
    },
    {
      "url": "https://rumble.com/shorts/v3kdien"
    },
    {
      "url": "https://rumble.com/shorts/v3wi9gj"
    },
    {
      "url": "https://rumble.com/shorts/v76ls9u"
    },
    {
      "url": "https://rumble.com/shorts/v43v49c"
    }
  ],
  "preferredQuality": "best",
  "saveVideoFiles": true
}
```

# Actor output Schema

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

Open one row per successful public Rumble video or Short with source identity, metadata, media variants, and saved file URLs when available.

# 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://rumble.com/shorts/vshp03"
        },
        {
            "url": "https://rumble.com/shorts/v22cu1z"
        },
        {
            "url": "https://rumble.com/shorts/v3kdien"
        },
        {
            "url": "https://rumble.com/shorts/v3wi9gj"
        },
        {
            "url": "https://rumble.com/shorts/v76ls9u"
        },
        {
            "url": "https://rumble.com/shorts/v43v49c"
        }
    ],
    "preferredQuality": "best"
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/rumble-video-downloader").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://rumble.com/shorts/vshp03" },
        { "url": "https://rumble.com/shorts/v22cu1z" },
        { "url": "https://rumble.com/shorts/v3kdien" },
        { "url": "https://rumble.com/shorts/v3wi9gj" },
        { "url": "https://rumble.com/shorts/v76ls9u" },
        { "url": "https://rumble.com/shorts/v43v49c" },
    ],
    "preferredQuality": "best",
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/rumble-video-downloader").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://rumble.com/shorts/vshp03"
    },
    {
      "url": "https://rumble.com/shorts/v22cu1z"
    },
    {
      "url": "https://rumble.com/shorts/v3kdien"
    },
    {
      "url": "https://rumble.com/shorts/v3wi9gj"
    },
    {
      "url": "https://rumble.com/shorts/v76ls9u"
    },
    {
      "url": "https://rumble.com/shorts/v43v49c"
    }
  ],
  "preferredQuality": "best"
}' |
apify call maximedupre/rumble-video-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rumble Video Downloader",
        "description": "Download public Rumble videos, Shorts, and embeds. Get direct MP4, WebM, and audio links with titles, channels, thumbnails, durations, file sizes, and saved MP4 files when enabled.",
        "version": "0.1",
        "x-build-id": "RNRWl8D1kl1xIjwgk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~rumble-video-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-rumble-video-downloader",
                "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/maximedupre~rumble-video-downloader/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-rumble-video-downloader",
                "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/maximedupre~rumble-video-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-rumble-video-downloader",
                "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": "Rumble video URLs",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Paste public Rumble video, Shorts, or embed URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "preferredQuality": {
                        "title": "Quality to save",
                        "type": "string",
                        "description": "Choose which MP4 quality to save when file saving is enabled. Output rows still include every detected media format.",
                        "default": "best"
                    },
                    "saveVideoFiles": {
                        "title": "Save MP4 files",
                        "type": "boolean",
                        "description": "Save the selected MP4 files to Apify storage.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```