# UK Companies House Scraper — Official API, Officers & SIC (`bovi/companies-house-uk`) Actor

Search UK companies by name or number via the official Companies House API. Returns company number, name, status, type, incorporation and cessation dates, and full registered address. Optional officers/directors enrichment. No proxy. Free API key required. Pay per result.

- **URL**: https://apify.com/bovi/companies-house-uk.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Business, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.75 / 1,000 company records

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

## UK Companies House Scraper — Official API

Used by KYC analysts, M&A associates, and B2B sales teams who need live UK company status, directors, and SIC codes without managing a Companies House integration.

Search and extract UK company data from the official **Companies House** API. Returns company number, name, status, type, incorporation date, registered address, SIC codes, and optionally officers (directors). Pay per result.

**$5.00/1K records** (Pay Per Event). Officers add-on +$2.00/1K. First 10 results free. No proxy needed. No scraping ban risk. Government data source — authoritative, directly from the Companies House API.

### Getting your free API key

1. Go to https://developer.company-information.service.gov.uk/get-started
2. Sign in or create a free account
3. Create an application — choose "Live" environment
4. Copy the **API key** (also called "key")
5. Paste it into the `apiKey` input field

The key is free and gives you 600 requests per 5 minutes (enough for thousands of companies per run).

### What you get

| Field | Description |
|---|---|
| `company_number` | Companies House company number (e.g. `00445790`) |
| `name` | Full company name |
| `status` | `active`, `dissolved`, `liquidation`, etc. |
| `company_type` | `ltd`, `plc`, `llp`, `unregistered-company`, etc. |
| `incorporation_date` | Date of formation (YYYY-MM-DD) |
| `cessation_date` | Dissolution date if applicable |
| `address_line_1` | Registered office address |
| `address_line_2` | Second address line |
| `locality` | City / town |
| `region` | County / region |
| `postal_code` | Postal code |
| `country` | Country (`England`, `Scotland`, `Wales`, `Northern Ireland`) |
| `address_snippet` | Formatted address fallback |
| `sic_codes` | List of SIC (Standard Industrial Classification) codes |
| `jurisdiction` | `england-wales`, `scotland`, `northern-ireland`, etc. |
| `officers` | List of directors/secretaries (when `fetchOfficers=true`) |
| `officers_count` | Total officer count |
| `profile_url` | Direct link to company on Companies House website |
| `query` | Which search query or company number produced this record |
| `parse_confidence` | Data quality score 0–1 |
| `warnings` | Machine-readable quality flags |

### Modes

**Search by name** — provide `searchQueries` (e.g. `["Rolls Royce", "BP plc"]`). Paginates automatically up to `maxResultsPerQuery`.

**Direct lookup by number** — provide `companyNumbers` (e.g. `["00445790", "00102498"]`). Fetches the full company profile for each number. More precise — returns one record per number.

**Both modes** — combine `searchQueries` and `companyNumbers` in the same run. Results are deduplicated by company number.

### Officers

Set `fetchOfficers: true` to include the list of current and past directors and secretaries. This makes one additional API call per company — will use more of your rate limit quota on large runs.

### Use cases

- **KYC / due diligence** — verify UK counterparty legal status, registration, and directors
- **B2B lead generation** — find companies by SIC code or name
- **Compliance screening** — identify dissolved or liquidated entities
- **Beneficial ownership** — extract officer lists for corporate structure mapping
- **Market research** — map UK company types, sectors, incorporation trends

### Data source

**Companies House** — official UK government company registry, maintained by the Department for Business and Trade. Data is authoritative and updated in near-real-time from company filings.

### Pricing

**Pay-per-result (PPE):**

| Event | Rate | Trigger |
|---|---|---|
| `company-record` (base) | **$5.00/1K** | Every company record returned |
| `officers-fetch` (add-on) | **$2.00/1K** | Records with officers when `fetchOfficers: true` |

Officers premium fires only when officer data is actually returned. No monthly subscription.

**Worked examples:**

| Run | Records | Officers? | Cost |
|---|---|---|---|
| 100 company search results | 100 | No | **$0.50** |
| 1,000 company search results | 1,000 | No | **$5.00** |
| 500 companies with officers | 500 | Yes | **$3.50** ($2.50 base + $1.00 officers) |

### FAQ

**Do I need a proxy or API key?**
You need a free **Companies House API key** (5 minutes to get at developer.company-information.service.gov.uk). No proxy needed — the official API works from any IP.

**What output formats are available?**
JSON, CSV, and Excel — all via the Apify dataset. Download directly or pipe into n8n / Make / Zapier.

**Can I schedule this to run daily?**
Yes. Set up a scheduled run in the Apify console to monitor new incorporations, officer changes, or status updates for a watched list of companies.

**What if a search returns empty results?**
Empty queries return zero records and are not charged. Check that your search term matches a known UK company name or use a direct `companyNumbers` lookup for precision.

### Notes

- A free Companies House API key is required — get one at developer.company-information.service.gov.uk (5 minutes)
- Rate limit: 600 requests / 5 minutes per key (generous for typical use cases)
- Officers (`fetchOfficers=true`) doubles API calls — budget accordingly
- `parse_confidence` is always 1.0 for records with a valid company number and name; it deducts for truly malformed responses
- Live validation requires a CH API key — set `COMPANIES_HOUSE_API_KEY` in the environment and run `scripts/probe.py` to verify

### vs. Competitors

| Feature | This Actor | opencorporates-scraper (Store) | SerpApi / web scrapers |
|---|---|---|---|
| Data source | Official CH REST API | HTML scraping CH | HTML / SERP |
| Proxy needed | No | Yes ($$$) | Yes ($$$) |
| Officer list | Yes (`fetchOfficers` toggle) | Partial | No |
| parse_confidence | Yes (1.0 for valid number) | No | No |
| Real-time data | Near-real-time (gov filings) | Stale / cached | Stale |
| Cost | **$5/1K** | ~$3-5/1K + proxy | $3-8/1K + proxy COGS |

### Use with AI agents (MCP)

An agent calls this tool to **look up UK company registration status, address, SIC codes, and officers mid-conversation** — e.g. "is Barclays PLC still active?", "who are the directors of company 00445790?", or "find all active FinTech companies named 'Monzo'".

Point your MCP client at this tool:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.apify.com/?tools=bovi/companies-house-uk",
        "--header",
        "Authorization: Bearer <YOUR_APIFY_TOKEN>"
      ]
    }
  }
}
````

Minimal agent input (name search):

```json
{
  "apiKey": "<YOUR_COMPANIES_HOUSE_API_KEY>",
  "searchQueries": ["Barclays"],
  "maxResultsPerQuery": 5,
  "activeOnly": true
}
```

Direct lookup by company number (most precise):

```json
{
  "apiKey": "<YOUR_COMPANIES_HOUSE_API_KEY>",
  "companyNumbers": ["00445790", "00102498"]
}
```

Example output row an agent can reason over directly:

```json
{
  "company_number": "01026167",
  "name": "BARCLAYS BANK PLC",
  "status": "active",
  "company_type": "plc",
  "incorporation_date": "1971-10-13",
  "locality": "London",
  "postal_code": "E14 5HP",
  "country": "England",
  "sic_codes": ["64190"],
  "officers_count": null,
  "profile_url": "https://find-and-update.company-information.service.gov.uk/company/01026167",
  "parse_confidence": 1.0,
  "warnings": []
}
```

Reliability for agents: data comes from the **official UK government Companies House API** (not HTML scraping), so results don't break on website redesigns. Every record includes a stable `company_number` for de-duplication and joining across runs. Data quality is tracked via `parse_confidence` (1.0 = fully clean record; deducts for missing critical fields) and machine-readable `warnings`. A free Companies House API key is required — obtain one in ~5 minutes at developer.company-information.service.gov.uk.

### Integrations

Built for KYC analysts, M\&A associates, and B2B sales teams enriching UK company status, directors, and SIC codes — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

### More scrapers from our toolkit

Building a data pipeline? These actors pair well with this one — each runs on your own Apify account with the same pay-per-result pricing, no subscription:

- [Companies France](https://apify.com/bovi/companies-france)
- [Crunchbase Scraper](https://apify.com/bovi/crunchbase-scraper)
- [Seeking Alpha Scraper](https://apify.com/bovi/seeking-alpha-scraper)
- [Transfermarkt Scraper](https://apify.com/bovi/transfermarkt-scraper)
- [Unusual Options Activity](https://apify.com/bovi/unusual-options-activity)
- [Yahoo Finance Scraper](https://apify.com/bovi/yahoo-finance-scraper)

Chain any of them together from the **Integrations** tab (the *Run succeeded* trigger) to build a multi-step workflow — one actor's output feeds the next.

### Use it from your existing tools

#### Use with Claude Desktop / Cursor / Cline (MCP)

Load this actor as a tool in your AI assistant. Call it directly from your AI assistant via the Apify MCP server — no Store browsing needed. Paste this into your MCP client config (e.g. `claude_desktop_config.json`) and restart the client:

```json
{
  "mcpServers": {
    "apify-companies-house-uk": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server",
        "--tools",
        "bovi/companies-house-uk"
      ],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Replace `YOUR_APIFY_TOKEN` with your own Apify API token (free at apify.com → Settings → Integrations). Curated to a handful of tools so the agent selects reliably.

#### Works with Clay

Run this actor as an HTTP enrichment step inside a Clay table:

- **Method:** `POST`
- **URL:** `https://api.apify.com/v2/acts/bovi~companies-house-uk/run-sync-get-dataset-items?token={{apify_token}}`
- **Body (JSON):** map your Clay columns to the actor input (see the Input section above), e.g. `{"apiKey": "{{clay_column}}"}`

The run finishes synchronously and returns the dataset rows straight into your Clay table. It runs on Apify's cloud under your own token and usage. Synchronous runs must complete within 300 seconds.

# Actor input Schema

## `apiKey` (type: `string`):

Your free Companies House API key. Obtain one at https://developer.company-information.service.gov.uk/get-started — sign in, create a 'Live' application, copy the key. Used as HTTP Basic Auth username (password is blank). Rate limit: 600 requests per 5 minutes — sufficient for thousands of companies per run.

## `searchQueries` (type: `array`):

One or more company name search terms. Each is searched separately; results are ranked by relevance and deduplicated by company number. Example: \["Rolls Royce", "Barclays", "Monzo"]. Use this OR companyNumbers — or both together.

## `companyNumbers` (type: `array`):

Companies House registration numbers for precise direct lookup. 8-character strings, zero-padded (e.g. '00445790' for BP plc, '01026167' for Barclays Bank). Returns one full profile per number. More precise than name search — use when you already have the company number.

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

Maximum number of company records to return for each name search query. The API paginates at 100 per page; set 0 for no limit. Keep this low (10–50) when searching common names to avoid returning hundreds of irrelevant companies.

## `fetchOfficers` (type: `boolean`):

When true, fetches the list of current and past officers (directors, secretaries, persons with significant control) for each company. Makes one additional API call per company — increases run time and API quota usage proportionally. Set false (default) when you only need company identity and status.

## `activeOnly` (type: `boolean`):

When true, only companies with status 'active' are included in the output. Dissolved, liquidated, or struck-off companies are silently dropped. Useful for KYC/compliance checks where you only care about live entities.

## Actor input object example

```json
{
  "searchQueries": [
    "Rolls Royce",
    "Barclays"
  ],
  "companyNumbers": [
    "00445790",
    "01026167"
  ],
  "maxResultsPerQuery": 20,
  "fetchOfficers": false,
  "activeOnly": false
}
```

# Actor output Schema

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

Dataset containing Companies House Uk records (company\_number, name, status, company\_type, incorporation\_date, locality, postal\_code, country, sic\_codes, officers\_count, profile\_url, parse\_confidence).

# 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 = {
    "searchQueries": [
        "Rolls Royce",
        "Barclays"
    ],
    "companyNumbers": [
        "00445790",
        "01026167"
    ],
    "maxResultsPerQuery": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/companies-house-uk").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 = {
    "searchQueries": [
        "Rolls Royce",
        "Barclays",
    ],
    "companyNumbers": [
        "00445790",
        "01026167",
    ],
    "maxResultsPerQuery": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/companies-house-uk").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 '{
  "searchQueries": [
    "Rolls Royce",
    "Barclays"
  ],
  "companyNumbers": [
    "00445790",
    "01026167"
  ],
  "maxResultsPerQuery": 20
}' |
apify call bovi/companies-house-uk --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=bovi/companies-house-uk",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UK Companies House Scraper — Official API, Officers & SIC",
        "description": "Search UK companies by name or number via the official Companies House API. Returns company number, name, status, type, incorporation and cessation dates, and full registered address. Optional officers/directors enrichment. No proxy. Free API key required. Pay per result.",
        "version": "0.1",
        "x-build-id": "8m8TEZKnu8M7ze7L7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~companies-house-uk/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-companies-house-uk",
                "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/bovi~companies-house-uk/runs": {
            "post": {
                "operationId": "runs-sync-bovi-companies-house-uk",
                "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/bovi~companies-house-uk/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-companies-house-uk",
                "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": [
                    "apiKey"
                ],
                "properties": {
                    "apiKey": {
                        "title": "Companies House API key",
                        "type": "string",
                        "description": "Your free Companies House API key. Obtain one at https://developer.company-information.service.gov.uk/get-started — sign in, create a 'Live' application, copy the key. Used as HTTP Basic Auth username (password is blank). Rate limit: 600 requests per 5 minutes — sufficient for thousands of companies per run."
                    },
                    "searchQueries": {
                        "title": "Search queries (company names)",
                        "type": "array",
                        "description": "One or more company name search terms. Each is searched separately; results are ranked by relevance and deduplicated by company number. Example: [\"Rolls Royce\", \"Barclays\", \"Monzo\"]. Use this OR companyNumbers — or both together.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyNumbers": {
                        "title": "Company numbers (direct lookup)",
                        "type": "array",
                        "description": "Companies House registration numbers for precise direct lookup. 8-character strings, zero-padded (e.g. '00445790' for BP plc, '01026167' for Barclays Bank). Returns one full profile per number. More precise than name search — use when you already have the company number.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per search query",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of company records to return for each name search query. The API paginates at 100 per page; set 0 for no limit. Keep this low (10–50) when searching common names to avoid returning hundreds of irrelevant companies.",
                        "default": 20
                    },
                    "fetchOfficers": {
                        "title": "Fetch officers (directors)",
                        "type": "boolean",
                        "description": "When true, fetches the list of current and past officers (directors, secretaries, persons with significant control) for each company. Makes one additional API call per company — increases run time and API quota usage proportionally. Set false (default) when you only need company identity and status.",
                        "default": false
                    },
                    "activeOnly": {
                        "title": "Active companies only",
                        "type": "boolean",
                        "description": "When true, only companies with status 'active' are included in the output. Dissolved, liquidated, or struck-off companies are silently dropped. Useful for KYC/compliance checks where you only care about live entities.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
