# Preunic Chile Product Price Scraper (`automation-lab/preunic-chile-product-price-scraper`) Actor

Extract Preunic Chile products, prices, offers, Mi Preunic card prices, promotions, brands, categories, images, and URLs. Export JSON, CSV, or Excel.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Preunic Chile Product Price Scraper

Extract product prices, offers, Mi Preunic card prices, promotions, categories, brands, images, availability state, and product URLs from Preunic Chile.

Use this actor to monitor Chilean beauty, pharmacy, personal care, baby, and retail catalog prices without opening a browser. It queries the public Preunic product search index and saves clean product rows to an Apify dataset.

### What does Preunic Chile Product Price Scraper do?

Preunic Chile Product Price Scraper turns Preunic search results into structured ecommerce data.

It collects:

- 🔎 Product names and descriptions
- 🏷️ Preunic SKU and object identifiers
- 💰 Normal catalog prices
- 🔥 Offer prices
- 💳 Mi Preunic card prices
- 🎁 Promotion badges and structured promotion details
- 🧴 Brands and product options
- 🗂️ Category paths
- 🖼️ Product image URLs
- 🔗 Product URLs
- 📦 Preunic state / availability indicators
- ⏱️ Scrape timestamp and source query

### Who is it for?

This actor is useful for teams that need fresh Preunic product intelligence.

- 🛒 Ecommerce category managers comparing assortment and price changes
- 📊 Retail analysts tracking Chilean beauty and pharmacy promotions
- 🧾 Price-monitoring teams watching normal, offer, and card prices
- 🤖 Repricing pipelines that need clean product rows
- 🧴 Beauty and personal care brands monitoring shelf visibility
- 🧪 Data teams enriching catalogs with Preunic product metadata
- 📈 Agencies preparing competitive retail reports for Chilean clients

### Why use this actor?

Preunic exposes product data through a public search backend used by its catalog pages. This actor calls that endpoint directly and avoids expensive browser automation.

Benefits:

- ⚡ Fast HTTP-only extraction
- 💸 Low compute cost
- 🧼 Clean normalized fields
- 🔁 Repeatable inputs for monitoring jobs
- 📦 Dataset output ready for export
- 🧩 Easy integration with Apify API, webhooks, and storage

### What data can I extract from Preunic?

The dataset contains one row per product.

| Field | Description |
| --- | --- |
| `sku` | Preunic product SKU |
| `objectId` | Algolia object identifier |
| `productId` | Numeric product ID when available |
| `name` | Product name |
| `description` | Product description from the catalog index |
| `brand` | Brand name |
| `categories` | Raw category levels from Preunic |
| `categoryPath` | Deepest available category path |
| `price` | Normal price in CLP |
| `offerPrice` | Offer price in CLP |
| `cardPrice` | Mi Preunic card price in CLP |
| `currency` | Always `CLP` |
| `discountBadge` | Main discount badge, such as `-20%` |
| `promotions` | Structured promotion objects |
| `image` | Product image URL |
| `slug` | Preunic product slug |
| `url` | Product URL |
| `state` | Raw Preunic product state |
| `availability` | Normalized state indicator |
| `storeExclusive` | Whether the product is store-exclusive |
| `exclusiveBrand` | Whether it is an exclusive brand |
| `optionsText` | Variant/options text when present |
| `query` | Search term that produced the item |
| `scrapedAt` | ISO timestamp |

### How much does it cost to scrape Preunic product prices?

This actor uses pay-per-event pricing.

You pay a small run-start fee and then a tiered per-product fee for each product saved to the dataset. The actor is HTTP-only, so typical runs are lightweight. For example, monitoring 100 Preunic products should finish quickly and produce exactly the rows you can export from the dataset.

The per-product event uses canonical Apify user tiers (FREE, BRONZE, SILVER, GOLD, PLATINUM, and DIAMOND). Final live tier pricing is visible on the Apify Store page after publishing.

### How to scrape Preunic products

1. Open the actor on Apify.
2. Add one or more search queries, such as `shampoo`, `bloqueador`, or `crema`.
3. Optionally add category filters.
4. Set `Maximum products`.
5. Start the run.
6. Download the dataset as JSON, CSV, Excel, or use the API.

### Input options

#### Search queries

Use Spanish terms that shoppers would enter on preunic.cl.

Examples:

- `shampoo`
- `bloqueador`
- `crema facial`
- `perfume`
- `pañales`
- `maquillaje`

#### Category facet filters

Use Preunic/Algolia category facets when you want narrower monitoring.

Examples:

- `categories.lvl0:capilar`
- `categories.lvl1:capilar > shampoo`
- `categories.lvl0:dermocosmetica`

If you enter only `capilar`, the actor treats it as `categories.lvl0:capilar`.

#### Maximum products

Controls the total number of unique products saved across all queries.

Use smaller values for testing and larger values for recurring catalog monitoring.

#### Hits per page

Controls the Algolia page size. The default and maximum is `100`.

#### Raw Algolia filters

Advanced users can pass a raw Algolia filter expression. Leave this empty unless you know the Preunic index fields.

### Example input

```json
{
  "queries": ["shampoo", "bloqueador"],
  "categoryFilters": [],
  "maxItems": 100,
  "hitsPerPage": 100
}
````

### Example output

```json
{
  "sku": "572970",
  "objectId": "572970",
  "productId": 3753,
  "name": "Shampoo",
  "description": "Shampoo 2 En 1 Frozen Ii, Disney 300Ml",
  "brand": "Gelatti",
  "categoryPath": "capilar > shampoo > hidratacion y reparacion",
  "price": 4999,
  "offerPrice": 4749,
  "cardPrice": 4999,
  "currency": "CLP",
  "discountBadge": "-5%",
  "url": "https://www.preunic.cl/products/shampoo-2-en-1-frozen-ii-disney-300ml",
  "availability": "not_active",
  "query": "shampoo",
  "scrapedAt": "2026-06-26T05:58:52.971Z"
}
```

### Tips for better results

- ✅ Use Spanish retail terms.
- ✅ Start with broad terms, then add category filters.
- ✅ Use the same input on a schedule to monitor changes.
- ✅ Keep `maxItems` low during testing.
- ✅ Export as CSV for spreadsheet comparison.
- ✅ Use product `sku` as the stable key in your database.

### Common workflows

#### Price monitoring

Run daily searches for important categories and compare `price`, `offerPrice`, and `cardPrice` over time.

#### Promotion tracking

Filter rows with a non-empty `discountBadge` or structured `promotions` data.

#### Category assortment analysis

Use `categoryPath`, `brand`, and `sku` to measure assortment size and brand presence by category.

#### Catalog enrichment

Join your internal product catalog with Preunic rows by SKU, product name, or brand.

### Integrations

This actor works with standard Apify integrations.

- 📁 Dataset exports to JSON, CSV, Excel, XML, RSS, and HTML
- 🔔 Webhooks for completed monitoring runs
- 🧩 Apify API for automated pipelines
- 🗃️ Key-value storage for run inputs and metadata
- 🧠 MCP tools for AI agents that need retail price data

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/preunic-chile-product-price-scraper').call({
  queries: ['shampoo'],
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 3));
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/preunic-chile-product-price-scraper').call({
    'queries': ['bloqueador'],
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~preunic-chile-product-price-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["shampoo"],"maxItems":100}'
```

### Using with MCP

You can use this actor from Claude Desktop, Claude Code, or other MCP-compatible clients through Apify MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/preunic-chile-product-price-scraper
```

Example prompts:

- "Scrape 100 Preunic shampoo products and summarize the offer price range."
- "Find Preunic bloqueador products with card prices lower than offer prices."
- "Compare Preunic category paths for maquillaje products."

### Scheduling

Use Apify schedules to run the same input daily, weekly, or monthly.

Recommended monitoring setup:

1. Create one task per category or product group.
2. Use stable query terms.
3. Store exports or consume the dataset through the API.
4. Compare rows by `sku` and timestamp.

### Data quality notes

Prices are extracted from the product search index. If a product page displays a different price because of location, stock, or a temporary campaign, the index may update after a short delay.

The actor preserves Preunic's raw `state` and also adds a normalized `availability` field.

### Limitations

- The actor does not log in to Preunic.
- The actor does not add products to cart.
- The actor does not scrape store-level stock.
- Product-detail pages are not opened in the MVP.
- The public search key or index name can change if Preunic changes its frontend.

### Is scraping Preunic legal?

This actor extracts publicly accessible product search data. You are responsible for using the data legally and respecting applicable laws, terms, and privacy obligations. Do not use the actor for abusive traffic, credentialed access, or personal data collection.

### Legality and responsible use

This actor is intended for legitimate catalog, price-monitoring, research, and business-intelligence workflows. Review Preunic's terms and applicable Chilean, consumer-protection, privacy, and competition rules before using exported data in production. Keep request volumes reasonable, avoid collecting personal data, and do not use the actor to bypass authentication or access non-public content.

### Troubleshooting

#### I got zero products

Try a broader Spanish query such as `shampoo`, `crema`, or `bloqueador`. Remove category filters and reduce advanced filters.

#### Prices look different on the website

Preunic campaigns can change quickly, and product pages may use location-specific or refreshed data. Re-run the actor and compare `scrapedAt` timestamps.

#### My category filter returns nothing

Check that your filter matches Algolia facet syntax. Good examples are `categories.lvl0:capilar` and `categories.lvl1:capilar > shampoo`.

### FAQ

#### Does this actor use a browser?

No. It is HTTP-only and queries the public product search backend.

#### Does it need proxies?

No proxy is configured by default because the public endpoint responded directly during development.

#### Can I scrape all Preunic products?

Use a broad query and a higher `maxItems`. For production monitoring, split large jobs by category or query for easier comparison.

#### Can I monitor price changes over time?

Yes. Schedule repeated runs and compare rows by `sku`, `price`, `offerPrice`, `cardPrice`, and `scrapedAt`.

### Related scrapers

Explore more Automation Lab retail and ecommerce scrapers:

- https://apify.com/automation-lab/paris-cl-product-scraper
- https://apify.com/automation-lab/mercado-libre-scraper
- https://apify.com/automation-lab/amazon-product-scraper
- https://apify.com/automation-lab/google-shopping-scraper

### Support

If Preunic changes its index or you need another Chilean retailer, open an issue on the actor page with your input and expected output.

### Changelog

#### 0.1

Initial private build for Preunic product search, price, offer, card price, promotion, category, image, and URL extraction.

# Actor input Schema

## `queries` (type: `array`):

One or more Preunic search terms. Use Spanish product terms such as shampoo, bloqueador, perfume, crema, pañales, or maquillaje.

## `categoryFilters` (type: `array`):

Optional Preunic/Algolia category filters. Examples: categories.lvl0:capilar, categories.lvl1:capilar > shampoo. If you enter only a category name, it is treated as categories.lvl0.

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

Maximum number of unique Preunic products to save across all queries.

## `hitsPerPage` (type: `integer`):

Algolia page size. Use 20 for small tests or 100 for efficient catalog extraction.

## `filters` (type: `string`):

Optional advanced Algolia filters expression. Leave empty unless you know the Preunic index fields.

## Actor input object example

```json
{
  "queries": [
    "shampoo",
    "bloqueador"
  ],
  "categoryFilters": [],
  "maxItems": 20,
  "hitsPerPage": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "shampoo",
        "bloqueador"
    ],
    "categoryFilters": [],
    "maxItems": 20,
    "hitsPerPage": 20,
    "filters": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/preunic-chile-product-price-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 = {
    "queries": [
        "shampoo",
        "bloqueador",
    ],
    "categoryFilters": [],
    "maxItems": 20,
    "hitsPerPage": 20,
    "filters": "",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/preunic-chile-product-price-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 '{
  "queries": [
    "shampoo",
    "bloqueador"
  ],
  "categoryFilters": [],
  "maxItems": 20,
  "hitsPerPage": 20,
  "filters": ""
}' |
apify call automation-lab/preunic-chile-product-price-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Preunic Chile Product Price Scraper",
        "description": "Extract Preunic Chile products, prices, offers, Mi Preunic card prices, promotions, brands, categories, images, and URLs. Export JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "Xog1BE0tLGBRim4E0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~preunic-chile-product-price-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-preunic-chile-product-price-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~preunic-chile-product-price-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-preunic-chile-product-price-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~preunic-chile-product-price-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-preunic-chile-product-price-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": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "One or more Preunic search terms. Use Spanish product terms such as shampoo, bloqueador, perfume, crema, pañales, or maquillaje.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "shampoo"
                        ]
                    },
                    "categoryFilters": {
                        "title": "Category facet filters",
                        "type": "array",
                        "description": "Optional Preunic/Algolia category filters. Examples: categories.lvl0:capilar, categories.lvl1:capilar > shampoo. If you enter only a category name, it is treated as categories.lvl0.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique Preunic products to save across all queries.",
                        "default": 20
                    },
                    "hitsPerPage": {
                        "title": "Hits per page",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Algolia page size. Use 20 for small tests or 100 for efficient catalog extraction.",
                        "default": 20
                    },
                    "filters": {
                        "title": "Raw Algolia filters",
                        "type": "string",
                        "description": "Optional advanced Algolia filters expression. Leave empty unless you know the Preunic index fields."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```