# Thomson Local Business Scraper (`automation-lab/thomson-local-business-scraper`) Actor

Scrape public UK Thomson Local business listings for lead generation: names, phones, addresses, websites, ratings, and profile URLs.

- **URL**: https://apify.com/automation-lab/thomson-local-business-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 60.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Business Scraper

Extract public UK business leads from Thomson Local search results and business profile pages.

Use this Apify Actor to collect company names, categories, postal addresses, phone numbers, websites, profile URLs, ratings, review counts, badges, and short descriptions from Thomson Local.

### What does Thomson Local Business Scraper do?

Thomson Local Business Scraper turns Thomson Local category and location searches into structured lead records.

It is designed for public business-directory data.

You can provide category/location pairs such as `plumbers` + `London`.

You can also provide Thomson Local search URLs directly.

The Actor follows pagination when a next-page link is available.

It can optionally open public business profile pages for enrichment.

### Who is it for? Thomson Local Business Scraper users

#### Lead-generation agencies

Build prospect lists for local outreach campaigns.

#### Local SEO consultants

Find businesses in a target niche and city.

#### Sales teams

Collect phone and website fields for UK business prospecting.

#### Market researchers

Compare density of trades, services, and categories across UK locations.

#### Data teams

Create repeatable Thomson Local extracts for dashboards or CRM imports.

### Why use this Actor?

- 🌍 Focused on a UK business directory source.
- 📍 Supports category + location searches.
- ☎️ Extracts phone and address lead data where public.
- 🔗 Captures profile and website URLs for verification.
- ⭐ Includes ratings and review counts when available.
- 🧾 Outputs clean JSON rows in an Apify dataset.
- ⚙️ Offers optional profile-page enrichment.

### Data extracted

| Field | Description |
| --- | --- |
| `businessName` | Public business/listing name |
| `category` | Thomson Local category or breadcrumb context |
| `address` | Public postal address text |
| `locality` | City/town when detected |
| `postalCode` | UK postcode when detected |
| `phone` | Public phone number when available |
| `website` | Business website URL when available |
| `profileUrl` | Thomson Local business profile URL |
| `searchUrl` | Search page where the record was found |
| `rating` | Rating text/value when visible |
| `reviewCount` | Number of reviews when visible |
| `description` | Listing/profile description snippet |
| `badges` | Public badges such as quote/availability labels when visible |
| `source` | Always `thomsonlocal.com` |
| `scrapedAt` | ISO timestamp of extraction |

### How much does it cost to scrape Thomson Local business leads?

The Actor uses pay-per-event pricing.

There is a small start event per run.

Each saved business lead is charged as an item event.

Exact tiered prices are shown on the Apify Store page after the Actor is configured for production.

Use a low `maxItems` value for your first run.

### Input options

#### Category/location searches

Use `searches` to enter objects like:

```json
[
  { "category": "plumbers", "location": "London" },
  { "category": "electricians", "location": "Manchester" }
]
````

#### Start URLs

Use `startUrls` when you already have a Thomson Local URL.

```json
[
  { "url": "https://www.thomsonlocal.com/search/plumbers/london" }
]
```

#### Maximum businesses

`maxItems` controls the total number of saved rows.

#### Maximum pages

`maxPages` controls how many search pages are followed for each search.

#### Include details

`includeDetails` visits public profile pages for enrichment when profile links are available. It is off by default for fast lead-list collection; enable it when you need richer profile-page data.

#### Use proxy

`useProxy` is enabled by default because Thomson Local rejects Apify cloud direct IPs. You can disable it for local/direct network tests.

### Example input

```json
{
  "searches": [
    { "category": "plumbers", "location": "London" }
  ],
  "maxItems": 25,
  "maxPages": 3,
  "includeDetails": false,
  "useProxy": true
}
```

### Example output

```json
{
  "businessName": "Example Plumbing Ltd",
  "category": "Plumbers",
  "address": "1 High Street, London, SW1A 1AA",
  "locality": "London",
  "postalCode": "SW1A 1AA",
  "phone": "020 0000 0000",
  "website": "https://example.co.uk",
  "profileUrl": "https://www.thomsonlocal.com/...",
  "searchUrl": "https://www.thomsonlocal.com/search/plumbers/london",
  "rating": "4.8",
  "reviewCount": 12,
  "description": "Local plumbing services...",
  "badges": ["Open now"],
  "source": "thomsonlocal.com",
  "scrapedAt": "2026-06-19T00:00:00.000Z"
}
```

### How to scrape Thomson Local business leads

1. Open the Actor on Apify.
2. Add one or more category/location searches.
3. Keep `maxItems` small for your first test.
4. Run the Actor.
5. Open the dataset.
6. Export JSON, CSV, Excel, XML, RSS, or HTML.
7. Import the leads into your CRM or spreadsheet.

### Tips for better results

- Use specific categories such as `roofers`, `dentists`, or `restaurants`.
- Use real UK towns, cities, or postcodes.
- Increase `maxPages` only after a small test succeeds.
- Enable profile enrichment when you need websites and descriptions.
- Disable profile enrichment for faster broad scans.
- Keep searches focused to avoid mixing unrelated services.

### Integrations

Send results to Google Sheets with Apify integrations.

Push leads to Make or Zapier workflows.

Store the dataset in S3 or Google Drive.

Trigger follow-up enrichment Actors from the dataset.

Feed records into CRM imports for HubSpot, Pipedrive, or Salesforce.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/thomson-local-business-scraper').call({
  searches: [{ category: 'plumbers', location: 'London' }],
  maxItems: 25,
  includeDetails: false
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/thomson-local-business-scraper').call(run_input={
    'searches': [{'category': 'plumbers', 'location': 'London'}],
    'maxItems': 25,
    'includeDetails': False,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~thomson-local-business-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searches":[{"category":"plumbers","location":"London"}],"maxItems":25}'
```

### MCP usage

Use this Actor from Claude Desktop, Claude Code, or other MCP clients through Apify MCP.

MCP endpoint:

```text
https://mcp.apify.com/?tools=automation-lab/thomson-local-business-scraper
```

Claude Code setup:

```bash
claude mcp add apify-thomson-local https://mcp.apify.com/?tools=automation-lab/thomson-local-business-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-thomson-local": {
      "url": "https://mcp.apify.com/?tools=automation-lab/thomson-local-business-scraper"
    }
  }
}
```

Example prompts showing MCP usage:

- "Scrape 25 Thomson Local plumbers in London."
- "Find electricians in Manchester from Thomson Local and return phone numbers."
- "Collect Thomson Local business profile URLs for dentists in Bristol."
- "Run automation-lab/thomson-local-business-scraper for builders in Leeds and summarize rows with websites."

### Data quality notes

Thomson Local pages can vary by category and location.

Some listings may not publish a website.

Some listings may not publish ratings or reviews.

The Actor leaves missing fields as `null` rather than inventing values.

The `searchUrl` field helps audit where each record came from.

### FAQ

#### Can I scrape by Thomson Local URL instead of category and location?

Yes. Add one or more Thomson Local search URLs to `startUrls` if you already have the exact directory pages you want to process.

#### Does the Actor visit business profile pages?

Yes, when `includeDetails` is enabled. Turn it off for faster lead-list collection when search-page fields are enough.

### Troubleshooting

#### Why did I get no results?

Try a different category/location pair, reduce spelling ambiguity, or provide a Thomson Local search URL directly.

If requests are slow or blocked, keep `useProxy` enabled (the default) or try a different proxy country/group.

#### Why are some websites missing?

Not every Thomson Local listing exposes a website on the search page or public profile page.

Enable `includeDetails` to improve website coverage.

#### Why are there fewer rows than `maxItems`?

The source may have fewer visible listings for your search, or the Actor may stop after `maxPages` pages.

Increase `maxPages` if the source has more pages.

### Legality and responsible use

This Actor extracts publicly available business-directory information.

You are responsible for ensuring that your use complies with applicable laws, platform terms, and privacy rules.

Do not use scraped contact data for spam.

Respect opt-out requests and local marketing regulations.

### Related scrapers

- https://apify.com/automation-lab/yellowpages-scraper
- https://apify.com/automation-lab/gelbeseiten-scraper
- https://apify.com/automation-lab/das-telefonbuch-business-scraper

### Limits

This Actor does not log in.

It does not bypass paywalls.

It only targets public Thomson Local pages.

It does not guarantee every listing has every field.

### Changelog

#### 0.1

Initial version for public Thomson Local business lead extraction.

### Support

If you need help, open an issue on the Apify Actor page and include your run ID.

### Development status

This Actor is part of the Automation Lab business-directory lead-generation cluster.

It is intended as a UK Thomson Local satellite source for agencies that already use other local-business scrapers.

# Actor input Schema

## `searches` (type: `array`):

Add Thomson Local category and UK location pairs. Example: category 'plumbers', location 'London'.

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

Optional Thomson Local search result or business profile URLs to scrape.

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

Maximum number of business lead records to save.

## `maxPages` (type: `integer`):

Safety limit for pagination on each Thomson Local search URL.

## `includeDetails` (type: `boolean`):

Open each public Thomson Local business profile when available to enrich phone, website, description, rating, and address fields. Keep disabled for fast default QA/smoke runs; enable for richer lead records.

## `useProxy` (type: `boolean`):

Enable Apify Proxy for cloud reliability. Thomson Local rejects Apify cloud direct IPs, so this is enabled by default.

## `proxyGroups` (type: `array`):

Advanced: Apify Proxy groups to use when proxy is enabled. Leave empty to use Apify automatic proxy selection.

## `proxyCountryCode` (type: `string`):

Advanced: optional country code for Apify Proxy when proxy is enabled. Leave empty for Apify automatic country selection.

## Actor input object example

```json
{
  "searches": [
    {
      "category": "plumbers",
      "location": "London"
    }
  ],
  "startUrls": [
    {
      "url": "https://www.thomsonlocal.com/search/plumbers/london"
    }
  ],
  "maxItems": 20,
  "maxPages": 3,
  "includeDetails": false,
  "useProxy": true,
  "proxyGroups": [],
  "proxyCountryCode": ""
}
```

# Actor output Schema

## `businessLeads` (type: `string`):

No description

# 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 = {
    "searches": [
        {
            "category": "plumbers",
            "location": "London"
        }
    ],
    "startUrls": [
        {
            "url": "https://www.thomsonlocal.com/search/plumbers/london"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/thomson-local-business-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 = {
    "searches": [{
            "category": "plumbers",
            "location": "London",
        }],
    "startUrls": [{ "url": "https://www.thomsonlocal.com/search/plumbers/london" }],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/thomson-local-business-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 '{
  "searches": [
    {
      "category": "plumbers",
      "location": "London"
    }
  ],
  "startUrls": [
    {
      "url": "https://www.thomsonlocal.com/search/plumbers/london"
    }
  ]
}' |
apify call automation-lab/thomson-local-business-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Thomson Local Business Scraper",
        "description": "Scrape public UK Thomson Local business listings for lead generation: names, phones, addresses, websites, ratings, and profile URLs.",
        "version": "0.1",
        "x-build-id": "9FW78KbDgctRlRdBc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~thomson-local-business-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-thomson-local-business-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/automation-lab~thomson-local-business-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-thomson-local-business-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/automation-lab~thomson-local-business-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-thomson-local-business-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": {
                    "searches": {
                        "title": "Category/location searches",
                        "type": "array",
                        "description": "Add Thomson Local category and UK location pairs. Example: category 'plumbers', location 'London'."
                    },
                    "startUrls": {
                        "title": "Thomson Local search/profile URLs",
                        "type": "array",
                        "description": "Optional Thomson Local search result or business profile URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum businesses",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of business lead records to save.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Maximum search pages per search",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Safety limit for pagination on each Thomson Local search URL.",
                        "default": 3
                    },
                    "includeDetails": {
                        "title": "Visit business profile pages",
                        "type": "boolean",
                        "description": "Open each public Thomson Local business profile when available to enrich phone, website, description, rating, and address fields. Keep disabled for fast default QA/smoke runs; enable for richer lead records.",
                        "default": false
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Enable Apify Proxy for cloud reliability. Thomson Local rejects Apify cloud direct IPs, so this is enabled by default.",
                        "default": true
                    },
                    "proxyGroups": {
                        "title": "Proxy groups",
                        "type": "array",
                        "description": "Advanced: Apify Proxy groups to use when proxy is enabled. Leave empty to use Apify automatic proxy selection.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyCountryCode": {
                        "title": "Proxy country code",
                        "type": "string",
                        "description": "Advanced: optional country code for Apify Proxy when proxy is enabled. Leave empty for Apify automatic country selection.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
