# Pepper Network Deals Scraper (`automation-lab/pepper-network-deals-scraper`) Actor

Scrape Dealabs, HotUKDeals, MyDealz, Pepper.pl, and Pepper NL deals with normalized prices, merchants, temperatures, comments, and URLs.

- **URL**: https://apify.com/automation-lab/pepper-network-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

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

## Pepper Network Deals Scraper

Scrape normalized deal listings from Pepper-network communities such as Dealabs, HotUKDeals, MyDealz, Pepper.pl, and nl.pepper.com. The actor turns public community deal cards into structured ecommerce intelligence with prices, temperatures, merchants, categories, comments, and URLs.

Use it when you need one workflow for multiple Pepper sites instead of maintaining separate parsers for every locale.

### What does Pepper Network Deals Scraper do?

Pepper Network Deals Scraper fetches public listing, hot, search, category, merchant, and voucher pages from supported Pepper deal communities.

It extracts deal cards from the server-rendered HTML and embedded Pepper thread payloads.

Each dataset item is normalized across locales so downstream spreadsheets, dashboards, alerts, and affiliate workflows can compare UK, French, German, Polish, and Dutch deal communities with the same field names.

### Supported Pepper communities

The actor currently supports these public Pepper-network sites:

- Dealabs France (`dealabs`)
- HotUKDeals United Kingdom (`hotukdeals`)
- MyDealz Germany (`mydealz`)
- Pepper.pl Poland (`pepper_pl`)
- Pepper Netherlands (`pepper_nl`)

You can provide search terms and let the actor generate each site's search URL, or paste direct listing URLs from supported sites.

### Who is it for?

This scraper is useful for ecommerce operators, affiliate publishers, marketplace analysts, resellers, deal hunters, pricing teams, and data teams that monitor consumer deal communities.

Common users include:

- Affiliate editors looking for trending offers before writing buying guides
- Ecommerce analysts comparing merchant promotions across countries
- Resellers checking hot products, categories, and price signals
- Brand teams watching community temperature and comment activity
- Developers building deal-monitoring, alerting, or BI pipelines

### Why use this actor?

Pepper communities share similar structures but expose different locales, currencies, URLs, and community labels.

This actor saves time by normalizing those differences into one dataset.

Instead of running separate scrapers, joining outputs manually, and renaming fields, you get consistent `site`, `priceText`, `currency`, `temperature`, `merchant`, `category`, `commentCount`, `dealUrl`, and `sourceUrl` columns.

### Data you can extract

| Field | Description |
| --- | --- |
| `site` / `siteName` | Pepper community identifier and readable name |
| `title` | Deal title from the listing card |
| `price`, `priceText`, `currency` | Numeric and formatted price signals |
| `oldPrice`, `oldPriceText`, `discountPercent` | Comparison price and discount data when available |
| `temperature`, `temperatureText`, `temperatureLevel` | Community heat signal |
| `merchant`, `merchantHost` | Merchant or destination host |
| `category`, `categorySlug` | Pepper category/group fields |
| `isExpired`, `isHot`, `isNew` | Deal status flags |
| `voucherCode`, `hasVoucherCode` | Voucher information when exposed on the card |
| `commentCount`, `voteCount` | Engagement signals |
| `author` | Deal submitter username when available |
| `dealUrl`, `shareUrl`, `outboundUrl` | Useful URLs for review and workflows |
| `imageUrl` | Deal image when present |
| `postedAt`, `updatedAt` | Timestamps when exposed by Pepper |
| `sourceUrl`, `sourcePage`, `scrapedAt` | Crawl provenance |

### How much does it cost to scrape Pepper deal listings?

The actor uses pay-per-event pricing.

There is a small start charge per run and a per-item charge for each saved deal row.

The current pricing configured for QA is:

- Start: `$0.005` per run
- Item: tiered pricing with BRONZE at `$0.000032796` per saved deal

Final live pricing should always be checked on the actor's Apify Store page before production use.

### Input options

You can control the crawl with these inputs:

- `searchQueries` — product, brand, or category keywords to search across selected Pepper sites
- `sites` — supported Pepper communities to use for generated searches
- `startUrls` — direct URLs such as `/deals`, `/hot`, `/search?q=...`, category, merchant, or voucher pages
- `maxItems` — total maximum deal rows to save
- `maxPagesPerSource` — pagination depth for each source URL
- `includeExpired` — include expired deal cards if the listing returns them
- `requestDelayMs` — polite delay between page requests

Use either `searchQueries`, `startUrls`, or both.

If neither is provided, the actor scrapes default hot/deal pages for Dealabs, HotUKDeals, and MyDealz.

### Example input: search laptops across markets

```json
{
  "searchQueries": ["laptop"],
  "sites": ["dealabs", "hotukdeals", "mydealz"],
  "maxItems": 60,
  "maxPagesPerSource": 2,
  "includeExpired": false,
  "requestDelayMs": 500
}
````

This run searches three Pepper communities and returns comparable deal rows for laptop-related offers.

### Example input: scrape a direct HotUKDeals page

```json
{
  "startUrls": [{ "url": "https://www.hotukdeals.com/deals" }],
  "maxItems": 50,
  "maxPagesPerSource": 2,
  "includeExpired": false,
  "requestDelayMs": 500
}
```

Use direct URLs when you already know the listing, category, merchant, or voucher page you want to monitor.

### Example output

```json
{
  "site": "hotukdeals",
  "siteName": "HotUKDeals",
  "locale": "en-GB",
  "query": null,
  "dealId": "4921281",
  "title": "Tronic Air Conditioner Unit - Lidl - 7000BTU 2kW",
  "price": 149,
  "priceText": "£149.00",
  "currency": "GBP",
  "temperature": 129.14,
  "temperatureText": "129.14°",
  "merchant": "Lidl",
  "category": "Groceries",
  "commentCount": 8,
  "isExpired": false,
  "dealUrl": "https://www.hotukdeals.com/deals/tronic-air-conditioner-unit-lidl-7000btu-2kw-4921281",
  "sourceUrl": "https://www.hotukdeals.com/deals",
  "sourcePage": 1,
  "scrapedAt": "2026-06-25T00:00:00.000Z"
}
```

Fields can be `null` when a particular Pepper card does not expose the value.

### Tips for best results

Start with small `maxItems` values while validating your workflow.

Use direct `startUrls` for known categories or merchant pages because they reduce irrelevant search results.

Set `maxPagesPerSource` to `1` for frequent monitoring and increase it for one-off research exports.

Keep `requestDelayMs` above `0` for larger crawls to be polite and reduce retry pressure.

Use `includeExpired: true` only when historical or voucher-expiry analysis matters.

### Pagination behavior

Pepper pages usually return around 30 listing cards per page.

The actor appends a `page` query parameter when requesting additional pages.

It stops early when a page returns no parsable deal cards or when the global `maxItems` limit is reached.

Duplicate deals are skipped by `site + dealId`.

### Integrations

You can connect the dataset to:

- Google Sheets for editorial deal queues
- BI dashboards for merchant/category trend reporting
- Slack or email alerts for high-temperature deals
- Affiliate CMS workflows for product research
- Price-monitoring systems that compare merchant promotions by country
- Warehouses such as BigQuery, Snowflake, or Postgres via Apify integrations

### 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/pepper-network-deals-scraper').call({
  searchQueries: ['coffee machine'],
  sites: ['dealabs', 'hotukdeals', 'mydealz'],
  maxItems: 100,
  maxPagesPerSource: 2,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 3));
```

### API usage: Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/pepper-network-deals-scraper').call(run_input={
    'searchQueries': ['espresso'],
    'sites': ['dealabs', 'hotukdeals', 'mydealz'],
    'maxItems': 100,
    'maxPagesPerSource': 2,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

### API usage: cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~pepper-network-deals-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["laptop"],"sites":["dealabs","hotukdeals","mydealz"],"maxItems":60,"maxPagesPerSource":2}'
```

After the run finishes, download dataset items from the run's default dataset.

### MCP usage

Use Apify MCP to run this actor from Claude Desktop, Claude Code, or other MCP-compatible clients.

Add the Apify MCP server in Claude Code:

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

Claude Desktop JSON configuration:

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

Example MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/pepper-network-deals-scraper
```

Example prompts showing MCP usage:

- "Use the Pepper Network Deals Scraper MCP tool to find coffee machine deals in France, the UK, and Germany."
- "Run the MCP deal scraper for HotUKDeals listings with high temperature and export the top merchants."
- "Compare laptop deal titles, prices, and comments across Dealabs and MyDealz using the Apify MCP actor tool."

### Quality and freshness notes

Pepper communities are public, fast-changing websites.

Listings can move, expire, or be moderated after they are posted.

The actor records `scrapedAt`, `sourceUrl`, and `sourcePage` so you can audit when and where a value was collected.

For high-stakes price decisions, re-run the scraper close to your reporting or publishing time.

### Limitations

The actor extracts listing-card data and embedded card payloads.

It does not log in, vote, comment, buy products, or scrape private user/account areas.

Some fields depend on what the Pepper page exposes in HTML. For example, not every card has an old price, voucher code, shipping value, or outbound URL.

CSS and embedded-data changes on Pepper sites can require parser updates.

### Legality and responsible use

Only scrape public pages that you are allowed to access.

Respect website terms, privacy rules, intellectual-property rights, and applicable laws in your jurisdiction.

Do not use scraped data for spam, fraud, impersonation, or abusive automation.

If your use case involves personal data, make sure you have a lawful basis and retention policy.

### Troubleshooting

If the dataset is empty, check that your `startUrls` belong to supported Pepper sites and that your search query has public results.

If you see fewer items than requested, the listing may have duplicates, expired cards filtered out, or fewer available results than `maxItems`.

If a source page is slow, increase `requestDelayMs` and reduce `maxPagesPerSource`.

If a specific locale changes layout, run a small direct URL test and report the failing `sourceUrl`.

### FAQ

#### Can I scrape only HotUKDeals?

Yes. Use a HotUKDeals `startUrls` value or set `sites` to `["hotukdeals"]` with `searchQueries`.

#### Can I compare currencies?

The actor preserves each site's local currency, such as GBP, EUR, or PLN. Convert currencies downstream if you need a single reporting currency.

#### Does this actor open product detail pages?

No. The MVP focuses on reliable listing-card extraction. The `dealUrl` and `outboundUrl` fields let you review or process details separately.

#### Why are some prices null?

Some community posts are discussions, freebies, vouchers, or deal cards without a numeric price. The actor keeps the row and leaves missing price fields as `null`.

### Related scrapers

Related Automation Labs actors:

- [Dealabs Deals Scraper](https://apify.com/automation-lab/dealabs-deals-scraper) for France-only deal monitoring
- [HotUKDeals Deals Scraper](https://apify.com/automation-lab/hotukdeals-deals-scraper) for UK-only workflows
- [MyDealz Deals Scraper](https://apify.com/automation-lab/mydealz-deals-scraper) for Germany-only workflows

Choose this Pepper Network Deals Scraper when you want one normalized multi-site workflow.

# Actor input Schema

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

Keywords to search on each selected Pepper-network site, for example product names, brands, or categories.

## `sites` (type: `array`):

Pepper-network communities to search when using search queries. Start URLs can still target any supported site directly.

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

Optional direct URLs from supported Pepper-network sites, including search, hot, group/category, merchant, or voucher pages.

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

Maximum number of deal records to save across all selected sites and start URLs.

## `maxPagesPerSource` (type: `integer`):

How many paginated listing pages to visit for each generated search URL or direct start URL.

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

When enabled, save expired deal cards if the Pepper listing page returns them.

## `requestDelayMs` (type: `integer`):

Polite delay between listing page requests. Increase if a site responds slowly.

## Actor input object example

```json
{
  "searchQueries": [
    "laptop",
    "coffee machine"
  ],
  "sites": [
    "dealabs",
    "hotukdeals",
    "mydealz"
  ],
  "startUrls": [
    {
      "url": "https://www.hotukdeals.com/search?q=laptop"
    },
    {
      "url": "https://www.dealabs.com/search?q=smartphone"
    }
  ],
  "maxItems": 20,
  "maxPagesPerSource": 2,
  "includeExpired": false,
  "requestDelayMs": 500
}
```

# 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",
        "coffee machine"
    ],
    "sites": [
        "dealabs",
        "hotukdeals",
        "mydealz"
    ],
    "startUrls": [
        {
            "url": "https://www.hotukdeals.com/search?q=laptop"
        },
        {
            "url": "https://www.dealabs.com/search?q=smartphone"
        }
    ],
    "maxItems": 20,
    "maxPagesPerSource": 2,
    "includeExpired": false,
    "requestDelayMs": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/pepper-network-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",
        "coffee machine",
    ],
    "sites": [
        "dealabs",
        "hotukdeals",
        "mydealz",
    ],
    "startUrls": [
        { "url": "https://www.hotukdeals.com/search?q=laptop" },
        { "url": "https://www.dealabs.com/search?q=smartphone" },
    ],
    "maxItems": 20,
    "maxPagesPerSource": 2,
    "includeExpired": False,
    "requestDelayMs": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/pepper-network-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",
    "coffee machine"
  ],
  "sites": [
    "dealabs",
    "hotukdeals",
    "mydealz"
  ],
  "startUrls": [
    {
      "url": "https://www.hotukdeals.com/search?q=laptop"
    },
    {
      "url": "https://www.dealabs.com/search?q=smartphone"
    }
  ],
  "maxItems": 20,
  "maxPagesPerSource": 2,
  "includeExpired": false,
  "requestDelayMs": 500
}' |
apify call automation-lab/pepper-network-deals-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pepper Network Deals Scraper",
        "description": "Scrape Dealabs, HotUKDeals, MyDealz, Pepper.pl, and Pepper NL deals with normalized prices, merchants, temperatures, comments, and URLs.",
        "version": "0.1",
        "x-build-id": "5th5oKulWjq22gFfk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~pepper-network-deals-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-pepper-network-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~pepper-network-deals-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-pepper-network-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~pepper-network-deals-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-pepper-network-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 each selected Pepper-network site, for example product names, brands, or categories.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sites": {
                        "title": "Pepper sites",
                        "type": "array",
                        "description": "Pepper-network communities to search when using search queries. Start URLs can still target any supported site directly.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "dealabs",
                                "hotukdeals",
                                "mydealz",
                                "pepper_pl",
                                "pepper_nl"
                            ],
                            "enumTitles": [
                                "Dealabs (France)",
                                "HotUKDeals (UK)",
                                "MyDealz (Germany)",
                                "Pepper.pl (Poland)",
                                "Pepper NL (Netherlands)"
                            ]
                        },
                        "default": [
                            "dealabs",
                            "hotukdeals",
                            "mydealz"
                        ]
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional direct URLs from supported Pepper-network sites, including search, hot, group/category, merchant, or voucher 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 selected sites and start URLs.",
                        "default": 20
                    },
                    "maxPagesPerSource": {
                        "title": "Maximum pages per source",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many paginated listing pages to visit for each generated search URL or direct start URL.",
                        "default": 2
                    },
                    "includeExpired": {
                        "title": "Include expired deals",
                        "type": "boolean",
                        "description": "When enabled, save expired deal cards if the Pepper listing page returns them.",
                        "default": false
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite delay between listing page requests. Increase if a site responds slowly.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
