# Google Keywords Suggest Scraper Pro (`crawlerbros/google-keywords-suggest-scraper-pro`) Actor

Scrape Google Suggest autocomplete keywords for any seed term. Pro modes: exact, all (related), questions (who/what/why), prepositions (with/for/vs), comparisons, alphabet expansion (a-z). Multi-keyword + multi-language + 200+ Google country codes.

- **URL**: https://apify.com/crawlerbros/google-keywords-suggest-scraper-pro.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** SEO tools, Developer tools, Automation
- **Stats:** 5 total users, 4 monthly users, 100.0% runs succeeded, 20 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.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

## Google Keywords Suggest Scraper Pro

Pull Google Suggest autocomplete keywords for any seed term — exactly what shows up in the Google search box as you type. Perfect for SEO research, content planning, and long-tail keyword discovery.

### Modes

- **exact** — just the seed
- **all** — Google's default related suggestions
- **questions** — appends `who/what/when/where/why/how/which/whose` for question-style queries
- **prepositions** — appends `for/with/vs/like/near/...` for intent-rich keywords
- **comparisons** — appends `vs/or/versus`
- **alphabet** — appends each letter `a-z` to surface long-tail variants (one query per letter, all 26)

### Output (flat mode — one record per suggestion)

```json
{
  "recordType": "suggestion",
  "text": "python tutorial for beginners",
  "source_keyword": "python tutorial",
  "expansion_query": "python tutorial f",
  "mode": "alphabet",
  "country": "US",
  "language": "en",
  "relevance": 601,
  "suggestion_type": "QUERY",
  "sub_types": [512],
  "scrapedAt": "2026-04-29T..."
}
````

### Output (tree mode — one record per seed)

```json
{
  "recordType": "keyword_tree",
  "source_keyword": "python tutorial",
  "mode": "alphabet",
  "country": "US",
  "language": "en",
  "suggestion_count": 124,
  "suggestions": [
    {"text": "python tutorial for beginners", "relevance": 601, ...},
    ...
  ]
}
```

### Input

| Field | Type | Description |
|---|---|---|
| `keywords` | array (required) | One or more seed keywords |
| `mode` | enum | `exact`, `all`, `questions`, `prepositions`, `comparisons`, `alphabet` |
| `country` | enum | Google `gl=` market code such as `US`, `GB`, `DE`, `IN`, `BR`, or `ALL` |
| `language` | enum | Google `hl=` language code such as `en`, `es`, `fr`, `de`, `ja`, `zh-CN` |
| `maxItemsPerKeyword` | int | Cap per seed (1-5000, default 200) |
| `minLength` | int | Drop suggestions shorter than N chars |
| `maxLength` | int | Drop suggestions longer than N chars |
| `containsKeyword` | string | Substring filter on suggestion text. Prefix `!` to invert. |
| `outputFormat` | enum | `flat` (one record per suggestion) or `tree` (one record per seed) |

### Use cases

- **SEO research** — find the long-tail variants real users search for
- **Content planning** — group suggestions by question modes to map "people also ask" topics
- **PPC research** — discover negative-match candidates with `containsKeyword: "!free"`
- **Competitor analysis** — combine `<brand> alternative`, `<brand> vs`, `<brand> for` modes
- **Multi-market SEO** — run the same seeds across different `country` + `language` combinations

### FAQ

**Does it require a login?** No. Google Suggest is a public endpoint. No cookies, no proxy.

**How many suggestions per seed?** Google returns up to ~10 per query. With `mode=alphabet` you get up to 260 (10 × 26), `questions` up to 80, etc.

**What's the difference between `country` and `language`?** `country` (gl=) influences geographic ranking — `python` in `IN` returns Indian programming-related suggestions; in `BR` returns more cooking ones. `language` (hl=) affects which language Google translates suggestions to.

**Can I get search volumes?** Volume requires Google Ads Keyword Planner (paid + OAuth). This actor returns Suggest's `relevance` score (~600 typical, higher = more popular) which is a useful proxy.

**What happens when filters drop everything?** The actor finishes without fake rows and sets a status message with the active filters so you can loosen them.

**What is `expansion_query`?** It's the generated query that was sent to Google Suggest for that batch of results, such as `python tutorial a` or `what openai api`. Google can still return nearby variants, so the suggestion text is not guaranteed to start with that exact string.

# Actor input Schema

## `keywords` (type: `array`):

One or more seed keywords. Each is expanded according to `mode`.

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

How each seed keyword is expanded. `exact` = no expansion. `all` = Google's related suggestions. `questions` = adds who/what/when/where/why/how prefixes. `prepositions` = adds for/with/vs/like/near. `comparisons` = adds vs/or/versus. `alphabet` = appends each letter a-z to surface long-tail.

## `country` (type: `string`):

Two-letter Google country code (e.g. `US`, `GB`, `IN`, `DE`, `BR`). Affects suggestion ranking by region.

## `language` (type: `string`):

Two-letter language code (e.g. `en`, `es`, `fr`, `de`).

## `maxItemsPerKeyword` (type: `integer`):

Hard cap on how many suggestions are emitted per seed keyword (across the whole expansion).

## `minLength` (type: `integer`):

Drop suggestions shorter than this many characters.

## `maxLength` (type: `integer`):

Drop suggestions longer than this many characters.

## `containsKeyword` (type: `string`):

Only emit suggestions that contain this substring (case-insensitive). Prefix with `!` to invert (drop matches).

## `outputFormat` (type: `string`):

`flat` (one record per suggestion) or `tree` (one record per seed with nested suggestion list).

## Actor input object example

```json
{
  "keywords": [
    "python tutorial"
  ],
  "mode": "all",
  "country": "US",
  "language": "en",
  "maxItemsPerKeyword": 200,
  "outputFormat": "flat"
}
```

# 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 = {
    "keywords": [
        "python tutorial"
    ],
    "mode": "all",
    "country": "US",
    "language": "en",
    "maxItemsPerKeyword": 200,
    "outputFormat": "flat"
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/google-keywords-suggest-scraper-pro").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 = {
    "keywords": ["python tutorial"],
    "mode": "all",
    "country": "US",
    "language": "en",
    "maxItemsPerKeyword": 200,
    "outputFormat": "flat",
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/google-keywords-suggest-scraper-pro").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 '{
  "keywords": [
    "python tutorial"
  ],
  "mode": "all",
  "country": "US",
  "language": "en",
  "maxItemsPerKeyword": 200,
  "outputFormat": "flat"
}' |
apify call crawlerbros/google-keywords-suggest-scraper-pro --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Keywords Suggest Scraper Pro",
        "description": "Scrape Google Suggest autocomplete keywords for any seed term. Pro modes: exact, all (related), questions (who/what/why), prepositions (with/for/vs), comparisons, alphabet expansion (a-z). Multi-keyword + multi-language + 200+ Google country codes.",
        "version": "1.0",
        "x-build-id": "aBiev17hnl2xGONaR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~google-keywords-suggest-scraper-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-google-keywords-suggest-scraper-pro",
                "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~google-keywords-suggest-scraper-pro/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-google-keywords-suggest-scraper-pro",
                "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~google-keywords-suggest-scraper-pro/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-google-keywords-suggest-scraper-pro",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Seed keywords",
                        "type": "array",
                        "description": "One or more seed keywords. Each is expanded according to `mode`.",
                        "default": [
                            "python tutorial"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "mode": {
                        "title": "Expansion mode",
                        "enum": [
                            "exact",
                            "all",
                            "questions",
                            "prepositions",
                            "comparisons",
                            "alphabet"
                        ],
                        "type": "string",
                        "description": "How each seed keyword is expanded. `exact` = no expansion. `all` = Google's related suggestions. `questions` = adds who/what/when/where/why/how prefixes. `prepositions` = adds for/with/vs/like/near. `comparisons` = adds vs/or/versus. `alphabet` = appends each letter a-z to surface long-tail.",
                        "default": "all"
                    },
                    "country": {
                        "title": "Country (gl=)",
                        "enum": [
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "NZ",
                            "IE",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "NL",
                            "BE",
                            "AT",
                            "CH",
                            "PT",
                            "GR",
                            "CZ",
                            "PL",
                            "SE",
                            "NO",
                            "DK",
                            "FI",
                            "HU",
                            "RO",
                            "BG",
                            "HR",
                            "SK",
                            "SI",
                            "EE",
                            "LV",
                            "LT",
                            "LU",
                            "MT",
                            "CY",
                            "IS",
                            "LI",
                            "MC",
                            "AD",
                            "SM",
                            "JP",
                            "KR",
                            "CN",
                            "TW",
                            "HK",
                            "MO",
                            "IN",
                            "PK",
                            "BD",
                            "LK",
                            "NP",
                            "AF",
                            "ID",
                            "TH",
                            "VN",
                            "PH",
                            "MY",
                            "SG",
                            "BN",
                            "MM",
                            "KH",
                            "LA",
                            "TL",
                            "BR",
                            "MX",
                            "AR",
                            "CL",
                            "CO",
                            "PE",
                            "VE",
                            "EC",
                            "BO",
                            "PY",
                            "UY",
                            "GT",
                            "CR",
                            "PA",
                            "DO",
                            "PR",
                            "CU",
                            "SV",
                            "HN",
                            "NI",
                            "JM",
                            "TT",
                            "BB",
                            "RU",
                            "TR",
                            "UA",
                            "BY",
                            "KZ",
                            "UZ",
                            "AZ",
                            "AM",
                            "GE",
                            "MD",
                            "RS",
                            "BA",
                            "MK",
                            "AL",
                            "ME",
                            "XK",
                            "ZA",
                            "NG",
                            "EG",
                            "MA",
                            "DZ",
                            "TN",
                            "KE",
                            "GH",
                            "ET",
                            "UG",
                            "TZ",
                            "RW",
                            "ZW",
                            "SN",
                            "CI",
                            "CM",
                            "MZ",
                            "AO",
                            "ZM",
                            "AE",
                            "SA",
                            "IL",
                            "QA",
                            "KW",
                            "BH",
                            "OM",
                            "JO",
                            "LB",
                            "SY",
                            "IQ",
                            "IR",
                            "YE",
                            "PS",
                            "ALL"
                        ],
                        "type": "string",
                        "description": "Two-letter Google country code (e.g. `US`, `GB`, `IN`, `DE`, `BR`). Affects suggestion ranking by region.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language (hl=)",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "nl",
                            "pl",
                            "sv",
                            "no",
                            "da",
                            "fi",
                            "cs",
                            "el",
                            "hu",
                            "ro",
                            "bg",
                            "hr",
                            "sk",
                            "sl",
                            "et",
                            "lv",
                            "lt",
                            "ga",
                            "is",
                            "mt",
                            "ru",
                            "uk",
                            "be",
                            "sr",
                            "bs",
                            "mk",
                            "sq",
                            "ar",
                            "tr",
                            "he",
                            "fa",
                            "ur",
                            "ku",
                            "ja",
                            "ko",
                            "zh-CN",
                            "zh-TW",
                            "hi",
                            "bn",
                            "ta",
                            "te",
                            "ml",
                            "mr",
                            "gu",
                            "kn",
                            "pa",
                            "ne",
                            "si",
                            "my",
                            "id",
                            "th",
                            "vi",
                            "ms",
                            "tl",
                            "km",
                            "lo",
                            "sw",
                            "am",
                            "ha",
                            "yo",
                            "ig",
                            "zu",
                            "xh",
                            "af",
                            "az",
                            "kk",
                            "uz",
                            "ky",
                            "tg",
                            "mn",
                            "ka",
                            "hy"
                        ],
                        "type": "string",
                        "description": "Two-letter language code (e.g. `en`, `es`, `fr`, `de`).",
                        "default": "en"
                    },
                    "maxItemsPerKeyword": {
                        "title": "Max suggestions per seed keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on how many suggestions are emitted per seed keyword (across the whole expansion).",
                        "default": 200
                    },
                    "minLength": {
                        "title": "Min characters per suggestion",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Drop suggestions shorter than this many characters."
                    },
                    "maxLength": {
                        "title": "Max characters per suggestion",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Drop suggestions longer than this many characters."
                    },
                    "containsKeyword": {
                        "title": "Must contain (substring filter)",
                        "type": "string",
                        "description": "Only emit suggestions that contain this substring (case-insensitive). Prefix with `!` to invert (drop matches)."
                    },
                    "outputFormat": {
                        "title": "Output shape",
                        "enum": [
                            "flat",
                            "tree"
                        ],
                        "type": "string",
                        "description": "`flat` (one record per suggestion) or `tree` (one record per seed with nested suggestion list).",
                        "default": "flat"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
