# Thomson Local Scraper (`solidcode/thomson-local-scraper`) Actor

\[💰 $1.5 / 1K] Extract UK business listings from Thomson Local — name, full address, phone, website, email, category, and opening hours. Search by business type and location or paste search URLs, with optional deep contact-detail enrichment.

- **URL**: https://apify.com/solidcode/thomson-local-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

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

## Thomson Local Scraper

Pull UK business listings from Thomson Local at scale — company names, full postal addresses, phone numbers, websites, emails, categories, opening hours, and trade accreditations, all in one clean row per business. Search by business type and town in plain English, batch dozens of trades and cities in a single run, or paste search-result URLs straight from your browser. Built for UK lead-generation teams, sales and territory planners, and market researchers who need structured local-business contact data without copy-pasting the directory by hand.

### Why This Scraper?

- **20 structured fields per business** — name, categories, description, phone, extra phones, fax, email, website, street address, locality, postcode, logo image, opening hours, payment options, accreditations, and more, ready for a CRM the moment the run finishes.
- **Logo and photo image URLs on featured listings** — the `image` field captures each promoted listing's logo or photo straight from the results page, ready to display in your own lists and dashboards.
- **Batch many trades and towns in one run** — `searchTerms` takes a whole list (plumbers, electricians, accountants…), each searched in your chosen UK location. The competing tool accepts a single search term at a time.
- **Deep contact enrichment on demand** — flip on `scrapeContactDetails` to pull each listing's website, email, extra phone numbers, opening hours, payment methods, and trade accreditations — data that never appears on the results page.
- **Opening hours as a day-by-day map** — Monday through Sunday returned as a structured `{ day: hours }` object with full English day names, not a blob of text you have to re-parse.
- **Trade-body accreditations captured** — memberships and badges such as Gas Safe Registered and the Institute of Plumbing come through in their own field, ideal for vetting qualified tradespeople.
- **Result-count caps, not page caps** — ask for exactly the number of listings you want with `maxResults`, and balance multi-trade runs with a per-term cap via `maxResultsPerSearch`. No more guessing how many pages equals 250 businesses.
- **Overshoot-safe capping** — the actor keeps the full final page instead of cutting it off mid-way, so you never lose the last handful of businesses to a hard trim.
- **Paste any Thomson Local search URL** — hand the actor a filtered or sorted view straight from your browser via `searchUrls`; it reads the business type and location from the link automatically.
- **Nationwide UK coverage** — search any town, city, or region across the United Kingdom, or leave the location blank for a UK-wide sweep.

### Use Cases

**Lead Generation**
- Build targeted contact lists of tradespeople, shops, and service firms in any UK town
- Capture phone, email, and website for each business in a single pass
- Assemble outreach lists by trade — plumbers, electricians, roofers, accountants
- Enrich thin CRM records with full addresses and opening hours

**Sales Prospecting & Territory Planning**
- Map every business of a given type across a city or region before a sales push
- Balance prospect counts across territories with per-term result caps
- Prioritise accredited firms (e.g. Gas Safe Registered) for higher-value outreach
- Segment prospects by locality and postcode for route planning

**Market & Competitor Research**
- Size a local market by counting active businesses in a category and area
- Compare business density across towns and regions
- Track categories, descriptions, and payment options competitors advertise
- Benchmark opening hours and service offerings in your sector

**Local SEO & Directory Audits**
- Verify a client's NAP (name, address, phone) consistency against the directory
- Audit which competitors appear for a keyword-and-location search
- Spot missing websites or emails to pitch listing-improvement services
- Monitor category tags and descriptions across a client portfolio

**Data Enrichment & Integration**
- Append postcodes, websites, and emails to an existing supplier database
- Feed clean UK business records into analytics dashboards and BI tools
- Power comparison tools and local directories with fresh listing data
- Keep contact databases current with scheduled re-runs

### Getting Started

#### Simple — one trade in one town

```json
{
    "searchTerms": ["plumbers"],
    "location": "London",
    "maxResults": 100
}
````

#### Multiple trades with a per-term cap

```json
{
    "searchTerms": ["plumbers", "electricians", "roofers"],
    "location": "Manchester",
    "maxResults": 300,
    "maxResultsPerSearch": 100
}
```

#### Full contact details from pasted search URLs

```json
{
    "searchUrls": [
        "https://www.thomsonlocal.com/search/plumbers/london",
        "https://www.thomsonlocal.com/search/accountants/bristol"
    ],
    "scrapeContactDetails": true,
    "maxResults": 200
}
```

### Input Reference

#### Search — what to find and where

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | string\[] | `["plumbers"]` | Business types or keywords to look up (e.g. "plumbers", "car dealers", "accountants"). Each term is searched in the location below. Add as many as you like. |
| `location` | string | `"London"` | UK town, city, or region to search in. Leave empty for a UK-wide search, or if your search URLs already include a location. |
| `searchUrls` | string\[] | `[]` | Paste Thomson Local search-result URLs directly. The actor reads the business type and location from each URL — handy when you already have searches set up in your browser. |

At least one of `searchTerms` or `searchUrls` is required.

#### Options — how much to collect

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum listings to return in total across all searches. Set to 0 for unlimited (a safety cap still applies to prevent runaway paging). The full final page is kept even if it slightly overshoots this number. |
| `maxResultsPerSearch` | integer | `0` | Optional cap on results for each individual search term — useful for balancing results across many terms. Set to 0 for no per-term limit. |
| `scrapeContactDetails` | boolean | `false` | Open each listing's detail page to also collect website, email, extra phones, fax, opening hours, payment options, and accreditations. Much richer data, but slower and a little more costly. |

### Output

Each business is one flat row. Here's a representative result with contact details enabled:

```json
{
    "name": "Mike Griffin Heating & Plumbing",
    "categories": ["plumbers", "heating engineers"],
    "description": "Family-run heating and plumbing company serving Greater London since 1998.",
    "phone": "020 7946 0123",
    "additionalPhones": ["07973 288275"],
    "fax": [],
    "email": "info@mikegriffinplumbing.co.uk",
    "website": "https://www.mikegriffinplumbing.co.uk",
    "address": "42 Kingsland Road",
    "locality": "London",
    "postcode": "E2 8DA",
    "image": "https://images.thomsonlocal.com/advantage/98/thumb_ff258078.png",
    "openingHours": {
        "Monday": "09:00-17:30",
        "Tuesday": "09:00-17:30",
        "Wednesday": "09:00-17:30",
        "Thursday": "09:00-17:30",
        "Friday": "09:00-17:30",
        "Saturday": "09:00-13:00",
        "Sunday": "Closed"
    },
    "paymentOptions": ["Visa", "Mastercard", "Cash", "Bank transfer"],
    "accreditations": ["Gas Safe Registered", "Institute of Plumbing"],
    "additionalLinks": ["https://www.facebook.com/mikegriffinplumbing"],
    "listingType": null,
    "detailUrl": "https://www.thomsonlocal.com/search/plumbers/london/mike-griffin-heating-plumbing/2862515/02079460123",
    "searchTerm": "plumbers",
    "scrapedAt": "2026-07-02T14:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Business name |
| `categories` | string\[] | Category tags for the business. This reflects the search term the listing was found under; when a listing publishes its own extra directory categories, `scrapeContactDetails` adds them too |
| `description` | string | Short business description or sales blurb |
| `listingType` | string | Listing tier (e.g. premium, featured) — populated only when the directory flags a paid tier on the listing; otherwise `null` |
| `detailUrl` | string | URL of the listing's detail page |
| `searchTerm` | string | The search term this row came from |
| `scrapedAt` | string | ISO-8601 timestamp of capture |

#### Media Field

Pulled straight from the results page — no `scrapeContactDetails` needed.

| Field | Type | Description |
|-------|------|-------------|
| `image` | string | Logo or photo image URL — present on featured/promoted listings that supply one |

#### Contact Fields

Website, email, and extra phones populate when `scrapeContactDetails` is on and the business publishes them.

| Field | Type | Description |
|-------|------|-------------|
| `phone` | string | Primary phone number |
| `additionalPhones` | string\[] | Additional phone numbers |
| `email` | string | Contact email address |
| `website` | string | Business website URL |
| `fax` | string\[] | Fax numbers — included only when the business publishes a fax number (uncommon today, so usually `[]`) |

#### Address Fields

| Field | Type | Description |
|-------|------|-------------|
| `address` | string | Street address line |
| `locality` | string | Town or city |
| `postcode` | string | UK postcode |

#### Extra Detail Fields

Populated when `scrapeContactDetails` is on.

| Field | Type | Description |
|-------|------|-------------|
| `openingHours` | object | Day-to-hours map with full English day names (e.g. `{ "Monday": "09:00-17:30", "Sunday": "Closed" }`) |
| `paymentOptions` | string\[] | Accepted payment methods |
| `accreditations` | string\[] | Trade-body memberships and badges (e.g. Gas Safe Registered) |
| `additionalLinks` | string\[] | Other links on the listing (social profiles, booking pages) |

### Tips for Best Results

- **Turn on full contact details only when you need email and website** — leave `scrapeContactDetails` off for fast, broad listing sweeps, and switch it on when you need email, website, opening hours, and accreditations. It adds a per-listing lookup, so runs take a little longer.
- **Balance multi-trade runs with a per-term cap** — set `maxResultsPerSearch` when you list several business types so one busy category (like plumbers in London) doesn't crowd out the rest.
- **Start small to test** — run with `maxResults` of 25–50 first to confirm the data fits your needs, then scale up.
- **Paste a search URL to mirror an exact filtered view** — if you've already set up a sorted or filtered search on Thomson Local, drop the URL into `searchUrls` and the actor reproduces that exact view.
- **Leave the location blank for a UK-wide sweep** — omit `location` (and use plain search terms) to collect a business type across the whole country.
- **Use precise trade keywords** — specific terms like "gas engineers" or "commercial electricians" return tighter, higher-quality lists than broad ones.
- **Filter for accredited firms downstream** — the `accreditations` field makes it easy to keep only Gas Safe Registered or trade-body-certified businesses for higher-value outreach.

### Pricing

**From $1.50 per 1,000 results** — a clean, flat per-result rate that undercuts other UK directory scrapers. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.18 | $0.17 | $0.16 | $0.15 |
| 1,000 | $1.80 | $1.70 | $1.60 | $1.50 |
| 10,000 | $18.00 | $17.00 | $16.00 | $15.00 |
| 100,000 | $180.00 | $170.00 | $160.00 | $150.00 |

A "result" is any business row in the output dataset. **No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.**

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor collects publicly available business-listing information from Thomson Local for legitimate purposes such as market research, sales prospecting, and lead generation. You are responsible for complying with applicable laws and Thomson Local's Terms of Service. Contact details may constitute personal data under UK GDPR — handle them lawfully, honour opt-outs and marketing-preference rules, and do not use extracted data for spam, harassment, or any unlawful purpose.

# Actor input Schema

## `searchTerms` (type: `array`):

Business categories or keywords to look up, such as 'plumbers', 'car dealers', or 'accountants'. Each term is searched in the location below. Add as many as you like.

## `location` (type: `string`):

UK town, city, or region to search in, such as 'London', 'Manchester', or 'Bristol'. Leave empty for a UK-wide search, or if your search URLs already include a location.

## `searchUrls` (type: `array`):

Paste Thomson Local search-result URLs directly (e.g. https://www.thomsonlocal.com/search/plumbers/london). The actor reads the business type and location from each URL — handy if you already have searches set up in your browser.

## `maxResults` (type: `integer`):

Maximum number of business listings to return in total across all your searches. Set to 0 for unlimited (a safety maximum of 400 pages per search still applies to prevent runaway paging — about 10,000 listings). The actor keeps the full final page even if it slightly overshoots this number.

## `maxResultsPerSearch` (type: `integer`):

Optional cap on results for each individual search term. Useful for balancing results when you have many terms. Set to 0 for no per-term limit.

## `scrapeContactDetails` (type: `boolean`):

Open each listing's detail page to also collect website, email, extra phone numbers, fax, opening hours, payment options, and accreditations. This gives much richer data but is slower and costs more.

## Actor input object example

```json
{
  "searchTerms": [
    "plumbers"
  ],
  "location": "London",
  "searchUrls": [],
  "maxResults": 100,
  "maxResultsPerSearch": 0,
  "scrapeContactDetails": false
}
```

# Actor output Schema

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

Table of business listings with key fields like name, category, address, and phone.

## `contact` (type: `string`):

Full per-listing contact info including website, email, extra phones, fax, and opening hours.

# 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 = {
    "searchTerms": [
        "plumbers"
    ],
    "location": "London",
    "searchUrls": [],
    "maxResults": 100,
    "maxResultsPerSearch": 0,
    "scrapeContactDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/thomson-local-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 = {
    "searchTerms": ["plumbers"],
    "location": "London",
    "searchUrls": [],
    "maxResults": 100,
    "maxResultsPerSearch": 0,
    "scrapeContactDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/thomson-local-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 '{
  "searchTerms": [
    "plumbers"
  ],
  "location": "London",
  "searchUrls": [],
  "maxResults": 100,
  "maxResultsPerSearch": 0,
  "scrapeContactDetails": false
}' |
apify call solidcode/thomson-local-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Thomson Local Scraper",
        "description": "[💰 $1.5 / 1K] Extract UK business listings from Thomson Local — name, full address, phone, website, email, category, and opening hours. Search by business type and location or paste search URLs, with optional deep contact-detail enrichment.",
        "version": "1.0",
        "x-build-id": "X2nGYmD7gi6Oo4iDl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~thomson-local-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-thomson-local-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/solidcode~thomson-local-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-thomson-local-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/solidcode~thomson-local-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-thomson-local-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": {
                    "searchTerms": {
                        "title": "Business Types or Keywords",
                        "type": "array",
                        "description": "Business categories or keywords to look up, such as 'plumbers', 'car dealers', or 'accountants'. Each term is searched in the location below. Add as many as you like.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "UK town, city, or region to search in, such as 'London', 'Manchester', or 'Bristol'. Leave empty for a UK-wide search, or if your search URLs already include a location."
                    },
                    "searchUrls": {
                        "title": "Thomson Local Search URLs",
                        "type": "array",
                        "description": "Paste Thomson Local search-result URLs directly (e.g. https://www.thomsonlocal.com/search/plumbers/london). The actor reads the business type and location from each URL — handy if you already have searches set up in your browser.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of business listings to return in total across all your searches. Set to 0 for unlimited (a safety maximum of 400 pages per search still applies to prevent runaway paging — about 10,000 listings). The actor keeps the full final page even if it slightly overshoots this number.",
                        "default": 100
                    },
                    "maxResultsPerSearch": {
                        "title": "Maximum Results Per Search Term",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional cap on results for each individual search term. Useful for balancing results when you have many terms. Set to 0 for no per-term limit.",
                        "default": 0
                    },
                    "scrapeContactDetails": {
                        "title": "Collect Full Contact Details",
                        "type": "boolean",
                        "description": "Open each listing's detail page to also collect website, email, extra phone numbers, fax, opening hours, payment options, and accreditations. This gives much richer data but is slower and costs more.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
