# Bing Search Results Scraper (`fetch_cat/bing-search-results-scraper`) Actor

🔎 Export ranked Bing organic search results for keywords or SERP URLs, including titles, URLs, snippets, sitelinks, and related searches.

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

## Pricing

from $0.02 / 1,000 result extracteds

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 Search Results Scraper

Export Bing organic search results for SEO research, lead generation, competitor monitoring, and market analysis.

### What does Bing Search Results Scraper do?

Bing Search Results Scraper turns public Bing search result pages into a structured dataset.

It accepts a list of search queries or direct Bing result URLs and returns organic results with rank, title, URL, display URL, snippet, sitelinks, related searches, and scrape timestamp. It does not access private Bing data, ads dashboards, signed-in results, or guaranteed personalized rankings.

Use it when you need repeatable Bing SERP exports without manually copying results from a browser. If your workflow needs Google SERP coverage instead of Bing coverage, use a Google-specific search actor so the source and ranking context stay explicit.

### Who is it for?

- 🔎 SEO teams tracking keyword positions on Bing.
- 📈 Growth marketers researching competitors and content gaps.
- 🧲 Lead generation teams collecting companies, directories, and niche prospects from search results.
- 📰 PR and brand monitoring teams checking what appears for names, products, or campaigns.
- 🧪 Data teams building search-result benchmarks for internal dashboards.

### Why use this Bing scraper?

Bing is still a meaningful discovery channel for many industries and regions.

This actor helps you collect search result data in a clean format that can be exported to CSV, JSON, Excel, Google Sheets, or your own database.

The first version focuses on reliable organic results and keeps the input simple.

### What data can you extract?

| Field | Description |
| --- | --- |
| `query` | Search query that produced the result |
| `position` | Organic rank for that query |
| `page` | Bing results page number |
| `title` | Result title |
| `url` | Result landing page URL |
| `displayUrl` | Visible URL shown on Bing |
| `snippet` | Search result description |
| `cachedUrl` | Cached result URL when available |
| `sitelinks` | Extra links shown below a result |
| `relatedSearches` | Related search suggestions found on the page |
| `scrapedAt` | ISO timestamp for the scrape |

### How much does it cost to scrape Bing search results?

This actor uses pay-per-event pricing.

You pay a $0.005 start fee for each run plus a per-result fee for each Bing organic result saved to the dataset.

Current BRONZE per-result price is $0.000026349 (about $0.026 per 1,000 results), with automatic lower per-result prices on higher Apify tiers.

The input prefill is intentionally small so a first test run stays cheap.

### Quick start

1. Open the actor on Apify.
2. Add one or more Bing search queries.
3. Set the maximum results per query.
4. Choose market, language, and SafeSearch settings if needed.
5. Run the actor.
6. Download the dataset or connect it to your workflow.

### Input: queries

Use `queries` when you want the actor to build Bing search URLs for you.

Example queries:

```json
[
  "apify web scraping",
  "best crm software for agencies",
  "site:example.com pricing"
]
````

Each query is scraped separately and ranks restart at position 1 for each query.

### Input: start URLs

Use `startUrls` when you already have Bing search URLs.

Example:

```json
[
  { "url": "https://www.bing.com/search?q=apify&count=10" }
]
```

The actor reads the query from the URL and continues pagination from the URL page.

### Input options

`maxResultsPerQuery` controls how many organic results to save for each query or start URL.

`market` requests a Bing market such as `en-US`, `en-GB`, `de-DE`, or `fr-FR`.

`language` requests a preferred result language such as `en`, `de`, `fr`, or `es`.

`safeSearch` can be `Off`, `Moderate`, or `Strict`.

`includeRelatedSearches` adds related search suggestions to result rows when Bing provides them.

### Output example

```json
{
  "query": "apify web scraping",
  "position": 1,
  "page": 1,
  "title": "Apify: Full-stack web scraping and data extraction platform",
  "url": "https://apify.com/",
  "displayUrl": "https://apify.com",
  "snippet": "Apify is a platform for web scraping, browser automation, and data extraction.",
  "cachedUrl": null,
  "sitelinks": [],
  "relatedSearches": ["apify pricing", "apify actors"],
  "scrapedAt": "2026-06-17T00:00:00.000Z"
}
```

### Tips for better results

- ✅ Keep early tests small, then scale once the output looks correct.
- ✅ Use exact phrases for brand monitoring.
- ✅ Add `site:` operators for domain-specific research.
- ✅ Use market and language settings for regional checks.
- ✅ Split very different keyword groups into separate runs for easier analysis.

### Pagination behavior

Bing normally shows around 10 organic results per page.

When you request more than 10 results per query, the actor requests additional result pages until it reaches your limit or Bing stops returning organic results.

Each row includes both `position` and `page` so you can filter by page or rank range.

### Integrations

You can connect the dataset to:

- Google Sheets for keyword research reviews.
- BigQuery or Snowflake for search monitoring dashboards.
- Slack alerts for brand or competitor checks.
- CRM enrichment flows for lead generation.
- Scheduled Apify tasks for recurring SERP snapshots.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/bing-search-results-scraper').call({
  queries: ['apify web scraping'],
  maxResultsPerQuery: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/bing-search-results-scraper').call(run_input={
    'queries': ['apify web scraping'],
    'maxResultsPerQuery': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~bing-search-results-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"queries":["apify web scraping"],"maxResultsPerQuery":10}'
```

### MCP: use from Claude tools

You can call this actor from Apify MCP-enabled clients.

Claude Code MCP URL pattern:

```text
https://mcp.apify.com/?tools=fetch_cat/bing-search-results-scraper
```

Add it in Claude Code with:

```bash
claude mcp add apify-bing-serp https://mcp.apify.com/?tools=fetch_cat/bing-search-results-scraper
```

Claude Desktop JSON configuration example:

```json
{
  "mcpServers": {
    "apify-bing-serp": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/bing-search-results-scraper"
    }
  }
}
```

Claude Desktop can use the same Apify MCP server URL with your Apify token.

Example prompts:

- "Scrape the top 20 Bing results for `best no-code database` and summarize the domains."
- "Run Bing Search Results Scraper for these 10 keywords and export titles and URLs."
- "Find related searches for my brand query on Bing."

### Scheduling

Create an Apify task with your keywords and run it daily, weekly, or monthly.

Recurring runs are useful for rank tracking, competitor monitoring, and campaign snapshots.

### Common SEO workflows

- Track whether your domain appears for target keywords.
- Compare page-one competitors across markets.
- Collect titles and snippets for content analysis.
- Monitor brand SERPs after launches or press releases.
- Export SERP data for internal dashboards.

### Common lead generation workflows

- Search for niche directories.
- Find companies using keyword modifiers.
- Collect URLs for later enrichment.
- Combine with website contact scrapers.
- Build prospect lists from regional searches.

### Limits and reliability

Search engines can change markup and may throttle repeated automated requests.

Start with moderate limits, use scheduling responsibly, and enable proxy settings if direct traffic is throttled.

The actor is designed to stop gracefully when Bing returns no more organic results.

### Troubleshooting

If you get fewer results than requested, Bing may have returned fewer organic results for that query or region.

If a run returns no results, try a simple query such as `apify web scraping`, lower the limit, or enable Apify Proxy in the input.

If regional results look unexpected, check the `market`, `language`, and SafeSearch values.

### Legality

This actor extracts publicly available search result information.

You are responsible for using the data lawfully, respecting applicable terms, privacy rules, and rate limits, and avoiding collection of sensitive personal data where it is not appropriate.

### FAQ

#### Can I scrape multiple keywords?

Yes. Add multiple strings to `queries`. The actor processes each query separately.

#### Can I scrape direct Bing URLs?

Yes. Add Bing search result URLs to `startUrls`.

#### Does it include ads?

Version 0.1 focuses on organic search results. Paid ads and rich answer modules may be added later.

#### Does it work with markets outside the United States?

Yes. Set `market` and `language` to request localized results.

#### Why are some fields empty?

Bing does not show every field for every result. For example, cached URLs and sitelinks are optional.

### Related Actors

Explore other Apify actors from the same publisher for search, SEO, and lead-generation workflows:

- https://apify.com/fetch\_cat/google-maps-lead-finder
- https://apify.com/fetch\_cat/trustpilot-scraper
- https://apify.com/fetch\_cat/google-news-scraper

### Changelog

#### 0.1

Initial version with keyword input, direct Bing URL input, pagination, organic result extraction, sitelinks, related searches, localization settings, and structured dataset output.

### Support

If the actor stops returning expected fields, open an issue with the run URL, input, and a short description of what looked wrong.

Small reproducible inputs help us diagnose markup changes quickly.

# Actor input Schema

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

Bing search keywords to scrape, one query per row.

## `startUrls` (type: `array`):

Optional direct Bing search result URLs. Use these when you already have a Bing SERP URL with query parameters.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of organic results to save for each query or start URL.

## `market` (type: `string`):

Bing market code, for example en-US, en-GB, de-DE, fr-FR, or es-ES.

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

Preferred result language code, for example en, de, fr, or es.

## `safeSearch` (type: `string`):

Bing SafeSearch level to request.

## `includeRelatedSearches` (type: `boolean`):

Add related search suggestions found on the result page to each result row.

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

Optional Apify Proxy settings. Leave disabled for the cheapest first run; enable Apify Proxy if Bing throttles direct traffic.

## Actor input object example

```json
{
  "queries": [
    "apify web scraping",
    "open source crawlee"
  ],
  "startUrls": [
    {
      "url": "https://www.bing.com/search?q=apify&count=10"
    }
  ],
  "maxResultsPerQuery": 10,
  "market": "en-US",
  "language": "en",
  "safeSearch": "Moderate",
  "includeRelatedSearches": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "apify web scraping",
        "open source crawlee"
    ],
    "startUrls": [
        {
            "url": "https://www.bing.com/search?q=apify&count=10"
        }
    ],
    "market": "en-US",
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/bing-search-results-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "queries": [
        "apify web scraping",
        "open source crawlee",
    ],
    "startUrls": [{ "url": "https://www.bing.com/search?q=apify&count=10" }],
    "market": "en-US",
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/bing-search-results-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "apify web scraping",
    "open source crawlee"
  ],
  "startUrls": [
    {
      "url": "https://www.bing.com/search?q=apify&count=10"
    }
  ],
  "market": "en-US",
  "language": "en"
}' |
apify call fetch_cat/bing-search-results-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bing Search Results Scraper",
        "description": "🔎 Export ranked Bing organic search results for keywords or SERP URLs, including titles, URLs, snippets, sitelinks, and related searches.",
        "version": "0.1",
        "x-build-id": "EiXLJe8rRId3iMfLy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~bing-search-results-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-bing-search-results-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fetch_cat~bing-search-results-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-bing-search-results-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fetch_cat~bing-search-results-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-bing-search-results-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "queries": {
                        "title": "Queries",
                        "type": "array",
                        "description": "Bing search keywords to scrape, one query per row.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Bing search URLs",
                        "type": "array",
                        "description": "Optional direct Bing search result URLs. Use these when you already have a Bing SERP URL with query parameters.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum results per query",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of organic results to save for each query or start URL.",
                        "default": 10
                    },
                    "market": {
                        "title": "Market",
                        "type": "string",
                        "description": "Bing market code, for example en-US, en-GB, de-DE, fr-FR, or es-ES.",
                        "default": "en-US"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Preferred result language code, for example en, de, fr, or es.",
                        "default": "en"
                    },
                    "safeSearch": {
                        "title": "SafeSearch",
                        "enum": [
                            "Off",
                            "Moderate",
                            "Strict"
                        ],
                        "type": "string",
                        "description": "Bing SafeSearch level to request.",
                        "default": "Moderate"
                    },
                    "includeRelatedSearches": {
                        "title": "Include related searches",
                        "type": "boolean",
                        "description": "Add related search suggestions found on the result page to each result row.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Leave disabled for the cheapest first run; enable Apify Proxy if Bing throttles direct traffic.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```