# Twitter Video Downloader (`scrapevanta/twitter-video-downloader`) Actor

Twitter Video Downloader lets you quickly save videos from Twitter/X in high quality. Extract and download public videos for content archiving, research, monitoring, and offline viewing. Fast, reliable, and easy to use for marketers, creators, and businesses.

- **URL**: https://apify.com/scrapevanta/twitter-video-downloader.md
- **Developed by:** [ScrapeVanta](https://apify.com/scrapevanta) (community)
- **Categories:** Videos, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### Twitter Video Downloader 🎬 — Download X video links fast (from public status URLs)

If you have an X (Twitter) post link and need the direct downloadable video URL, manually digging through the page is slow and inconsistent. **Twitter Video Downloader** extracts the media link for you from the status URL you provide, so you can quickly turn a tweet video link into a usable download target. It’s a great fit for a **twitter video downloader**, **download twitter videos**, or an **x video downloader** workflow. Built for marketers, analysts, and researchers who need video link extraction at scale—without spending hours on copy-paste work. In one run, you can process multiple status URLs and start seeing results almost immediately.

---

### See the Data: Sample Output

Here's a real record from a single run:

```json
{
  "sourceUrl": "https://x.com/TinaDebove/status/1967637722476212406",
  "downloadUrl": "https://video.example.cdn/abcdef123456.mp4",
  "status": "success"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `sourceUrl` | string | The status URL used as the record’s starting point (including a resolved link when a shortened link is found). |
| `downloadUrl` | string | The direct media URL you can use to download the video (or the best available direct link the extractor returns). |
| `status` | string | Indicates whether the actor produced a result for that input URL. |
| `error_message` | string | null | Error details when a specific URL fails to process (null when successful). |

Export your full dataset as JSON, CSV, or Excel from the Apify dashboard.

***

### Setting It Up

Drop this into your `input.json` and you're ready to go:

```json
{
  "startUrls": [
    "https://x.com/TinaDebove/status/1967637722476212406",
    "https://x.com/someuser/status/1234567890123456789"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `startUrls` | ✅ | List of Twitter/X status URLs to scrape for video media links (for example, tweet video downloader inputs like `https://x.com/.../status/...`). |
| `proxyConfiguration` | ⬜ | Proxy settings for your run to help with reliable fetching. |
| ↳ `proxy support` | ⬜ | Set to `true` to route requests through Apify Proxy. |
| ↳ `proxy support` | ⬜ | Choose proxy group(s) for the run (the default includes `"RESIDENTIAL"`). |

***

### What It Does

Twitter Video Downloader extracts video and image metadata inputs from the Twitter/X links you provide and returns direct media URLs where available.

#### Turn status links into direct download URLs

You provide one or more X status URLs, and the actor returns a clean record containing `sourceUrl` and `downloadUrl`. This makes it much easier to move from “tweet video link downloader” needs to an actual downloadable target in your workflow.

#### Works with shortened links in descriptions

If the extracted page description contains a shortened link in the `t.co` format, the actor resolves it and uses it as the `sourceUrl`. That helps keep your “download twitter videos” pipeline consistent even when posts reference shortened URLs.

#### Clean, integration-ready output

Each processed URL is pushed as a JSON record with consistent field names—`sourceUrl` and `downloadUrl`. This is ideal for automation where you want to “download x videos” in a repeatable, dataset-driven way.

#### Built-in proxy support for reliable scraping

You can enable proxy settings via `proxyConfiguration` to improve reliability for bulk runs and repeated access. If you’re building a “twitter video downloader online” workflow, this reduces friction when scaling.

#### Includes straightforward error handling per URL

If a given URL fails, the actor logs the error and continues processing the remaining URLs. Your run won’t be blocked by a single problematic input.

Overall, Twitter Video Downloader helps you extract usable media links from public X status URLs fast—perfect for tweet video downloader and mp4-style link workflows.

***

### Why Twitter Video Downloader?

There are plenty of ways to pull data from X links—here’s why Twitter Video Downloader stands out.

#### Results appear as you process URLs

The actor pushes each result as it’s ready, so you can monitor progress while it’s running. This improves feedback speed when you’re downloading twitter videos as part of an active pipeline.

#### Simple input, dataset-friendly output

You only need `startUrls`, and the actor returns a minimal, consistent structure that’s easy to export or feed into downstream steps. That makes it practical for anything from a quick twitter video downloader use to a structured, repeatable data process.

#### Direct focus on media link extraction

Instead of you manually inspecting post pages, Twitter Video Downloader outputs the direct `downloadUrl` it extracts. If your goal is to save twitter video to gallery, download twitter videos in bulk, or build an x video downloader flow, the output is designed for that.

***

### Real-World Use Cases

Here's how different teams put Twitter Video Downloader to work:

**Content Ops for social teams**\
A social team gets a batch of X links from contributors and needs direct downloadable targets to package media for editing. They run Twitter Video Downloader with the status URLs in `startUrls`, export the dataset, and immediately hand `downloadUrl` links to editors instead of manually hunting for each file. The result: faster turnaround on “download twitter videos” requests.

**Marketing analysts building creator shortlists**\
An analyst collects posts to evaluate which campaigns generate the most engagement, but they also need the actual video assets or direct download links for review. They run the actor on a curated set of tweet links, export results, and store `sourceUrl` → `downloadUrl` pairs for internal review workflows—supporting an “x video downloader” style process.

**Automation specialists (developers & integrators)**\
A workflow developer wants to automate media link extraction as part of a data pipeline. They trigger Twitter Video Downloader, then feed the dataset into their next step for downloading, archiving, or routing files to storage—using the consistent JSON fields (`sourceUrl`, `downloadUrl`) the actor outputs.

**Researchers comparing video formats**\
A research project needs consistent direct media links for comparative analysis (e.g., verifying which posts provide higher-quality download targets). The team batches many Twitter/X status URLs through Twitter Video Downloader, exports the dataset, and uses `downloadUrl` as the reliable reference point for analysis.

**Agencies handling client requests**\
An agency receives “twitter video downloader online” requests from multiple clients every day. They batch each client’s status URLs, export the dataset, and deliver direct media links without repeated manual steps—helping them scale “tweet video downloader” tasks with less overhead.

***

### How to Run It

No code required. Here's how to get your first results in under 5 minutes:

1. **Open the actor on Apify**\
   Go to [console.apify.com](https://console.apify.com) and open Twitter Video Downloader.

2. **Enter your inputs**\
   Paste your list of Twitter/X status URLs into `startUrls`. Add `proxyConfiguration` only if you want to customize proxy usage.

3. **Configure proxy settings (optional)**\
   If you enable proxy configuration, set `proxy support` and (optionally) `proxy support` based on your needs.

4. **Start the run and watch the live log**\
   Launch the actor and monitor progress as URLs are processed.

5. **Open the Dataset tab**\
   Each completed URL produces a JSON record with `sourceUrl` and `downloadUrl`.

6. **Export in your preferred format**\
   Download the dataset as JSON, CSV, or Excel from the Apify dashboard.

The whole setup takes under 5 minutes — results start appearing within seconds of launch.

***

### Export & Integration Options

Once your data is collected, Twitter Video Downloader fits directly into your existing workflow.

You can download your dataset from the Apify dashboard in common formats like JSON, CSV, or Excel. If you’re using a “twitter video downloader mp4” style workflow, exporting gives you the direct `downloadUrl` links your downstream steps need.

For automation, you can integrate via Apify’s API and connect the exported results to tools using no-code automation or webhooks (depending on how your stack is set up). For details, refer to Apify’s documentation for datasets, API access, and automations.

***

### Pricing

Twitter Video Downloader runs on Apify, which includes a **free tier** — no credit card needed to start. You’ll get $5 platform credits on sign-up, enough for several real test runs. After that, you pay as you go based on Apify Actor compute units (CU), with no monthly fee lock-in. Start free at [apify.com](https://apify.com) — scale up when you need.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Public link processing | Processes each URL from your provided `startUrls` list. |
| Proxy usage (optional) | You can set `proxyConfiguration` to improve reliability for your run. |
| Per-URL failures | If one URL fails, the actor logs the error and continues. |
| Progress visibility | Results are pushed as they’re processed for better run visibility. |
| Bulk runs | Designed to handle multiple URLs in one dataset output. |
| Resilient output | Each successful item outputs `sourceUrl` and `downloadUrl` as a consistent JSON record. |

**Limitations:** Twitter Video Downloader works from the Twitter/X status URLs you provide and extracts direct media links where available from the public page data. If a post doesn’t provide a usable direct media link in the extracted info, the `downloadUrl` may not match what you expected for every input. For enterprise-scale needs or custom configurations, reach out and we'll help.

***

### Frequently Asked Questions

#### Is there a free plan?

Yes. Apify offers a free tier with monthly usage credits, which is typically enough to test a few Twitter/X status links before you scale up.

#### Do I need to log in or create an account on X?

No. This actor works with public Twitter/X status URLs you provide in `startUrls`.

#### How accurate is the extracted data?

Accuracy depends on what the public status page provides to be extracted. The actor outputs `sourceUrl` and `downloadUrl` based on the extracted information it retrieves from the provided link.

#### How many results can I get per run?

Your results count corresponds to how many URLs you include in `startUrls`. The actor processes your list and pushes one dataset record per successfully processed input.

#### How fresh is the data?

The data reflects what is publicly available at the moment you run the actor and fetch the pages. If a post’s underlying media links change, the freshest values come from running again.

#### Is this legal? Does it comply with GDPR / CCPA?

Using Twitter Video Downloader for publicly available data is generally aligned with common compliance expectations, but legality depends on your use case and how you store and process the extracted links. You’re responsible for complying with GDPR, CCPA, platform Terms of Service, and any applicable regulations.

#### Can I export to Google Sheets or Excel?

Yes. You can export your dataset as JSON, CSV, or Excel from the Apify dashboard, and then import it into Google Sheets or other tools as needed.

#### Can I schedule this to run automatically?

Yes. You can schedule Apify runs using Apify’s scheduling options so your Twitter video downloader workflow runs on a recurring cadence.

#### Can I access results via the API?

Yes. You can retrieve dataset results programmatically via the Apify API, depending on how you integrate with the platform.

#### What happens when the actor encounters an error?

If an error occurs while processing a specific URL, the actor logs the error and continues processing the remaining URLs. Successful inputs still produce records pushed to the dataset.

***

### Get Help & Use Responsibly

Got a question about Twitter Video Downloader or a feature you'd like added? Reach out to <dataforleads@gmail.com> — we welcome feedback and we actively maintain this actor. If you want improvements like better support for bulk “download twitter videos” workflows or enhanced output fields, tell us what you need.

**publicly available data** — the actor does not access private accounts, login-gated pages, or password-protected content. It’s your responsibility to comply with GDPR, CCPA, and platform ToS when collecting and using any extracted data. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

List of Twitter/X status URLs to scrape.

## `proxyConfiguration` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "startUrls": [
    "https://x.com/TinaDebove/status/1967637722476212406"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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": [
        "https://x.com/TinaDebove/status/1967637722476212406"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapevanta/twitter-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": ["https://x.com/TinaDebove/status/1967637722476212406"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapevanta/twitter-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": [
    "https://x.com/TinaDebove/status/1967637722476212406"
  ]
}' |
apify call scrapevanta/twitter-video-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitter Video Downloader",
        "description": "Twitter Video Downloader lets you quickly save videos from Twitter/X in high quality. Extract and download public videos for content archiving, research, monitoring, and offline viewing. Fast, reliable, and easy to use for marketers, creators, and businesses.",
        "version": "0.1",
        "x-build-id": "0tKszuZjp6BvkwtU9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapevanta~twitter-video-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapevanta-twitter-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/scrapevanta~twitter-video-downloader/runs": {
            "post": {
                "operationId": "runs-sync-scrapevanta-twitter-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/scrapevanta~twitter-video-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-scrapevanta-twitter-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": "Start URLs",
                        "type": "array",
                        "description": "List of Twitter/X status URLs to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by your crawler.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
