# Bing Autocomplete Actor (`solid-scraper/bing-autocomplete-actor`) Actor

🤖 Bing Autocomplete Actor predicts real-time search suggestions, speeding up keyword research and content planning. Perfect for SEO teams and marketers targeting high-intent queries—faster insights, better rankings, smoother workflows. 🚀

- **URL**: https://apify.com/solid-scraper/bing-autocomplete-actor.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** SEO tools, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Autocomplete Scraper 🔍

**Bing Autocomplete Scraper** is an Apify actor that scrapes Bing autocomplete suggestions for a given query. If you’re doing keyword research, building content ideas, or need autocomplete data for analysis, this **bing autocomplete scraper** helps you collect suggestion sets quickly—so you can stop manually copying suggestions and start working at scale.

Whether you’re a marketer, data analyst, or SEO researcher, this **bing search autocomplete scraper** streamlines the process of pulling **bing autocomplete data** and turning it into structured records you can analyze immediately.

---

### Why choose Bing Autocomplete Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ **All-in-one autocomplete collection** | Pulls the autocomplete suggestions for your main query and optional variations in one run |
| ✅ **Reliable proxy configuration** | Supports proxy configuration for more consistent scraping runs |
| ✅ **Resilient request handling** | Returns empty suggestions for failed requests instead of stopping the whole job |
| ✅ **Structured output for easy analysis** | Saves results as JSON records with labeled suggestion fields |
| ✅ **Scales with bulk variations** | Can generate additional query variants using alphabetic prefixes and/or suffixes |
| ✅ **Apify Console friendly** | Designed to run easily via Apify Console with a simple input form |

---

### Key features

- 🌟 **Autocomplete suggestions collection**: Fetches suggestion lists for your provided query using Bing’s autocomplete endpoint  
- 🧩 **Query variation support (prefixes/suffixes)**: Optionally adds alphabetic prefixes and/or suffixes to broaden the suggestions you collect (bing autocomplete keyword extractor style workflows)  
- 🛡️ **Proxy configuration support**: Lets you provide `proxyConfiguration` to improve reliability for bulk scraping scenarios  
- 🔄 **Non-blocking failures**: If a request fails for a particular variant, that variant returns suggestions as an empty list while the run can continue  
- 📊 **Consistent, structured dataset output**: Each record contains a `query` and multiple `suggestion_XX` fields for straightforward downstream processing  
- 💾 **Dataset-ready results**: Pushes all collected suggestion records to Apify’s default dataset in JSON format  
- 🤖 **Automation-ready**: Works well as a building block for a **bing autocomplete bulk scraper** workflow in your pipelines  
- 🔍 **Keyword-first extraction**: Great for tasks like extracting related autocomplete queries and building **bing suggestions scraper** datasets

---

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "query": "apple watch",
  "use_prefix": false,
  "use_suffix": false,
  "proxyConfiguration": {}
}
````

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `query` | ✅ Yes | The search term to get suggestions for. |
| `use_prefix` | ❌ No | Whether to add alphabetic prefixes to the query (helps you expand beyond a single autocomplete keyword set). |
| `use_suffix` | ❌ No | Whether to add alphabetic suffixes to the query (useful for more breadth in a bing autocomplete data scraper workflow). |
| `proxyConfiguration` | ❌ No | Configure proxies for this Actor. This object is passed in as `proxyConfiguration` (supports proxy-based runs for higher reliability). |

**Note:** `query` is the only required field. If `use_prefix` and `use_suffix` are both `false`, the actor will only fetch suggestions for the single input query.

***

### Output

The actor saves collected results to the default dataset as JSON. Each dataset record contains the original query and multiple suggestion fields.

Example output (shape may vary depending on the number of suggestions returned):

```json
[
  {
    "query": "apple watch",
    "suggestion_01": "apple watch series 9",
    "suggestion_02": "apple watch bands",
    "suggestion_03": "apple watch deals"
  }
]
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `query` | string | The query string for which suggestions were fetched |
| `suggestion_01` | string | The first autocomplete suggestion returned for the query |
| `suggestion_02` | string | The second autocomplete suggestion returned for the query |
| `suggestion_03` | string | The third autocomplete suggestion returned for the query |
| `suggestion_04` | string | The fourth autocomplete suggestion returned for the query |
| `suggestion_05` | string | The fifth autocomplete suggestion returned for the query |
| `suggestion_06` | string | The sixth autocomplete suggestion returned for the query |
| `suggestion_07` | string | The seventh autocomplete suggestion returned for the query |
| `suggestion_08` | string | The eighth autocomplete suggestion returned for the query |
| `suggestion_09` | string | The ninth autocomplete suggestion returned for the query |
| `suggestion_10` | string | The tenth autocomplete suggestion returned for the query |
| `suggestion_11` | string | Additional suggestion fields continue when more suggestions are returned |
| `suggestion_12` | string | Additional suggestion fields continue when more suggestions are returned |
| `suggestion_13` | string | Additional suggestion fields continue when more suggestions are returned |
| `suggestion_14` | string | Additional suggestion fields continue when more suggestions are returned |
| `suggestion_15` | string | Additional suggestion fields continue when more suggestions are returned |

**Important:** The actor dynamically labels suggestions as `suggestion_01`, `suggestion_02`, etc. (it adds `{f"suggestion_{i:02}": sug}` for each suggestion index it receives). There is no explicit error field included in the pushed records.

You can export your dataset from Apify Console in common formats like JSON/CSV depending on your workflow.

***

### How to use Bing Autocomplete Scraper (via Apify Console)

1. **Open Apify Console**\
   Go to [console.apify.com](https://console.apify.com) and log in.

2. **Find the actor**\
   Search for **Bing Autocomplete Scraper** and open its actor page.

3. **Open the INPUT section**\
   Use the built-in input form (or switch to an `input.json` file if your workflow prefers that).

4. **Set your `query`**\
   Enter the search term you want autocomplete suggestions for (for example, a product or topic you’re researching).

5. **Choose whether to enable variations**\
   If you want more than the original query’s suggestions, enable `use_prefix` and/or `use_suffix` to expand the autocomplete keyword sets.

6. **Configure proxies (optional)**\
   If you need proxy support for your run, provide a `proxyConfiguration` object in the input.

7. **Click Run**\
   Start the actor. You’ll see logs as it fetches suggestions for the main query and any prefix/suffix variants.

8. **Open Output / Dataset**\
   After the run finishes, open the default dataset to view and export the JSON records (useful for building a **bing autosuggest dataset scraper** style output for analysis).

No coding required—get autocomplete results in minutes with this **bing autocomplete scraper**.

***

### Advanced features & SEO optimization

- 🔧 **Engineered for bing autocomplete keyword extraction**: Works directly with autocomplete suggestion sets, making it convenient for tasks like extracting autocomplete queries for keyword research and content planning.
- 📈 **Built for breadth using prefixes and suffixes**: Use `use_prefix` and `use_suffix` to expand your coverage beyond a single prompt—great for a **bing autocomplete keyword scraper** approach.
- 🌐 **Reliable scraping in production runs**: Includes proxy configuration support and resilience so runs can continue even when individual requests fail.
- 💾 **Structured output for analysis**: Each suggestion list is saved as labeled `suggestion_XX` fields, making it easy to transform into tables for SEO reporting and analytics.

***

### Best use cases

- 📊 **SEO researchers building autocomplete datasets**: Collect autocomplete suggestions for multiple variants and feed them into clustering or topic modeling workflows.
- 🧠 **Content strategists generating article ideas**: Use autocomplete expansions to discover related query phrasing and content angles faster.
- 🛒 **Ecommerce marketers validating product demand**: Pull suggestion sets for product-related queries to guide merchandising and campaign planning.
- 🧾 **Data analysts creating keyword intelligence tables**: Convert labeled `suggestion_XX` fields into structured datasets for reporting dashboards.
- 💡 **Growth teams running experiments**: Test how different query phrasings (prefix/suffix variants) map to suggestion trends over time.
- 🧩 **Developer workflows integrating autocomplete into pipelines**: Use this **bing autocomplete API alternative** as a data source feeding downstream enrichment and storage.
- 🔍 **Research teams studying suggestion patterns**: Build **bing suggest scraper** outputs to analyze how autocomplete evolves across related query forms.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `query` (string): required search term
  - ✅ `use_prefix` (boolean): expands queries with alphabetic prefixes
  - ✅ `use_suffix` (boolean): expands queries with alphabetic suffixes
  - ✅ `proxyConfiguration` (object): optional proxy configuration input

- **Proxy Support**
  - ✅ Configurable proxy support via `proxyConfiguration`

- **Retry Mechanism**
  - ❗ Not explicitly defined in the provided source code details (failures for a given request return an empty list while the run continues)

- **Dataset Structure**
  - ✅ Default dataset
  - ✅ One record per fetched query variant
  - ✅ Fields include `query` plus dynamic `suggestion_01`…`suggestion_XX`

- **Rate Limits & Performance**
  - ❗ No explicit limits are defined in the provided source code; performance will depend on request latency and response time.

- **Limitations**
  - ❌ No dedicated error field is pushed to the dataset records; failed requests result in an empty suggestions list for that query variant.

***

### FAQ

#### What does Bing Autocomplete Scraper return?

✅ It saves results to the default dataset as JSON records. Each record includes the `query` and multiple `suggestion_XX` fields for the autocomplete suggestions returned for that query.

#### Do I need to write code to run it?

✅ No. You can run it directly in Apify Console by setting the `query` (and optionally `use_prefix`, `use_suffix`, and `proxyConfiguration`).

#### Can I scrape more than one query at a time?

✅ Yes. If you enable `use_prefix` and/or `use_suffix`, the actor will generate additional query variants and fetch suggestions for each variant in the same run.

#### How do I configure proxies?

✅ You can provide a `proxyConfiguration` object in the input. The actor uses that proxy configuration when fetching autocomplete suggestions.

#### What if a request fails for one query variant?

✅ The actor handles request failures by returning an empty list for that particular query variant’s suggestions, while the job can still complete for other variants.

#### Is there an API endpoint I can call?

✅ This actor is run via Apify. If you’re looking to integrate into a pipeline, you typically run the actor programmatically through Apify’s APIs/SDKs (while the actor itself is designed for Apify Console and dataset output workflows).

#### What data type is saved in the dataset?

✅ The actor pushes JSON records to the default dataset using `Actor.push_data(all_suggestions)`.

#### Is it suitable for keyword research and a bing suggestions scraper workflow?

✅ Yes. It’s designed specifically to scrape autocomplete suggestions, making it useful for tasks like extracting related autocomplete queries and building suggestion datasets.

***

### Support & feature requests

If you’re using **Bing Autocomplete Scraper** for a **bing autocomplete bulk scraper** workflow and want improvements, let us know what would make your results better.

- 💡 **Feature Requests**: For example, CSV export, richer metadata fields, or additional filtering options for autocomplete variants.
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for this **bing autocomplete data scraper**.

***

### Closing CTA / Final thoughts

*If you need a reliable way to build a structured **Bing Autocomplete Scraper** dataset, this actor is a fast, SEO-optimized starting point.*

*Run it in Apify Console and use the output immediately for keyword research, content planning, and analysis.*

***

### Disclaimer

**This tool only accesses publicly accessible sources** to scrape autocomplete suggestions. It does not access private profiles, authenticated data, or password-protected pages.

You are responsible for ensuring your use complies with applicable laws (including GDPR and CCPA where relevant), platform policies, and any applicable regulations regarding data usage and automated scraping.

For data removal requests, contact <dataforleads@gmail.com>. Please use this tool responsibly, ethically, and only for legitimate purposes.

# Actor input Schema

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

The search term to get suggestions for.

## `use_prefix` (type: `boolean`):

Whether to add alphabetic prefixes to the query.

## `use_suffix` (type: `boolean`):

Whether to add alphabetic suffixes to the query.

## `proxyConfiguration` (type: `object`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "query": "apple watch",
  "use_prefix": false,
  "use_suffix": false
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/bing-autocomplete-actor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/bing-autocomplete-actor").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 '{}' |
apify call solid-scraper/bing-autocomplete-actor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bing Autocomplete Actor",
        "description": "🤖 Bing Autocomplete Actor predicts real-time search suggestions, speeding up keyword research and content planning. Perfect for SEO teams and marketers targeting high-intent queries—faster insights, better rankings, smoother workflows. 🚀",
        "version": "1.0",
        "x-build-id": "I0mBtbU5FfKlhB9zq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~bing-autocomplete-actor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-bing-autocomplete-actor",
                "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/solid-scraper~bing-autocomplete-actor/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-bing-autocomplete-actor",
                "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/solid-scraper~bing-autocomplete-actor/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-bing-autocomplete-actor",
                "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": "Query",
                        "type": "string",
                        "description": "The search term to get suggestions for.",
                        "default": "apple watch"
                    },
                    "use_prefix": {
                        "title": "Use Prefix",
                        "type": "boolean",
                        "description": "Whether to add alphabetic prefixes to the query.",
                        "default": false
                    },
                    "use_suffix": {
                        "title": "Use Suffix",
                        "type": "boolean",
                        "description": "Whether to add alphabetic suffixes to the query.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
