# Bing Search Scraper (Cheap) (`data_api/bing-search-scraper-cheap`) Actor

Bing Search Scraper pulls organic results, ads, and related searches from Bing for any keyword. Good for rank tracking, SERP research, and watching what shows up for your competitors.

- **URL**: https://apify.com/data\_api/bing-search-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** SEO tools, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 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

## Bing SERP Results Scraper

![Bing SERP Results Scraper](cover.jpg)

Checking Bing rankings by hand means typing a keyword, scrolling the page, copying titles and links one at a time, then doing it again for the next term and the next market. Bing also wraps every result link in a redirect, so the URL you copy is not the URL that actually loads. This scraper takes a list of keywords and hands back the full results page as clean rows: rank slot, headline, the real destination link, the snippet, paid placements, the answer box, and the related keywords Bing suggests at the bottom. Run one keyword or a few hundred, and export to JSON, CSV, or Excel.

One thing to set straight: this reads Bing, not Google. If you track both engines you will want a separate tool for Google.

### What you get

Every result becomes one row with the same shape, so the columns stay steady when you load the data into a sheet or a database. Fields that Bing does not show for a given result come back as `null` rather than dropping out. Each row carries:

- **The result itself** — `resultTitle`, `resultUrl` (decoded from Bing's redirect), `shownUrl`, `descriptionText`, and `rankPosition`
- **Result flags** — `listingType` (organic or ad), `sponsored`, plus `answerBox` and `answerBoxText` when Bing shows an answer box
- **Page context** — `relatedTerms`, `resultCountEstimate`, the `regionCode`, `languageCode`, and `contentFilter` used for the run, the originating `searchTerm`, and a `collectedAt` timestamp

### Quick start

1. Click **Try for free** and open the input form.
2. Type one or more keywords into **Keywords to look up**.
3. Set **Results to grab per keyword** and pick a **Region market** (for example en-GB or de-DE).
4. Press **Start**, then export the rows as JSON, CSV, Excel, or XML once the run wraps up.

![How it works](how-it-works.jpg)

### Use cases

- **Bing rank tracking** — watch where your pages sit on Bing, an engine with real desktop and enterprise share in the US, Germany, and Japan
- **Competitor SERP monitoring** — pull the top 20 for your target keywords each week and see who moves in and out of the front page
- **Keyword discovery** — collect the related keywords Bing surfaces for a batch of seed terms and grow your keyword clusters
- **Multi-market checks** — run the same keywords across regions to compare how Bing's index shifts by country
- **Content gap review** — gather the snippets ranking for a keyword and find angles the top pages cover that yours skips
- **Ad intelligence** — paid placements come through tagged with `sponsored: true`, so you can see who is bidding on your keywords

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchTerms` | array of strings | Yes | Keywords to look up. Each one runs as its own query and is kept separate. |
| `resultsPerTerm` | integer | No | How many hits to return per keyword, up to 50. The scraper paginates on its own. Default `20`. |
| `regionCode` | string | No | Bing market code that selects the regional index, such as en-US or de-DE. Default `en-US`. |
| `contentFilter` | string | No | Explicit-content filter: Off, Moderate, or Strict. Default `Moderate`. |
| `dateRange` | string | No | Recency window: blank (any time), Day, Week, or Month. Default any time. |
| `interfaceLanguage` | string | No | Two-letter language code Bing renders the page in. Default `en`. |
| `resultsLimit` | integer | No | Cap on total rows across all keywords. Default `200`. |
| `timeoutSeconds` | integer | No | Seconds to wait per request before giving up. Default `45`. |

#### Example input

```json
{
  "searchTerms": ["best noise cancelling headphones", "coffee shops in Berlin"],
  "resultsPerTerm": 20,
  "regionCode": "en-GB",
  "contentFilter": "Moderate",
  "dateRange": "",
  "interfaceLanguage": "en",
  "resultsLimit": 200,
  "timeoutSeconds": 45
}
````

### Output

Each result is saved as one row, and every field is always present — values Bing does not supply come back as `null` so the dataset stays rectangular.

#### Example output

```json
{
  "searchTerm": "best noise cancelling headphones",
  "rankPosition": 1,
  "listingType": "organic",
  "resultTitle": "The Best Noise-Cancelling Headphones - Reviewed",
  "resultUrl": "https://www.reviewed.com/headphones/best-right-now/noise-cancelling",
  "shownUrl": "https://www.reviewed.com › headphones › best-right-now",
  "descriptionText": "We tested dozens of models across price tiers. Here are the noise-cancelling headphones we recommend for travel, the office, and home.",
  "sponsored": false,
  "answerBox": false,
  "answerBoxText": null,
  "relatedTerms": [
    "best noise cancelling headphones under 200",
    "best wireless noise cancelling headphones",
    "sony vs bose noise cancelling",
    "best noise cancelling earbuds"
  ],
  "resultCountEstimate": "About 12,400,000 results",
  "regionCode": "en-GB",
  "languageCode": "en",
  "contentFilter": "Moderate",
  "collectedAt": "2026-06-29T12:00:00.000000+00:00",
  "errorMessage": null
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `searchTerm` | string | The keyword that produced this row |
| `rankPosition` | integer | Rank slot, 1 being the top result. Null for ads |
| `listingType` | string | `organic` or `ad` |
| `resultTitle` | string | The result's headline |
| `resultUrl` | string | Real destination link, decoded from Bing's redirect |
| `shownUrl` | string | The short link Bing shows under the headline |
| `descriptionText` | string | Description text shown beneath the title |
| `sponsored` | boolean | `true` when the row is a paid placement |
| `answerBox` | boolean | `true` when the text comes from Bing's answer box |
| `answerBoxText` | string | Answer box copy, or `null` when there is none |
| `relatedTerms` | array | Suggested keywords pulled from the page |
| `resultCountEstimate` | string | Bing's rough count of total matches for the keyword |
| `regionCode` | string | Market code used for the query |
| `languageCode` | string | Language code used for the query |
| `contentFilter` | string | Content filter level applied |
| `collectedAt` | string | ISO 8601 timestamp of when the row was captured |
| `errorMessage` | string | Reason a keyword failed; `null` on success |

### Tips for best results

- **Start with a couple of keywords.** Confirm the markets and snippets look right on a small run before you push hundreds of terms through.
- **Cap test runs with `resultsLimit`.** Keep it low while you confirm the output fits your pipeline, then raise it for the full batch.
- **Raise `timeoutSeconds` for big batches.** A higher value around 60 helps when a slow page would otherwise time out mid-run.
- **Answer boxes are not guaranteed.** They show up for definitions, how-to questions, and fact lookups, so `answerBoxText` is `null` for most commercial or navigational keywords.
- **Treat results as a snapshot.** Run the same keyword an hour later and the set can shift, since Bing tunes results by region and session.
- **`dateRange` filters the whole page.** A few older results may still appear under a Day or Week window when Bing rates them highly relevant.

### How can I use Bing search data?

**How can I use the Bing SERP Results Scraper to track my keyword rankings?**
Feed it the keywords you care about and set `regionCode` to your target market. Each run returns the ranked results with `rankPosition`, `resultTitle`, and the real `resultUrl`, so you can log where your pages land over time and watch the snippets competitors are using.

**How can I scrape Bing search results without copying links by hand?**
Paste a list into `searchTerms` and start the run. The scraper walks the pages, decodes every redirect into the true destination link, and writes one clean row per result — no manual copying, and no broken redirect URLs in your export.

**How can I pull related keywords from Bing for keyword research?**
Run a batch of seed keywords and read the `relatedTerms` field on each row. Those are the suggestions Bing itself surfaces at the foot of the page, which makes them a solid starting point for expanding keyword clusters and finding terms real searchers use.

**How can I compare Bing results across different countries?**
Run the same `searchTerms` with different `regionCode` values, such as en-US, en-GB, and de-DE. Comparing the rows side by side shows how Bing's index and rankings shift by market, which is handy for international SEO and localization work.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `searchTerms` (type: `array`):

The search phrases you want pulled from Bing. Every phrase runs as its own query and the results are kept apart.

## `resultsPerTerm` (type: `integer`):

How many hits to bring back for each keyword. Bing shows roughly 10 per page, and the scraper walks through the pages on its own to reach your number.

## `regionCode` (type: `string`):

Bing market code that picks the regional index to query. Try en-US, en-GB, de-DE, fr-FR, or ja-JP.

## `contentFilter` (type: `string`):

Controls how aggressively explicit material is filtered out of the results.

## `dateRange` (type: `string`):

Keep only results from a chosen time window. Leave it blank to pull from any date.

## `interfaceLanguage` (type: `string`):

Two-letter code for the language Bing renders the page in. For example en, de, fr, es, or ja.

## `resultsLimit` (type: `integer`):

Upper bound on how many rows land in the dataset once every keyword has been counted.

## `timeoutSeconds` (type: `integer`):

How long to wait on a single request before giving up on it.

## Actor input object example

```json
{
  "searchTerms": [
    "best noise cancelling headphones",
    "coffee shops in Berlin"
  ],
  "resultsPerTerm": 10,
  "regionCode": "en-GB",
  "contentFilter": "Moderate",
  "dateRange": "",
  "interfaceLanguage": "de",
  "resultsLimit": 200,
  "timeoutSeconds": 45
}
```

# 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 = {
    "searchTerms": [
        "best noise cancelling headphones"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/bing-search-scraper-cheap").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 = { "searchTerms": ["best noise cancelling headphones"] }

# Run the Actor and wait for it to finish
run = client.actor("data_api/bing-search-scraper-cheap").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 '{
  "searchTerms": [
    "best noise cancelling headphones"
  ]
}' |
apify call data_api/bing-search-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bing Search Scraper (Cheap)",
        "description": "Bing Search Scraper pulls organic results, ads, and related searches from Bing for any keyword. Good for rank tracking, SERP research, and watching what shows up for your competitors.",
        "version": "0.0",
        "x-build-id": "FDkRvmjyMU7LNCmu6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~bing-search-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-bing-search-scraper-cheap",
                "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/data_api~bing-search-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-bing-search-scraper-cheap",
                "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/data_api~bing-search-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-bing-search-scraper-cheap",
                "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": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Keywords to look up",
                        "type": "array",
                        "description": "The search phrases you want pulled from Bing. Every phrase runs as its own query and the results are kept apart.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsPerTerm": {
                        "title": "Results to grab per keyword",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many hits to bring back for each keyword. Bing shows roughly 10 per page, and the scraper walks through the pages on its own to reach your number.",
                        "default": 10
                    },
                    "regionCode": {
                        "title": "Region market",
                        "type": "string",
                        "description": "Bing market code that picks the regional index to query. Try en-US, en-GB, de-DE, fr-FR, or ja-JP.",
                        "default": "en-US"
                    },
                    "contentFilter": {
                        "title": "Content filter level",
                        "enum": [
                            "Off",
                            "Moderate",
                            "Strict"
                        ],
                        "type": "string",
                        "description": "Controls how aggressively explicit material is filtered out of the results.",
                        "default": "Moderate"
                    },
                    "dateRange": {
                        "title": "Recency window",
                        "enum": [
                            "",
                            "Day",
                            "Week",
                            "Month"
                        ],
                        "type": "string",
                        "description": "Keep only results from a chosen time window. Leave it blank to pull from any date.",
                        "default": ""
                    },
                    "interfaceLanguage": {
                        "title": "Interface language",
                        "type": "string",
                        "description": "Two-letter code for the language Bing renders the page in. For example en, de, fr, es, or ja.",
                        "default": "en"
                    },
                    "resultsLimit": {
                        "title": "Total results cap",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Upper bound on how many rows land in the dataset once every keyword has been counted.",
                        "default": 200
                    },
                    "timeoutSeconds": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait on a single request before giving up on it.",
                        "default": 45
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
