# Cloudflare Turnstile & Challenge Solver (`crawlex/cf-solver`) Actor

$0.002 per success, failures free. Bypass Cloudflare interstitials and Turnstile. Returns cf\_clearance + replay headers. Usable from any HTTP client or language. HTTP or SOCKS5 proxies.

- **URL**: https://apify.com/crawlex/cf-solver.md
- **Developed by:** [Crawlex](https://apify.com/crawlex) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 7 total users, 1 monthly users, 57.1% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 successful solves

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

## Cloudflare Challenge Solver

Give it a URL and a proxy. Get back the `cf_clearance` cookie plus the exact `User-Agent` and Client-Hint headers that earned it, ready to drop into any HTTP client.

💰 **Pricing.** $0.002 per successful solve. Failures are free. You pay only when a real clearance cookie is returned.

📡 **Proxy usage.** Around 500 KB per solve. The Actor cancels the page load the moment Cloudflare issues the cookie, so target page bodies, images, scripts, and analytics are never fetched. Residential bandwidth stays cheap.

### What is it?

Cloudflare blocks scrapers with a "Just a moment..." challenge that runs JavaScript, checks the browser fingerprint, and issues a `cf_clearance` cookie when you pass. This Actor does that for you.

A real Chromium browser (Windows UA, honest Chrome TLS handshake) navigates your URL through the proxy you supply. The challenge runs, Turnstile gets clicked if present, Cloudflare hands out the cookie, and the Actor captures the exact UA and Client-Hint headers that went with it so you can replay them byte-identical from your own client.

Typical solve: 8 to 15 seconds. Actor memory: 128 MB.

### Use cases

- Scrape CF-protected sites. Pair this with your crawler, refresh the clearance on a 403 or before the 30-minute expiry.
- Price and inventory monitoring on e-commerce that sits behind the anti-bot wall.
- Ticketing, drops, SNKRS-style flows: grab the clearance once, paste it into the HTTP client running your checkout.
- Cookie rotation. Prime a pool of valid sessions cheaply, failures do not bill.
- Research and data journalism: collect publicly accessible pages that happen to sit behind CF.

### Key features

- 💰 **Only pay for success.** $0.002 per successful solve. Failures are free.
- 📡 **Low bandwidth.** Around 500 KB per solve. The target page body is never downloaded.
- ⚡ **Fast.** 8 to 15 seconds typical, p95 under 30 seconds.
- 🧩 **Replay-ready headers.** Cookie, UA, and client hints returned together. Works with `curl_cffi` and `impersonate="chrome"` out of the box.
- 🌐 **Any proxy.** HTTP, HTTPS, SOCKS5, SOCKS5h, with or without auth.
- 🔗 **IP-bound.** Cookie tied to your proxy's IP so it actually works from your scraper.

### Input

```json
{
  "url":     "https://cf-protected.example.com/",
  "proxy":   "http://user:pass@proxy.host:8080",
  "timeout": 60
}
````

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `url` | string | required | Any Cloudflare-protected URL. |
| `proxy` | string | required | Proxy URL. `http://`, `https://`, `socks5://`, or `socks5h://`, optional `user:pass@`. The cookie will be bound to this proxy's IP, so use the same proxy IP in the scraper that consumes the cookie. |
| `timeout` | integer | `60` | Seconds to wait for the challenge to clear. 10 to 120. Most solves finish in 8 to 15 seconds, so keep this at 45 or above for headroom against CF escalations. |

### Output

The Actor writes one item to the default dataset per run.

#### Success

```json
{
  "success": true,
  "cookies": {
    "cf_clearance": "Um7l_YtFbyWHndjVSXc2LRU4..."
  },
  "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
  "headers": {
    "user-agent":          "Mozilla/5.0 (Windows NT 10.0; Win64; x64) ... Chrome/147.0.0.0 Safari/537.36",
    "accept-language":     "en-US,en;q=0.9",
    "sec-ch-ua":           "\"Chromium\";v=\"147\", \"Google Chrome\";v=\"147\", \"Not_A Brand\";v=\"24\"",
    "sec-ch-ua-mobile":    "?0",
    "sec-ch-ua-platform":  "\"Windows\""
  },
  "timeTakenS": 9.42
}
```

The `headers` object goes straight into your HTTP client's headers. Sending a different UA or missing client hints makes Cloudflare re-challenge.

#### Failure

```json
{
  "success": false,
  "error": "TIMEOUT",
  "message": "challenge not solved within 60s",
  "timeTakenS": 60.1
}
```

| Error code | Meaning |
|------------|---------|
| `INVALID_INPUT` | `url` missing, `proxy` malformed, or proxy points at a private or loopback address. |
| `PROXY_ERROR` | Upstream proxy refused the connection or failed authentication. |
| `NO_CHALLENGE` | The page loaded but CF didn't present a challenge. The site is unprotected or your IP is whitelisted. |
| `TIMEOUT` | CF didn't issue a clearance cookie within `timeout` seconds. |
| `BROWSER_ERROR` | Internal navigation failure. |
| `FREE_TIER_LIMIT` | Free Apify accounts are capped at 20 successful solves per 24 hours. Upgrade to a paid Apify plan to remove the cap. |

Failed runs are free. No charge fires unless `success` is `true`.

### How to use the cookies

Replay with the same proxy IP, the same User-Agent, the same client hints, and a Chrome-shaped TLS fingerprint. Python's built-in `requests` uses a Python TLS signature that Cloudflare will re-challenge even with a valid cookie. Use [curl\_cffi](https://github.com/lexiforest/curl_cffi) with `impersonate="chrome"`:

```python
from curl_cffi import requests

result = ...  ## the dataset item from the Actor

resp = requests.get(
    "https://cf-protected.example.com/data",
    impersonate="chrome",           ## Chrome-shaped TLS + HTTP/2 fingerprint
    cookies=result["cookies"],
    headers=result["headers"],      ## UA + client hints that earned the cookie
    proxies={"http":  "http://user:pass@proxy.host:8080",
             "https": "http://user:pass@proxy.host:8080"},
)
```

```bash
pip install curl_cffi
```

One `cf_clearance` is usually good for 30 minutes on the same IP. Refresh when you get a 403 or a fresh "Just a moment..." page.

### Integrations

#### REST API

One call, waits for the result, returns just the dataset items:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/crawlex~cf-solver/run-sync-get-dataset-items?token=$APIFY_TOKEN&timeout=120" \
  -H "Content-Type: application/json" \
  -d '{
    "url":     "https://cf-protected.example.com/",
    "proxy":   "http://user:pass@proxy.host:8080",
    "timeout": 60
  }'
```

#### Python, apify-client

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_APIFY_TOKEN")

run = client.actor("crawlex/cf-solver").call(run_input={
    "url":     "https://cf-protected.example.com/",
    "proxy":   "http://user:pass@proxy.host:8080",
    "timeout": 60,
})

[item] = client.dataset(run["defaultDatasetId"]).list_items().items
print(item["cookies"]["cf_clearance"])
print(item["headers"])
```

#### JavaScript, apify-client

```js
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_APIFY_TOKEN" });

const run = await client.actor("crawlex/cf-solver").call({
  url:     "https://cf-protected.example.com/",
  proxy:   "http://user:pass@proxy.host:8080",
  timeout: 60,
});

const { items: [item] } = await client.dataset(run.defaultDatasetId).listItems();
console.log(item.cookies.cf_clearance);
console.log(item.headers);
```

### Pricing

$0.002 per successful solve. Failures are free. No monthly fee, no subscription. At 1,000 successful solves, total $2.00. Because proxy usage is around 500 KB per solve, residential proxy costs stay small compared to any full-page-load scraper.

### Limits

- **Free Apify accounts: 20 successful solves per rolling 24 hours.** Failures don't count. Paid Apify accounts are uncapped. If you hit the cap you'll see `FREE_TIER_LIMIT` in the error field; upgrade your Apify plan to lift it.
- One URL per run. If you need many, trigger many runs in parallel. The Apify API and the REST example above handle that.
- Interactive Turnstile (the "Verify you are human" checkbox) and passive "Just a moment..." challenges are both supported.
- Multi-step walls that require login, email verification, or CAPTCHAs beyond Turnstile are out of scope.
- Cookie lifetime is about 30 minutes on the same IP. Rotate when you see a 403.

### FAQ

**How do I use it?**
Send the URL you want to scrape and the proxy you plan to use. You get back the `cf_clearance` cookie plus the exact `User-Agent` and Client-Hint headers that go with it. Drop all three into your HTTP client and your requests to the protected site start working.

**Why around 500 KB of proxy bandwidth?**
The Actor only fetches what Cloudflare needs to issue a cookie. Once the cookie arrives, it stops. The target page's body, images, scripts, and analytics are never pulled through your proxy, so there's nothing left to pay for.

**Why do I need to use the same proxy IP afterwards?**
Cloudflare binds `cf_clearance` to the IP that earned it. Switch IPs and CF re-challenges on the first request. Use the same proxy, or at minimum the same IP, for both the solve and your follow-up scraping.

**Why return `headers` instead of just the cookie?**
Cloudflare checks that the UA, Client Hints, and TLS fingerprint on every replay match what earned the cookie. Miss one and CF challenges you again. The `headers` object contains exactly what your HTTP client should send.

**What happens if my solve fails?**
You get a dataset item with `success: false` and an error code. No charge fires. Retry with a different proxy, a longer `timeout`, or check that the URL is actually CF-protected.

**What if my proxy is slow?**
CF challenges involve several small round-trips. A slow proxy pushes the solve time up. Keep `timeout` at 45 seconds or above when using residential proxies. Datacenter or fast residential proxies give the quickest solves.

**Can I use this programmatically?**
Yes. See the REST, Python, and JS examples above. The Apify API supports runs, webhooks, schedules, and integrations with Zapier, Make, Airbyte, and Google Sheets.

**Is this legal?**
Solving a challenge in front of publicly accessible data is within the same scraping legality many commercial scrapers operate under. Always respect the target site's Terms of Service and the law in your jurisdiction.

### Feedback

Hit a bug or want a feature? Open an issue on the Actor's Issues tab.

# Actor input Schema

## `url` (type: `string`):

The Cloudflare-protected URL you want a cf\_clearance cookie for.

Must be reachable through the proxy below.

## `proxy` (type: `string`):

Proxy the solver will navigate through.

The clearance cookie is tied to the IP that earned it, so use the same proxy for your follow-up scraper requests.

Supports http, https, socks5, socks5h with optional user:pass authentication. Residential proxies recommended, since datacenter IPs are often auto-challenged by Cloudflare.

## `timeout` (type: `integer`):

Seconds to wait for the challenge to clear.

Most solves finish in 8 to 15 seconds, but Cloudflare occasionally runs a longer verification.

Keep this at 45 or above unless you know your target resolves fast. You are not billed for timeouts.

## Actor input object example

```json
{
  "url": "https://your-target.example/",
  "proxy": "http://user:pass@proxy.host:8080",
  "timeout": 60
}
```

# Actor output Schema

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

Dataset of solve results. One item per Actor run. On success: cookies.cf\_clearance plus the matching headers and userAgent. On failure: error code + message.

# 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 = {
    "url": "https://your-target.example/",
    "proxy": "http://user:pass@proxy.host:8080"
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlex/cf-solver").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 = {
    "url": "https://your-target.example/",
    "proxy": "http://user:pass@proxy.host:8080",
}

# Run the Actor and wait for it to finish
run = client.actor("crawlex/cf-solver").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 '{
  "url": "https://your-target.example/",
  "proxy": "http://user:pass@proxy.host:8080"
}' |
apify call crawlex/cf-solver --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Cloudflare Turnstile & Challenge Solver",
        "description": "$0.002 per success, failures free. Bypass Cloudflare interstitials and Turnstile. Returns cf_clearance + replay headers. Usable from any HTTP client or language. HTTP or SOCKS5 proxies.",
        "version": "0.3",
        "x-build-id": "mbdS2iiXW2YReTqnK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlex~cf-solver/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlex-cf-solver",
                "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/crawlex~cf-solver/runs": {
            "post": {
                "operationId": "runs-sync-crawlex-cf-solver",
                "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/crawlex~cf-solver/run-sync": {
            "post": {
                "operationId": "run-sync-crawlex-cf-solver",
                "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": [
                    "url",
                    "proxy"
                ],
                "properties": {
                    "url": {
                        "title": "Target URL",
                        "type": "string",
                        "description": "The Cloudflare-protected URL you want a cf_clearance cookie for.\n\nMust be reachable through the proxy below."
                    },
                    "proxy": {
                        "title": "Proxy",
                        "type": "string",
                        "description": "Proxy the solver will navigate through.\n\nThe clearance cookie is tied to the IP that earned it, so use the same proxy for your follow-up scraper requests.\n\nSupports http, https, socks5, socks5h with optional user:pass authentication. Residential proxies recommended, since datacenter IPs are often auto-challenged by Cloudflare."
                    },
                    "timeout": {
                        "title": "Timeout (seconds)",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Seconds to wait for the challenge to clear.\n\nMost solves finish in 8 to 15 seconds, but Cloudflare occasionally runs a longer verification.\n\nKeep this at 45 or above unless you know your target resolves fast. You are not billed for timeouts.",
                        "default": 60
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```