# Google Keyword  Scraper ( With SEO Metrics ) (`dxbear/google-keyword-scraper`) Actor

Discover keyword ideas instantly, scrapes Google autocomplete, expands with similar keywords, and adds SEO metrics.

- **URL**: https://apify.com/dxbear/google-keyword-scraper.md
- **Developed by:** [Dxbear](https://apify.com/dxbear) (community)
- **Categories:** SEO tools, MCP servers, Agents
- **Stats:** 57 total users, 2 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 2.61 out of 5 stars

## Pricing

$6.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

Unlock powerful keyword research with our Google Keyword Scraper — the ultimate tool for discovering thousands of keyword ideas in minutes. This actor taps into Google's autocomplete suggestions, intelligently expands your keyword list, and enriches each keyword with essential SEO metrics like search volume, keyword difficulty, CPC, and competition data. Whether you're doing SEO research, planning content strategy, or building PPC campaigns, this tool gives you the data-driven insights you need to make smart decisions.

### What This Actor Does  

**Discover Keywords That People Actually Search For**  
Start with a seed keyword and instantly get hundreds of related terms from Google Autocomplete—real queries matching real user intent.  

**Uncover Long-Tail Variations**  
Goes beyond basic suggestions by smartly adding words before/after your keyword, revealing hidden long-tail phrases and fresh content ideas.  

**Pro Mode = Full SEO Data**  
Get powerful insights with search volume, keyword difficulty (KD), CPC, and competition stats—so you know which keywords are worth targeting.  

**Flexible Modes**  
- **Free Mode:** Quick keyword brainstorming.  
- **Pro Mode:** Expanded discovery + complete SEO metrics.  

**Scale to Your Needs**  
Generate 1K+, 5K+, or even 10K keywords depending on your project scope.  

**Global Reach**  
Supports 39+ languages and 80+ countries for accurate local and international keyword research.  

**Fast & Reliable**  
Optimized for speed with parallel scraping, auto retries, and thousands of results in minutes.  

### How to Use It

#### 1. Set Up Your Input

Here's a simple example to get started:

    {
        "seedKeyword": "best laptops",
        "country": "us",
        "language": "en",
        "scraperSettings": "after",
        "maxKeywords": "moderate",
        "scrapingType": "pro",
        "concurrency": 10,
        "maxRetries": 3
    }

### What Each Field Means  

**seedKeyword**  
Your main keyword (e.g., *best laptops*, *logo designer*). The actor expands it into hundreds or thousands of related terms.  

**country**  
Two-letter country code (*us*, *uk*, *in*, *fr*). Ensures results come from the right regional Google.  

**language**  
Language code (*en*, *es*, *fr*, *de*). Combined with country, this lets you target any market worldwide.  

**scraperSettings**  
Where to place autocomplete words:  
- **after** → “best laptops for gaming”  
- **before** → “cheap best laptops”  

**maxKeywords**  
How many keywords to generate:  
- **basic** → ~1,000–1,500 (niche)  
- **moderate** → up to 5,000 (standard SEO)  
- **advanced** → up to 10,000 (large-scale)  

**scrapingType**  
Choose mode:  
- **free** → Google suggestions only (quick ideas)  
- **pro** → Expanded list + SEO metrics (volume, KD, CPC, competition)  

**concurrency**  
How many searches run at once (1–50, default 10). Higher = faster, but may hit limits.  

**maxRetries**  
Retries for failed requests (1–5, default 3). Ensures complete results even if some queries fail.  
#### 2. Run the Actor

Just click the "Start" button and wait for the results! Depending on your settings, the actor will take a few minutes to complete. You can monitor progress in the actor's log and see keywords being discovered in real-time.

#### 3. Get Your Results

**Free Mode Output** (suggestions only):

    [
      {
        "rank": 1,
        "keyword": "best laptops for students"
      },
      {
        "rank": 2,
        "keyword": "best laptops for gaming"
      },
      {
        "rank": 3,
        "keyword": "best laptops under 500"
      }
    ]


**Pro Mode Output** (with SEO metrics):

    [
      {
        "rank": 1,
        "keyword": "best laptops for students",
        "searchVolume": "12.5K",
        "KD": "Medium",
        "CPC": "1.85",
        "SERP Count": "2.3B"
      },
      {
        "rank": 2,
        "keyword": "best laptops for gaming",
        "searchVolume": "18.2K",
        "KD": "Hard",
        "CPC": "2.45",
        "SERP Count": "3.1B"
      },
      {
        "rank": 3,
        "keyword": "best laptops under 500",
        "searchVolume": "8.9K",
        "KD": "Challenging",
        "CPC": "1.52",
        "SERP Count": "1.8B"
      }
    ]



### Using via MCP Server or API  

**🔹 Apify MCP Server**  
Connect this actor to your AI workflows so assistants can run keyword research automatically.  
1. Install the MCP Server and follow the setup guide.  
2. Configure your Apify API token.  
3. Tell your AI assistant in plain language (e.g., *“Find keyword ideas for coffee shops in the US with SEO metrics”*).  

👉 [MCP docs — setup & reference](https://docs.apify.com/platform/integrations/mcp)  
👉 [MCP how-to (step-by-step)](https://blog.apify.com/how-to-use-mcp/)  

---

**🔹 Apify API**  
Run the actor programmatically from apps, dashboards, or automation pipelines — perfect for integrating keyword research into your stack.  

👉 [API docs — run actors via API](https://docs.apify.com/api)  

### Tips for Best Results  

- **Pick the right seed keyword**  
  Be specific (e.g., *best laptops for students*) but not overly narrow.  

- **Test both "before" & "after" settings**  
  “After” → natural long-tails.  
  “Before” → modifiers & variations.  

- **Choose the right mode**  
  - **Free:** Quick brainstorming & content ideas.  
  - **Pro:** Full SEO data for serious targeting.  

- **Scale keyword volume wisely**  
  - **Basic:** Niche or subtopics.  
  - **Moderate:** Standard SEO projects.  
  - **Advanced:** Large-scale campaigns.  

- **Use concurrency carefully**  
  Default = 10. Go higher for speed, but too high may hit limits.  

- **Match country & language**  
  Example: `us + en` for US, `mx + es` for Mexico.  

- **Look for patterns**  
  Spot themes, questions, and buyer intent to guide your strategy.  

- **Export & organize**  
  Download results (CSV/JSON), group by topic, and build content clusters.  


### Use Cases  

- **SEO keyword research and content planning**  
  Find thousands of keyword opportunities to build your content calendar, identify gaps in existing content, and discover new topics.  
  👉 [Beginner’s guide to keyword research (Moz)](https://moz.com/beginners-guide-to-seo/keyword-research)  

- **PPC campaign keyword discovery**  
  Build keyword lists for Google Ads with CPC insights to estimate costs and find high-value, low-competition opportunities.  
  👉 [Google Ads Keyword Planner tutorial](https://support.google.com/google-ads/answer/6325025)  

- **Competitor analysis and gap identification**  
  Compare your keyword coverage to competitors and uncover untapped niches.  
  👉 [SEO competitor analysis guide (Ahrefs Blog)](https://ahrefs.com/blog/seo-competitor-analysis/)  

- **Long-tail keyword mining**  
  Find specific, low-competition keywords that convert better and are easier to rank for.  
  👉 [What are long-tail keywords? (Semrush Blog)](https://www.semrush.com/blog/what-are-long-tail-keywords/)  

- **Market research and trend analysis**  
  Analyze keyword volumes and variations to spot demand, seasonal shifts, and emerging topics.  

- **E-commerce product research**  
  Discover product-related keywords to optimize product pages for visibility.  
  👉 [E-commerce SEO best practices (Shopify Blog)](https://www.shopify.com/blog/ecommerce-seo)  

- **Local SEO optimization**  
  Target location-specific keywords to attract customers in your area.  
  👉 [Local SEO basics (Search Engine Journal)](https://www.searchenginejournal.com/local-seo/)

# Actor input Schema

## `seedKeyword` (type: `string`):

The initial keyword to generate suggestions from.
## `country` (type: `string`):

Select the country for result localization (affects search engine regional variations and result prioritization).
## `language` (type: `string`):

Choose the primary language for search results.
## `scraperSettings` (type: `string`):

Should the autocomplete word appear before or after the seed keyword?
## `maxKeywords` (type: `string`):

Choose the keyword suggestion level.
## `scrapingType` (type: `string`):

Choose between Free or Pro mode.
## `maxRetries` (type: `integer`):

Number of retry attempts for failed requests (1-5).
## `concurrency` (type: `integer`):

Number of concurrent requests to make (1-50). Higher values may speed up scraping but increase load.

## Actor input object example

```json
{
  "seedKeyword": "best laptops",
  "country": "us",
  "language": "en",
  "scraperSettings": "after",
  "maxKeywords": "basic",
  "scrapingType": "free",
  "maxRetries": 3,
  "concurrency": 10
}
````

# 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 = {
    "seedKeyword": "best laptops"
};

// Run the Actor and wait for it to finish
const run = await client.actor("dxbear/google-keyword-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 = { "seedKeyword": "best laptops" }

# Run the Actor and wait for it to finish
run = client.actor("dxbear/google-keyword-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 '{
  "seedKeyword": "best laptops"
}' |
apify call dxbear/google-keyword-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Keyword  Scraper ( With SEO Metrics )",
        "description": "Discover keyword ideas instantly, scrapes Google autocomplete, expands with similar keywords, and adds SEO metrics.",
        "version": "1.0",
        "x-build-id": "gbch3DfsRC9zKJaam"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dxbear~google-keyword-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dxbear-google-keyword-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/dxbear~google-keyword-scraper/runs": {
            "post": {
                "operationId": "runs-sync-dxbear-google-keyword-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/dxbear~google-keyword-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-dxbear-google-keyword-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": [
                    "seedKeyword"
                ],
                "properties": {
                    "seedKeyword": {
                        "title": "Seed Keyword",
                        "minLength": 1,
                        "type": "string",
                        "description": "The initial keyword to generate suggestions from.",
                        "default": "best laptops"
                    },
                    "country": {
                        "title": "Target Country",
                        "enum": [
                            "us",
                            "in",
                            "fr",
                            "de",
                            "ae",
                            "ar",
                            "at",
                            "au",
                            "bd",
                            "be",
                            "bg",
                            "bo",
                            "br",
                            "ca",
                            "cl",
                            "co",
                            "cr",
                            "cy",
                            "cz",
                            "dk",
                            "do",
                            "dz",
                            "ec",
                            "ee",
                            "eg",
                            "es",
                            "et",
                            "fi",
                            "uk",
                            "ge",
                            "gr",
                            "gt",
                            "hk",
                            "hr",
                            "hu",
                            "id",
                            "ie",
                            "il",
                            "it",
                            "jo",
                            "jp",
                            "kw",
                            "lt",
                            "lv",
                            "ma",
                            "my",
                            "mx",
                            "nl",
                            "ng",
                            "no",
                            "nz",
                            "pa",
                            "pe",
                            "ph",
                            "pk",
                            "pl",
                            "pr",
                            "pt",
                            "ro",
                            "rs",
                            "ru",
                            "sa",
                            "se",
                            "sg",
                            "si",
                            "sk",
                            "th",
                            "tn",
                            "tr",
                            "ua",
                            "uy",
                            "ve",
                            "vn",
                            "za"
                        ],
                        "type": "string",
                        "description": "Select the country for result localization (affects search engine regional variations and result prioritization).",
                        "default": "us"
                    },
                    "language": {
                        "title": "Content Language",
                        "enum": [
                            "en",
                            "hi",
                            "fr",
                            "de",
                            "ar",
                            "bg",
                            "ca",
                            "cs",
                            "da",
                            "el",
                            "es",
                            "et",
                            "fi",
                            "hr",
                            "hu",
                            "id",
                            "is",
                            "it",
                            "ja",
                            "ko",
                            "lt",
                            "lv",
                            "ms",
                            "nl",
                            "no",
                            "pl",
                            "pt",
                            "ro",
                            "ru",
                            "sk",
                            "sl",
                            "sr",
                            "sv",
                            "th",
                            "tl",
                            "tr",
                            "uk",
                            "ur",
                            "vi"
                        ],
                        "type": "string",
                        "description": "Choose the primary language for search results.",
                        "default": "en"
                    },
                    "scraperSettings": {
                        "title": "autocompletePosition",
                        "enum": [
                            "before",
                            "after"
                        ],
                        "type": "string",
                        "description": "Should the autocomplete word appear before or after the seed keyword?",
                        "default": "after"
                    },
                    "maxKeywords": {
                        "title": "Max Keywords",
                        "enum": [
                            "basic",
                            "moderate",
                            "advanced"
                        ],
                        "type": "string",
                        "description": "Choose the keyword suggestion level.",
                        "default": "basic"
                    },
                    "scrapingType": {
                        "title": "Scraping Type",
                        "enum": [
                            "free",
                            "pro"
                        ],
                        "type": "string",
                        "description": "Choose between Free or Pro mode.",
                        "default": "free"
                    },
                    "maxRetries": {
                        "title": "Max Retries",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of retry attempts for failed requests (1-5).",
                        "default": 3
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Number of concurrent requests to make (1-50). Higher values may speed up scraping but increase load.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
