# Hot UK Deals Scraper (`automation-lab/hot-uk-deals-scraper`) Actor

🛍️ Scrape HotUKDeals search and listing pages for prices, merchants, temperatures, comments, vouchers, categories, and deal URLs.

- **URL**: https://apify.com/automation-lab/hot-uk-deals-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 deal saveds

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

## Hot UK Deals Scraper

Scrape public HotUKDeals pages for deal monitoring, ecommerce price intelligence, affiliate research, and bargain alerts.

The actor extracts structured deal records from HotUKDeals search results, category/tag pages, and other public listing URLs. It uses lightweight HTTP requests and Cheerio parsing, so runs stay fast and inexpensive compared with browser-based scrapers.

### What does Hot UK Deals Scraper do?

Hot UK Deals Scraper collects public deal cards from `hotukdeals.com` and saves them as clean dataset rows.

It can extract:

- 🛍️ Deal titles and public deal URLs
- 💷 Prices and GBP currency markers
- 🏬 Merchants and merchant slugs
- 🌡️ Temperature / hotness scores
- 💬 Comment counts
- 🎟️ Voucher codes when visible
- 🧭 Categories and source queries
- 🖼️ Image URLs
- 👤 Public author usernames
- ⏱️ Published and expiry timestamps

### Who is it for?

#### Ecommerce analysts

Track market prices and promotional pressure across UK deal communities.

#### Affiliate publishers

Find fresh offers, product angles, and merchant opportunities for content planning.

#### Deal monitoring teams

Run scheduled searches for brands, categories, products, or competitor names.

#### Retail operators

Watch how community shoppers react to promotions through temperature and comments.

#### Automation builders

Feed HotUKDeals data into Slack, Google Sheets, Airtable, CRMs, dashboards, or custom alert systems.

### Why use this scraper?

- ⚡ Cheerio-first implementation for low compute usage
- 🔎 Search-query and direct-URL modes in one actor
- 🧾 Typed output with source attribution
- 🧊 Optional expired-deal filtering
- 🧱 Conservative pagination and item limits
- 🌐 Optional Apify proxy support
- 💸 Pay-per-event pricing suitable for scheduled monitoring

### How much does it cost to scrape HotUKDeals?

This actor uses pay-per-event pricing.

You pay a small run start fee and then a per-deal fee for each saved dataset item.

The final production prices are visible on the Apify actor page and in the run cost breakdown.

Cost depends mainly on:

- Number of search queries or start URLs
- Maximum pages per source
- Maximum deals saved
- Whether you enable proxies
- How often you schedule the actor

For most monitoring jobs, keep `maxItems` and `maxPages` close to the number of deals you actually need.

### Input overview

You can provide search queries, start URLs, or both.

#### Search queries

Use `searchQueries` when you want the actor to build HotUKDeals search URLs for you.

Examples:

- `laptop`
- `air fryer`
- `lego`
- `iphone`
- `samsung tv`

#### Start URLs

Use `startUrls` when you already know the HotUKDeals page you want to monitor.

Good examples:

- `https://www.hotukdeals.com/search?q=laptop`
- `https://www.hotukdeals.com/tag/electronics`
- `https://www.hotukdeals.com/tag/groceries`
- `https://www.hotukdeals.com/hot`

#### Limits

Use `maxItems` to cap total saved deals.

Use `maxPages` to cap pagination per query or start URL.

#### Expired deals

Set `includeExpired` to `false` if you only want currently active deals.

### Example input

```json
{
  "searchQueries": ["laptop", "air fryer"],
  "startUrls": [
    { "url": "https://www.hotukdeals.com/tag/electronics" }
  ],
  "maxItems": 100,
  "maxPages": 5,
  "includeExpired": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### Output data

Each dataset item is one HotUKDeals deal record.

| Field | Description |
| --- | --- |
| `id` | HotUKDeals thread ID |
| `title` | Deal title |
| `dealUrl` | Public HotUKDeals URL |
| `price` | Numeric price when available |
| `currency` | Currency marker, usually `GBP` |
| `merchant` | Merchant name |
| `merchantUrlName` | HotUKDeals merchant slug |
| `temperature` | Deal hotness score |
| `temperatureLevel` | HotUKDeals temperature level |
| `commentCount` | Number of comments |
| `isExpired` | Whether the deal is expired |
| `isHot` | Hot deal flag |
| `isNew` | New deal flag |
| `voucherCode` | Voucher code when exposed |
| `category` | Main category |
| `tags` | Keyword tags when available |
| `imageUrl` | Deal image URL |
| `description` | Listing snippet |
| `dealLinkHost` | External merchant host |
| `shareableLink` | HotUKDeals share URL |
| `author` | Public author username |
| `authorProfileUrl` | Public author profile URL |
| `publishedAt` | ISO publication timestamp |
| `expiresAt` | ISO expiry timestamp |
| `sourcePageUrl` | Page that produced the row |
| `sourceQuery` | Search query when applicable |
| `scrapedAt` | Scrape timestamp |

### Example output

```json
{
  "id": "4920103",
  "title": "UGREEN Adjustable Laptop Stand for Desk Prime Deal",
  "dealUrl": "https://www.hotukdeals.com/deals/example-4920103",
  "price": 22.52,
  "currency": "GBP",
  "merchant": "Amazon",
  "temperature": 72.63,
  "commentCount": 1,
  "isExpired": false,
  "category": "Electronics",
  "sourceQuery": "laptop",
  "scrapedAt": "2026-06-24T04:25:45.748Z"
}
```

### How to scrape HotUKDeals search results

1. Open the actor on Apify.
2. Add one or more `searchQueries`.
3. Set `maxItems` to your desired total deal count.
4. Keep `maxPages` modest for scheduled monitoring.
5. Run the actor.
6. Download the dataset as JSON, CSV, Excel, XML, or HTML.

### How to monitor a category

1. Open HotUKDeals in your browser.
2. Navigate to the category, tag, hot, or listing page you need.
3. Copy the URL.
4. Paste it into `startUrls`.
5. Set `includeExpired` depending on your workflow.
6. Schedule the actor hourly, daily, or weekly.

### Tips for better results

- Start with one query and a small item limit.
- Use specific product terms for alerting workflows.
- Use broader category pages for market discovery.
- Keep `includeExpired` enabled for historical price research.
- Disable `includeExpired` for active bargain alerts.
- Avoid very high page limits unless you need deep backfills.
- Use source fields to separate multiple queries in downstream tools.

### Integrations

#### Google Sheets

Connect the default dataset to Google Sheets to build a live deal tracker.

#### Slack or Discord

Use Apify integrations or webhooks to alert a channel when new deals match a search query.

#### Airtable

Store deal records in Airtable for editorial review and affiliate workflow tracking.

#### BI dashboards

Export recurring runs to BigQuery, Snowflake, or a warehouse for price trend analysis.

#### Zapier and Make

Trigger automations from completed Apify runs or dataset items.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/hot-uk-deals-scraper').call({
  searchQueries: ['laptop'],
  maxItems: 100,
  maxPages: 5
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/hot-uk-deals-scraper').call(run_input={
    'searchQueries': ['laptop'],
    'maxItems': 100,
    'maxPages': 5,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~hot-uk-deals-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["laptop"],"maxItems":100,"maxPages":5}'
```

### MCP usage

Use the actor from MCP-compatible tools through Apify MCP.

Claude Code setup:

```bash
claude mcp add apify-hotukdeals "https://mcp.apify.com/?tools=automation-lab/hot-uk-deals-scraper"
```

Claude Desktop configuration example:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/hot-uk-deals-scraper"
    }
  }
}
```

Example prompts:

- "Run the Hot UK Deals Scraper for laptop and summarize merchants with the hottest deals."
- "Monitor air fryer deals and tell me which ones are not expired."
- "Export the newest electronics deals to a CSV-friendly table."

### Scheduling

Scheduled runs are useful for recurring deal monitoring.

Recommended schedules:

- Hourly for urgent bargain alerts
- Daily for affiliate content planning
- Weekly for broad market trend snapshots

Use low limits for frequent schedules.

### Proxy settings

The actor works without a proxy for normal public pages.

Enable Apify Proxy only if your workload is rate-limited or your environment blocks direct access.

For cost control, try datacenter proxy settings before residential proxy settings.

### Troubleshooting

#### The run returns fewer deals than expected

Increase `maxPages`, use broader search terms, or enable `includeExpired`.

#### A query returns loosely related deals

HotUKDeals search may return related community results when an exact query has little inventory. Use more specific product names or direct category URLs.

#### A page fails with an HTTP error

Retry with a lower page limit. If repeated runs fail, enable proxy settings and keep the item limit small.

### Data freshness

HotUKDeals content changes constantly as users post, expire, vote, and comment on deals.

Run the actor on a schedule if you need a fresh monitoring feed.

### Limitations

- The actor extracts public listing/search data only.
- It does not log in to HotUKDeals.
- It does not post, vote, message users, or interact with accounts.
- Detail-page-only fields may be unavailable when not present in listing HTML.

### Legality

This actor extracts publicly available information from public HotUKDeals pages.

You are responsible for using the data in a lawful way and respecting applicable terms, privacy rules, and intellectual property rights.

Do not use scraped data for spam, harassment, or deceptive activity.

### Related scrapers

Explore related Automation Lab actors:

- https://apify.com/automation-lab/amazon-search-scraper
- https://apify.com/automation-lab/ebay-search-scraper
- https://apify.com/automation-lab/google-shopping-scraper
- https://apify.com/automation-lab/price-comparison-scraper
- https://apify.com/automation-lab/hotukdeals-deals-scraper

### FAQ

#### Can I scrape HotUKDeals by keyword?

Yes. Add keywords to `searchQueries` and the actor creates HotUKDeals search URLs automatically.

#### Can I scrape a category page?

Yes. Paste the public category or tag URL into `startUrls`.

#### Does it scrape voucher codes?

Yes, when voucher codes are visible in the public listing data.

#### Does it use a browser?

No. The MVP uses HTTP and Cheerio because HotUKDeals exposes deal data in server-rendered HTML.

#### Can I filter expired deals?

Yes. Set `includeExpired` to `false`.

#### Can I schedule recurring monitoring?

Yes. Use Apify schedules and keep limits appropriate for your monitoring cadence.

# Actor input Schema

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

Keywords to search on HotUKDeals, for example laptop, LEGO, air fryer, or iPhone. Each query creates a /search?q=... source.

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

Optional HotUKDeals URLs to scrape directly. Use search URLs, category pages, hot pages, or listing pages.

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

Maximum number of deal records to save across all queries and URLs.

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

Maximum listing/search result pages to request per query or start URL.

## `includeExpired` (type: `boolean`):

Keep expired deals in the output. Disable this for active-deal monitoring only.

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

Optional Apify proxy settings. The scraper works without a proxy for normal runs; enable proxy only if your workload is rate-limited.

## Actor input object example

```json
{
  "searchQueries": [
    "laptop",
    "air fryer"
  ],
  "startUrls": [
    {
      "url": "https://www.hotukdeals.com/search?q=laptop"
    }
  ],
  "maxItems": 20,
  "maxPages": 5,
  "includeExpired": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "searchQueries": [
        "laptop",
        "air fryer"
    ],
    "startUrls": [
        {
            "url": "https://www.hotukdeals.com/search?q=laptop"
        }
    ],
    "maxItems": 20,
    "maxPages": 5,
    "includeExpired": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/hot-uk-deals-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 = {
    "searchQueries": [
        "laptop",
        "air fryer",
    ],
    "startUrls": [{ "url": "https://www.hotukdeals.com/search?q=laptop" }],
    "maxItems": 20,
    "maxPages": 5,
    "includeExpired": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/hot-uk-deals-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 '{
  "searchQueries": [
    "laptop",
    "air fryer"
  ],
  "startUrls": [
    {
      "url": "https://www.hotukdeals.com/search?q=laptop"
    }
  ],
  "maxItems": 20,
  "maxPages": 5,
  "includeExpired": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/hot-uk-deals-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hot UK Deals Scraper",
        "description": "🛍️ Scrape HotUKDeals search and listing pages for prices, merchants, temperatures, comments, vouchers, categories, and deal URLs.",
        "version": "0.1",
        "x-build-id": "me2wjrejOPGXHyUZQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~hot-uk-deals-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-hot-uk-deals-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~hot-uk-deals-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-hot-uk-deals-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~hot-uk-deals-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-hot-uk-deals-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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords to search on HotUKDeals, for example laptop, LEGO, air fryer, or iPhone. Each query creates a /search?q=... source.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional HotUKDeals URLs to scrape directly. Use search URLs, category pages, hot pages, or listing pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum deals",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of deal records to save across all queries and URLs.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Maximum pages per source",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum listing/search result pages to request per query or start URL.",
                        "default": 5
                    },
                    "includeExpired": {
                        "title": "Include expired deals",
                        "type": "boolean",
                        "description": "Keep expired deals in the output. Disable this for active-deal monitoring only.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings. The scraper works without a proxy for normal runs; enable proxy only if your workload is rate-limited."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```