# Google Autocomplete Scraper — Keyword Suggestions API (`fetch_cat/google-autocomplete-scraper`) Actor

Collect Google autocomplete suggestions by seed query, language, and country; export long-tail keyword ideas with rank, locale, source URL, and timestamp.

- **URL**: https://apify.com/fetch\_cat/google-autocomplete-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 keyword suggestions

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

## Google Autocomplete Scraper

Collect Google autocomplete keyword suggestions at scale for SEO, content, PPC, product, and market research workflows.

### What does Google Autocomplete Scraper do?

Google Autocomplete Scraper turns seed keywords into suggestion datasets you can export, enrich, and monitor.
Use it to collect long-tail search phrases from Google autocomplete by language and country.
Each dataset row contains the original seed, suggestion text, rank, locale, source URL, and fetch time.

### Who is it for?

🧑‍💼 SEO teams building keyword maps for content calendars.
📈 Growth marketers researching search intent before launching campaigns.
🏢 Agencies producing repeatable keyword reports for clients.
🛒 Ecommerce teams discovering product modifiers and category questions.
🧪 Product researchers validating how users phrase problems.

### Why use this actor?

✅ Batch many seed keywords in one run.
✅ Localize suggestions with language and country settings.
✅ Export clean rows instead of manually copying dropdown suggestions.
✅ Schedule recurring runs to spot changes in search demand.
✅ Use optional proxy settings for large batches.

### What data can you extract?

The actor returns keyword suggestion rows. The table below summarizes the output fields.

### Output data table

| Field | Description |
| --- | --- |
| `query` | Seed keyword you provided. |
| `suggestion` | Autocomplete suggestion text. |
| `rank` | Suggestion position for the seed. |
| `language` | Language code used for the run. |
| `country` | Country code used for the run. |
| `client` | Autocomplete response format. |
| `sourceUrl` | Source request URL for traceability. |
| `fetchedAt` | ISO timestamp for the fetch. |

### How much does it cost to scrape Google autocomplete suggestions?

The actor uses pay-per-event pricing. You pay a small start fee plus a per-suggestion price.
A typical first run with three seed keywords returns about 20–30 suggestions and costs only a few cents.
For large keyword batches, volume tiers reduce the per-suggestion price automatically.

### How to use Google Autocomplete Scraper

1. Add one or more seed keywords.
2. Choose a language such as `en`, `es`, `de`, or `fr`.
3. Choose a country such as `us`, `gb`, `de`, or `br`.
4. Keep the default limit of 10 suggestions per keyword for normal runs.
5. Start the actor and export the dataset as JSON, CSV, Excel, or via API.

### Input settings

`queries` is the only required input. Add keywords such as `best crm`, `running shoes`, or `apify`.
`language` controls the Google interface language.
`country` controls the market hint.
`maxSuggestionsPerQuery` caps saved suggestions per seed keyword.
`requestDelayMs` adds a pause between requests for polite larger batches.
`useProxy` is optional and normally disabled for small runs.

### Example input

```json
{
  "queries": ["apify", "web scraping", "keyword research"],
  "language": "en",
  "country": "us",
  "maxSuggestionsPerQuery": 10
}
````

### Example output

```json
{
  "query": "apify",
  "suggestion": "apify api",
  "rank": 2,
  "language": "en",
  "country": "us",
  "client": "firefox",
  "sourceUrl": "https://suggestqueries.google.com/complete/search?...",
  "fetchedAt": "2026-06-20T06:20:00.000Z"
}
```

### Tips for better keyword research

Start with broad head terms, then re-run promising suggestions as new seeds.
Run separate datasets for different countries instead of mixing markets in one export.
Use consistent language and country codes when comparing month-over-month changes.
Keep seed lists focused by topic so downstream clustering is easier.

### Integrations

Send the dataset to Google Sheets for editorial review.
Export CSV files into SEO tools or BI dashboards.
Schedule weekly runs and compare new suggestions with previous datasets.
Use webhooks to trigger downstream keyword clustering after each successful run.

### API usage with Node.js

```js
import { ApifyClient } from "apify-client";
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("fetch_cat/google-autocomplete-scraper").call({
  queries: ["content marketing"],
  language: "en",
  country: "us"
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("fetch_cat/google-autocomplete-scraper").call(run_input={
    "queries": ["content marketing"],
    "language": "en",
    "country": "us",
})
print(run["defaultDatasetId"])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~google-autocomplete-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["content marketing"],"language":"en","country":"us"}'
```

### MCP usage

Use Apify MCP tools to run this actor from Claude Code or Claude Desktop.
MCP URL: `https://mcp.apify.com?tools=fetch_cat/google-autocomplete-scraper`

Add the server in Claude Code:

```bash
claude mcp add apify-google-autocomplete "https://mcp.apify.com?tools=fetch_cat/google-autocomplete-scraper"
```

Claude Desktop JSON config example:

```json
{
  "mcpServers": {
    "apify-google-autocomplete": {
      "url": "https://mcp.apify.com?tools=fetch_cat/google-autocomplete-scraper"
    }
  }
}
```

Example prompts:

- “Run Google Autocomplete Scraper for SaaS onboarding keywords in the US.”
- “Collect autocomplete suggestions for these ecommerce category seeds and summarize patterns.”

### Scheduling and monitoring

Create a schedule in Apify Console for weekly or monthly keyword tracking.
Use stable seed lists to detect new, removed, or reordered suggestions over time.
Export each run and compare by `query`, `suggestion`, and `rank`.

### Proxy guidance

Most small runs do not need a proxy.
Enable Apify Proxy for large batches, unusual geographies, or repeated automated monitoring.
Increase request delay before increasing proxy spend.

### Limits and caveats

Google suggestions can change by time, location, language, and personalization experiments.
Autocomplete is a discovery signal, not a search volume metric.
Some seed keywords may return fewer than the requested maximum suggestions.

### Legality and responsible use

This actor collects publicly available autocomplete suggestions.
Use the data responsibly and respect applicable laws, platform terms, and privacy obligations.
Do not use keyword data to target protected classes or sensitive personal attributes.

### Troubleshooting

**Why did a keyword return no suggestions?** Google may not have suggestions for the term, or it may temporarily limit automated requests.
**Why do results differ by country?** Autocomplete is localized, so market hints can change suggestion text and rank.
**How can I reduce costs?** Keep seed lists focused, use the default 10-suggestion cap, and avoid unnecessary proxy use.

### FAQ

**Can I run thousands of seed keywords?** Yes, but increase request delays and consider proxy settings for very large jobs.
**Can I get monthly search volume?** No. This actor returns autocomplete suggestions, not volume estimates.
**Can I choose any language or country?** Use standard two-letter Google language and country codes.

### Related actors and scrapers

- [Google Search Results Scraper](https://apify.com/fetch_cat/google-search-results-scraper)
- [Reddit Scraper](https://apify.com/fetch_cat/reddit-scraper)
- [Apple App Store Reviews Scraper](https://apify.com/fetch_cat/apple-app-store-reviews-scraper)

### Support

If a run fails, open the run log and include the run URL when reporting the issue.
For best support, share your input JSON and expected locale behavior.

### Keyword workflow ideas

1. Build a seed list from product categories, customer questions, internal site search terms, or competitor topics.
2. Run localized batches for each target market so language and country differences stay easy to compare.
3. Re-run high-value suggestions as new seeds to expand long-tail keyword coverage.
4. Group suggestions by modifier, intent, product category, and question pattern.
5. Separate brand and non-brand phrases before passing terms to SEO or paid search teams.
6. Compare recurring exports to detect seasonal shifts, emerging topics, and disappearing suggestions.
7. Export CSV or Excel files for editorial briefs, content calendars, and client reporting.
8. Use Apify API, webhooks, or schedules to plug recurring keyword discovery into your existing workflow.

# Actor input Schema

## `queries` (type: `array`):

Enter the words or phrases you want to expand into Google autocomplete suggestions.

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

Two-letter Google language code, for example en, es, de, fr, it, pt, or ja.

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

Two-letter Google country code used to localize suggestions, for example us, gb, de, fr, br, or au.

## `maxSuggestionsPerQuery` (type: `integer`):

Upper limit of suggestions saved for each seed keyword. Google usually returns up to 10 suggestions.

## `client` (type: `string`):

Google autocomplete response format. Firefox is compact JSON and recommended.

## `requestDelayMs` (type: `integer`):

Polite pause between seed keyword requests. Increase for very large batches.

## `maxRetries` (type: `integer`):

Retry temporary rate-limit or server errors before skipping a keyword.

## `useProxy` (type: `boolean`):

Enable only if you run very large batches or need proxy routing. Most small runs work without a proxy.

## `proxyGroups` (type: `array`):

Optional Apify Proxy groups, for example RESIDENTIAL. Leave empty to use automatic proxy settings.

## Actor input object example

```json
{
  "queries": [
    "apify",
    "web scraping",
    "keyword research"
  ],
  "language": "en",
  "country": "us",
  "maxSuggestionsPerQuery": 10,
  "client": "firefox",
  "requestDelayMs": 250,
  "maxRetries": 2,
  "useProxy": false,
  "proxyGroups": []
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "queries": [
        "apify",
        "web scraping",
        "keyword research"
    ],
    "language": "en",
    "country": "us",
    "maxSuggestionsPerQuery": 10,
    "client": "firefox"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/google-autocomplete-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 = {
    "queries": [
        "apify",
        "web scraping",
        "keyword research",
    ],
    "language": "en",
    "country": "us",
    "maxSuggestionsPerQuery": 10,
    "client": "firefox",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/google-autocomplete-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 '{
  "queries": [
    "apify",
    "web scraping",
    "keyword research"
  ],
  "language": "en",
  "country": "us",
  "maxSuggestionsPerQuery": 10,
  "client": "firefox"
}' |
apify call fetch_cat/google-autocomplete-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Autocomplete Scraper — Keyword Suggestions API",
        "description": "Collect Google autocomplete suggestions by seed query, language, and country; export long-tail keyword ideas with rank, locale, source URL, and timestamp.",
        "version": "0.1",
        "x-build-id": "Njle9N2Qq7FeuYn1Y"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~google-autocomplete-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-google-autocomplete-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/fetch_cat~google-autocomplete-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-google-autocomplete-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/fetch_cat~google-autocomplete-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-google-autocomplete-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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Seed keywords",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Enter the words or phrases you want to expand into Google autocomplete suggestions.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language (hl)",
                        "type": "string",
                        "description": "Two-letter Google language code, for example en, es, de, fr, it, pt, or ja.",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country (gl)",
                        "type": "string",
                        "description": "Two-letter Google country code used to localize suggestions, for example us, gb, de, fr, br, or au.",
                        "default": "us"
                    },
                    "maxSuggestionsPerQuery": {
                        "title": "Maximum suggestions per keyword",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Upper limit of suggestions saved for each seed keyword. Google usually returns up to 10 suggestions.",
                        "default": 10
                    },
                    "client": {
                        "title": "Autocomplete client",
                        "enum": [
                            "firefox",
                            "chrome",
                            "toolbar"
                        ],
                        "type": "string",
                        "description": "Google autocomplete response format. Firefox is compact JSON and recommended.",
                        "default": "firefox"
                    },
                    "requestDelayMs": {
                        "title": "Delay between keyword requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite pause between seed keyword requests. Increase for very large batches.",
                        "default": 250
                    },
                    "maxRetries": {
                        "title": "Retries per keyword",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Retry temporary rate-limit or server errors before skipping a keyword.",
                        "default": 2
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Enable only if you run very large batches or need proxy routing. Most small runs work without a proxy.",
                        "default": false
                    },
                    "proxyGroups": {
                        "title": "Proxy groups",
                        "type": "array",
                        "description": "Optional Apify Proxy groups, for example RESIDENTIAL. Leave empty to use automatic proxy settings.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```