# KKday Tours Scraper (`solidcode/kkday-tours-scraper`) Actor

\[💰 $1.70 / 1K] Extract KKday tours, activities, and experiences at scale — names, prices (from/original/discount), star ratings, review counts, supplier details, destinations, categories, images, and video clips. Search by destination keyword or paste KKday list, search, and category page URLs.

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

## Pricing

from $1.70 / 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

## KKday Tours Scraper

Pull tours, activities, and experiences from KKday at scale — names, four-point pricing, star ratings, review counts, suppliers, destinations, image galleries, and promo video clips, localized to 13 markets and 15 currencies. Built for travel-market analysts, OTAs, and affiliate teams who need live KKday activity data without copy-pasting listings by hand.

### Why This Scraper?

- **13 markets from one dropdown** — collect listings localized to any of 13 language/market pairs, from English (US, Australia, Singapore, Malaysia, Philippines, Hong Kong) to Traditional and Simplified Chinese, Japanese, Korean, Thai, and Vietnamese.
- **Prices in 15 currencies** — return every tour price in USD, EUR, GBP, JPY, TWD, HKD, SGD, KRW, THB, and 6 more, without hand-editing a single URL parameter.
- **Four price points per tour** — the "from" price, the original list price, the top-package price, and the discount amount plus its type, so deal-depth and margin analysis work straight out of the dataset.
- **Rating, review count, and lifetime orders** — every activity carries its star rating, total number of ratings, and a sold-orders figure (e.g. "300K+") for popularity and demand ranking.
- **Supplier and marketplace signals** — operator name, logo, badge, and a marketplace flag on each listing to separate KKday-direct products from third-party sellers.
- **Image gallery plus promo video clip** — a full array of product photo URLs and any KKday marketing video URL per tour, ready for catalog and landing-page builds.
- **Destination, country, and four tag families** — structured destination names, country, category, plus display tags, activity labels, discount labels, and promotion labels for clean faceting.
- **Keyword search built in** — type a destination like "Tokyo" or an activity like "Bali diving" and get results without hand-building a single list URL, or paste KKday search, category, and product-list URLs directly (page numbers respected).
- **Unlimited results, deduped** — cap at 100 or lift the limit entirely; pagination never truncates a fetched page and dedups every tour by product ID, so overlapping searches never double-count.

### Use Cases

**Travel Market Research & Pricing Intelligence**
- Benchmark tour and activity prices across cities and countries
- Track discount depth and promotional pricing over time
- Compare "from" prices for the same experience across 15 currencies
- See which categories dominate a destination's inventory

**OTA & Affiliate Content**
- Populate a travel affiliate site with tour names, images, and live prices
- Build "things to do in [city]" landing pages from category listings
- Keep an activities catalog synced with current KKday pricing and ratings
- Surface top-rated experiences by review count for editorial picks

**Competitive & Supplier Intelligence**
- Map which suppliers and operators list on KKday in a given market
- Separate marketplace listings from KKday-direct products
- Track a rival destination's activity mix and price bands

**Lead Generation & Partnerships**
- Build a list of tour operators active on KKday by destination
- Find high-volume experiences (by order count) to approach for partnerships
- Spot suppliers with strong ratings but thin coverage in a city

**Data & Analytics**
- Feed activity pricing into travel dashboards and BI tools
- Build rating-vs-price scatter analyses per destination
- Localize a market snapshot by pairing language and currency

### Getting Started

#### Search a Single Destination

The simplest run — one keyword, 50 tours:

```json
{
    "searchQueries": ["Tokyo"],
    "maxResults": 50
}
````

#### Localized Market Snapshot

Pair language and currency to see exactly what a local shopper sees:

```json
{
    "searchQueries": ["Seoul", "Busan"],
    "language": "ko",
    "currency": "KRW",
    "maxResults": 200
}
```

#### From KKday URLs

Paste search and product-list URLs directly — any page number is respected:

```json
{
    "startUrls": [
        "https://www.kkday.com/en/search?keyword=bali",
        "https://www.kkday.com/en-us/product/productlist/Osaka?page=2"
    ],
    "currency": "USD",
    "maxResults": 300
}
```

#### Full-Featured Example

```json
{
    "searchQueries": ["Universal Studios", "Bali diving"],
    "startUrls": [
        "https://www.kkday.com/en/search?keyword=singapore"
    ],
    "language": "en-sg",
    "currency": "SGD",
    "maxResults": 500,
    "ignoreUrlFailures": true
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `["Tokyo"]` | Destinations, activities, or keywords to search — such as "Tokyo", "Universal Studios", or "Bali diving". Each term runs its own search. |
| `startUrls` | string\[] | `[]` | KKday listing URLs to scrape directly — search results, category, or country/city pages. Any page number in the URL is respected. Use instead of, or alongside, search terms. |

#### Localization

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `language` | select | `en-us` | Market and language for results. 13 options: English (US, Australia, Singapore, Malaysia, Philippines, Hong Kong), Chinese (Traditional, Hong Kong, Simplified), Japanese, Korean, Thai, and Vietnamese. |
| `currency` | select | `USD` | Currency tour prices are returned in. 15 options including USD, EUR, GBP, JPY, TWD, HKD, SGD, MYR, THB, KRW, and more. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum tours to return across all searches and URLs. Set to `0` for unlimited. The last page is always collected in full, so a run may return slightly more than this number. |
| `ignoreUrlFailures` | boolean | `true` | Keep running if a single search term or URL fails, instead of stopping the whole run. |

### Output

Each row is one tour, with pricing, ratings, supplier, destinations, and media. Empty fields are omitted rather than padded with nulls, so every row stays clean.

```json
{
    "productId": "133300",
    "productOid": "20059",
    "name": "SHIBUYA SKY Observation Deck Ticket",
    "introduction": "Take in 360-degree views of Tokyo from the rooftop of Shibuya Scramble Square.",
    "category": "CATEGORY_002",
    "url": "https://www.kkday.com/en/product/133300",
    "currency": "USD",
    "minPrice": 15.5,
    "officialPrice": 18,
    "maxPrice": 32,
    "discount": 14,
    "discountType": "PERCENT",
    "rating": 4.71,
    "ratingCount": 14524,
    "orderCount": "300K+",
    "saleStatus": 1,
    "earliestSaleDate": "2026-07-12",
    "isTourismProduct": true,
    "supplierName": "KKday Japan",
    "isMarketplace": false,
    "isKkdayBestRoute": true,
    "destinations": ["Shibuya", "Tokyo"],
    "country": "Japan",
    "displayTags": ["Instant confirmation", "Mobile voucher"],
    "activityLabels": ["Observation Deck"],
    "discountLabels": ["14% OFF"],
    "promotionLabels": ["Summer Sale"],
    "images": ["https://image.kkday.com/v2/image/shibuya-sky-1.jpg"],
    "videoClips": ["https://image.kkday.com/v2/clip/shibuya-sky.mp4"],
    "searchQuery": "Tokyo"
}
```

#### Identity & Description

| Field | Type | Description |
|-------|------|-------------|
| `productId` | string | KKday product ID, as it appears in the product URL |
| `productOid` | string | KKday's internal product identifier |
| `name` | string | Tour / activity title |
| `introduction` | string | Short product summary |
| `category` | string | KKday category identifier for the product |
| `url` | string | Canonical KKday product URL |
| `searchQuery` | string | The search term or URL that produced this row |

#### Pricing

| Field | Type | Description |
|-------|------|-------------|
| `currency` | string | Currency code for every price on the row |
| `minPrice` | number | "From" / lowest package price |
| `officialPrice` | number | Original list price before discount |
| `maxPrice` | number | Highest package price |
| `discount` | number | Discount amount or percentage |
| `discountType` | string | How the discount is expressed (e.g. percentage) |

#### Ratings & Popularity

| Field | Type | Description |
|-------|------|-------------|
| `rating` | number | Average star rating |
| `ratingCount` | number | Total number of ratings / reviews |
| `orderCount` | string | Sold-orders label (e.g. "300K+") |
| `saleStatus` | number | Current sale status of the product |
| `earliestSaleDate` | string | Earliest available booking date |
| `purchaseType` | number | Purchase-type indicator |
| `isTourismProduct` | boolean | Whether the item is classed as a tourism product |

#### Supplier

| Field | Type | Description |
|-------|------|-------------|
| `supplierName` | string | Operator / supplier name |
| `supplierLogo` | string | Supplier logo image URL |
| `supplierBadge` | string | Supplier badge indicator |
| `isMarketplace` | boolean | Whether the listing is a marketplace (third-party) product |
| `isKkdayBestRoute` | boolean | KKday "best route" flag |

#### Destination & Tags

| Field | Type | Description |
|-------|------|-------------|
| `destinations` | string\[] | Destination names attached to the tour |
| `country` | string | Country the tour takes place in |
| `displayTags` | string\[] | Display tags shown on the listing card |
| `activityLabels` | string\[] | Activity-type labels |
| `discountLabels` | string\[] | Discount / deal labels |
| `promotionLabels` | string\[] | Active promotion labels |

#### Media

| Field | Type | Description |
|-------|------|-------------|
| `images` | string\[] | Product image URLs |
| `videoClips` | string\[] | Promo video clip URLs |

### Tips for Best Results

- **Start broad, then narrow.** A city or landmark keyword like "Tokyo", "Universal Studios Singapore", or "Bali diving" returns the widest inventory; add a modifier to tighten the set.
- **Pair language and currency for a true market snapshot.** Set `language` to `ja` and `currency` to `JPY` to capture exactly what a Japanese shopper sees, including local pricing and destination names.
- **Paste filtered category or search URLs for exhaustive coverage.** A KKday category or search URL that carries a keyword, category, or destination filter pulls far more of a destination's catalog than a single keyword search — the power-user route to a complete city inventory.
- **Page numbers in a pasted URL are honored.** End a URL with `?page=5` to start deep in a result set instead of at page one.
- **Use `maxResults: 0` for a full destination sweep**, or keep it at 50–100 for a quick, low-cost sample before scaling up.
- **`category` returns KKday's internal category code** — map it once against your own labels if you need human-readable category names.
- **Rows omit empty fields.** Supplier name, logo, and country appear only on tours where KKday publishes them, so absent fields mean "not provided by KKday," not a scraping gap.

### Pricing

**From $1.70 per 1,000 results** — undercuts the going market rate for KKday activity extraction, with no compute or time-based charges. You pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows the total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.20 | $0.19 | $0.18 | $0.17 |
| 1,000 | $2.00 | $1.90 | $1.80 | $1.70 |
| 10,000 | $20.00 | $19.00 | $18.00 | $17.00 |
| 100,000 | $200.00 | $190.00 | $180.00 | $170.00 |

A "result" is one tour row in the output dataset. Platform fees (compute, storage) are additional and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate travel market research, competitive analysis, catalog building, and partnership prospecting. Users are responsible for complying with applicable laws and KKday's terms of service, including making reasonable-rate requests and respecting content usage rules for any listings and media linked from KKday. Do not use extracted data for spam, harassment, or any illegal purpose.

# Actor input Schema

## `searchQueries` (type: `array`):

Destinations, activities, or keywords to search on KKday, such as "Tokyo", "Universal Studios", or "Bali diving". Each term runs its own search. Leave empty if you are pasting URLs below.

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

Optional. Paste KKday listing page URLs directly — search results (e.g. https://www.kkday.com/en/search?keyword=tokyo), category pages, or country/city pages. Any page number in the URL is respected. Use this instead of, or alongside, search terms.

## `language` (type: `string`):

The KKday market and language for results. This controls the language of tour names, descriptions, and destination names.

## `currency` (type: `string`):

The currency tour prices are returned in. Leave on the default to use the market's standard currency.

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

Maximum number of tours to return across all searches and URLs. Set to 0 for unlimited — collect every tour found, up to a safety ceiling of about 3,000 tours per search (well above KKday's inventory for any single keyword). The last page is always collected in full, so a run may return slightly more than this number.

## `ignoreUrlFailures` (type: `boolean`):

Keep running when a single search term or URL fails — a URL we can't turn into a KKday search, or a search we can't reach after several tries — by skipping it with a warning and moving on. Turn this off to stop the whole run as soon as any search term or URL fails. (A valid search that simply finds no tours is not a failure — it is reported as an empty result either way.)

## Actor input object example

```json
{
  "searchQueries": [
    "Tokyo"
  ],
  "startUrls": [],
  "language": "en-us",
  "currency": "USD",
  "maxResults": 100,
  "ignoreUrlFailures": true
}
```

# Actor output Schema

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

Compact table of scraped tours — name, category, price, rating, and KKday URL.

## `details` (type: `string`):

Full tour metadata including pricing tiers, discounts, supplier, destinations, tags, images, and video clips.

# 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 = {
    "searchQueries": [
        "Tokyo"
    ],
    "startUrls": [],
    "language": "en-us",
    "currency": "USD",
    "maxResults": 100,
    "ignoreUrlFailures": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/kkday-tours-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 = {
    "searchQueries": ["Tokyo"],
    "startUrls": [],
    "language": "en-us",
    "currency": "USD",
    "maxResults": 100,
    "ignoreUrlFailures": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/kkday-tours-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 '{
  "searchQueries": [
    "Tokyo"
  ],
  "startUrls": [],
  "language": "en-us",
  "currency": "USD",
  "maxResults": 100,
  "ignoreUrlFailures": true
}' |
apify call solidcode/kkday-tours-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "KKday Tours Scraper",
        "description": "[💰 $1.70 / 1K] Extract KKday tours, activities, and experiences at scale — names, prices (from/original/discount), star ratings, review counts, supplier details, destinations, categories, images, and video clips. Search by destination keyword or paste KKday list, search, and category page URLs.",
        "version": "1.0",
        "x-build-id": "VBv5bea77GDf9Ixyc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~kkday-tours-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-kkday-tours-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/solidcode~kkday-tours-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-kkday-tours-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/solidcode~kkday-tours-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-kkday-tours-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": {
                    "searchQueries": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Destinations, activities, or keywords to search on KKday, such as \"Tokyo\", \"Universal Studios\", or \"Bali diving\". Each term runs its own search. Leave empty if you are pasting URLs below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional. Paste KKday listing page URLs directly — search results (e.g. https://www.kkday.com/en/search?keyword=tokyo), category pages, or country/city pages. Any page number in the URL is respected. Use this instead of, or alongside, search terms.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language / Market",
                        "enum": [
                            "en-us",
                            "en-au",
                            "en-sg",
                            "en-my",
                            "en-ph",
                            "en-hk",
                            "zh-tw",
                            "zh-hk",
                            "zh-cn",
                            "ja",
                            "ko",
                            "th",
                            "vi"
                        ],
                        "type": "string",
                        "description": "The KKday market and language for results. This controls the language of tour names, descriptions, and destination names.",
                        "default": "en-us"
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "USD",
                            "TWD",
                            "HKD",
                            "SGD",
                            "MYR",
                            "THB",
                            "JPY",
                            "KRW",
                            "PHP",
                            "VND",
                            "IDR",
                            "CNY",
                            "AUD",
                            "EUR",
                            "GBP"
                        ],
                        "type": "string",
                        "description": "The currency tour prices are returned in. Leave on the default to use the market's standard currency.",
                        "default": "USD"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of tours to return across all searches and URLs. Set to 0 for unlimited — collect every tour found, up to a safety ceiling of about 3,000 tours per search (well above KKday's inventory for any single keyword). The last page is always collected in full, so a run may return slightly more than this number.",
                        "default": 100
                    },
                    "ignoreUrlFailures": {
                        "title": "Continue on Errors",
                        "type": "boolean",
                        "description": "Keep running when a single search term or URL fails — a URL we can't turn into a KKday search, or a search we can't reach after several tries — by skipping it with a warning and moving on. Turn this off to stop the whole run as soon as any search term or URL fails. (A valid search that simply finds no tours is not a failure — it is reported as an empty result either way.)",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
