# KuantoKusta Scraper — Portuguese Price Comparison & Deals (`studio-amba/kuantokusta-scraper`) Actor

Scrape products, prices, store offers, specs, and ratings from KuantoKusta.pt — Portugal's leading price comparison site. No login required.

- **URL**: https://apify.com/studio-amba/kuantokusta-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## KuantoKusta Scraper - Product Prices & Store Offers from Portugal's Price Comparison Leader

Extract product data, prices across multiple stores, ratings, specifications, and availability from [KuantoKusta.pt](https://www.kuantokusta.pt) — Portugal's largest and most popular price comparison website, aggregating offers from 50+ Portuguese online retailers.

### What is KuantoKusta Scraper?

KuantoKusta Scraper collects structured product data from KuantoKusta.pt. It searches for products, navigates category pages, follows pagination, and optionally visits individual product detail pages to extract rich data including store-level pricing, specifications, EAN barcodes, ratings, and breadcrumb categories.

KuantoKusta is the go-to price comparison platform in Portugal. With thousands of products across electronics, home appliances, smartphones, fashion, sports, and more, it aggregates prices from retailers like Fnac, Worten, DARTY, MediaMarkt, and dozens of smaller Portuguese shops. Their "desde X" (from X) pricing model shows the lowest available price across all stores.

**No login required. No cookies needed. Fully automated.**

### Why use this actor?

- **Price intelligence** — Track the lowest prices across 50+ Portuguese retailers in one scrape. KuantoKusta already does the comparison — you just extract the data.
- **Market research** — Understand Portuguese e-commerce pricing, product availability, and retailer competition. Essential for brands entering the PT market.
- **Competitor monitoring** — See which retailers carry your products and at what prices. KuantoKusta lists individual store prices with shipping costs.
- **Deal detection** — KuantoKusta badges products as "Boa compra" (good deal), "Mais vendido" (bestseller), and "Favorito clientes" (customer favorite).
- **MAP enforcement** — Match products by EAN barcode across retailers to monitor Minimum Advertised Price compliance in Portugal.

### How to scrape KuantoKusta data

#### Option 1: Search by keyword

Set `searchQuery` to any product name or keyword in Portuguese. KuantoKusta supports broad queries.

**Examples:** `"televisao"`, `"smartphone"`, `"aspirador"`, `"portatil"`, `"maquina de cafe"`, `"samsung galaxy"`

#### Option 2: Browse categories

Provide KuantoKusta category URLs. The site uses the pattern `/a/{id}/{category-name}`:

- `https://www.kuantokusta.pt/a/1/informatica` — Computers & IT
- `https://www.kuantokusta.pt/a/155/smartphones-e-acessorios` — Smartphones
- `https://www.kuantokusta.pt/a/356/electrodomesticos` — Home appliances
- `https://www.kuantokusta.pt/a/1469/gaming` — Gaming
- `https://www.kuantokusta.pt/a/1075/casa-e-decoracao` — Home & Decor
- `https://www.kuantokusta.pt/a/818/desporto` — Sports

#### Option 3: Direct product URLs

Provide individual product URLs (`/p/{id}/{slug}`) to scrape specific products with full detail data.

#### Option 4: Fast listing mode

Set `scrapeDetails` to `false` for quick price sweeps. The scraper extracts basic data (name, price, store count, rating) from listing pages only, skipping individual product visits. 5-10x faster.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchQuery` | String | `smartphone` | Keyword search in Portuguese |
| `categoryUrls` | Array | — | Category or product page URLs to scrape |
| `maxResults` | Integer | `100` | Maximum products to return (up to 100,000) |
| `maxPages` | Integer | `5` | Max pagination pages per search/category (~40 products/page) |
| `scrapeDetails` | Boolean | `true` | Visit product pages for full data (slower but richer) |
| `proxyConfiguration` | Object | — | Proxy settings for reliability |

**Tips:**
- KuantoKusta has minimal anti-bot protection, but proxies help for large runs.
- Each listing page shows ~40 products. With `maxPages: 5`, you get up to ~200 products per search.
- For full catalog dumps, increase `maxPages` to 25+ and set a high `maxResults`.
- The `scrapeDetails` toggle controls speed vs depth. Off = faster but basic data only.

### Output

Each result contains:

| Field | Type | Example |
|-------|------|---------|
| `name` | String | `"TV LG 43\" 43LR60006LA LED Smart TV Full HD HDR10 Pro"` |
| `brand` | String | `"LG"` |
| `price` | Number | `192.49` |
| `currency` | String | `"EUR"` |
| `storeCount` | Number | `33` |
| `inStock` | Boolean | `true` |
| `rating` | Number | `4.9` |
| `reviewCount` | Number | `8` |
| `ean` | String | `"8806096520963"` |
| `imageUrl` | String | Primary product image URL |
| `specs` | Object | `{"Resolution": "1920x1080", "Screen Size": "43\""}` |
| `category` | String | `"Televisores / TV LED-LCD"` |
| `categories` | Array | `["Imagem e Som", "Televisores", "TV LED-LCD"]` |
| `url` | String | Full product URL on KuantoKusta |
| `scrapedAt` | String | ISO 8601 timestamp |

### Example output

```json
[
  {
    "name": "TV LG 43\" 43LR60006LA LED Smart TV Full HD HDR10 Pro",
    "brand": "LG",
    "price": 192.49,
    "currency": "EUR",
    "storeCount": 33,
    "inStock": true,
    "rating": 4.9,
    "reviewCount": 8,
    "ean": "8806096520963",
    "productId": "11925036",
    "imageUrl": "https://s1.kuantokusta.pt/img_upload/produtos_imagemsom/602329_3_lg-43-43lr60006la-led-smart-tv-full-hd-hdr10-pro.jpg",
    "specs": {
      "Resolution": "1920x1080 (Full HD/1080p)",
      "Screen Size": "43\" (109 cm)",
      "Technology": "LED Direct-LED",
      "HDR": "HDR10 Pro",
      "Audio": "20W, 2.0 channels, Dolby AC3",
      "Energy Class": "F (SDR)"
    },
    "category": "Televisores / TV LED-LCD",
    "categories": ["Imagem e Som", "Televisores", "Televisores / TV LED-LCD"],
    "description": "TV LG 43\" com Full HD, HDR10 Pro, webOS 23, Wi-Fi 5, Bluetooth 5.0",
    "url": "https://www.kuantokusta.pt/p/11925036/lg-43-43lr60006la-led-smart-tv-full-hd-hdr10-pro",
    "language": "pt",
    "scrapedAt": "2026-06-07T10:30:15.000Z"
  },
  {
    "name": "Samsung Galaxy A56 5G 6.7\" Dual SIM 8GB/256GB Graphite",
    "brand": "Samsung",
    "price": 349.90,
    "currency": "EUR",
    "storeCount": 28,
    "inStock": true,
    "rating": 4.5,
    "productId": "11837891",
    "imageUrl": "https://s1.kuantokusta.pt/img_upload/produtos_comunicacoes/123456_2_samsung-galaxy-a56.jpg",
    "category": "Smartphones",
    "url": "https://www.kuantokusta.pt/p/11837891/samsung-galaxy-a56-5g-dual-sim-8gb-256gb-graphite",
    "language": "pt",
    "scrapedAt": "2026-06-07T10:30:18.000Z"
  }
]
````

### How much does it cost?

KuantoKusta Scraper uses CheerioCrawler (HTTP-only, no browser) which keeps costs very low.

| Scenario | Products | Detail pages | Estimated cost | Time |
|----------|----------|-------------|---------------|------|
| Quick listing sweep | 100 | Off | ~$0.01 | ~10 sec |
| Search with details | 100 | On | ~$0.05 | ~1 min |
| Large category | 500 | On | ~$0.20 | ~5 min |
| Multi-category dump | 2,000 | On | ~$0.70 | ~15 min |
| Price-only bulk run | 2,000 | Off | ~$0.05 | ~2 min |

### Can I integrate?

KuantoKusta Scraper connects to the full Apify integration ecosystem:

- **Apify API** — Trigger runs programmatically, stream results in real-time
- **Webhooks** — Notify your systems when scraping completes
- **Google Sheets** — Auto-export Portuguese price data for team access
- **Zapier / Make** — Build no-code automations triggered by new product data
- **Slack alerts** — Get notified when tracked product prices drop
- **Airbyte / BigQuery / Snowflake** — Stream to your data warehouse for analytics
- **Scheduled runs** — Set up daily price monitoring with Apify Schedules
- **Direct download** — CSV, JSON, XML, or Excel export from the Apify Console

### Can I use it as an API?

Use KuantoKusta Scraper as a Portuguese product price API. Start runs, poll for results, and process data in your application.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/kuantokusta-scraper").call(run_input={
    "searchQuery": "televisao",
    "maxResults": 50,
    "scrapeDetails": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    stores = item.get("storeCount", "?")
    print(f"{item['name']} — desde EUR {item['price']} (em {stores} lojas)")
```

#### JavaScript

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

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("studio-amba/kuantokusta-scraper").call({
  searchQuery: "portatil",
  maxResults: 200,
  maxPages: 10,
  scrapeDetails: true,
});

const { items } = await client
  .dataset(run.defaultDatasetId)
  .listItems();

items.forEach((item) => {
  const stores = item.storeCount ? ` (${item.storeCount} lojas)` : "";
  console.log(`${item.name} — EUR ${item.price}${stores}`);
});
```

### FAQ

#### What is KuantoKusta?

KuantoKusta is Portugal's largest price comparison website. It aggregates product prices from 50+ online Portuguese retailers including Fnac, Worten, DARTY, MediaMarkt, and many smaller shops. The name means "How much does it cost?" in Portuguese.

#### What does "desde" mean in the prices?

"Desde" means "from" in Portuguese. KuantoKusta shows the lowest available price across all stores that sell the product. When you scrape with `scrapeDetails: true`, you get individual store prices.

#### What are the KuantoKusta badges?

KuantoKusta awards badges to products: "Boa compra" (good buy — best value), "Mais vendido" (bestseller — highest sales), and "Favorito clientes" (customer favorite — highest rated). These indicate consumer-validated quality.

#### Can I get prices from individual stores?

Yes. When scraping with `scrapeDetails: true`, the product detail pages show individual store offers with prices and shipping costs. The `price` field always shows the lowest available price.

#### What product categories does KuantoKusta cover?

Electronics, smartphones, computers, home appliances, gaming, fashion, sports, home decor, beauty, baby products, and more. It covers most consumer product categories available in the Portuguese market.

### Limitations

- **JavaScript-rendered content** — Some dynamic elements may not be captured by the HTTP-only CheerioCrawler. The vast majority of product data is in the static HTML.
- **Store-level data** — Individual store offers are extracted best from product detail pages (`scrapeDetails: true`).
- **Portuguese market only** — KuantoKusta covers the Portuguese market. Prices are in EUR.
- **Rate limits** — For very large runs (5,000+ products), use Apify proxies and moderate concurrency.
- **Category pages** — Some category landing pages show featured products rather than full listings. Use search queries for comprehensive results.

### Other European price comparison scrapers

Build a complete view of European consumer pricing by combining KuantoKusta data with these companion scrapers:

- **[Coolblue Scraper](https://apify.com/studio-amba/coolblue-scraper)** — Belgium & Netherlands electronics prices from the Benelux's top retailer.
- **[Vanden Borre Scraper](https://apify.com/studio-amba/vandenborre-scraper)** — Belgian electronics chain (Fnac Darty group), 13,000+ products.
- **[Krefel Scraper](https://apify.com/studio-amba/krefel-scraper)** — Belgium's #2 electronics retailer with detailed specs and stock data.

### Your feedback

KuantoKusta updates their site regularly. If you notice data quality issues, missing fields, or broken runs, let us know through the Apify Console or GitHub. We monitor and update this scraper actively.

# Actor input Schema

## `searchQuery` (type: `string`):

Search for products by keyword in Portuguese (e.g., 'televisao', 'smartphone', 'aspirador'). If empty, defaults to 'smartphone'.

## `categoryUrls` (type: `array`):

KuantoKusta category URLs to scrape. Use category pages like https://www.kuantokusta.pt/a/1/informatica or direct product URLs like https://www.kuantokusta.pt/p/12345/product-slug.

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

Maximum number of products to return.

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

Maximum number of pagination pages to scrape per search or category. Each page has ~40 products.

## `scrapeDetails` (type: `boolean`):

Visit each product page to get full details (specs, store prices, EAN, rating). If false, only basic data from listing pages is returned. Slower but much richer data.

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

Proxy settings. KuantoKusta is a price comparison site with minimal anti-bot, but proxies improve reliability for large runs.

## Actor input object example

```json
{
  "searchQuery": "smartphone",
  "maxResults": 20,
  "maxPages": 5,
  "scrapeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "PT"
  }
}
```

# 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 = {
    "searchQuery": "smartphone",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "PT"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/kuantokusta-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 = {
    "searchQuery": "smartphone",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "PT",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/kuantokusta-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 '{
  "searchQuery": "smartphone",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "PT"
  }
}' |
apify call studio-amba/kuantokusta-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "KuantoKusta Scraper — Portuguese Price Comparison & Deals",
        "description": "Scrape products, prices, store offers, specs, and ratings from KuantoKusta.pt — Portugal's leading price comparison site. No login required.",
        "version": "0.1",
        "x-build-id": "h7flUzt0m3QPyMTro"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~kuantokusta-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-kuantokusta-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/studio-amba~kuantokusta-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-kuantokusta-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/studio-amba~kuantokusta-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-kuantokusta-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for products by keyword in Portuguese (e.g., 'televisao', 'smartphone', 'aspirador'). If empty, defaults to 'smartphone'."
                    },
                    "categoryUrls": {
                        "title": "Category URLs",
                        "type": "array",
                        "description": "KuantoKusta category URLs to scrape. Use category pages like https://www.kuantokusta.pt/a/1/informatica or direct product URLs like https://www.kuantokusta.pt/p/12345/product-slug.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Max Pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of pagination pages to scrape per search or category. Each page has ~40 products.",
                        "default": 5
                    },
                    "scrapeDetails": {
                        "title": "Scrape Product Details",
                        "type": "boolean",
                        "description": "Visit each product page to get full details (specs, store prices, EAN, rating). If false, only basic data from listing pages is returned. Slower but much richer data.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. KuantoKusta is a price comparison site with minimal anti-bot, but proxies improve reliability for large runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
