# MisterWhat UK Business Directory Scraper (`crawlerbros/misterwhat-uk-business-directory-scraper`) Actor

Scrape MisterWhat.co.uk (UK business directory) listings. Search by category and city, or fetch full business profiles by URL. Get names, addresses, phone numbers, websites, categories, ratings, and reviews.

- **URL**: https://apify.com/crawlerbros/misterwhat-uk-business-directory-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## MisterWhat UK Business Directory Scraper

Scrape **MisterWhat** (misterwhat.co.uk) — a UK-wide business directory covering restaurants, tradespeople, professional services, shops, and more across every English, Scottish, Welsh, and Northern Irish city and town. Search any business category in any UK city and get names, addresses, ratings, and review counts instantly, or turn on full-profile fetching for phone numbers, websites, price range, and customer reviews. No login, no cookies, no API key required.

### What this actor does

- **Two modes:** `search` (category + city) and `byUrl` (direct business profile URLs)
- **50+ curated categories** to pick from, or type any custom category
- **50+ curated UK cities** to pick from, or type any custom city/town
- **Filter by** minimum star rating (1-5) or "has at least one rating"
- **Rich business profiles** — phone number, website, full category list, price range, and customer reviews
- **Empty fields are omitted** — you only ever see fields that were actually found for a business

### Output per business

- `name` — business name
- `category` — the business's primary listed category (when profile fetched)
- `categories[]` — every category the business is listed under (when profile fetched)
- `rating`, `reviewCount` — average star rating (1-5) and number of reviews
- `street`, `city`, `postalCode`, `country`, `address` — full postal address
- `region` — the wider UK region/county the business is listed under (when profile fetched)
- `latitude`, `longitude` — map coordinates of the business (when profile fetched)
- `phone`, `website` — contact details (when profile fetched)
- `priceRange` — relative price indicator (e.g. `$`, `$$`) when the business publishes one (when profile fetched)
- `description` — the business's own free-text description, when it has written one (when profile fetched)
- `isVerified` — `true` if MisterWhat has verified the listing, `false` otherwise (when profile fetched)
- `imageUrl` — business photo, when the business has uploaded a real photo (generic placeholder icons are never included)
- `reviews[]` — customer reviews (`author`, `date`, `rating`, `text`) when profile fetched and reviews exist
- `profileUrl` — canonical MisterWhat profile URL for the business
- `companyId` — MisterWhat's internal business ID
- `recordType: "business"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` (category + city) or `byUrl` (fetch by URL) |
| `category` | string (select) | `restaurants` | Pick a common category, or `custom` to use `customCategory` (mode=search) |
| `customCategory` | string | – | Any free-text category, overrides `category` (mode=search) |
| `city` | string (select) | `london` | Pick a common UK city, or use `customCity` for any other town (mode=search) |
| `customCity` | string | – | Any free-text UK city, town, or postcode area, overrides `city` (mode=search) |
| `ratedOnly` | boolean | `false` | Only return businesses that have at least one rating (ignored when `minRating` is set) |
| `minRating` | string (select) | – (no minimum) | Only return businesses rated at least `1`-`5` stars |
| `fetchDetails` | boolean | `true` | Also visit each business's profile page for phone, website, categories, price range, and reviews (slower but richer) |
| `profileUrls` | array | – | MisterWhat profile URLs to fetch directly (mode=byUrl) |
| `maxItems` | int | `50` | Hard cap on returned records (1-1000) |
| `proxyConfiguration` | object | Apify AUTO proxy | MisterWhat works without a proxy; the free AUTO datacenter group is used automatically as a fallback if a request is ever blocked |

#### Example: search restaurants in London

```json
{
  "mode": "search",
  "category": "restaurants",
  "city": "london",
  "maxItems": 50
}
````

#### Example: highest-rated plumbers in Manchester, with full profiles

```json
{
  "mode": "search",
  "category": "plumbers",
  "city": "manchester",
  "fetchDetails": true,
  "ratedOnly": true,
  "maxItems": 30
}
```

#### Example: custom category and town not in the curated lists

```json
{
  "mode": "search",
  "customCategory": "wedding photographers",
  "customCity": "Harrogate",
  "maxItems": 40
}
```

#### Example: 4+ star solicitors in Birmingham

```json
{
  "mode": "search",
  "category": "solicitors",
  "city": "birmingham",
  "minRating": "4",
  "fetchDetails": true,
  "maxItems": 40
}
```

#### Example: fetch specific business profiles

```json
{
  "mode": "byUrl",
  "profileUrls": [
    { "url": "https://www.misterwhat.co.uk/company/98196-leon-restaurants-london" }
  ]
}
```

### Use cases

- **Local lead generation** — build a prospect list of UK businesses by trade and city for B2B outreach
- **Market research** — measure business density and average ratings for a category across UK cities
- **Directory aggregation** — feed structured UK business data into your own local-search product
- **Competitor mapping** — see who else operates in a category and area, with ratings and contact info
- **Franchise & site-selection analysis** — evaluate service-business coverage across UK towns

### FAQ

**What data source does this actor use?**
It reads the publicly available search and business-profile pages on misterwhat.co.uk, a UK business directory. No account or API key is needed.

**Is this affiliated with MisterWhat?**
No. This is an independent, third-party actor that reads publicly accessible pages.

**Why do some businesses have no rating, phone, or website?**
MisterWhat only shows a rating once a business has received at least one review, and only shows contact details a business itself provided. Fields with no data are simply omitted from the record rather than shown as empty or null.

**What does `isVerified` mean?**
It reflects MisterWhat's own "Verified Listing" badge, shown on business profiles the platform has verified. It's `false` (not omitted) for unverified listings, since "not verified" is itself meaningful signal — only available with `fetchDetails: true` (mode=search) or in `byUrl` mode.

**What's the difference between `category` and `categories`?**
`categories` lists every category the business is registered under on its profile page (e.g. a restaurant might be listed as "Bistro", "Mediterranean Restaurant", and "Restaurant"). `category` is simply the first of those. Both are only populated with `fetchDetails: true` (mode=search) or always in `byUrl` mode.

**Can I search by town or area not in the curated city list?**
Yes — use `customCity` with any UK city, town, or postcode area name.

**Why is `imageUrl` sometimes missing?**
MisterWhat only shows a business photo when the business (or a user) has actually uploaded one. Businesses without a real photo show the site's generic placeholder icon instead — this actor deliberately excludes that placeholder so `imageUrl` only ever contains genuine photos.

**Why is `fetchDetails` on by default?**
It's the only way to get phone numbers, websites, price range, and reviews — the search-results page itself only shows name, address, and (sometimes) rating. Turn it off for a faster, listing-only scrape when you just need names and addresses.

**How does `minRating` differ from `ratedOnly`?**
`ratedOnly` returns any business with at least one review (any star rating). `minRating` is stricter — it only returns businesses rated at least the chosen number of stars. Set `minRating` when you need a quality bar, not just "has reviews".

**What happens if a category or city has very few results?**
The actor stops paging as soon as MisterWhat returns a results page with no listings, so you'll simply receive however many genuine matches exist — never fabricated or padded results.

**Why do only a small fraction of businesses have a `rating`?**
MisterWhat only shows a rating once a real customer has left a review, and most listed businesses haven't received one yet. This is a genuine characteristic of the data source, not a bug — use `ratedOnly: true` or `minRating` to focus specifically on reviewed businesses.

**Some city names (e.g. "Leeds") match more than one UK location — how is that handled?**
MisterWhat automatically resolves this by following the location with by far the most listings (e.g. "Leeds, Yorkshire and the Humber" over a same-named hamlet elsewhere in the UK), so you always get results instead of an empty page.

# Actor input Schema

## `mode` (type: `string`):

What to fetch: search a category + city, or fetch full business profiles from direct URLs.

## `category` (type: `string`):

Type of business to search for. Pick a common category from the list, or choose 'Custom category' and type your own in the field below (mode=search).

## `customCategory` (type: `string`):

Free-text business category not in the curated list above, e.g. 'wedding photographers' or 'yoga studios' (mode=search). Takes priority over 'Business category' when set.

## `city` (type: `string`):

UK city or town to search in, e.g. 'london', 'manchester', 'birmingham', 'leeds' (mode=search).

## `customCity` (type: `string`):

Free-text UK city, town, or postcode area not in the list above, e.g. 'Kingston upon Thames' or 'Harrogate' (mode=search). Takes priority over 'City / town' when set.

## `ratedOnly` (type: `boolean`):

Only return businesses that have at least one customer rating (mode=search). Ignored when 'Minimum rating' below is set.

## `minRating` (type: `string`):

Only return businesses rated at least this many stars, e.g. '4' for 4.0+ (mode=search).

## `fetchDetails` (type: `boolean`):

For each search result, also visit its business profile page to collect the phone number, website, full category list, price range, and customer reviews. Slower but much richer (mode=search).

## `profileUrls` (type: `array`):

Direct MisterWhat.co.uk business profile URLs to fetch, e.g. https://www.misterwhat.co.uk/company/98196-leon-restaurants-london. Use the 'profileUrl' field from search results.

## `maxItems` (type: `integer`):

Hard cap on the number of business records to return.

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

MisterWhat.co.uk is publicly accessible without a proxy. Apify's free AUTO datacenter proxy is used automatically as a fallback if a request is ever blocked from your run location -- you don't need to configure anything here.

## Actor input object example

```json
{
  "mode": "search",
  "category": "restaurants",
  "city": "london",
  "ratedOnly": false,
  "minRating": "",
  "fetchDetails": true,
  "profileUrls": [],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `businesses` (type: `string`):

Dataset containing all scraped MisterWhat business listings.

# 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 = {
    "mode": "search",
    "category": "restaurants",
    "city": "london",
    "ratedOnly": false,
    "minRating": "",
    "fetchDetails": true,
    "profileUrls": [],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/misterwhat-uk-business-directory-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 = {
    "mode": "search",
    "category": "restaurants",
    "city": "london",
    "ratedOnly": False,
    "minRating": "",
    "fetchDetails": True,
    "profileUrls": [],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/misterwhat-uk-business-directory-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 '{
  "mode": "search",
  "category": "restaurants",
  "city": "london",
  "ratedOnly": false,
  "minRating": "",
  "fetchDetails": true,
  "profileUrls": [],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/misterwhat-uk-business-directory-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/misterwhat-uk-business-directory-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MisterWhat UK Business Directory Scraper",
        "description": "Scrape MisterWhat.co.uk (UK business directory) listings. Search by category and city, or fetch full business profiles by URL. Get names, addresses, phone numbers, websites, categories, ratings, and reviews.",
        "version": "1.0",
        "x-build-id": "nhBD0oarUIeNe7JJA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~misterwhat-uk-business-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-misterwhat-uk-business-directory-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/crawlerbros~misterwhat-uk-business-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-misterwhat-uk-business-directory-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/crawlerbros~misterwhat-uk-business-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-misterwhat-uk-business-directory-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to fetch: search a category + city, or fetch full business profiles from direct URLs.",
                        "default": "search"
                    },
                    "category": {
                        "title": "Business category",
                        "enum": [
                            "custom",
                            "restaurants",
                            "plumbers",
                            "electricians",
                            "solicitors",
                            "dentists",
                            "doctors",
                            "hairdressers",
                            "hotels",
                            "roofers",
                            "painters and decorators",
                            "accountants",
                            "estate agents",
                            "landscape gardeners",
                            "funeral directors",
                            "physiotherapists",
                            "vets",
                            "pharmacies",
                            "opticians",
                            "driving schools",
                            "car garages",
                            "cleaning services",
                            "removal companies",
                            "bakeries",
                            "butchers",
                            "beauty salons",
                            "massage therapists",
                            "gyms",
                            "heating engineers",
                            "carpenters",
                            "window fitters",
                            "drain cleaning",
                            "pest control",
                            "builders",
                            "architects",
                            "insurance brokers",
                            "tutoring",
                            "locksmiths",
                            "florists",
                            "photographers",
                            "marketing agencies",
                            "it support",
                            "printing services",
                            "computer repair",
                            "cafes",
                            "pubs",
                            "bars",
                            "fast food",
                            "veterinary clinics",
                            "nurseries",
                            "care homes",
                            "taxis"
                        ],
                        "type": "string",
                        "description": "Type of business to search for. Pick a common category from the list, or choose 'Custom category' and type your own in the field below (mode=search).",
                        "default": "restaurants"
                    },
                    "customCategory": {
                        "title": "Custom category (overrides selection above)",
                        "type": "string",
                        "description": "Free-text business category not in the curated list above, e.g. 'wedding photographers' or 'yoga studios' (mode=search). Takes priority over 'Business category' when set."
                    },
                    "city": {
                        "title": "City / town",
                        "enum": [
                            "london",
                            "birmingham",
                            "manchester",
                            "leeds",
                            "glasgow",
                            "sheffield",
                            "bradford",
                            "edinburgh",
                            "liverpool",
                            "bristol",
                            "cardiff",
                            "belfast",
                            "leicester",
                            "coventry",
                            "nottingham",
                            "newcastle",
                            "sunderland",
                            "brighton",
                            "hull",
                            "plymouth",
                            "stoke-on-trent",
                            "wolverhampton",
                            "derby",
                            "southampton",
                            "portsmouth",
                            "york",
                            "peterborough",
                            "dundee",
                            "oxford",
                            "cambridge",
                            "reading",
                            "aberdeen",
                            "swansea",
                            "milton keynes",
                            "norwich",
                            "bath",
                            "exeter",
                            "ipswich",
                            "luton",
                            "bolton",
                            "preston",
                            "middlesbrough",
                            "blackpool",
                            "bournemouth",
                            "swindon",
                            "watford",
                            "gloucester",
                            "chester",
                            "harrogate",
                            "colchester",
                            "worcester"
                        ],
                        "type": "string",
                        "description": "UK city or town to search in, e.g. 'london', 'manchester', 'birmingham', 'leeds' (mode=search).",
                        "default": "london"
                    },
                    "customCity": {
                        "title": "Custom city / town (overrides selection above)",
                        "type": "string",
                        "description": "Free-text UK city, town, or postcode area not in the list above, e.g. 'Kingston upon Thames' or 'Harrogate' (mode=search). Takes priority over 'City / town' when set."
                    },
                    "ratedOnly": {
                        "title": "Only businesses with ratings",
                        "type": "boolean",
                        "description": "Only return businesses that have at least one customer rating (mode=search). Ignored when 'Minimum rating' below is set.",
                        "default": false
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5"
                        ],
                        "type": "string",
                        "description": "Only return businesses rated at least this many stars, e.g. '4' for 4.0+ (mode=search).",
                        "default": ""
                    },
                    "fetchDetails": {
                        "title": "Fetch full business profiles",
                        "type": "boolean",
                        "description": "For each search result, also visit its business profile page to collect the phone number, website, full category list, price range, and customer reviews. Slower but much richer (mode=search).",
                        "default": true
                    },
                    "profileUrls": {
                        "title": "Business profile URLs (mode=byUrl)",
                        "type": "array",
                        "description": "Direct MisterWhat.co.uk business profile URLs to fetch, e.g. https://www.misterwhat.co.uk/company/98196-leon-restaurants-london. Use the 'profileUrl' field from search results.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "type": "string",
                                    "description": "MisterWhat business profile URL."
                                }
                            }
                        },
                        "default": []
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on the number of business records to return.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "MisterWhat.co.uk is publicly accessible without a proxy. Apify's free AUTO datacenter proxy is used automatically as a fallback if a request is ever blocked from your run location -- you don't need to configure anything here.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
