# Chrono24 $1💰 Luxury Watches, Prices, Specs & Reviews (`abotapi/chrono24-scraper`) Actor

From $1/1K. Extract luxury watch listings from Chrono24, the global marketplace for new and pre-owned watches. Search by keyword, filters, or URLs. Returns 50+ fields including brand, model, reference number, price, year, condition, movement, case specs, seller, location, and images.

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

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## Chrono24 Watch Scraper

Extract structured luxury watch listings from Chrono24, the global marketplace for new and pre-owned watches. Search by keyword and filters, or paste any mix of detail, brand, model, and search URLs. Each listing comes back as clean JSON with 50+ fields: brand, model, reference number, price, year, condition, the full movement and case spec sheet, seller and location, and every image. Ideal for dealers, collectors, analysts, and anyone tracking the watch market.

### Why this scraper

- 50+ fields per watch: full spec sheet plus seller, certification, listing code, base caliber, dial numerals, and the buying-agent block.
- Seller rating and recent buyer reviews (date, stars, watch, reviewer, text) attached to every listing, at no extra cost.
- Two modes: keyword + filter search, or direct URLs (detail, brand, model, or search pages mixed freely).
- Card mode for fast, cheap harvesting (lightweight fields straight from the results page) or full-detail mode for the complete spec sheet.
- Rich filters: price, year, condition, case material, dial color, bracelet material, seller type, country, reference number, and more, with five sort orders.
- Runs on every Apify plan including Free; residential proxy is optional for the widest IP rotation on large runs.
- Automatic pagination, de-duplication, per-record output, and optional flattening to specs_* columns for CSV.

### Data you get

> Sample shape, values are illustrative placeholders, not from a live listing.

| Field | Example |
|---|---|
| listingId | 00000001 |
| title | Rolex Submariner Date |
| brand | Rolex |
| model | Submariner Date |
| referenceNumber | 126610LN |
| price | 12500 |
| currency | USD |
| year | 2022 |
| condition | Used (Very good) |
| sellerCountry | DE |
| sellerType | Dealer |
| sellerUsername | sample_dealer |
| certificationStatus | Basic |
| specs_movement | Automatic |
| specs_caliber | 3235 |
| specs_caseMaterial | Steel |
| specs_caseDiameter | 41 mm |
| specs_waterResistance | 30 ATM |
| specs_dialColor | Black |
| specs_braceletMaterial | Steel |
| specs_functions | Date |
| sellerRating | 4.8 |
| reviewCount | 12 |
| reviews | [{"date":"2026-01-01","rating":5,"watch":"Rolex Submariner","reviewerName":"Jane D.","reviewerCountry":"United States of America","text":"Sample review text."}] |
| images | ["https://img.chrono24.com/images/uhren/00000001-Square480.jpg"] |
| listingUrl | https://www.chrono24.com/rolex/submariner--id00000001.htm |

### How to use

Search by keyword with filters:

```json
{
  "mode": "search",
  "searchQuery": "Rolex Submariner",
  "searchParams": { "priceFrom": 8000, "priceTo": 15000, "usedOrNew": "used", "caseMaterials": "steel" },
  "sortBy": "price-asc",
  "fetchDetails": true,
  "maxListings": 50
}
````

Fast card harvesting (no per-listing fetch):

```json
{
  "mode": "search",
  "searchQuery": "Omega Speedmaster",
  "fetchDetails": false,
  "maxListings": 200
}
```

Direct URLs (detail + model + search mixed):

```json
{
  "mode": "url",
  "urls": [
    "https://www.chrono24.com/rolex/submariner--mod4.htm",
    "https://www.chrono24.com/patek-philippe/nautilus--id00000001.htm",
    "https://www.chrono24.com/search/index.htm?query=Daytona&dosearch=true"
  ],
  "fetchDetails": true,
  "maxListings": 100
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| mode | string | search | "search" (keyword + filters) or "url" (paste links). |
| searchQuery | string | - | Keyword for search mode. Empty browses everything matching the filters. |
| searchParams | object | {} | Filters: priceFrom, priceTo (USD), year, usedOrNew, caseMaterials, dialColor, braceletMaterial, sellerType, countryIds, referenceNumber, caseDiameter, man, certified, inStock. Friendly words or raw Chrono24 ids. |
| sortBy | string | relevance | relevance, price-asc, price-desc, newest, popularity. |
| urls | array | - | Detail, brand, model, or search URLs (URL mode). |
| fetchDetails | boolean | true | On: full spec sheet per listing. Off: lightweight cards from the results page. |
| fetchSellerReviews | boolean | true | Attach seller rating + recent buyer reviews to each listing. Read in the same pass as the details, so no extra cost. Only applies when fetchDetails is on. |
| flatten | boolean | true | Also expose nested specs as flat specs\_\* columns. |
| includeRaw | boolean | false | Attach a rawHtmlBytes diagnostic field. |
| maxListings | integer | 20 | The single cap on output. 0 means unlimited. |
| maxPages | integer | 2000 | Safety bound on pages per search URL (120 listings per page). The run stops at Max listings. |
| proxy | object | Apify Proxy | Works on every plan. Residential gives the widest rotation. |

### Output example

> Sample shape, values are illustrative placeholders, not from a live listing.

```json
{
  "rowType": "detail",
  "listingId": "00000001",
  "watchId": "00000001",
  "listingUrl": "https://www.chrono24.com/rolex/submariner--id00000001.htm",
  "title": "Rolex Submariner Date",
  "brand": "Rolex",
  "model": "Submariner Date",
  "referenceNumber": "126610LN",
  "listingCode": "AAA000",
  "price": 12500,
  "currency": "USD",
  "availability": "InStock",
  "condition": "Used (Very good)",
  "year": "2022",
  "location": "Germany, Bavaria, Munich",
  "sellerCountry": "DE",
  "sellerUsername": "sample_dealer",
  "merchantCountry": "Germany",
  "certificationStatus": "Basic",
  "isDeal": false,
  "scopeOfDelivery": "Original box, original papers",
  "gender": "Men's watch/Unisex",
  "buyingAgent": { "fullName": "Client Advisor", "office": "Sample Office", "region": "Europe" },
  "specs": {
    "movement": "Automatic",
    "caliber": "3235",
    "baseCaliber": "3235",
    "powerReserve": "70 h",
    "jewels": "31",
    "caseMaterial": "Steel",
    "caseDiameter": "41 mm",
    "waterResistance": "30 ATM",
    "bezelMaterial": "Ceramic",
    "crystal": "Sapphire crystal",
    "dialColor": "Black",
    "braceletMaterial": "Steel",
    "clasp": "Fold clasp",
    "functions": "Date"
  },
  "sellerRating": 4.8,
  "reviewCount": 12,
  "reviews": [
    {
      "date": "2026-01-01",
      "rating": 5,
      "watch": "Rolex Submariner",
      "received": "2026-01-01",
      "shippedFrom": "United States of America",
      "reviewerName": "Jane D.",
      "reviewerCountry": "United States of America",
      "text": "Sample review text appears here."
    }
  ],
  "images": ["https://img.chrono24.com/images/uhren/00000001-Square480.jpg"],
  "scrapedAt": "2026-01-01T00:00:00.000Z"
}
```

### Send results into your apps (MCP connectors)

Optionally pipe results into the apps you already use through Model Context Protocol (MCP) connectors. Authorize a connector once under Apify, Settings, Integrations, then select it in the input. Notion receives a page per item; other connectors get a best-effort write or digest. The connector receives a condensed, human-readable summary per item (a title plus key fields), not the full JSON; the complete record always stays in the Apify dataset. Leave the field empty to skip. Supported: Notion, Linear, Airtable, Apify.

### Plan requirement

This actor runs on Apify Proxy, available on every plan including Free. For the widest IP rotation on large runs, set Proxy to Residential (included on Starter and above). If no Apify Proxy is available, the actor falls back to a backup connection that may be slower or return fewer results.

# Actor input Schema

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

How to find watches: build a search from a keyword + filters, or paste your own URLs.

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

Keyword to search, e.g. 'Submariner', 'Omega Speedmaster', 'Patek Nautilus'. Leave empty to browse everything matching the filters below.

## `searchParams` (type: `object`):

Filter the search. Accepts friendly words or raw Chrono24 ids. Keys: priceFrom, priceTo (USD), year, usedOrNew ('new' | 'used'), caseMaterials (steel | yellow gold | rose gold | white gold | platinum | titanium | ceramic), dialColor (black | blue | green | white | silver | grey | meteorite), braceletMaterial (steel | leather | rubber | yellow gold), sellerType ('chrono24 direct' | 'professional dealer' | 'private sellers'), countryIds (ISO code, e.g. DE), referenceNumber, caseDiameter (mm), man (brand slug, e.g. rolex), certified (true), inStock (true).

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

Result order (search mode).

## `urls` (type: `array`):

Any mix of Chrono24 detail (--id), brand (/rolex/index.htm), model (--mod) or search URLs. Detail URLs return one watch each; brand / model / search URLs paginate automatically.

## `fetchDetails` (type: `boolean`):

On (default): fetch each listing's detail page for the full 50+ field spec sheet. Off: emit lightweight cards straight from the results page (faster, fewer fields, no per-listing fetch).

## `fetchSellerReviews` (type: `boolean`):

Attach the seller's rating and recent buyer reviews (date, stars, watch, reviewer, text) to each listing. Read from the listing page in the same pass, so it adds no extra cost. Only applies when Fetch full details is on.

## `flatten` (type: `boolean`):

Also expose nested specs as flat specs\_\* columns for easy CSV / spreadsheet export.

## `includeRaw` (type: `boolean`):

Attach a rawHtmlBytes field per record (diagnostics). Does not change other fields.

## `maxListings` (type: `integer`):

The one cap on output. Stops the run once this many listings are collected. Set 0 for unlimited.

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

Safety bound on pages walked per search / brand / model URL (120 listings per page). No page limit by default: the run stops at Max listings.

## `proxy` (type: `object`):

Works on every Apify plan including Free. Residential gives the widest IP rotation. Free plans fall back to a backup connection.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON; the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "Rolex Submariner",
  "searchParams": {},
  "sortBy": "relevance",
  "urls": [
    "https://www.chrono24.com/rolex/submariner--mod4.htm"
  ],
  "fetchDetails": true,
  "fetchSellerReviews": true,
  "flatten": true,
  "includeRaw": false,
  "maxListings": 20,
  "maxPages": 2000,
  "proxy": {
    "useApifyProxy": true
  },
  "maxNotifyListings": 50
}
```

# 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 = {
    "searchQuery": "Rolex Submariner",
    "searchParams": {},
    "urls": [
        "https://www.chrono24.com/rolex/submariner--mod4.htm"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/chrono24-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQuery": "Rolex Submariner",
    "searchParams": {},
    "urls": ["https://www.chrono24.com/rolex/submariner--mod4.htm"],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/chrono24-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQuery": "Rolex Submariner",
  "searchParams": {},
  "urls": [
    "https://www.chrono24.com/rolex/submariner--mod4.htm"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/chrono24-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Chrono24 $1💰 Luxury Watches, Prices, Specs & Reviews",
        "description": "From $1/1K. Extract luxury watch listings from Chrono24, the global marketplace for new and pre-owned watches. Search by keyword, filters, or URLs. Returns 50+ fields including brand, model, reference number, price, year, condition, movement, case specs, seller, location, and images.",
        "version": "1.0",
        "x-build-id": "htj7ijTt0yBKYoCzu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~chrono24-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-chrono24-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/abotapi~chrono24-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-chrono24-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/abotapi~chrono24-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-chrono24-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"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "How to find watches: build a search from a keyword + filters, or paste your own URLs.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Keyword to search, e.g. 'Submariner', 'Omega Speedmaster', 'Patek Nautilus'. Leave empty to browse everything matching the filters below."
                    },
                    "searchParams": {
                        "title": "Filters",
                        "type": "object",
                        "description": "Filter the search. Accepts friendly words or raw Chrono24 ids. Keys: priceFrom, priceTo (USD), year, usedOrNew ('new' | 'used'), caseMaterials (steel | yellow gold | rose gold | white gold | platinum | titanium | ceramic), dialColor (black | blue | green | white | silver | grey | meteorite), braceletMaterial (steel | leather | rubber | yellow gold), sellerType ('chrono24 direct' | 'professional dealer' | 'private sellers'), countryIds (ISO code, e.g. DE), referenceNumber, caseDiameter (mm), man (brand slug, e.g. rolex), certified (true), inStock (true)."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "price-asc",
                            "price-desc",
                            "newest",
                            "popularity"
                        ],
                        "type": "string",
                        "description": "Result order (search mode).",
                        "default": "relevance"
                    },
                    "urls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Any mix of Chrono24 detail (--id), brand (/rolex/index.htm), model (--mod) or search URLs. Detail URLs return one watch each; brand / model / search URLs paginate automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchDetails": {
                        "title": "Fetch full details",
                        "type": "boolean",
                        "description": "On (default): fetch each listing's detail page for the full 50+ field spec sheet. Off: emit lightweight cards straight from the results page (faster, fewer fields, no per-listing fetch).",
                        "default": true
                    },
                    "fetchSellerReviews": {
                        "title": "Include seller reviews",
                        "type": "boolean",
                        "description": "Attach the seller's rating and recent buyer reviews (date, stars, watch, reviewer, text) to each listing. Read from the listing page in the same pass, so it adds no extra cost. Only applies when Fetch full details is on.",
                        "default": true
                    },
                    "flatten": {
                        "title": "Flatten specs",
                        "type": "boolean",
                        "description": "Also expose nested specs as flat specs_* columns for easy CSV / spreadsheet export.",
                        "default": true
                    },
                    "includeRaw": {
                        "title": "Include raw size marker",
                        "type": "boolean",
                        "description": "Attach a rawHtmlBytes field per record (diagnostics). Does not change other fields.",
                        "default": false
                    },
                    "maxListings": {
                        "title": "Max listings",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The one cap on output. Stops the run once this many listings are collected. Set 0 for unlimited.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Safety bound on pages walked per search / brand / model URL (120 listings per page). No page limit by default: the run stops at Max listings.",
                        "default": 2000
                    },
                    "proxy": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Works on every Apify plan including Free. Residential gives the widest IP rotation. Free plans fall back to a backup connection."
                    },
                    "mcpConnectors": {
                        "title": "Pipe results into your apps (optional)",
                        "type": "array",
                        "description": "Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON; the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com)."
                    },
                    "notionParentPageUrl": {
                        "title": "Notion parent page (Notion connector only)",
                        "type": "string",
                        "description": "URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors."
                    },
                    "maxNotifyListings": {
                        "title": "Max items to export per connector",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on items written to each connector per run. Does not affect the dataset.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
