# Allegro Price Scraper — All Sellers & Prices by URL (`klevio/allegro-price-comparison`) Actor

Give a product or offer URL, get every seller + price for that product on Allegro.pl — sorted, with min/max/avg. Built by Klevio — Polish e-commerce specialists.

- **URL**: https://apify.com/klevio/allegro-price-comparison.md
- **Developed by:** [Klevio](https://apify.com/klevio) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.00005 / actor start

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

> Maintained by **[Klevio](https://klevio.pl)** — Polish e-commerce specialists.
> More actors → **[apify.com/klevio](https://apify.com/klevio)** · Custom Allegro / BaseLinker integration → **support@klevio.pl**

## Allegro Price Comparison — All Sellers & Prices by URL

Give it an Allegro **product or offer URL**, get back **every seller offering that product plus their prices** — sorted, filtered, with min / max / average computed for you. Built for repricers, MAP monitoring, and dropshipping price discovery.

> 🔎 **Bulk EAN lookup is coming soon.** Today the actor takes product/offer URLs (paste up to 1000 per run). Need EAN-based search now? → support@klevio.pl

### What it does

For each URL, the actor:

1. **Resolves the product** — reads the product straight from your URL (a `/produkt/…` or `/oferta/…` link; `business.allegro.pl` links are accepted too — see the B2B/B2C note below).
2. **Pulls every offer** — opens the product's "Wszystkie oferty" list and extracts all sellers, prices, ratings, delivery and **Allegro Smart!** status.
3. **Filters, sorts, caps** — Smart!-only / exclude-Smart, drop sponsored, sort by price or seller rating, keep the top N.
4. **Computes stats** — lowest / highest / average price across the returned offers.

Couldn't resolve a URL? You get a clean `found: false` row — and **you are not charged** for it.

### Key features

- 🔍 **Multi-seller price comparison** for any Allegro product
- 💰 **Min / max / avg price** computed automatically
- 🔗 **Bulk URL input** — up to 1000 product/offer links per run
- 💎 **Real Allegro Smart! flag** per offer (detected from the Smart! badge — not just "free delivery")
- ⭐ **Seller rating, review count & Super Seller badge** for trust signals
- 🎯 **Sponsored-offer filter** — clean data for true price comparison
- 🛡️ **DataDome bypass included** — managed Bright Data proxy, nothing to configure
- ⚡ **Parallel workers + fresh IP per product** — fast and block-resistant
- 📦 **CSV / JSON / Excel export** — or pipe via API into your system

### ⚠️ B2B vs B2C — important

Allegro runs **two marketplaces** for the same products:

| | Consumer — `allegro.pl` | Business — `business.allegro.pl` |
|---|---|---|
| Prices shown | **gross (brutto, incl. VAT)** | **net (netto, excl. VAT)** |
| Offers / sellers | consumer offers | B2B offers (often a **different set** of sellers) |

**This actor returns CONSUMER (`allegro.pl`) offers with gross prices.** A `business.allegro.pl` URL is accepted, but it is resolved to the consumer product page — so:

- the offers and sellers **may differ** from what you see on `business.allegro.pl`,
- an offer visible on the B2B site (e.g. a "Firma" seller) **may be absent** from the consumer results, and
- **prices are gross** here, whereas the B2B site shows **net** amounts.

In short: don't expect a 1:1 match between this actor's output and the `business.allegro.pl` view — they are different marketplaces. (Native B2B support is on the roadmap; contact support@klevio.pl if you need it.)

### Use cases

- **Repricing** — track competitor prices daily, auto-adjust your store
- **MAP monitoring** — alert when a seller drops below minimum advertised price
- **Dropshipping** — find the cheapest supplier for your product list
- **Brand monitoring** — see who sells your products and at what price
- **Market intelligence** — price-distribution and seller-landscape analysis

### How to use

**1) Bulk price check (most common):**
```json
{
  "productUrls": [
    "https://allegro.pl/produkt/...-6d62d906-796a-4610-a854-a98cfc5f3298",
    "https://allegro.pl/oferta/...-18102117865"
  ],
  "topNOffers": 20,
  "sortBy": "price-asc",
  "smartFilter": "all",
  "includePromoted": true
}
````

**2) Single product → all sellers:**

```json
{
  "productUrls": ["https://allegro.pl/produkt/telewizor-...-6d62d906-796a-4610-a854-a98cfc5f3298"]
}
```

**3) Daily competitor monitoring** — schedule the run every few hours with Apify's built-in scheduler; pipe results to Google Sheets / your backend via the native integrations.

### Output

One dataset row per input URL. Successful match:

```json
{
  "input": "https://allegro.pl/produkt/...-6d62d906-796a-4610-a854-a98cfc5f3298",
  "inputType": "url",
  "found": true,
  "productId": "6d62d906-796a-4610-a854-a98cfc5f3298",
  "productName": "Blaupunkt 43QLW6000S QLED Smart TV 4K UHD WebOS HDR10 Dolby Audio",
  "productUrl": "https://allegro.pl/produkt/telewizor-blaupunkt-...-6d62d906-...",
  "categoryPath": "Allegro > Elektronika > RTV i AGD > TV i Video > Telewizory",
  "multipleMatches": false,
  "totalOffersAvailable": 12,
  "offerCount": 12,
  "lowestPrice": 964.13,
  "highestPrice": 3466.99,
  "avgPrice": 1175.12,
  "offers": [
    {
      "sellerLogin": "e-eldom_pl",
      "sellerId": "13256856",
      "price": 964.13,
      "currency": "PLN",
      "offerUrl": "https://allegro.pl/produkt/...?offerId=...",
      "offerId": "...",
      "smart": true,
      "sellerRating": 99.1,
      "sellerReviewCount": 534,
      "isSuperSeller": true,
      "isPromoted": false,
      "deliveryFreeFrom": null
    }
  ],
  "scrapedAt": "2026-06-01T..."
}
```

Prices are **gross (PLN, incl. VAT)** — see the B2B/B2C note above. Couldn't resolve → `{ "found": false, "error": "...", ... }` — **no charge**.

#### Field reference

| Field | Notes |
|---|---|
| `found` | `false` if the URL couldn't be resolved (no charge) |
| `productId` / `productName` / `productUrl` | resolved product identity (consumer `allegro.pl`) |
| `categoryPath` | breadcrumb category path |
| `totalOffersAvailable` | all offers found for the product (before `topNOffers` cap) |
| `offerCount` | offers returned after filter + cap |
| `lowestPrice` / `highestPrice` / `avgPrice` | stats over the returned offers (gross PLN) |
| `offers[].smart` | **true Allegro Smart!** (from the Smart! badge) |
| `offers[].isSuperSeller` | Allegro "Super Sprzedawca" badge |
| `offers[].isPromoted` | paid/sponsored placement |
| `offers[].sellerRating` / `sellerReviewCount` | % positive feedback / number of ratings |

### Pricing

Pay-per-event — you pay only for what's actually resolved:

| Event | Price | When |
|---|---|---|
| Product resolved | **$0.03** ($30 / 1000) | Per URL successfully matched |
| Offer scraped | **$0.003** ($3 / 1000) | Per offer in the result |
| Run start fee | $0.05 | Once per run |

**Unresolved URLs are FREE — no charge.**

**Example:** 100 products × 8 sellers avg ≈ 100 × $0.03 + 800 × $0.003 + $0.05 = **~$5.45 per run** (~$163/month if run daily).

### FAQ

**How do I compare prices across all Allegro sellers for a product?**
Paste the product (or offer) URL. The actor opens the product's "Wszystkie oferty" list and returns every seller's offer with price, rating, Smart! and delivery — sorted cheapest-first by default.

**Why do I see a cheaper / different offer on the Allegro page than in the results?**
You're most likely looking at **`business.allegro.pl`** (the B2B marketplace), which shows a **different set of offers** and **net (netto) prices**. This actor returns **consumer `allegro.pl`** offers with **gross (brutto)** prices — see the *B2B vs B2C* note above. The two marketplaces don't match 1:1.

**Does `business.allegro.pl` work?**
You can paste `business.allegro.pl` links, but they're resolved to the **consumer** product page (gross prices, consumer offers). Native B2B (net prices) is on the roadmap — contact support@klevio.pl.

**What does the `smart` flag mean?**
It's the **real Allegro Smart!** status, read from the offer's Smart! badge — **not** simply "free delivery" (a Smart! offer can have paid delivery for non-subscribers). Use `smartFilter: "smart-only"` / `"exclude-smart"` to filter.

**How do I find the cheapest seller?**
Keep `sortBy: "price-asc"` (default) — `offers[0]` and `lowestPrice` give the cheapest current offer with the seller's login, rating and Super Seller status.

**How do I scrape Allegro prices programmatically?**
Run the actor from the Apify API or SDK with a JSON input (`productUrls`, `topNOffers`, `sortBy`, …). Poll the run and read the dataset as JSON/CSV. Schedule it for recurring price tracking.

**Can I exclude sponsored/promoted offers?**
Yes — set `includePromoted: false` for a clean comparison without paid placements.

**How do I bypass DataDome on Allegro?**
You don't have to — the actor routes through a managed Bright Data browser that solves the challenge automatically and rotates a fresh IP per product. Power users can supply their own Bright Data WSS URL.

**Is scraping Allegro prices legal / GDPR-compliant?**
The actor reads only public offer data — no buyer data, no reviews/PII. Seller logins/IDs are public business identifiers. Allegro's ToS restrict automated access; use responsibly and consult a lawyer for commercial use.

**Can I push results to BaseLinker?**
The output is BaseLinker-friendly (price, seller, offer URL). Native sync is on our roadmap — for a custom BaseLinker workflow now, email support@klevio.pl.

### More Polish e-commerce scrapers by Klevio

See all our actors → **[apify.com/klevio](https://apify.com/klevio)**

- 🛒 **[Allegro Seller Scraper](https://apify.com/klevio/allegro-seller-scraper)** — full seller catalog (EAN, SKU, 36+ parameters, descriptions, images)
- 🔍 **Allegro Price Comparison** — all sellers + prices by URL (this actor)
- ⭐ **Allegro Reviews Scraper** — reviews + ratings extraction (coming Q4 2026)
- 🏪 **OLX Seller Scraper** — same model for OLX (coming Q4 2026)
- 🔄 **Allegro → BaseLinker Sync** — auto-push to BaseLinker inventory (coming 2027)

Want a custom Polish e-commerce scraper now? → support@klevio.pl

### Support & contact

- **Issues tab** — bug reports, feature requests, questions
- **Email** — support@klevio.pl
- **All Klevio actors** — [apify.com/klevio](https://apify.com/klevio)

Built with ❤️ for the Polish e-commerce ecosystem by [Klevio](https://klevio.pl).

# Actor input Schema

## `productUrls` (type: `array`):

Lista URL-i Allegro: /produkt/... lub /oferta/... (działa też business.allegro.pl). Dla każdego aktor znajdzie wszystkie oferty wszystkich sprzedawców + ceny. Max 1000 na run, jeden URL per linia.

## `topNOffers` (type: `integer`):

Maks. liczba ofert do zwrócenia per EAN/URL. Default 20 pokrywa 99% przypadków (większość produktów ma 5-20 sprzedawców).

## `sortBy` (type: `string`):

Kolejność ofert w wyniku (i które trafią do top N).

## `smartFilter` (type: `string`):

Allegro Smart! = darmowa dostawa.

## `includePromoted` (type: `boolean`):

Jeśli WYŁĄCZONE — pomijamy oferty paid-promoted (sponsored placements). Czystsza data dla price comparison.

## `brightDataWssUrl` (type: `string`):

Zostaw puste — domyślnie używamy naszej infrastruktury. Jeśli masz własne konto Bright Data — wklej swój WSS URL.

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

Liczba równoległych sesji browsera. Default 2 dla balansu speed/reliability.

## `minDelayMs` (type: `integer`):

Minimalne opóźnienie między żądaniami. Wyższe = bezpieczniejsze dla DataDome.

## `maxDelayMs` (type: `integer`):

Maksymalne opóźnienie między żądaniami. Aktor losuje wartość między min a max.

## Actor input object example

```json
{
  "productUrls": [
    "https://allegro.pl/produkt/telewizor-blaupunkt-43qlw6000s-43-qled-4k-uhd-webos-tv-hdr10-dolby-audio-6d62d906-796a-4610-a854-a98cfc5f3298"
  ],
  "topNOffers": 20,
  "sortBy": "price-asc",
  "smartFilter": "all",
  "includePromoted": true,
  "maxConcurrency": 2,
  "minDelayMs": 1500,
  "maxDelayMs": 4000
}
```

# Actor output Schema

## `products` (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 = {
    "productUrls": [
        "https://allegro.pl/produkt/telewizor-blaupunkt-43qlw6000s-43-qled-4k-uhd-webos-tv-hdr10-dolby-audio-6d62d906-796a-4610-a854-a98cfc5f3298"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("klevio/allegro-price-comparison").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 = { "productUrls": ["https://allegro.pl/produkt/telewizor-blaupunkt-43qlw6000s-43-qled-4k-uhd-webos-tv-hdr10-dolby-audio-6d62d906-796a-4610-a854-a98cfc5f3298"] }

# Run the Actor and wait for it to finish
run = client.actor("klevio/allegro-price-comparison").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 '{
  "productUrls": [
    "https://allegro.pl/produkt/telewizor-blaupunkt-43qlw6000s-43-qled-4k-uhd-webos-tv-hdr10-dolby-audio-6d62d906-796a-4610-a854-a98cfc5f3298"
  ]
}' |
apify call klevio/allegro-price-comparison --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Allegro Price Scraper — All Sellers & Prices by URL",
        "description": "Give a product or offer URL, get every seller + price for that product on Allegro.pl — sorted, with min/max/avg. Built by Klevio — Polish e-commerce specialists.",
        "version": "0.6",
        "x-build-id": "E1pJ5PFPnoikConE5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/klevio~allegro-price-comparison/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-klevio-allegro-price-comparison",
                "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/klevio~allegro-price-comparison/runs": {
            "post": {
                "operationId": "runs-sync-klevio-allegro-price-comparison",
                "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/klevio~allegro-price-comparison/run-sync": {
            "post": {
                "operationId": "run-sync-klevio-allegro-price-comparison",
                "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",
                "required": [
                    "productUrls"
                ],
                "properties": {
                    "productUrls": {
                        "title": "Allegro product / offer URLs",
                        "type": "array",
                        "description": "Lista URL-i Allegro: /produkt/... lub /oferta/... (działa też business.allegro.pl). Dla każdego aktor znajdzie wszystkie oferty wszystkich sprzedawców + ceny. Max 1000 na run, jeden URL per linia.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "topNOffers": {
                        "title": "Top N ofert per produkt",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maks. liczba ofert do zwrócenia per EAN/URL. Default 20 pokrywa 99% przypadków (większość produktów ma 5-20 sprzedawców).",
                        "default": 20
                    },
                    "sortBy": {
                        "title": "Sortowanie ofert",
                        "enum": [
                            "price-asc",
                            "price-desc",
                            "rating-desc"
                        ],
                        "type": "string",
                        "description": "Kolejność ofert w wyniku (i które trafią do top N).",
                        "default": "price-asc"
                    },
                    "smartFilter": {
                        "title": "Filtr Allegro Smart!",
                        "enum": [
                            "all",
                            "smart-only",
                            "exclude-smart"
                        ],
                        "type": "string",
                        "description": "Allegro Smart! = darmowa dostawa.",
                        "default": "all"
                    },
                    "includePromoted": {
                        "title": "Uwzględnij oferty promowane (sponsorowane)",
                        "type": "boolean",
                        "description": "Jeśli WYŁĄCZONE — pomijamy oferty paid-promoted (sponsored placements). Czystsza data dla price comparison.",
                        "default": true
                    },
                    "brightDataWssUrl": {
                        "title": "Bright Data WSS URL (opcjonalne)",
                        "type": "string",
                        "description": "Zostaw puste — domyślnie używamy naszej infrastruktury. Jeśli masz własne konto Bright Data — wklej swój WSS URL."
                    },
                    "maxConcurrency": {
                        "title": "Równoległość",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Liczba równoległych sesji browsera. Default 2 dla balansu speed/reliability.",
                        "default": 2
                    },
                    "minDelayMs": {
                        "title": "Min delay (ms) — DataDome safety",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimalne opóźnienie między żądaniami. Wyższe = bezpieczniejsze dla DataDome.",
                        "default": 1500
                    },
                    "maxDelayMs": {
                        "title": "Max delay (ms) — DataDome safety",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maksymalne opóźnienie między żądaniami. Aktor losuje wartość między min a max.",
                        "default": 4000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```