# Bing Search Scraper – SERP Results (`datascraperes/bing-search-scraper`) Actor

Scrape Bing organic search results for any keyword. Get rank, URLs, domains, snippets, dates, sitelinks and SERP features across 50 countries with pagination.

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

## Pricing

$0.60 / 1,000 organic results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Scraper

[Run the Actor on Apify](https://apify.com/datascraperes/bing-search-scraper)

Get structured **Bing organic web-search results** for one or many keywords. The Actor returns each result as a separate dataset row with its rank, title, destination URL, domain, snippet, date (when Bing shows one), sitelinks, rich facts and optional SERP features.

It is intended for Bing web search research: it does not scrape Bing Images, News, Maps, Copilot chats or logged-in/private content.

### Who is it for?

- **SEO teams** tracking Bing rankings by keyword and country.
- **Competitor researchers** comparing domains and result-page visibility.
- **Content and topic researchers** discovering related searches, questions and answer cards.
- **Analysts and developers** building reproducible SERP datasets for reporting or downstream workflows.
- **Lead-research teams** finding public websites that match targeted commercial searches.

### What the Actor does

- Runs from **1 to 1,000 unique search queries** in one run.
- Localizes results to one of **50 countries**. You select a country code; the Actor selects the matching Bing market automatically.
- Retrieves **1–20 Bing pages** per query, subject to a maximum of **50 unique organic results** per query.
- Decodes Bing redirect links where possible, so `url` contains the destination instead of a Bing tracking link.
- Removes duplicate organic URLs between pages.
- Optionally extracts query-level SERP modules: result-count text, related searches, People Also Ask links, answer cards, knowledge-panel summary and ads.
- Writes progress incrementally and a `SUMMARY` record at the end of the run.

### Quick start

1. Open [Bing Search Scraper on Apify](https://apify.com/datascraperes/bing-search-scraper).
2. Enter one or more terms in **Search queries**.
3. Select the **Search country** where you want Bing results localized.
4. Set the desired number of pages and maximum results per query.
5. Click **Start**. When the run finishes, open the **Dataset** tab to export JSON, CSV, Excel, JSONL, XML or RSS.

Example input:

```json
{
  "queries": [
    "best project management software",
    "web scraping tools"
  ],
  "country": "US",
  "pagesPerQuery": 2,
  "maxResultsPerQuery": 20,
  "safeSearch": "Moderate",
  "includeSerpFeatures": true,
  "includeAds": false
}
````

### Input reference

| Field | Type | Required | Default | Accepted values | Description |
| --- | --- | :---: | --- | --- | --- |
| `queries` | `string[]` | Yes | — | 1–1,000 items; each query up to 500 characters | Search terms to run. Blank entries and duplicate terms are discarded before processing. |
| `country` | `string` | No | `US` | One of the 50 country codes listed below | Country used to localize Bing results and interface. |
| `pagesPerQuery` | `integer` | No | `1` | 1–20 | Maximum Bing result pages to retrieve for each query. Retrieval can finish earlier; see [Pagination](#pagination-and-result-limits). |
| `maxResultsPerQuery` | `integer` | No | `10` | 1–50 | Maximum number of unique organic results returned for each query across all pages. |
| `safeSearch` | `string` | No | `Moderate` | `Strict`, `Moderate`, `Off` | Bing SafeSearch setting. |
| `includeSerpFeatures` | `boolean` | No | `true` | `true` or `false` | Adds optional query-level SERP modules from the first fetched page. |
| `includeAds` | `boolean` | No | `false` | `true` or `false` | Adds ads to `serpFeatures.ads`. Ads never appear as organic-result rows. Only relevant when `includeSerpFeatures` is enabled. |

#### Supported countries

| Code | Country | Code | Country | Code | Country | Code | Country |
| --- | --- | --- | --- | --- | --- | --- | --- |
| `US` | United States | `ES` | Spain | `GB` | United Kingdom | `DE` | Germany |
| `FR` | France | `IT` | Italy | `CA` | Canada | `MX` | Mexico |
| `BR` | Brazil | `AU` | Australia | `JP` | Japan | `IN` | India |
| `NL` | Netherlands | `PL` | Poland | `TR` | Turkey | `KR` | South Korea |
| `ID` | Indonesia | `AR` | Argentina | `CO` | Colombia | `SE` | Sweden |
| `CH` | Switzerland | `AT` | Austria | `BE` | Belgium | `DK` | Denmark |
| `FI` | Finland | `NO` | Norway | `IE` | Ireland | `PT` | Portugal |
| `CZ` | Czechia | `RO` | Romania | `HU` | Hungary | `GR` | Greece |
| `IL` | Israel | `SA` | Saudi Arabia | `AE` | United Arab Emirates | `ZA` | South Africa |
| `NZ` | New Zealand | `SG` | Singapore | `MY` | Malaysia | `TH` | Thailand |
| `VN` | Vietnam | `PH` | Philippines | `TW` | Taiwan | `HK` | Hong Kong |
| `CN` | China | `CL` | Chile | `PE` | Peru | `UY` | Uruguay |
| `EC` | Ecuador | `VE` | Venezuela |  |  |  |  |

#### Pagination and result limits

`pagesPerQuery` controls how far the Actor may paginate. `maxResultsPerQuery` controls how many unique organic rows it can return. For example, setting 10 pages and 20 results lets the Actor inspect pages until it has 20 unique results, but never returns more than 20.

Pagination stops early when any of these conditions is reached:

- The requested maximum result count has been reached.
- A page contains no new organic URLs after de-duplication.
- Bing returns a request error.
- The query time budget is reached.
- The configured number of pages has been processed.

The stop reason is exposed as `paginationStoppedReason` in every output row for that query.

### Output

The default dataset contains two record types.

#### 1. Organic result rows

Every delivered organic result is one row with `type: "organicResult"`. These are the rows used for billing and export.

```json
{
  "type": "organicResult",
  "query": "web scraping tools",
  "queryId": "a stable query identifier",
  "country": "US",
  "market": "en-US",
  "pagesRequested": 2,
  "pagesFetched": 2,
  "paginationStoppedReason": "max_results_reached",
  "organicResultsFound": 20,
  "page": 1,
  "position": 1,
  "title": "Example search-result title",
  "url": "https://example.com/page",
  "sourceDomain": "example.com",
  "displayUrl": "https://example.com/page",
  "description": "Snippet text shown by Bing.",
  "date": null,
  "sitelinks": [{"title": "Example subpage", "url": "https://example.com/subpage"}],
  "richFacts": ["Optional fact shown by Bing"],
  "serpFeatures": {
    "estimatedResultsText": "About 1,000 results",
    "relatedSearches": [],
    "peopleAlsoAsk": [],
    "answerCards": [],
    "knowledgePanel": {"title": null, "description": null}
  },
  "fetchedAt": "2026-07-13T12:00:00+00:00"
}
```

| Field | Description |
| --- | --- |
| `query` / `queryId` | Original normalized query and its stable identifier within the run. |
| `country` / `market` | Selected country and Bing locale used, for example `US` and `en-US`. |
| `page` / `position` | Bing page number and 1-based organic position on that page. |
| `title`, `url`, `sourceDomain`, `displayUrl`, `description`, `date` | Metadata displayed by Bing. `date` may be `null` when Bing does not show one. |
| `sitelinks` / `richFacts` | Optional extensions that Bing shows below an organic result. |
| `serpFeatures` | Optional query-level modules from the first page. The same value is attached to each organic row for convenient exports. |
| `pagesRequested`, `pagesFetched`, `paginationStoppedReason`, `organicResultsFound` | Query-level pagination diagnostics. |
| `fetchedAt` | UTC timestamp when the query was processed. |

#### 2. Query-status rows

If a query produces no chargeable organic results, the Actor writes one free row with `type: "queryStatus"`. It includes `resultCount: 0`, page diagnostics in `pages`, the stop reason and a structured `error` object when one exists. These rows make empty results and request failures visible without mixing them into the organic export.

#### SERP features

When `includeSerpFeatures` is `true`, `serpFeatures` can contain the following optional fields. They depend on what Bing renders, so an empty list or `null` is normal.

| Field | Content |
| --- | --- |
| `estimatedResultsText` | Text of Bing's displayed result estimate. |
| `relatedSearches` | Related-search links, with `title` and `url`. |
| `peopleAlsoAsk` | Links found in Bing's People Also Ask area, with `title` and `url`. |
| `answerCards` | Answer-card title, description and URL when available. |
| `knowledgePanel` | Knowledge-panel `title` and `description` when available. |
| `ads` | Sponsored-result title, URL and description. Included only when `includeAds` is `true`. |

#### Run summary

The default Key-Value Store keeps a `SUMMARY` record, linked from the Actor output. It contains counters for `requested`, `started`, `succeeded`, `failed`, `empty`, `organic_results_found`, `organic_results_delivered`, `organic_results_charged`, `skipped_by_budget`, `persistence_failures` and `stop_requested`, plus `chargedEventName` and `updatedAt`.

### Pricing

**$1 per 1,000 organic results delivered** (`$0.001` each).

One delivered `organicResult` dataset row is one billable event. Run starts, result pages, retries, empty queries, failed queries and `queryStatus` rows are not charged separately. The Actor checks the Apify spending limit before starting additional paid work; it may leave remaining queries pending when the configured budget cannot cover another result.

### Use through the Apify API

Use the Actor identifier `datascraperes/bing-search-scraper` in SDKs, or `datascraperes~bing-search-scraper` in REST endpoints. Replace `YOUR_APIFY_TOKEN` with an Apify API token and keep it private.

#### cURL

The synchronous endpoint waits for the run, then returns default-dataset items:

```bash
curl --request POST \
  "https://api.apify.com/v2/acts/datascraperes~bing-search-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
    "queries": ["best crm software"],
    "country": "GB",
    "pagesPerQuery": 2,
    "maxResultsPerQuery": 20
  }'
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("datascraperes/bing-search-scraper").call(
    run_input={
        "queries": ["best crm software"],
        "country": "GB",
        "pagesPerQuery": 2,
        "maxResultsPerQuery": 20,
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### JavaScript

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('datascraperes/bing-search-scraper').call({
  queries: ['best crm software'],
  country: 'GB',
  pagesPerQuery: 2,
  maxResultsPerQuery: 20,
});

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

### Reliability, data quality and responsible use

- Transient request failures are retried up to three times with exponential backoff and jitter.
- A query has a bounded processing time, so one slow Bing response cannot hold a run indefinitely.
- Completed query data is persisted incrementally and the Actor handles Apify migration events gracefully.
- Bing controls the result layout and content. Titles, snippets, dates, SERP modules and ranks can differ between runs and some optional fields can be empty.
- The Actor does not solve CAPTCHAs, bypass access controls or access private content.
- You are responsible for using exported data lawfully and in accordance with Bing's applicable terms, policies and data-protection obligations.

### Troubleshooting

| Situation | What to check |
| --- | --- |
| Fewer results than requested | Bing may have fewer unique results, duplicate URLs may have been removed, or pagination may have stopped early. Check `paginationStoppedReason` and `pagesFetched`. |
| No date, sitelinks or SERP modules | These fields are only available when Bing displays them for that query and market. |
| A query has `queryStatus` instead of results | Inspect its `pages` and `error` fields. The row is diagnostic and is not an organic, billable result. |
| The run stops before all queries | Review the run's spending limit and the `SUMMARY` record, particularly `skipped_by_budget`. |
| Different results than a browser session | Results can vary by time, country, Bing experiment and SafeSearch setting. Use the same input values for comparable runs. |

### Local development

The published Actor is intended to be run from Apify. For contributors, the project requires Python 3.11+ and a `BING_PROXY_URL` environment variable configured with an HTTP proxy URL.

```powershell
python -m venv .venv
.venv\Scripts\Activate.ps1
pip install -r requirements.txt
$env:BING_PROXY_URL = "http://user:password@host:port"
python -m pytest -q
```

### Support

For questions or support, contact the Actor developer through the Apify Actor page.

# Actor input Schema

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

One query per item. Duplicates and blank values are removed.

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

1-50 organic results per query in total, across all requested pages.

## `pagesPerQuery` (type: `integer`):

1-20 Bing result pages. The actor stops early when Bing returns no new organic URLs, preventing duplicate output.

## `country` (type: `string`):

The actor automatically selects the matching Bing interface and results market.

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

Bing SafeSearch setting.

## `includeSerpFeatures` (type: `boolean`):

Extract optional query-level blocks such as estimated results, related searches, answer cards and knowledge-panel summaries.

## `includeAds` (type: `boolean`):

Extract ads into a separate field. Ads are never mixed with organic results.

## Actor input object example

```json
{
  "queries": [
    "apify web scraping"
  ],
  "maxResultsPerQuery": 10,
  "pagesPerQuery": 1,
  "country": "US",
  "safeSearch": "Moderate",
  "includeSerpFeatures": true,
  "includeAds": false
}
```

# Actor output Schema

## `results` (type: `string`):

The default dataset containing one item per delivered organic Bing result and free query status diagnostics.

## `summary` (type: `string`):

The SUMMARY record with query, pagination, delivery and charged-result totals for this run.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascraperes/bing-search-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"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bing Search Scraper – SERP Results",
        "description": "Scrape Bing organic search results for any keyword. Get rank, URLs, domains, snippets, dates, sitelinks and SERP features across 50 countries with pagination.",
        "version": "0.1",
        "x-build-id": "1Sam89HzWwhUGu6uZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datascraperes~bing-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datascraperes-bing-search-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/datascraperes~bing-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datascraperes-bing-search-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/datascraperes~bing-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datascraperes-bing-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "One query per item. Duplicates and blank values are removed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum organic results per query",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "1-50 organic results per query in total, across all requested pages.",
                        "default": 10
                    },
                    "pagesPerQuery": {
                        "title": "Pages per query",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "1-20 Bing result pages. The actor stops early when Bing returns no new organic URLs, preventing duplicate output.",
                        "default": 1
                    },
                    "country": {
                        "title": "Search country",
                        "enum": [
                            "US",
                            "ES",
                            "GB",
                            "DE",
                            "FR",
                            "IT",
                            "CA",
                            "MX",
                            "BR",
                            "AU",
                            "JP",
                            "IN",
                            "NL",
                            "PL",
                            "TR",
                            "KR",
                            "ID",
                            "AR",
                            "CO",
                            "SE",
                            "CH",
                            "AT",
                            "BE",
                            "DK",
                            "FI",
                            "NO",
                            "IE",
                            "PT",
                            "CZ",
                            "RO",
                            "HU",
                            "GR",
                            "IL",
                            "SA",
                            "AE",
                            "ZA",
                            "NZ",
                            "SG",
                            "MY",
                            "TH",
                            "VN",
                            "PH",
                            "TW",
                            "HK",
                            "CN",
                            "CL",
                            "PE",
                            "UY",
                            "EC",
                            "VE"
                        ],
                        "type": "string",
                        "description": "The actor automatically selects the matching Bing interface and results market.",
                        "default": "US"
                    },
                    "safeSearch": {
                        "title": "SafeSearch",
                        "enum": [
                            "Strict",
                            "Moderate",
                            "Off"
                        ],
                        "type": "string",
                        "description": "Bing SafeSearch setting.",
                        "default": "Moderate"
                    },
                    "includeSerpFeatures": {
                        "title": "Include SERP features",
                        "type": "boolean",
                        "description": "Extract optional query-level blocks such as estimated results, related searches, answer cards and knowledge-panel summaries.",
                        "default": true
                    },
                    "includeAds": {
                        "title": "Include ads separately",
                        "type": "boolean",
                        "description": "Extract ads into a separate field. Ads are never mixed with organic results.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
