# Ozon Scraper - Products, Categories & Search (`crawlerbros/ozon-scraper`) Actor

Scrape Ozon.ru, Russia's largest e-commerce marketplace. Search products, browse categories, or fetch full product details - prices, discounts, ratings, reviews, sellers, images, and delivery info.

- **URL**: https://apify.com/crawlerbros/ozon-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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/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

## Ozon Scraper - Products, Categories & Search

Scrape [Ozon.ru](https://www.ozon.ru), Russia's largest e-commerce marketplace, in three modes: keyword search, category browsing, and full product-detail lookups by URL or SKU. Get pricing (including Ozon Card / discount pricing), ratings with a full 5-star breakdown, review counts, full seller profiles (name, storefront URL, rating, lifetime orders), complete spec/characteristic tables, structured category breadcrumbs, other colors/configurations of the same product, similar/alternative products, buyer Q&A counts, competing-seller offers, image galleries, product videos, promo/marketing labels, delivery estimates — ready for price monitoring, market research, and catalog enrichment.

### What this actor does

- **Three modes:** `search`, `byCategory`, `productDetails`
- **Universal product lookup:** full Ozon product URLs or bare numeric SKU/product IDs
- **Filters:** price range, minimum rating, in-stock only
- **Sort control:** relevance, price (asc/desc), rating, newest (search mode)
- **Empty fields are omitted** — every record only contains data that was actually found

### Output per product

| Field | Description |
|---|---|
| `sku` | Ozon product/SKU ID |
| `name` | Product title |
| `brand` | Brand name (productDetails mode, when Ozon exposes a distinct brand widget) |
| `price` | Current price in RUB |
| `originalPrice` | Pre-discount price in RUB, if the product is on sale |
| `discountPercent` | Computed discount percentage |
| `cardPrice` | Ozon Card member price, when different from `price` |
| `currency` | Always `RUB` when pricing is present |
| `rating` | Average rating (0–5) |
| `reviewCount` | Number of reviews |
| `ratingBreakdown` | Star-rating distribution as `[{stars, count, percentage}, ...]` for 5 down to 1 stars (productDetails mode) |
| `sellerName` | Seller/shop name |
| `sellerUrl` | Seller's Ozon storefront URL (productDetails mode) |
| `sellerRating` | Seller/shop rating, 0–5 (productDetails mode) |
| `sellerOrdersCount` | Seller's lifetime order count, as shown on-site e.g. `"12.3 K"` (productDetails mode) |
| `category` | Category breadcrumb trail as a single ` > `-joined string (productDetails mode) |
| `breadcrumbs` | Same trail as structured `[{text, url}, ...]`, each with its own category-page URL (productDetails mode) |
| `characteristics` | Full spec table as `{characteristic name: value}` (productDetails mode) |
| `variants` | Other colors/configurations of this exact product — each a distinct SKU with its own `sku`, `name`, `price`, `originalPrice`, `imageUrl`, `productUrl`, `availability` (productDetails mode) |
| `questionCount` | Number of buyer Q&A questions posted for the product (productDetails mode) |
| `otherSellersCount` | Number of other sellers listing the same product cheaper/faster, when Ozon shows a comparison banner (productDetails mode) |
| `otherSellersMinPrice` | Lowest price among those other sellers, in RUB (productDetails mode) |
| `imageUrl` | Primary product image |
| `images` | All gallery images (productDetails mode) |
| `videos` | Product video URLs (e.g. unboxing/demo clips), when Ozon's gallery carries one — most products don't have one, so this is often absent (productDetails mode) |
| `marketingLabels` | Promo badge texts shown on the page (e.g. cashback offers, "points for a review"), when present (productDetails mode) |
| `similarProducts` | Ozon's own "similar/alternative products" shelf — each a real, distinct SKU with `sku`, `name`, `price`, `originalPrice`, `discountPercent`, `imageUrl`, `productUrl`, `availability` (productDetails mode) |
| `availability` | Stock status — either a status text (e.g. "70 шт осталось") or the canonical `outOfStock` when the exact SKU has sold out |
| `availabilityText` | Ozon's own human-readable out-of-stock message, e.g. "Этот товар закончился" (productDetails mode, only when out of stock) |
| `deliveryInfo` | Delivery estimate text (productDetails mode) |
| `productUrl` | Canonical Ozon product page URL |
| `recordType` | `product` |
| `scrapedAt` | UTC ISO timestamp of the scrape |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` / `productDetails` |
| `searchQuery` | string | `iphone` | Keyword search (mode=search) |
| `sortBy` | string | – | `price` / `-price` / `rating` / `new` (mode=search). Leave empty (default relevance) for the tightest topical match — see FAQ note below on non-default sorts + deep pagination |
| `categoryUrl` | string | – | Category URL or slug (mode=byCategory) |
| `productUrls` | array | – | Product URLs or bare SKUs (mode=productDetails) |
| `minPrice` / `maxPrice` | integer | – | RUB price range filter |
| `minRating` | number | – | Minimum rating (0–5) |
| `inStockOnly` | boolean | `false` | Drop products marked out of stock |
| `maxItems` | integer | `20` | Hard cap on emitted records (1–500) |
| `proxyConfiguration` | object | RESIDENTIAL / RU | Required — see FAQ for why |

#### Example: search with filters

```json
{
  "mode": "search",
  "searchQuery": "телевизор",
  "sortBy": "price",
  "minPrice": 10000,
  "minRating": 4,
  "maxItems": 30
}
````

#### Example: browse a category

```json
{
  "mode": "byCategory",
  "categoryUrl": "https://www.ozon.ru/category/smartfony-15502/",
  "maxItems": 50
}
```

#### Example: fetch full product details

```json
{
  "mode": "productDetails",
  "productUrls": ["https://www.ozon.ru/product/apple-iphone-15-128gb-blue-123456789/", "987654321"]
}
```

### Use cases

- **Price monitoring** — track price and discount changes on competitor SKUs
- **Market research** — analyze ratings, review volume, and seller mix by category
- **Catalog enrichment** — pull structured product data by SKU for your own listings
- **Assortment analysis** — browse a category to see full product mix and pricing spread
- **Deal discovery** — sort by price/rating to surface the best-value listings

### Other Russian marketplace actors by CrawlerBros

| Actor | URL |
|---|---|
| Citilink Scraper - Russian Electronics Store Products | <https://apify.com/crawlerbros/citilink-scraper> |
| DNS-Shop Scraper | <https://apify.com/crawlerbros/dns-shop-scraper> |
| Eldorado Scraper | <https://apify.com/crawlerbros/eldorado-scraper> |
| ETM Electrical Equipment Scraper | <https://apify.com/crawlerbros/etm-scraper> |
| Holodilnik.ru Scraper | <https://apify.com/crawlerbros/holodilnik-scraper> |
| Lemanapro Scraper | <https://apify.com/crawlerbros/lemanapro-scraper> |
| Magnit Market (mm.ru) Scraper | <https://apify.com/crawlerbros/magnit-market-scraper> |
| Maxidom Scraper | <https://apify.com/crawlerbros/maxidom-scraper> |
| Megamarket.ru Scraper | <https://apify.com/crawlerbros/megamarket-scraper> |
| M.Video Scraper | <https://apify.com/crawlerbros/mvideo-scraper> |
| Onlinetrade.ru Scraper | <https://apify.com/crawlerbros/onlinetrade-scraper> |
| Ozon Scraper - Products, Categories & Search (this actor) | <https://apify.com/crawlerbros/ozon-scraper> |
| Petrovich Building Materials Scraper | <https://apify.com/crawlerbros/petrovich-scraper> |
| Regard Scraper | <https://apify.com/crawlerbros/regard-scraper> |
| Russkiy Svet (rs24.ru) Electrical Equipment Scraper | <https://apify.com/crawlerbros/russkiysvet-scraper> |
| Technopark.ru Scraper - Products, Categories & Search | <https://apify.com/crawlerbros/technopark-scraper> |
| VseInstrumenti.ru Scraper | <https://apify.com/crawlerbros/vseinstrumenti-scraper> |
| Wildberries Scraper | <https://apify.com/crawlerbros/wildberries-scraper> |
| X-Com Shop Scraper | <https://apify.com/crawlerbros/xcom-shop-scraper> |
| Yandex Market Pro Scraper | <https://apify.com/crawlerbros/yandex-pro-scraper> |

### FAQ

**Why does this actor require a residential proxy?** Ozon blocks non-Russian datacenter traffic at the network edge with a JS/CAPTCHA challenge before the storefront ever loads. A Russian residential IP passes this check transparently, so a residential proxy pinned to Russia is required input for every run — the actor fails fast if none is configured.

**Can I search in English?** Ozon's catalog is primarily Russian-language; search terms in Latin script (e.g. brand names, model numbers like "iphone") work well, but broader English keyword queries may return fewer results than the equivalent Russian term.

**What currency are prices in?** Russian rubles (RUB) — Ozon's only supported currency.

**Why is `cardPrice` sometimes missing?** It only appears when Ozon shows a separate Ozon Card member price distinct from the regular price.

**Can I look up a product by just its numeric ID?** Yes — `productUrls` accepts bare numeric SKU/product IDs as well as full product URLs.

**What are `variants`?** Other colors, storage sizes, or configurations Ozon sells under the same product listing (e.g. the same phone in a different color) — each entry is its own real, purchasable SKU with its own price and URL. This is not a generic "customers also viewed" recommendation list, just the same product's own selectable variants.

**Are `characteristics` the full spec sheet?** They're Ozon's own "About this product" panel — the same characteristic table shown on the product page. Coverage varies by category/product; sparse listings will have fewer entries.

**What is `ratingBreakdown`?** The 5-star-to-1-star distribution of a product's reviews, straight from Ozon's own rating widget — useful for spotting products with a polarized or thin review base that a single average rating hides.

**Why do a few results with `sortBy` set (e.g. `rating`) not match my keyword?** For a narrow query, Ozon's own site may only have a handful of genuine matches under a non-default sort order. Once its infinite-scroll widget runs out of true sorted matches, Ozon itself — not this actor — continues the same feed with its own "recommended for you" filler products to keep the scroll going, and the actor has no reliable way to tell filler from a real match at that point (page-level `mainState`/`state` shape is identical). This only shows up when a run needs several pages under a non-empty `sortBy` (e.g. combined with `minPrice`/`maxPrice`/`minRating`/`inStockOnly` that reject many cards, or a high `maxItems`); default relevance search (`sortBy` left empty) reliably stays on-topic for the whole result set in testing. If strict topical relevance matters more than sort order, leave `sortBy` empty and sort the returned dataset yourself.

**What are `similarProducts`?** Ozon's own "similar products" recommendation shelf — real, independently purchasable SKUs (not our guess), most commonly shown as substitutes when the requested product has sold out, but also present on some regular in-stock pages.

**Why does an out-of-stock product still return `name`/`price`/`sellerName`?** Ozon renders a dedicated "this item sold out" page in place of the normal product layout, but that page still carries the real last-known name, price, seller, and image for the exact SKU — the actor reads that data rather than returning an almost-empty record. `availability` will read `outOfStock` and `availabilityText` carries Ozon's own message in these cases.

**What are `videos` and `marketingLabels`?** `videos` are real product video URLs from Ozon's own gallery (brand-supplied unboxing/demo clips) — only a minority of listings have one. `marketingLabels` are the short promo badges Ozon shows on the product page (e.g. cashback or "get points for a review" offers) — informational only, not a parsed price/discount value.

**What if a category or search term has no matches?** The run completes successfully with 0 records and a status message explaining why — this is expected behavior, not a failure.

**How fresh is the data?** Real-time — every run reads Ozon's live storefront data at request time.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

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

Free-text keyword search, e.g. `iphone`, `телевизор`.

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

Result ordering for search mode. Leave as relevance for the default ranking.

## `categoryUrl` (type: `string`):

A full Ozon category URL (e.g. `https://www.ozon.ru/category/smartfony-15502/`) or a bare category slug (e.g. `smartfony-15502`).

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

Full Ozon product URLs, or bare numeric SKU/product IDs.

## `minPrice` (type: `integer`):

Drop products cheaper than this (in Russian rubles).

## `maxPrice` (type: `integer`):

Drop products pricier than this (in Russian rubles).

## `minRating` (type: `number`):

Drop products rated below this (0-5 scale).

## `inStockOnly` (type: `boolean`):

Only emit products that are not marked out of stock / sold out.

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

Hard cap on emitted records.

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

Apify RESIDENTIAL proxy (Russia) is required to bypass Ozon's anti-bot edge block, which returns a hard 403/captcha challenge to datacenter IPs outside Russia.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "iphone",
  "sortBy": "",
  "productUrls": [],
  "inStockOnly": false,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing all scraped Ozon products.

# 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 = {
    "mode": "search",
    "searchQuery": "iphone",
    "sortBy": "",
    "productUrls": [],
    "inStockOnly": false,
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "RU"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/ozon-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 = {
    "mode": "search",
    "searchQuery": "iphone",
    "sortBy": "",
    "productUrls": [],
    "inStockOnly": False,
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "RU",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/ozon-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 '{
  "mode": "search",
  "searchQuery": "iphone",
  "sortBy": "",
  "productUrls": [],
  "inStockOnly": false,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "RU"
  }
}' |
apify call crawlerbros/ozon-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ozon Scraper - Products, Categories & Search",
        "description": "Scrape Ozon.ru, Russia's largest e-commerce marketplace. Search products, browse categories, or fetch full product details - prices, discounts, ratings, reviews, sellers, images, and delivery info.",
        "version": "1.0",
        "x-build-id": "BtHFyWbArJ8W7N5YA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~ozon-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-ozon-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/crawlerbros~ozon-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-ozon-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/crawlerbros~ozon-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-ozon-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",
                "required": [
                    "mode",
                    "proxyConfiguration"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCategory",
                            "productDetails"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text keyword search, e.g. `iphone`, `телевизор`."
                    },
                    "sortBy": {
                        "title": "Sort order (mode=search)",
                        "enum": [
                            "",
                            "price",
                            "-price",
                            "rating",
                            "new"
                        ],
                        "type": "string",
                        "description": "Result ordering for search mode. Leave as relevance for the default ranking.",
                        "default": ""
                    },
                    "categoryUrl": {
                        "title": "Category URL or slug (mode=byCategory)",
                        "type": "string",
                        "description": "A full Ozon category URL (e.g. `https://www.ozon.ru/category/smartfony-15502/`) or a bare category slug (e.g. `smartfony-15502`)."
                    },
                    "productUrls": {
                        "title": "Product URLs or SKUs (mode=productDetails)",
                        "type": "array",
                        "description": "Full Ozon product URLs, or bare numeric SKU/product IDs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "minPrice": {
                        "title": "Minimum price (RUB)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop products cheaper than this (in Russian rubles)."
                    },
                    "maxPrice": {
                        "title": "Maximum price (RUB)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop products pricier than this (in Russian rubles)."
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Drop products rated below this (0-5 scale)."
                    },
                    "inStockOnly": {
                        "title": "In-stock only",
                        "type": "boolean",
                        "description": "Only emit products that are not marked out of stock / sold out.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify RESIDENTIAL proxy (Russia) is required to bypass Ozon's anti-bot edge block, which returns a hard 403/captcha challenge to datacenter IPs outside Russia.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "RU"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
