# OLX Bulgaria Classifieds Scraper (`automation-lab/olx-bulgaria-classifieds-scraper`) Actor

Scrape public OLX.bg classifieds listings with prices, locations, sellers, images, attributes, and listing URLs for research and lead generation.

- **URL**: https://apify.com/automation-lab/olx-bulgaria-classifieds-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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

## OLX Bulgaria Classifieds Scraper

Scrape public listings from OLX.bg search, category, and listing pages.

Use this actor to collect Bulgarian classifieds data for price monitoring, resale research, lead generation, inventory tracking, and regional marketplace analysis.

---

### What does OLX Bulgaria Classifieds Scraper do?

OLX Bulgaria Classifieds Scraper extracts structured listing data from public OLX.bg pages.

It can start from a keyword search or from exact OLX.bg URLs that already include your category, location, and filter choices.

The actor returns clean rows with listing titles, prices, URLs, locations, seller information, descriptions, attributes, images, and timestamps.

### Who is it for?

#### Resale and arbitrage teams

Track prices for phones, electronics, vehicles, furniture, tools, and other high-volume categories.

#### Market researchers

Measure supply, pricing ranges, seller behavior, promoted listings, and regional inventory depth.

#### Lead generation teams

Find public business sellers and listings that match your target category or geography.

#### Ecommerce operators

Monitor competitor offers and local marketplace prices in Bulgaria.

#### Data teams

Feed OLX.bg listing data into dashboards, warehouses, alerting systems, and enrichment workflows.

### Why use this actor?

- ⚡ Uses fast HTTP scraping instead of a browser when possible.
- 🇧🇬 Designed for OLX Bulgaria pages and Bulgarian category/search URLs.
- 🧾 Produces one clean dataset row per classified listing.
- 🖼️ Captures image URLs for visual review and catalog matching.
- 🏷️ Keeps OLX attributes as structured key-value data.
- 📍 Separates city, region, district, and full location path.
- 💰 Extracts both display price and numeric price value when available.
- 🔁 Supports pagination limits to control run cost.

### What data can you extract from OLX.bg?

| Field | Description |
| --- | --- |
| `listingId` | OLX listing identifier |
| `title` | Listing title |
| `url` | Public listing URL |
| `price` | Display price shown by OLX.bg |
| `priceValue` | Numeric price value when available |
| `currency` | Currency code, usually BGN |
| `location` | Full OLX location path |
| `city` | City name |
| `region` | Region name |
| `district` | District name when available |
| `postedAt` | Original listing creation time |
| `refreshedAt` | Last refresh or bump time |
| `category` | Category/type metadata |
| `breadcrumbs` | Listing breadcrumb labels when detail pages are opened |
| `sellerName` | Public seller/contact name |
| `sellerType` | Business/private signal when available |
| `sellerProfileUrl` | Public seller profile URL |
| `sellerId` | OLX seller ID |
| `description` | Clean text description |
| `attributes` | OLX listing parameters and specs |
| `imageUrls` | Listing image URLs |
| `isPromoted` | Whether OLX marks the listing as promoted |
| `isHighlighted` | Whether the listing is highlighted |
| `isBusiness` | Whether OLX marks seller/listing as business |
| `hasPhone` | Whether phone contact is publicly indicated |
| `phone` | Phone only if visible in public HTML |
| `scrapedAt` | Actor scrape timestamp |

### How much does it cost to scrape OLX Bulgaria classifieds?

This actor uses pay-per-event pricing.

You pay a $0.005 run-start event and a tiered per-result event for each listing saved.

The BRONZE per-listing price is $0.001, with lower prices on higher Apify plan tiers and $0.00115 on the FREE tier.

Use low `maxResults` values for quick checks and larger limits for production exports.

### How to scrape OLX.bg in 5 steps

1. Open OLX.bg in your browser.
2. Search or filter the category you need.
3. Copy the OLX.bg URL into `startUrls`.
4. Set `maxResults` to the number of listings you need.
5. Run the actor and export the dataset as JSON, CSV, Excel, or via API.

### Input configuration

#### `startUrls`

Paste OLX.bg search, category, or listing URLs.

Examples:

- `https://www.olx.bg/elektronika/telefoni/q-iphone/`
- `https://www.olx.bg/nedvizhimi-imoti/`
- `https://www.olx.bg/avtomobili/`

#### `searchQuery`

Used only when `startUrls` is empty.

Example: `iphone`, `velosiped`, `apartament`, or `bmw`.

#### `maxResults`

Maximum number of listings to save.

Use `20` for a quick test and increase it for production runs.

#### `includeDetails`

When enabled, the actor opens each listing page.

This can enrich breadcrumbs and detail-only fields, but it is slower.

Leave it off when search-result data is enough.

#### `maxPages`

Controls how many paginated result pages are checked for each start URL.

#### `maxRequestRetries`

Controls retry attempts for temporary request failures.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.olx.bg/elektronika/telefoni/q-iphone/" }
  ],
  "maxResults": 20,
  "includeDetails": false,
  "maxPages": 2
}
````

### Example output

```json
{
  "listingId": "147598379",
  "title": "Apple iPhone 17 256GB Lavender",
  "url": "https://www.olx.bg/d/ad/example.html",
  "price": "1562.71 лв. / 799 €",
  "priceValue": 1562,
  "currency": "BGN",
  "city": "гр. София",
  "sellerName": "Sweet Deals",
  "imageUrls": ["https://frankfurt.apollo.olxcdn.com/..."],
  "isPromoted": false,
  "scrapedAt": "2026-05-18T09:00:00.000Z"
}
```

### Tips for better results

- Use exact OLX.bg URLs when you need a specific city or category.
- Keep `includeDetails` disabled for faster monitoring runs.
- Enable `includeDetails` when breadcrumbs are important.
- Increase `maxPages` if OLX has many results for your search.
- Export as CSV for quick spreadsheet analysis.
- Export as JSON when you need nested `attributes` and `imageUrls`.

### Common OLX Bulgaria use cases

#### Price monitoring

Track average asking prices for used electronics, cars, furniture, and property listings.

#### Inventory monitoring

Watch how many listings appear in a category or region over time.

#### Seller intelligence

Identify business sellers, repeated sellers, and public seller profiles.

#### Lead sourcing

Collect public listing signals and route promising opportunities to your CRM.

#### Market research

Compare regional supply and price differences across Bulgarian cities.

### Integrations

You can connect the dataset to many downstream tools.

- 📊 Google Sheets for quick manual review.
- 🧱 Airtable for lightweight marketplace databases.
- 🧮 BigQuery or Snowflake for analytics.
- 🔔 Slack or email alerts when new matching listings appear.
- 🧩 Zapier or Make for no-code workflows.
- 🛒 Ecommerce repricing tools for competitive intelligence.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/olx-bulgaria-classifieds-scraper').call({
  startUrls: [{ url: 'https://www.olx.bg/elektronika/telefoni/q-iphone/' }],
  maxResults: 20
});

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

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/olx-bulgaria-classifieds-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.olx.bg/elektronika/telefoni/q-iphone/'}],
    'maxResults': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~olx-bulgaria-classifieds-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.olx.bg/elektronika/telefoni/q-iphone/"}],"maxResults":20}'
```

### MCP integration

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

MCP URL:

```text
https://mcp.apify.com?tools=automation-lab/olx-bulgaria-classifieds-scraper
```

Claude Code setup:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/olx-bulgaria-classifieds-scraper"
```

Claude Desktop, Cursor, or VS Code MCP JSON setup:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/olx-bulgaria-classifieds-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 30 iPhone listings from OLX Bulgaria and summarize price ranges."
- "Find OLX.bg listings in this category and group them by city."
- "Monitor this OLX.bg URL and tell me which listings are promoted."

### Data quality notes

OLX.bg can expose different fields by category.

Some listings include detailed attributes such as model, condition, memory, or delivery options.

Other categories may have different parameter names.

The actor keeps these values in the flexible `attributes` object.

### Phone and contact data

The actor only returns phone data if it is present in public page HTML.

OLX often masks phone numbers or requires interactive reveal flows.

This actor does not bypass login walls or access private data.

### Pagination behavior

The actor follows OLX result pages by adding the `page` query parameter.

It stops when it reaches `maxResults`, `maxPages`, or the number of pages reported by OLX.

Duplicate listing IDs are skipped.

### Performance

The actor is HTTP-based and normally runs quickly for small and medium jobs.

Opening detail pages increases request count, so use `includeDetails` only when needed.

### FAQ

### Troubleshooting

#### I got fewer results than requested. Why?

The selected OLX URL may have fewer available listings, or `maxPages` may be too low.

Increase `maxPages` or use a broader category/search URL.

#### Why is `phone` empty?

OLX.bg frequently masks phone numbers. The actor only returns publicly visible phone values.

#### Why are some attributes missing?

OLX categories have different parameter sets. Missing fields usually mean OLX did not provide that attribute for the listing.

### Legality

This actor extracts publicly available information from OLX.bg pages.

You are responsible for using the data in accordance with applicable laws, OLX terms, privacy rules, and Apify policies.

Do not use scraped data for spam, harassment, or prohibited profiling.

### Related scrapers

Other automation-lab actors can help with regional marketplace and ecommerce workflows.

- https://apify.com/automation-lab/zillow-scraper
- https://apify.com/automation-lab/pisos-com-real-estate-scraper
- https://apify.com/automation-lab/tradera-scraper
- https://apify.com/automation-lab/facebook-marketplace-scraper

### Changelog

#### 0.1

Initial OLX Bulgaria classifieds extraction for public search/category/listing pages.

### Support

If a run fails or output looks incomplete, share the run URL and input with support.

Include the OLX.bg URL you expected to scrape and the number of listings you expected.

# Actor input Schema

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

OLX.bg category, search, or listing URLs to scrape. Leave empty to use the search query.

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

Keyword used when no start URLs are provided.

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

Maximum number of classified listings to save.

## `includeDetails` (type: `boolean`):

Fetch each listing page to enrich breadcrumbs and any detail-only fields. Slower but more complete.

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

Pagination cap for each category or search URL.

## `maxRequestRetries` (type: `integer`):

Retry attempts for temporary OLX.bg request failures.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.olx.bg/elektronika/telefoni/q-iphone/"
    }
  ],
  "searchQuery": "iphone",
  "maxResults": 20,
  "includeDetails": false,
  "maxPages": 2,
  "maxRequestRetries": 3
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.olx.bg/elektronika/telefoni/q-iphone/"
        }
    ],
    "searchQuery": "iphone",
    "maxResults": 20,
    "includeDetails": false,
    "maxPages": 2,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/olx-bulgaria-classifieds-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.olx.bg/elektronika/telefoni/q-iphone/" }],
    "searchQuery": "iphone",
    "maxResults": 20,
    "includeDetails": False,
    "maxPages": 2,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/olx-bulgaria-classifieds-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.olx.bg/elektronika/telefoni/q-iphone/"
    }
  ],
  "searchQuery": "iphone",
  "maxResults": 20,
  "includeDetails": false,
  "maxPages": 2,
  "maxRequestRetries": 3
}' |
apify call automation-lab/olx-bulgaria-classifieds-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OLX Bulgaria Classifieds Scraper",
        "description": "Scrape public OLX.bg classifieds listings with prices, locations, sellers, images, attributes, and listing URLs for research and lead generation.",
        "version": "0.1",
        "x-build-id": "VTf9ntGE5KZSIA6tN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~olx-bulgaria-classifieds-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-olx-bulgaria-classifieds-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~olx-bulgaria-classifieds-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-olx-bulgaria-classifieds-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~olx-bulgaria-classifieds-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-olx-bulgaria-classifieds-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": "OLX.bg start URLs",
                        "type": "array",
                        "description": "OLX.bg category, search, or listing URLs to scrape. Leave empty to use the search query.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword used when no start URLs are provided.",
                        "default": "iphone"
                    },
                    "maxResults": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of classified listings to save.",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Open listing detail pages",
                        "type": "boolean",
                        "description": "Fetch each listing page to enrich breadcrumbs and any detail-only fields. Slower but more complete.",
                        "default": false
                    },
                    "maxPages": {
                        "title": "Maximum pages per start URL",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Pagination cap for each category or search URL.",
                        "default": 5
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Retry attempts for temporary OLX.bg request failures.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```