# Google Search Scraper — Organic Results & SERP Data Extractor (`maged120/google-search`) Actor

Scrape Google organic search results for any query. Returns titles, URLs, snippets, and result positions — no Google Search API key or quota needed.

- **URL**: https://apify.com/maged120/google-search.md
- **Developed by:** [Maged](https://apify.com/maged120) (community)
- **Categories:** SEO tools, Automation
- **Stats:** 14 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

### What does Google Search Scraper do?

**Google Search Scraper** extracts organic search results from Google for any keyword — titles, URLs, snippets, and result positions — without a Google Search API key or quota limits.

This Actor runs on the [Apify platform](https://apify.com). Use it for SEO research, SERP monitoring, competitor analysis, or building search-result datasets.

### Why use Google Search Scraper?

- **No Google API key** — bypass Google Custom Search API's 100 queries/day free limit
- **True organic results** — get the same results a real user sees
- **Batch searches** — run hundreds of queries in one Actor run
- **Full SERP data** — position, title, URL, snippet, and rich result indicators
- **SEO research** — track rankings, find featured snippets, analyze competitor visibility

### How to use Google Search Scraper

1. Open the Actor and click **Try for free**
2. Enter search queries in the `queries` field
3. Set number of results, language, and country
4. Click **Start** — SERP data appears in the Output tab
5. Download as JSON or CSV

### Input

```json
{
  "queries": ["best python web scraping library", "apify vs scrapy"],
  "maxResults": 10,
  "language": "en",
  "country": "us"
}
````

| Field | Type | Description | Default |
|---|---|---|---|
| `queries` | array | Search keywords | required |
| `maxResults` | integer | Results per query | `10` |
| `language` | string | Results language code | `en` |
| `country` | string | Country for localized results | `us` |

### Output

```json
{
  "query": "best python web scraping library",
  "position": 1,
  "title": "Scrapy vs. Beautiful Soup vs. Selenium: Which Is Best?",
  "url": "https://example.com/scrapy-vs-beautifulsoup",
  "snippet": "We compare the top Python scraping libraries to help you choose...",
  "domain": "example.com"
}
```

### Output fields

| Field | Type | Description |
|---|---|---|
| `query` | string | Search query |
| `position` | number | Ranking position (1 = first result) |
| `title` | string | Result title |
| `url` | string | Result URL |
| `snippet` | string | Result description snippet |
| `domain` | string | Root domain of the result |

### Cost

| Volume | Estimated cost |
|---|---|
| 100 queries × 10 results | ~$0.05–$0.50 |
| 1,000 queries | ~$0.50–$5.00 |

### FAQ

**Does this include ads?**
The Actor returns organic results only — paid ads are excluded.

**Is this Actor maintained?**
Yes. Report bugs or feature requests in the Issues tab.

**Need help or have questions?**
Open an issue in the Issues tab or reach out on Discord: **maged03211**

# Actor input Schema

## `query` (type: `string`):

The search query to look for

## `search_type` (type: `string`):

Type of search (e.g. 'web', 'images', 'news')

## `results_per_page` (type: `integer`):

Number of results per page

## `pages` (type: `integer`):

How many pages to crawl from search results

## `start_page` (type: `integer`):

Page number to start crawling from

## `unique_urls` (type: `boolean`):

Return only unique URLs

## `unique_domains` (type: `boolean`):

Return only unique domains

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

Restrict results to a specific language (e.g. 'en')

## `region` (type: `string`):

Restrict results to a specific region (e.g. 'US')

## `last_update` (type: `string`):

Restrict results to a certain update period (e.g. 'day', 'week', 'month', 'year')

## `site` (type: `string`):

Restrict results to a specific site

## `custom_url` (type: `string`):

overrides most of the other filters, this is for advanced users who know how to use google search params and filters from the url directly

## `all_words` (type: `string`):

All these words must appear in results

## `exact_phrase` (type: `string`):

Exact phrase to appear in results

## `any_words` (type: `string`):

Any of these words can appear in results

## `none_words` (type: `string`):

None of these words should appear in results

## `numbers_from` (type: `integer`):

Minimum number value to appear in results (normally used for price lookup)

## `numbers_to` (type: `integer`):

Maximum number value to appear in results (normally used for price lookup)

## `terms_appearing` (type: `string`):

Where terms should appear (e.g. 'any', 'title', 'url', 'body')

## `file_type` (type: `string`):

Restrict results to a specific file type (e.g. 'pdf')

## `safe_search` (type: `boolean`):

Enable safe search filtering

## `from_date` (type: `string`):

Restrict results from this date (YYYY-MM-DD)

## `to_date` (type: `string`):

Restrict results up to this date (YYYY-MM-DD)

## `custom_tbs` (type: `string`):

Custom Google TBS parameter this is also for advanced users who know what tbs param is

## `delay` (type: `string`):

Min and max delay between requests, e.g. 0.6,0.9

## `proxy_configuration` (type: `object`):

Configure the proxy settings for this Actor run. You can use Apify Proxy or your own custom proxies.

## Actor input object example

```json
{
  "query": "python scraping",
  "search_type": "web",
  "results_per_page": 10,
  "pages": 1,
  "start_page": 1,
  "unique_urls": false,
  "unique_domains": false,
  "safe_search": true,
  "delay": "0.6,0.9",
  "proxy_configuration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "query": "python scraping",
    "delay": "0.6,0.9"
};

// Run the Actor and wait for it to finish
const run = await client.actor("maged120/google-search").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 = {
    "query": "python scraping",
    "delay": "0.6,0.9",
}

# Run the Actor and wait for it to finish
run = client.actor("maged120/google-search").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 '{
  "query": "python scraping",
  "delay": "0.6,0.9"
}' |
apify call maged120/google-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Search Scraper — Organic Results & SERP Data Extractor",
        "description": "Scrape Google organic search results for any query. Returns titles, URLs, snippets, and result positions — no Google Search API key or quota needed.",
        "version": "0.0",
        "x-build-id": "w1fJETWM6Wv6Nz5mC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maged120~google-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maged120-google-search",
                "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/maged120~google-search/runs": {
            "post": {
                "operationId": "runs-sync-maged120-google-search",
                "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/maged120~google-search/run-sync": {
            "post": {
                "operationId": "run-sync-maged120-google-search",
                "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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "The search query to look for"
                    },
                    "search_type": {
                        "title": "Search Type",
                        "enum": [
                            "web",
                            "images",
                            "news",
                            "videos",
                            "books"
                        ],
                        "type": "string",
                        "description": "Type of search (e.g. 'web', 'images', 'news')",
                        "default": "web"
                    },
                    "results_per_page": {
                        "title": "Results Per Page",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of results per page",
                        "default": 10
                    },
                    "pages": {
                        "title": "Maximum Pages",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many pages to crawl from search results",
                        "default": 1
                    },
                    "start_page": {
                        "title": "Start Page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Page number to start crawling from",
                        "default": 1
                    },
                    "unique_urls": {
                        "title": "Unique URLs Only",
                        "type": "boolean",
                        "description": "Return only unique URLs",
                        "default": false
                    },
                    "unique_domains": {
                        "title": "Unique Domains Only",
                        "type": "boolean",
                        "description": "Return only unique domains",
                        "default": false
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "arabic",
                            "chinese_simplified",
                            "chinese_traditional",
                            "czech",
                            "danish",
                            "dutch",
                            "english",
                            "estonian",
                            "finnish",
                            "french",
                            "german",
                            "greek",
                            "hebrew",
                            "hindi",
                            "hungarian",
                            "icelandic",
                            "indonesian",
                            "italian",
                            "japanese",
                            "korean",
                            "latvian",
                            "lithuanian",
                            "norwegian",
                            "persian",
                            "polish",
                            "portuguese",
                            "romanian",
                            "russian",
                            "spanish",
                            "swedish",
                            "thai",
                            "turkish",
                            "ukrainian",
                            "vietnamese"
                        ],
                        "type": "string",
                        "description": "Restrict results to a specific language (e.g. 'en')"
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "afghanistan",
                            "albania",
                            "algeria",
                            "andorra",
                            "argentina",
                            "australia",
                            "austria",
                            "belgium",
                            "brazil",
                            "canada",
                            "chile",
                            "china",
                            "colombia",
                            "czech_republic",
                            "denmark",
                            "egypt",
                            "finland",
                            "france",
                            "germany",
                            "greece",
                            "hong_kong",
                            "india",
                            "indonesia",
                            "ireland",
                            "israel",
                            "italy",
                            "japan",
                            "kenya",
                            "malaysia",
                            "mexico",
                            "netherlands",
                            "new_zealand",
                            "nigeria",
                            "norway",
                            "pakistan",
                            "philippines",
                            "poland",
                            "portugal",
                            "romania",
                            "russia",
                            "saudi_arabia",
                            "singapore",
                            "south_africa",
                            "south_korea",
                            "spain",
                            "sweden",
                            "switzerland",
                            "taiwan",
                            "thailand",
                            "turkey",
                            "ukraine",
                            "united_kingdom",
                            "united_states",
                            "vietnam"
                        ],
                        "type": "string",
                        "description": "Restrict results to a specific region (e.g. 'US')"
                    },
                    "last_update": {
                        "title": "Last Update",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year"
                        ],
                        "type": "string",
                        "description": "Restrict results to a certain update period (e.g. 'day', 'week', 'month', 'year')"
                    },
                    "site": {
                        "title": "Site",
                        "type": "string",
                        "description": "Restrict results to a specific site"
                    },
                    "custom_url": {
                        "title": "Custom URL",
                        "pattern": "^(http|https):\\/\\/[\\w\\-\\.]+([:\\d]+)?([\\w\\-\\._~:\\/?#\\[\\]@!$&'()*+,;=])*$",
                        "type": "string",
                        "description": "overrides most of the other filters, this is for advanced users who know how to use google search params and filters from the url directly"
                    },
                    "all_words": {
                        "title": "All Words",
                        "type": "string",
                        "description": "All these words must appear in results"
                    },
                    "exact_phrase": {
                        "title": "Exact Phrase",
                        "type": "string",
                        "description": "Exact phrase to appear in results"
                    },
                    "any_words": {
                        "title": "Any Words",
                        "type": "string",
                        "description": "Any of these words can appear in results"
                    },
                    "none_words": {
                        "title": "None Words",
                        "type": "string",
                        "description": "None of these words should appear in results"
                    },
                    "numbers_from": {
                        "title": "Numbers From",
                        "type": "integer",
                        "description": "Minimum number value to appear in results (normally used for price lookup)"
                    },
                    "numbers_to": {
                        "title": "Numbers To",
                        "type": "integer",
                        "description": "Maximum number value to appear in results (normally used for price lookup)"
                    },
                    "terms_appearing": {
                        "title": "Terms Appearing",
                        "enum": [
                            "anywhere",
                            "title",
                            "url",
                            "body",
                            "links"
                        ],
                        "type": "string",
                        "description": "Where terms should appear (e.g. 'any', 'title', 'url', 'body')"
                    },
                    "file_type": {
                        "title": "File Type",
                        "enum": [
                            "pdf",
                            "doc",
                            "docx",
                            "xls",
                            "xlsx",
                            "ppt",
                            "pptx",
                            "txt",
                            "rtf",
                            "ps",
                            "swf",
                            "kml",
                            "kmz"
                        ],
                        "type": "string",
                        "description": "Restrict results to a specific file type (e.g. 'pdf')"
                    },
                    "safe_search": {
                        "title": "Safe Search",
                        "type": "boolean",
                        "description": "Enable safe search filtering",
                        "default": true
                    },
                    "from_date": {
                        "title": "From Date",
                        "type": "string",
                        "description": "Restrict results from this date (YYYY-MM-DD)"
                    },
                    "to_date": {
                        "title": "To Date",
                        "type": "string",
                        "description": "Restrict results up to this date (YYYY-MM-DD)"
                    },
                    "custom_tbs": {
                        "title": "Custom TBS",
                        "type": "string",
                        "description": "Custom Google TBS parameter this is also for advanced users who know what tbs param is"
                    },
                    "delay": {
                        "title": "Delay Between Requests (seconds)",
                        "pattern": "^\\d+(\\.\\d+)?,\\d+(\\.\\d+)?$",
                        "type": "string",
                        "description": "Min and max delay between requests, e.g. 0.6,0.9",
                        "default": "0.6,0.9"
                    },
                    "proxy_configuration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Configure the proxy settings for this Actor run. You can use Apify Proxy or your own custom proxies.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
