# Checkatrade Scraper - UK Tradesperson Data (`memo23/checkatrade-scraper`) Actor

Scrape verified UK tradespeople from Checkatrade by trade + location or URL. One row per tradesperson: name, phone, location, rating, review counts, skills, badges, logo and profile URL. Optional full-profile enrichment. JSON/CSV out

- **URL**: https://apify.com/memo23/checkatrade-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Lead generation, AI, Agents
- **Stats:** 21 total users, 19 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 tradespeople

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/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

## Checkatrade Scraper

Turn any [Checkatrade](https://www.checkatrade.com) search into clean, structured data. Search by **trade + location** (e.g. *Builder in London*) or paste **search-listing URLs** and **trade-profile URLs** — and get one flat row per tradesperson with name, phone, location, star rating, review counts, skills, badges, logo and profile URL. Flip on detail mode to add the full description, every skill, services offered and reviews.

Built for lead generation, local-market and competitor research, and building UK tradesperson datasets across every trade and town.

#### How it works

![How the Checkatrade Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-checkatrade.png)

#### ✨ Why use this scraper?

- **Rich rows out of the box** — ~30 fields per tradesperson from the search results alone: company name, phone (formatted + E.164), locality/region, recent rating (out of 10), recent + total review counts, skills and sub-skills, quality/insurance badges, membership, logo and profile URL.
- **Two ways in** — build a search from **trade + location**, or paste **search-listing URLs** and **profile URLs**. Mix them in one run.
- **Beats Checkatrade's block** — Checkatrade fronts scrapers with a Cloudflare managed challenge; this actor routes every request through a real browser fingerprint over UK residential IPs, so you get the real page instead of "Just a moment…".
- **Full detail on demand** — turn on *Scrape profile pages* (or paste a profile URL) to add the full description, all skill labels, services offered, accreditation and reviews.
- **No brittle DOM scraping** — reads Checkatrade's embedded Next.js data stream, so the output stays stable when the page layout changes.
- **JSON, CSV, Excel or API** — pipe straight into your sheet, CRM, BI tool or pipeline. Billed per tradesperson.

#### 🎯 Use cases

| You are a… | Use it to… |
|---|---|
| Lead-gen / sales team | Build a list of local tradespeople by trade + town, with phone, rating and skills |
| Market researcher | Measure rating and review distribution and trade density across UK regions |
| Trades business owner | Benchmark competitors in your area — ratings, review volume, skills and badges |
| Agency / directory builder | Seed a UK tradesperson dataset with structured company + contact rows |
| Recruiter | Find verified tradespeople by skill and location |

#### 📥 Supported inputs

| Input | Example | What it does |
|---|---|---|
| Trade + location | `trade: Builder`, `locations: ["London"]` | Builds the search and paginates the results |
| Search-listing URL | `https://www.checkatrade.com/Search/Builder/in/London` | Paginates that trade/location's results |
| Profile URL | `https://www.checkatrade.com/trades/{slug}` | Scrapes that single tradesperson in full detail |

**Not supported:** buyer messages, quote/booking flows, private/account-only data, and anything behind a Checkatrade login. The actor reads only public search-listing and trade-profile pages.

#### ⚙️ How it works

1. **Classify** every input — a trade + location becomes a `/Search/{Trade}/in/{Location}` URL; pasted URLs are sorted into search vs profile.
2. **Unlock** each page with a browser TLS fingerprint over a UK residential IP, so the real page is returned instead of the Cloudflare challenge.
3. **Parse** the page's embedded Next.js app-router data stream — a search page yields 12 tradespeople; the `?page=2`, `?page=3` … sequence is followed automatically up to your limit.
4. **Enrich** each tradesperson from their profile page (when *Scrape profile pages* is on): full description, all skills, services offered and reviews.
5. **Emit** one flat, deduplicated row per tradesperson to the dataset.

#### ⚙️ Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `trade` | string | — | Trade/category to search, e.g. `Builder`, `Electrician`, `Plumber`. |
| `locations` | array | — | Locations to search, e.g. `["London", "Manchester"]`. Combined with `trade`. |
| `startUrls` | array | — | Search-listing URLs and/or profile URLs. Auto-classified. |
| `scrapeDetails` | boolean | `false` | Also fetch each profile page for description, all skills, services and reviews (~2× requests). Pasted profile URLs are always fully detailed. |
| `maxItems` | integer | `1000` | Max rows for the whole run. |
| `maxItemsPerSearch` | integer | `1000` | Max tradespeople per search. |
| `maxConcurrency` | integer | `6` | Parallel requests. Keep moderate — Checkatrade is Cloudflare-protected. |
| `maxRequestRetries` | integer | `15` | Retry budget per request on Cloudflare challenges (403), 429 and network errors. |
| `proxy` | object | Apify Residential (GB) | Applies to free-tier runs; paid runs use a built-in UK residential pool. |

#### 📊 Output overview

Each dataset record is **one tradesperson** (company). Rows carry the search-card fields (name, phone, locality/region, rating, reviews, skills, badges, logo, profile URL) and — when *Scrape profile pages* is on, or for pasted profile URLs — the detail fields (full description, all skill labels, services offered, reviews). Ratings are out of 10.

#### 📦 Output sample

```json
{
  "rowType": "tradesperson",
  "companyId": "1183241",
  "name": "HS Construction Services Ltd",
  "slug": "hs-construction-services-ltd",
  "profileUrl": "https://www.checkatrade.com/trades/hs-construction-services-ltd",
  "summary": "Builders and general construction across London.",
  "logoUrl": "https://images.checkatrade.com/…/logo.png",
  "locality": "London",
  "region": "Greater London",
  "rating": 9.82,
  "recentReviewsCount": 40,
  "totalReviews": 77,
  "phone": "07401 291473",
  "phoneRaw": "+447401291473",
  "skills": [
    { "id": 12, "label": "Builder", "subSkills": ["Extensions", "Loft conversions"] },
    { "id": 34, "label": "Carpenter", "subSkills": ["Doors", "Flooring"] }
  ],
  "skillLabels": ["Builder", "Carpenter"],
  "qualityBadges": ["Verified"],
  "trackingBadges": ["insurance_verified"],
  "isSponsored": false,
  "memberSince": "2018",
  "images": ["https://images.checkatrade.com/…/project1.jpg"],
  "searchTrade": "Builder",
  "searchLocation": "London",
  "sourceUrl": "https://www.checkatrade.com/Search/Builder/in/London",
  "sourceMode": "search",
  "scrapedAt": "2026-07-06T05:00:00.000Z"
}
````

#### 🗂 Key output fields

| Field | Type | Notes |
|---|---|---|
| `name` / `profileUrl` | string | Company name + canonical profile URL |
| `phone` / `phoneRaw` | string | Formatted number + E.164 form |
| `locality` / `region` | string | Company location |
| `rating` | number | Recent mean review score, out of 10 |
| `recentReviewsCount` / `totalReviews` | number | Recent + all-time review counts |
| `skills` | array | Each skill group: id, label, sub-skills |
| `skillLabels` | string\[] | Flattened skill labels for easy filtering |
| `qualityBadges` / `trackingBadges` | string\[] | Quality + insurance-verification badges |
| `isSponsored` / `memberSince` | boolean / string | Sponsored flag + membership year |
| `logoUrl` / `images` | string / string\[] | Company logo + gallery images |
| `fullDescription` / `allSkillLabels` / `servicesOffered` / `reviews` | — | Present with `scrapeDetails` / on profile URLs |

#### ❓ FAQ

**Can I get the tradesperson's phone number?** Yes — the public phone number is returned for most listings, in both the formatted (`07401 291473`) and E.164 (`+447401291473`) forms.

**How many tradespeople can I get per search?** Checkatrade returns 12 per page and paginates deep (the stream carries `totalResults` / `totalPages`). Use a specific trade + location and `maxItemsPerSearch` to cap.

**What does *Scrape profile pages* add?** The search row is already rich (~30 fields). Turning it on visits each profile to add the **full description, all skill labels, services offered, accreditation and reviews** — at roughly double the requests. Profile URLs you paste are always fully detailed.

**Do I need to configure proxies?** No. UK residential routing is built in (Checkatrade blocks datacenter IPs with a Cloudflare challenge). Just give it a trade + location or URLs.

**Which locations work?** Any town, city or area Checkatrade supports, e.g. `London`, `Manchester`, `Birmingham`, `Leeds`. Multi-word areas are Title-Cased and dash-joined automatically.

#### 💬 Support

Found a bug or need an extra field? Open an issue on the [actor's Issues tab](https://apify.com/memo23/checkatrade-scraper/issues) and it'll be looked at quickly.

#### 🛠 Additional services

Need a custom field, another UK trades directory (Rated People, MyBuilder, TrustATrader), or a scheduled tradesperson feed into your CRM or warehouse? Custom scraping and pipeline work is available on request.

#### 🔎 Explore more scrapers

Looking for more directory, local-business or review data sources? Check out the other directory, lead-gen and review scrapers in the same publisher's collection on the Apify Store.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Checkatrade or any of its subsidiaries or affiliates. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available Checkatrade search-listing and trade-profile pages — no authenticated endpoints, no login-only or private data. Users are responsible for ensuring their use complies with Checkatrade's Terms of Service, applicable data-protection law (including UK GDPR where relevant) and any contractual obligations of their own organisation. Use scraped personal data (such as tradesperson names and phone numbers) lawfully and honour opt-out / do-not-contact requirements.

***

### SEO Keywords

checkatrade scraper, scrape checkatrade, checkatrade data extraction, checkatrade api, tradesperson scraper, uk trades directory scraper, checkatrade leads, checkatrade phone number scraper, builder scraper uk, electrician scraper, plumber scraper, checkatrade reviews scraper, local trades data, uk tradesmen data, checkatrade listings scraper, trades lead generation, checkatrade profiles, checkatrade search scraper, apify checkatrade, uk contractor data

# Actor input Schema

## `trade` (type: `string`):

The trade to search for, e.g. `Builder`, `Electrician`, `Plumber`, `Gas Boiler Servicing Repair`. Combined with each location below to build a search.

## `locations` (type: `array`):

Locations to search in, e.g. `London`, `Manchester`, `Birmingham`. Each is combined with the trade above (`/Search/{Trade}/in/{Location}`) and paginated. Leave empty with a trade set to search the whole UK.

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

Checkatrade search-listing URLs (`https://www.checkatrade.com/Search/Builder/in/London`) and/or trade-profile URLs (`https://www.checkatrade.com/trades/{slug}`). Auto-classified.

## `scrapeDetails` (type: `boolean`):

For each tradesperson found in a search, also fetch their profile page to add the full description, complete skills/sub-skills list, services offered and recent reviews. Richer rows, but ~2× the requests. Off = the listing-card fields (already ~30 per tradesperson). Profile URLs you paste are always fully detailed.

## `enrichEmails` (type: `boolean`):

If enabled, finds a contact email for each result from its own website (or by discovering it from the name). Adds contactEmail + contactWebsite columns plus a detailed emailEnrichment object. Best-effort.

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

Hard cap on rows across the entire run. Each row is one paid `tradesperson` event. Default 1000. Free-tier users are additionally capped at 100.

## `maxItemsPerSearch` (type: `integer`):

Cap per trade+location search. Checkatrade returns ~12 tradespeople per page. Default 1000.

## `maxConcurrency` (type: `integer`):

Parallel HTTP requests. Checkatrade is protected by Cloudflare — keep this moderate (4–8). Default 6.

## `maxRequestRetries` (type: `integer`):

Per-request retry budget on Cloudflare challenges (403), 429 and network errors. Each retry rotates to a fresh GB residential IP. Default 15 (the CF challenge is flaky — more retries help break through).

## `proxy` (type: `object`):

Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies.

## Actor input object example

```json
{
  "trade": "Builder",
  "locations": [
    "London"
  ],
  "startUrls": [],
  "scrapeDetails": false,
  "enrichEmails": false,
  "maxItems": 1000,
  "maxItemsPerSearch": 1000,
  "maxConcurrency": 6,
  "maxRequestRetries": 15
}
```

# 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 = {
    "trade": "Builder",
    "locations": [
        "London"
    ],
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/checkatrade-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 = {
    "trade": "Builder",
    "locations": ["London"],
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/checkatrade-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 '{
  "trade": "Builder",
  "locations": [
    "London"
  ],
  "startUrls": []
}' |
apify call memo23/checkatrade-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Checkatrade Scraper - UK Tradesperson Data",
        "description": "Scrape verified UK tradespeople from Checkatrade by trade + location or URL. One row per tradesperson: name, phone, location, rating, review counts, skills, badges, logo and profile URL. Optional full-profile enrichment. JSON/CSV out",
        "version": "0.1",
        "x-build-id": "vdzBwslJO3sd3ZLrF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~checkatrade-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-checkatrade-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/memo23~checkatrade-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-checkatrade-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/memo23~checkatrade-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-checkatrade-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "trade": {
                        "title": "Trade / category",
                        "type": "string",
                        "description": "The trade to search for, e.g. `Builder`, `Electrician`, `Plumber`, `Gas Boiler Servicing Repair`. Combined with each location below to build a search."
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Locations to search in, e.g. `London`, `Manchester`, `Birmingham`. Each is combined with the trade above (`/Search/{Trade}/in/{Location}`) and paginated. Leave empty with a trade set to search the whole UK.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Search & profile URLs",
                        "type": "array",
                        "description": "Checkatrade search-listing URLs (`https://www.checkatrade.com/Search/Builder/in/London`) and/or trade-profile URLs (`https://www.checkatrade.com/trades/{slug}`). Auto-classified.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeDetails": {
                        "title": "Scrape full profile pages",
                        "type": "boolean",
                        "description": "For each tradesperson found in a search, also fetch their profile page to add the full description, complete skills/sub-skills list, services offered and recent reviews. Richer rows, but ~2× the requests. Off = the listing-card fields (already ~30 per tradesperson). Profile URLs you paste are always fully detailed.",
                        "default": false
                    },
                    "enrichEmails": {
                        "title": "Enrich with contact emails (experimental)",
                        "type": "boolean",
                        "description": "If enabled, finds a contact email for each result from its own website (or by discovering it from the name). Adds contactEmail + contactWebsite columns plus a detailed emailEnrichment object. Best-effort.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max results (whole run)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on rows across the entire run. Each row is one paid `tradesperson` event. Default 1000. Free-tier users are additionally capped at 100.",
                        "default": 1000
                    },
                    "maxItemsPerSearch": {
                        "title": "Max tradespeople per search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap per trade+location search. Checkatrade returns ~12 tradespeople per page. Default 1000.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max parallel requests",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Parallel HTTP requests. Checkatrade is protected by Cloudflare — keep this moderate (4–8). Default 6.",
                        "default": 6
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Per-request retry budget on Cloudflare challenges (403), 429 and network errors. Each retry rotates to a fresh GB residential IP. Default 15 (the CF challenge is flaky — more retries help break through).",
                        "default": 15
                    },
                    "proxy": {
                        "title": "Proxy configuration (optional override)",
                        "type": "object",
                        "description": "Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
