# CoinGecko Scraper (`crawlerbros/coingecko-scraper`) Actor

Scrape CoinGecko - the world's largest crypto data aggregator. Get real-time prices, market caps, trending coins, detailed coin info, and category listings for 10,000+ cryptocurrencies. No API key required.

- **URL**: https://apify.com/crawlerbros/coingecko-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, News, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## CoinGecko Scraper

Scrape live cryptocurrency market data from **CoinGecko** — the world's largest independent crypto data aggregator. Get real-time prices, market caps, trending coins, detailed coin info, and category listings for 10,000+ cryptocurrencies. **No API key required.**

### What This Actor Does

- **Five modes:** `markets`, `search`, `byId`, `trending`, `categories`
- **Multi-currency support:** USD, EUR, GBP, JPY, CNY, KRW, BTC, ETH
- **Flexible filtering:** filter by market cap, rank, category, sort order
- **Real-time data:** prices, market caps, 24h changes, supply, ATH/ATL, trending scores
- **Clean output:** null fields are never included in output records

### Modes

#### markets (default)
List coins sorted by market cap, volume, or ID. Supports currency selection, category filter, and sort order. Returns up to 250 coins per run.

#### search
Search for coins by name or symbol (e.g. "bitcoin", "sol", "doge"). Returns matching coins with rank and image.

#### byId
Fetch rich detail for one or more specific coins by their CoinGecko ID. Returns description, categories, homepage, GitHub repos, price history changes (24h/7d/30d), and full market data.

#### trending
Returns the current trending coins on CoinGecko (last 24 hours). Includes score, price in BTC, and image.

#### categories
Lists all CoinGecko coin categories with market cap, 24h market cap change, and 24h volume. Useful for finding category slugs to use in the `category` filter.

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | Select | `markets` | What data to fetch (`markets`, `search`, `byId`, `trending`, `categories`) |
| `searchQuery` | String | — | Search term (mode=search, e.g. "bitcoin") |
| `coinIds` | String list | — | CoinGecko coin IDs (mode=byId, e.g. "bitcoin", "ethereum") |
| `vsCurrency` | Select | `usd` | Quote currency for prices (`usd`, `eur`, `gbp`, `jpy`, `cny`, `krw`, `btc`, `eth`) |
| `order` | Select | `market_cap_desc` | Sort order for markets mode |
| `category` | String | — | Filter markets to a category slug (e.g. `decentralized-finance-defi`, `layer-1`) |
| `maxItems` | Integer | 50 | Max records to return (1–250) |
| `minMarketCap` | Number | — | Filter: minimum market cap in USD (markets mode) |
| `maxMarketCap` | Number | — | Filter: maximum market cap in USD (markets mode) |
| `minRank` | Integer | — | Filter: minimum market cap rank (markets mode) |
| `maxRank` | Integer | — | Filter: maximum market cap rank (markets mode) |

### Output Fields

#### Markets mode (`recordType: "coin"`)

| Field | Type | Description |
|---|---|---|
| `coinId` | String | CoinGecko ID (e.g. `bitcoin`) |
| `symbol` | String | Ticker symbol (e.g. `BTC`) |
| `name` | String | Full name (e.g. `Bitcoin`) |
| `currentPrice` | Number | Current price in selected currency |
| `marketCap` | Number | Market capitalization |
| `marketCapRank` | Integer | Global market cap rank |
| `fullyDilutedValuation` | Number | Fully diluted valuation |
| `totalVolume` | Number | 24h trading volume |
| `priceHigh24h` | Number | 24h highest price |
| `priceLow24h` | Number | 24h lowest price |
| `priceChange24h` | Number | Absolute price change in 24h |
| `priceChangePercent24h` | Number | Percentage price change in 24h |
| `marketCapChangePercent24h` | Number | Market cap change % in 24h |
| `circulatingSupply` | Number | Circulating supply |
| `totalSupply` | Number | Total supply |
| `maxSupply` | Number | Maximum supply (if capped) |
| `ath` | Number | All-time high price |
| `athDate` | String | Date of all-time high (ISO 8601) |
| `atl` | Number | All-time low price |
| `atlDate` | String | Date of all-time low (ISO 8601) |
| `lastUpdated` | String | CoinGecko last-update timestamp |
| `imageUrl` | String | Coin logo URL |
| `sourceUrl` | String | CoinGecko page URL |
| `scrapedAt` | String | ISO 8601 scrape timestamp |
| `recordType` | String | `"coin"` |

#### byId mode (richer fields added)

All markets fields plus:

| Field | Type | Description |
|---|---|---|
| `description` | String | Plain-text coin description |
| `categories` | String list | CoinGecko category names |
| `homepageUrl` | String | Official website URL |
| `reposUrl` | String list | GitHub / Bitbucket repository URLs |
| `priceChangePercent7d` | Number | 7-day price change % |
| `priceChangePercent30d` | Number | 30-day price change % |

#### trending mode (`recordType: "trending_coin"`)

`coinId`, `name`, `symbol`, `marketCapRank`, `score`, `priceInBtc`, `imageUrl`, `sourceUrl`, `scrapedAt`

#### categories mode (`recordType: "coin_category"`)

`categoryId`, `name`, `marketCap`, `marketCapChange24h`, `volume24h`, `description`, `updatedAt`, `sourceUrl`, `scrapedAt`

### Example Output (markets mode)

```json
{
  "coinId": "bitcoin",
  "symbol": "BTC",
  "name": "Bitcoin",
  "currentPrice": 67000.0,
  "marketCap": 1320000000000.0,
  "marketCapRank": 1,
  "fullyDilutedValuation": 1400000000000.0,
  "totalVolume": 28000000000.0,
  "priceHigh24h": 68000.0,
  "priceLow24h": 65000.0,
  "priceChange24h": 1500.0,
  "priceChangePercent24h": 2.3,
  "marketCapChangePercent24h": -0.38,
  "circulatingSupply": 19700000.0,
  "totalSupply": 21000000.0,
  "maxSupply": 21000000.0,
  "ath": 73750.0,
  "athDate": "2024-03-14T07:10:36.635Z",
  "atl": 67.81,
  "atlDate": "2013-07-06T00:00:00.000Z",
  "lastUpdated": "2024-04-01T12:00:00.000Z",
  "imageUrl": "https://coin-images.coingecko.com/coins/images/1/large/bitcoin.png",
  "sourceUrl": "https://www.coingecko.com/en/coins/bitcoin",
  "recordType": "coin",
  "scrapedAt": "2026-06-06T12:00:00+00:00"
}
````

### Data Source

Data is sourced from [CoinGecko](https://www.coingecko.com) via their free public REST API (`api.coingecko.com/api/v3`). CoinGecko tracks 10,000+ cryptocurrencies across 600+ exchanges and is the world's largest independent crypto data aggregator.

### FAQs

**Do I need an API key?**
No. This actor uses CoinGecko's free public tier which requires no authentication.

**How fresh is the data?**
CoinGecko updates price data every 1–5 minutes for major coins.

**How do I find a coin's CoinGecko ID?**
Visit [coingecko.com](https://www.coingecko.com), search for the coin, and copy the ID from the URL (e.g. `bitcoin`, `ethereum`, `shiba-inu`).

**How do I find category slugs?**
Run the actor in `categories` mode to get all available category IDs, then use them as the `category` filter in `markets` mode.

**What does the `order` parameter do?**
It controls how markets results are sorted: `market_cap_desc` (default, largest first), `market_cap_asc`, `volume_desc`, `volume_asc`, `id_asc`, `id_desc`.

**Why might some fields be missing from output?**
CoinGecko may not have data for all fields for every coin (e.g. `maxSupply` is null for coins with no hard cap). Null/empty fields are never included in output records.

**Can I scrape multiple coins in byId mode?**
Yes — provide a list of CoinGecko IDs in `coinIds` (e.g. `["bitcoin", "ethereum", "solana"]`). Each coin is fetched individually with rate-limiting to avoid 429 errors.

# Actor input Schema

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

What data to fetch from CoinGecko.

## `searchQuery` (type: `string`):

Coin name or symbol to search for (mode=search). Example: bitcoin, sol, doge.

## `coinIds` (type: `array`):

CoinGecko coin IDs to fetch detailed data for (e.g. bitcoin, ethereum, solana). Find IDs at coingecko.com.

## `vsCurrency` (type: `string`):

Currency used for all price fields (markets and byId modes).

## `order` (type: `string`):

How to sort coins in markets mode.

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

Filter markets results to a specific category slug (e.g. decentralized-finance-defi, layer-1, stablecoins). Leave empty for all categories.

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

Maximum number of records to return.

## `minMarketCap` (type: `number`):

Filter out coins with market cap below this value (markets mode).

## `maxMarketCap` (type: `number`):

Filter out coins with market cap above this value (markets mode).

## `minRank` (type: `integer`):

Filter out coins with market cap rank below this value (markets mode).

## `maxRank` (type: `integer`):

Filter out coins with market cap rank above this value (markets mode).

## Actor input object example

```json
{
  "mode": "markets",
  "coinIds": [],
  "vsCurrency": "usd",
  "order": "market_cap_desc",
  "maxItems": 50
}
```

# Actor output Schema

## `coins` (type: `string`):

Dataset containing all scraped records (coins, trending coins, or categories depending on mode).

# 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 = {
    "mode": "markets",
    "coinIds": [],
    "vsCurrency": "usd",
    "order": "market_cap_desc",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/coingecko-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "markets",
    "coinIds": [],
    "vsCurrency": "usd",
    "order": "market_cap_desc",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/coingecko-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "markets",
  "coinIds": [],
  "vsCurrency": "usd",
  "order": "market_cap_desc",
  "maxItems": 50
}' |
apify call crawlerbros/coingecko-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CoinGecko Scraper",
        "description": "Scrape CoinGecko - the world's largest crypto data aggregator. Get real-time prices, market caps, trending coins, detailed coin info, and category listings for 10,000+ cryptocurrencies. No API key required.",
        "version": "1.0",
        "x-build-id": "e94hQaFBeXnJL2YUY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~coingecko-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-coingecko-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~coingecko-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-coingecko-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~coingecko-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-coingecko-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "markets",
                            "search",
                            "byId",
                            "trending",
                            "categories"
                        ],
                        "type": "string",
                        "description": "What data to fetch from CoinGecko.",
                        "default": "markets"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Coin name or symbol to search for (mode=search). Example: bitcoin, sol, doge."
                    },
                    "coinIds": {
                        "title": "Coin IDs (mode=byId)",
                        "type": "array",
                        "description": "CoinGecko coin IDs to fetch detailed data for (e.g. bitcoin, ethereum, solana). Find IDs at coingecko.com.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "vsCurrency": {
                        "title": "Quote currency",
                        "enum": [
                            "usd",
                            "eur",
                            "gbp",
                            "jpy",
                            "cny",
                            "krw",
                            "btc",
                            "eth"
                        ],
                        "type": "string",
                        "description": "Currency used for all price fields (markets and byId modes).",
                        "default": "usd"
                    },
                    "order": {
                        "title": "Sort order",
                        "enum": [
                            "market_cap_desc",
                            "market_cap_asc",
                            "volume_desc",
                            "volume_asc",
                            "id_asc",
                            "id_desc"
                        ],
                        "type": "string",
                        "description": "How to sort coins in markets mode.",
                        "default": "market_cap_desc"
                    },
                    "category": {
                        "title": "Category filter (markets mode)",
                        "type": "string",
                        "description": "Filter markets results to a specific category slug (e.g. decentralized-finance-defi, layer-1, stablecoins). Leave empty for all categories."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Maximum number of records to return.",
                        "default": 50
                    },
                    "minMarketCap": {
                        "title": "Min market cap (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Filter out coins with market cap below this value (markets mode)."
                    },
                    "maxMarketCap": {
                        "title": "Max market cap (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Filter out coins with market cap above this value (markets mode)."
                    },
                    "minRank": {
                        "title": "Min market cap rank",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Filter out coins with market cap rank below this value (markets mode)."
                    },
                    "maxRank": {
                        "title": "Max market cap rank",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Filter out coins with market cap rank above this value (markets mode)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
