# Technopolis Product & Promotions Scraper (`scraping_crew/technopolis-scraper`) Actor

Track weekly and monthly Technopolis promotions and scrape the full product catalog — prices, old prices, specifications, brands, and images — as clean, structured data ready for price analysis and AI workflows.

- **URL**: https://apify.com/scraping\_crew/technopolis-scraper.md
- **Developed by:** [Scraping Crew](https://apify.com/scraping_crew) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 22.2% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### Technopolis Product & Promotions Scraper

**Track weekly and monthly Technopolis promotions and collect the full product catalog — prices, old prices, specifications, brands, and images — in one clean, structured dataset.** This scraper monitors the [Technopolis](https://www.technopolis.bg) online store (Bulgaria's leading electronics retailer), follows the **weekly brochure** and the **monthly promotion brochure**, and pulls complete product details from any category you choose. You can also **specify your own category URLs** and the scraper will parse them as well — scrape a single category, several at once, or the whole catalog. The result is **ready-to-use data for price analysis, product management, and AI workflows** — perfectly structured for **LLM and RAG pipelines**, dashboards, and reports.

Running on the Apify platform gives you scheduling, monitoring, proxy rotation, and one-click integrations, so you can keep an always-fresh feed of Technopolis prices and promotions with no maintenance on your side.

### Features

- ⚡ Track weekly Technopolis brochure promotions automatically *(paid plans)*
- 🗓️ Track the monthly promotion brochure *(paid plans)*
- 💰 Collect current price and previous (old) price for every product
- 🏷️ Capture discounts and promotional items across the whole catalog
- 📦 Full product data — name, brand, category path, EAN, specifications, and images
- 🔁 Cheap recurring monitoring — repeat runs refresh prices without re-collecting everything
- 🧠 Clean, structured output ready for LLM, RAG, and AI workflows
- 🤖 Connect to AI agents and assistants through the Apify MCP server
- 📊 Perfect for product managers, price analysts, and market research
- 🌍 Scrape any category, or just the promotion brochures
- 📥 Export as JSON, CSV, or Excel, or pull straight into your tools via integrations

### Why use the Technopolis Scraper?

- ✅ **Track weekly brochure promotions** — never miss a weekly offer
- ✅ **Track the monthly brochure** — capture every promotional campaign
- ✅ **Collect current and old prices** — ready-made input for price and discount analysis
- ✅ **Get the full product catalog** — specifications, brand, EAN, categories, and images
- ✅ **Clean, structured data ready for LLM / RAG / AI workflows** — feed it straight into your models
- ✅ **Works with AI agents via MCP** — call the scraper directly from Claude, ChatGPT, and other assistants
- ✅ **Perfect for product managers and price analysts** — no cleanup needed, just use it
- ✅ **Build price history over time** — schedule runs and watch prices move
- ✅ **Recurring runs stay cheap** — prices refresh without re-scraping full records
- ✅ **Fully hands-off on Apify** — scheduling, monitoring, proxies, and integrations included

### How to use the Technopolis Scraper

1. Click **Try for free** / add the scraper to your Apify account.
2. In the **Input** tab, paste one or more **category URLs** from technopolis.bg, and/or turn on the **weekly offers** and **monthly brochure** toggles.
3. Optionally set a **maximum number of items** to keep a test run small and fast.
4. Click **Start** / **Run**.
5. When the run finishes, open the **Output** tab and **download your data** as JSON, CSV, or Excel — or connect it to your other tools.

That's it — no code, no setup, no maintenance.

### Input

You can configure the scraper with a few simple options in the **Input** tab:

- **Start URLs** — the Technopolis category pages you want to scrape. Leave this empty only if you want the promotion brochures below (paid plans).
- **Extract weekly brochure offers** — turn on to collect every product in the current weekly promotion brochure. **Available on paid plans only** — ignored on the free tier.
- **Extract the monthly brochure offers** — turn on to collect every product in the monthly promotion brochure. **Available on paid plans only** — ignored on the free tier.
- **Max items** — stop the run after this many products (set to 0 for unlimited).
- **Proxy configuration** — optional proxy settings to keep runs reliable.

You can mix and match: scrape specific categories, only the brochures, or all of them together in a single run.

#### Input example

```json
{
    "startUrls": [
        { "url": "https://www.technopolis.bg/bg/TV--Video-i-Gaming/Televizori/c/P11090104" }
    ],
    "getWeaklyOffers": true,
    "getMonthlyBrochure": false,
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": true }
}
````

### Output

Every run produces a clean dataset where each row is one product, including its name, brand, category path, identifiers, current and previous price, specifications, and image links. Promotional items from the weekly and monthly brochures are included alongside their prices, so you can immediately see what is on offer and by how much.

You can download the dataset in various formats such as **JSON, HTML, CSV, or Excel**, or access it through the Apify API and integrations for use in your own tools, spreadsheets, dashboards, or AI pipelines.

#### Output example

Each dataset item represents a single product:

```json
{
    "name": "Аудио система JBL AUTHENTICS 300",
    "prod_id": "10861",
    "category": "TV, Аудио и Gaming|Аудио системи",
    "brand": "JBL",
    "eans": ["1200130000744"],
    "part_nums": ["JBLAUTH300BLKEP"],
    "price": "329.9",
    "old_price": "349.9",
    "images": [
        "https://api.technopolis.bg/medias/Product-details-main-10861.jpg"
    ],
    "specs_table": [
        { "key": "МОДЕЛ", "value": "AUTHENTICS 300" },
        { "key": "ТИП АУДИО СИСТЕМА", "value": "МИКРО" },
        { "key": "ОБЩА МОЩНОСТ", "value": "100 W" },
        { "key": "WI-FI", "value": "ДА" },
        { "key": "BLUETOOTH", "value": "ДА" },
        { "key": "ЦВЯТ", "value": "ЧЕРЕН" },
        { "key": "ГАРАНЦИЯ", "value": "24 МЕСЕЦА" }
    ]
}
```

> When a product is not discounted, `old_price` is omitted (or empty). `eans` and `part_nums` are lists because a product can carry more than one identifier.

### Use with AI agents (MCP)

This scraper works with the **Model Context Protocol (MCP)**, so AI agents and assistants can run it and use its data directly. Through the **Apify MCP server**, tools like **Claude**, **ChatGPT**, and other MCP-compatible assistants can trigger the scraper, ask for Technopolis prices and promotions in plain language, and pull the results straight into a conversation or an automated workflow — no manual exporting needed. This makes it a natural fit for **AI shopping assistants, price-monitoring agents, and RAG pipelines** that need fresh, structured product data on demand.

### Data table

| Field | Description |
|-------|-------------|
| Name | Product title as shown on Technopolis |
| Product ID | Unique product code used by the store |
| Category | Full category path the product belongs to |
| Brand | Manufacturer / brand name |
| EAN | Product barcode identifier(s) |
| Price | Current selling price (in EUR) |
| Old price | Previous price, when the product is discounted (in EUR) |
| Images | Links to the product images |
| Specifications | Full technical specification list (name and value pairs) |

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

Costs depend on how many products you collect and how often you run the scraper. A quick test with a small **Max items** limit costs very little, while a full catalog run is larger.

The scraper is built for **affordable ongoing monitoring**: after the first run, repeat runs mainly **refresh prices** instead of re-collecting every product from scratch, which keeps recurring price-tracking runs fast and cheap. New Apify accounts include free monthly usage credits, so you can try it at no cost.

### Residential Proxy Usage & Estimated Cost Example

For example, the first time a brochure is processed, every product page must be visited to build the cache. After that, only the brochure itself is downloaded and product data is served from the cache until it expires (depending on your storage plan).

| Scenario | Products | Estimated Cost ($8/GB) | Cost per Product |
|----------|---------:|-----------------------:|-----------------:|
| **First crawl (cache miss)** | 500 | **~$0.12** | ~$0.00025 |
| **Subsequent crawl (cache hit)** | 500 | **~$0.02** | ~$0.00004 |

> **Example:** Processing the same 500-product brochure after the cache has been built reduces proxy traffic by **~85%**, resulting in significantly lower bandwidth usage, faster execution, and reduced residential proxy costs.

#### How caching works

- ✅ **First crawl:** Downloads every product page and stores the extracted data in the cache.
- ✅ **Later crawls:** Only the brochure page is fetched. Previously cached products are reused, **while each cached product's current brochure price and promotional information are refreshed**. Only new or previously uncached products require an additional product page request.
- ✅ Cached entries remain available until they expire according to your selected storage plan.

> **Note:** Product details (name, images, specifications, etc.) are served from the cache, but **prices are always updated from the latest brochure** on every run, ensuring pricing remains current while minimizing residential proxy usage.

### Free User Limitations

- **Weekly and monthly brochure offers are paid-only.** On the free tier the **Extract weekly brochure offers** and **Extract the monthly brochure offers** options are ignored. Normal category scraping via **Start URLs** works for everyone, free and paid.
- **Brochure-only runs need a paid plan.** If you provide **no Start URLs** and only enable the weekly/monthly brochures on a free plan, there is nothing to scrape — the run closes immediately with an informative status message. Add category **Start URLs**, or [upgrade to a paid plan](https://apify.com/pricing) to fetch the weekly and monthly brochures.

### Tips and advanced options

- Start with a small **Max items** value to preview the data before a full run.
- Combine **category URLs** with the **weekly** and **monthly** brochure toggles to get exactly the coverage you need.
- **Schedule** the scraper to run daily or weekly to build a price history and spot trends and discounts over time.
- Enable **proxy** for the most reliable large runs.
- Use the weekly and monthly brochure options on their own for a focused, lightweight promotions feed.

### FAQ, disclaimers, and support

**In what language and currency is the data?** Product names, categories, and specifications are in Bulgarian, matching the source store, and prices are in EUR.

**Something looks off or missing?** Use the **Issues** tab to report a problem or request a feature — feedback is welcome and helps improve the scraper.

**Need a custom solution?** If you need extra fields, a different site, or a tailored data feed, custom scraping solutions can be arranged.

### SEO Keywords

Technopolis scraper, Technopolis.bg scraper, Technopolis price tracker, Technopolis promotions, Technopolis offers, Technopolis catalog, Technopolis products, Technopolis prices, Technopolis API, weekly brochure offers, monthly brochure offers, promotion tracking Bulgaria, Bulgarian electronics prices, electronics price scraper, price monitoring, product monitoring, price comparison, price intelligence, discount tracking, competitor price monitoring, retail price analysis, product catalog scraper, product data scraper, product data extraction, e-commerce data extraction, product specifications scraper, EAN product data, product manager data, price analyst tools, LLM ready data, RAG dataset, AI training data, MCP server, Model Context Protocol, AI agent scraper, Claude MCP, ChatGPT integration

# Actor input Schema

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

Category URLs to scrape. Leave empty if you only want the weekly and/or monthly brochure offers below.

## `getWeaklyOffers` (type: `boolean`):

If enabled the crawler will collect all products which are in the weakly promo brochure

## `getMonthlyBrochure` (type: `boolean`):

If enabled the crawler will collect all products which are in the monthly promo brochure

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

Stop the run after this many products have been scraped. Set to 0 for unlimited.

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

Specifies proxy servers that will be used by the scraper in order to hide its origin.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.technopolis.bg/bg/TV--Audio-i-Gaming/Televizori/c/P11090104"
    }
  ],
  "getWeaklyOffers": false,
  "getMonthlyBrochure": false,
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Structured product records (prices, specs, images) collected during the run.

## `productCache` (type: `string`):

Key-value store holding cached product records reused across runs.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.technopolis.bg/bg/TV--Audio-i-Gaming/Televizori/c/P11090104"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraping_crew/technopolis-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 = {
    "startUrls": [{ "url": "https://www.technopolis.bg/bg/TV--Audio-i-Gaming/Televizori/c/P11090104" }],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scraping_crew/technopolis-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 '{
  "startUrls": [
    {
      "url": "https://www.technopolis.bg/bg/TV--Audio-i-Gaming/Televizori/c/P11090104"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scraping_crew/technopolis-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Technopolis Product & Promotions Scraper",
        "description": "Track weekly and monthly Technopolis promotions and scrape the full product catalog — prices, old prices, specifications, brands, and images — as clean, structured data ready for price analysis and AI workflows.",
        "version": "0.1",
        "x-build-id": "a027gOJU5WENvnNPR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraping_crew~technopolis-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraping_crew-technopolis-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/scraping_crew~technopolis-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraping_crew-technopolis-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/scraping_crew~technopolis-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraping_crew-technopolis-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Category URLs to scrape. Leave empty if you only want the weekly and/or monthly brochure offers below.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "getWeaklyOffers": {
                        "title": "Extract weakly brochure offers",
                        "type": "boolean",
                        "description": "If enabled the crawler will collect all products which are in the weakly promo brochure",
                        "default": false
                    },
                    "getMonthlyBrochure": {
                        "title": "Extract the monthly brochure offers",
                        "type": "boolean",
                        "description": "If enabled the crawler will collect all products which are in the monthly promo brochure",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop the run after this many products have been scraped. Set to 0 for unlimited.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Specifies proxy servers that will be used by the scraper in order to hide its origin.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
