# Costco Scraper — Prices, Item Numbers, Ratings & Specs (`khadinakbar/costco-scraper`) Actor

Scrape Costco.com by keyword or product/category URL: prices, item numbers, brand, ratings, availability, images, and optional specs. Uses a managed JavaScript unlocker with browser-proxy fallback and transparent run outcomes. Pay per event. MCP-ready.

- **URL**: https://apify.com/khadinakbar/costco-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 costco product scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## Costco Scraper — Prices, Item Numbers, Ratings & Specs

**Costco Scraper** extracts structured product data from Costco.com search results, category pages, and product URLs. Use it for competitor price monitoring, retail catalog research, procurement, resale analysis, and AI shopping workflows that need current Costco product facts in JSON, CSV, Excel, or an Apify dataset.

The Actor accepts a search keyword such as `laptop` or `olive oil`, a Costco search/category URL, or a direct product URL. It returns one normalized record per product with the product title, price, Costco item number, brand, rating, review count, availability, images, and source URL. Turn on detail enrichment when you also need product specifications, breadcrumbs, description, image gallery, and member-price handling.

Costco uses Akamai bot protection. This Actor uses a managed US JavaScript-unlocker route when owner capacity is available; otherwise it can use a session-consistent browser with residential proxies. You do not need to provide cookies, a Costco account, or an API key.

### When to use this Costco Scraper

Use it when you need publicly available Costco.com catalog data for:

- Monitoring a list of Costco product pages for price, stock, or rating changes.
- Finding products from a Costco keyword search or category page.
- Building a product comparison or competitive-pricing dataset.
- Researching wholesale, resale, procurement, or retail assortment opportunities.
- Giving an AI agent a focused product-research tool that returns structured rows rather than webpage text.

Avoid this Actor for Costco warehouse inventory, member accounts, checkout, orders, or personal data. Those are outside the public catalog contract.

### Workflow: from a Costco query to a buying decision

A retail analyst starts with a focused query such as `robot vacuum` and a small `maxResults` value. The Actor then stores normalized Costco product rows, including the public price, item number, rating, availability, and source URL. Next, the analyst exports the dataset to a spreadsheet or database, compares the current Costco offer with other retailers, and schedules the same input for repeat monitoring. This turns a changing catalog page into a reviewable price and assortment decision.

### What data can I extract?

Each dataset item represents one Costco product. Values that Costco does not display are returned as `null`, not guessed.

| Field | Description |
| --- | --- |
| `title` | Product name shown by Costco. |
| `productUrl` | Canonical Costco product URL. |
| `itemId`, `itemNumber`, `sku` | Costco product identifiers when exposed. |
| `price`, `originalPrice`, `savings`, `savingsPercent` | Current public price and promotion information in USD. |
| `requiresMembership` | `true` when Costco displays **Sign In For Price** instead of a public price. |
| `brand` | Brand extracted from Product JSON-LD or the product page. |
| `rating`, `reviewCount` | Public aggregate rating and review count. |
| `availability` | Public stock signal when Costco exposes one. |
| `imageUrl`, `images` | Main image and available image gallery URLs. |
| `breadcrumbs`, `category`, `subCategory` | Catalog taxonomy, available with detail enrichment. |
| `description`, `features`, `specs` | Product description and specifications, available with detail enrichment. |
| `sourceUrl`, `searchQuery`, `scrapedAt` | Traceability back to the source page, search, and scrape timestamp. |

### How much does Costco scraping cost?

This Actor uses **Pay per event + platform usage**:

- **$0.00005** per actor start.
- **$0.005** for each product successfully written to the dataset.
- Apify compute and proxy usage are charged separately by the platform.

Examples: a run with 10 records costs **$0.05005** in Actor events; a run with 100 records costs **$0.50005** in Actor events, plus platform usage. Products rejected by a price or rating filter, blocked pages, and invalid records are not billed as products. `maxResults` is your product-event ceiling. Check the live [Pricing tab](https://apify.com/khadinakbar/costco-scraper#pricing) before a large scheduled run.

### How to use the Actor

#### Search Costco by keyword

Use `searchQuery` for a normal Costco catalog search. Start with a small limit to verify the exact data you need.

```json
{
  "searchQuery": "robot vacuum",
  "maxResults": 10,
  "enrichProductDetails": false
}
````

#### Scrape a Costco category or product URL

Use `startUrls` for a Costco search URL, category URL, or a product URL ending in `.product.<id>.html`. Product URLs always receive the full detail extractor.

```json
{
  "startUrls": [
    "https://www.costco.com/CatalogSearch?keyword=olive%20oil",
    "https://www.costco.com/kirkland-signature-organic-extra-virgin-olive-oil.product.100334221.html"
  ],
  "maxResults": 20,
  "enrichProductDetails": true
}
```

#### Filter the catalog results

Use `minPrice`, `maxPrice`, and `minRating` after extraction. A member-only product without a visible public price is excluded when a price filter is set.

```json
{
  "searchQuery": "laptop",
  "maxResults": 25,
  "minPrice": 500,
  "minRating": 4,
  "enrichProductDetails": true
}
```

### Input reference

| Input | Use it for | Notes |
| --- | --- | --- |
| `searchQuery` | A keyword search such as `patio set`. | Leave empty when using only URLs. |
| `startUrls` | Costco search, category, or product URLs. | Non-Costco URLs are skipped with a diagnostic. |
| `maxResults` | Cap returned and billable product records. | 1–5,000; start small for monitoring. |
| `minPrice` / `maxPrice` | Price filtering in USD. | Applied after product extraction. |
| `minRating` | Keep products at or above a public rating. | Accepts 0–5. |
| `enrichProductDetails` | Add detailed product fields. | Slower, but still billed once per product. |
| `proxyConfiguration` | Optional browser-proxy settings. | Used when the managed unlocker is not configured. |

### Output example

```json
{
  "recordType": "product",
  "title": "Example Costco Product",
  "productUrl": "https://www.costco.com/example.product.100000001.html",
  "itemId": "100000001",
  "itemNumber": "100000001",
  "brand": "Example Brand",
  "price": 49.99,
  "currency": "USD",
  "rating": 4.7,
  "reviewCount": 218,
  "availability": "In Stock",
  "requiresMembership": false,
  "imageUrl": "https://cdn.example.com/product.jpg",
  "sourceUrl": "https://www.costco.com/CatalogSearch?keyword=example",
  "searchQuery": "example",
  "scrapedAt": "2026-07-20T12:00:00.000Z"
}
```

The Output tab also links to `OUTPUT` and `RUN_SUMMARY`. These records state whether the run was complete, partial, a valid empty result, invalid input, or an upstream failure, along with counts, billing events, route diagnostics, and safe warnings.

### Run with the Apify API

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/costco-scraper').call({
  searchQuery: 'wireless headphones',
  maxResults: 10,
  enrichProductDetails: true,
});

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

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("khadinakbar/costco-scraper").call(
    run_input={"searchQuery": "protein powder", "maxResults": 5}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item.get("price"))
```

### MCP and AI-agent workflow

Use this Actor through Apify MCP when an agent needs Costco facts with a clear source and bounded result count:

> Search Costco for wireless headphones, return up to 10 product rows, then summarize the lowest public price, the rating, the item number, and the source URL. If the result is partial or fails, report the run outcome instead of treating it as an empty catalog.

The agent should read the default dataset for products and `OUTPUT` or `RUN_SUMMARY` for the outcome, row count, route diagnostics, and billing-event counts. It should keep pagination and cost bounded with `maxResults`, and it should use `sourceUrl` and `scrapedAt` as provenance for any downstream recommendation.

### Reliability and troubleshooting

Costco may deny a request before its public product page is rendered. The Actor retries its active extraction route. If no product can be obtained after every available route is exhausted, the run is marked `UPSTREAM_FAILED`, no product event is charged, and `RUN_SUMMARY` explains what happened. If the owner-managed unlocker rejects its credentials or capacity, the run is marked `CONFIG_ERROR` so the provider can be restored; it is never presented as a successful empty scrape. A successful zero-result run means Costco processed the request but no product matched your search or filters.

For the most reliable results, use US Costco.com URLs, avoid combining thousands of URLs with a large detail-enrichment request, and schedule small monitoring batches. Prices, availability, images, and member-only price visibility can change at any time on Costco.com.

### Freshness and provenance

Every product row includes the Costco `sourceUrl` and its `scrapedAt` collection time, so a downstream user can verify the public source behind a price or availability decision. The 2026-07-20 source update also writes versioned `OUTPUT` and `RUN_SUMMARY` records on each run; these describe the collection outcome separately from the returned product data.

### Other product and retail scrapers

For a cross-retailer comparison, collect Costco products first and then use [Walmart Data Extractor](https://apify.com/khadinakbar/walmart-data-extractor) to monitor comparable Walmart listings. For marketplace discovery before a Costco price check, use [Amazon Product Scraper](https://apify.com/khadinakbar/amazon-product-scraper) or [Google Shopping Scraper](https://apify.com/khadinakbar/google-shopping-scraper), then pass the focused product terms into this Actor.

### FAQ

#### How many results can I scrape with Costco Scraper?

Set `maxResults` from 1 to 5,000. The Actor stops after the specified number of successfully stored products or when Apify’s product-charge limit is reached.

#### Can I integrate Costco Scraper with other apps?

Yes. Use an Apify integration, webhook, dataset export, or the Apify API to send the resulting dataset to a spreadsheet, database, workflow, or monitoring system.

#### Can I use Costco Scraper with the Apify API?

Yes. The JavaScript and Python examples above start a run and read its default dataset. `OUTPUT` and `RUN_SUMMARY` are available from the run’s default key-value store.

#### Can I use Costco Scraper through an MCP Server?

Yes. Search for this Actor through Apify MCP and call it as a focused Costco product-data tool. It returns structured product rows rather than unstructured product-page text.

#### Do I need proxies to scrape Costco data?

No proxy setup is required for the default managed route. `proxyConfiguration` is available only when you want to control the browser fallback.

#### Is it legal to scrape Costco data?

You are responsible for ensuring your use complies with applicable law, Costco’s terms, rate limits, and data-protection obligations. Do not use this Actor to access accounts, checkout flows, private inventory systems, or personal information.

#### Your feedback

If a page type is missing a field or Costco changes its catalog markup, open an issue with a public example URL and the field you expected. That makes it possible to improve the extractor without exposing private account data.

# Actor input Schema

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

Free-text keyword to search Costco.com (e.g. 'laptop', 'olive oil', 'patio set'). The Actor opens Costco's CatalogSearch results and collects product cards across pages up to your Max results cap. Leave empty if you instead paste Start URLs. NOT a single product URL — for one product, paste a .product. link into Start URLs.

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

Optional list of Costco.com URLs: search pages (/CatalogSearch?keyword=...), category/department pages (e.g. /laptops.html), or product detail pages (/.../<slug>.product.<id>.html). Each URL's type is auto-detected — listing URLs are paginated for product cards; product URLs return one full detail record. Plain https strings only; non-Costco URLs are skipped.

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

Maximum number of product records to return across all sources. The Actor auto-paginates listing pages until this cap is hit, then stops, so it doubles as your product cost ceiling (each product returned is one billable event). Defaults to 100. Products dropped by your price/rating filters are not counted or billed.

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

Only return products whose current price is at or above this value, in US dollars. Applied after extraction on the parsed price; products with no visible price (member-only 'Sign In For Price') are dropped when this is set. Filtered products are not billed. Leave empty for no minimum.

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

Only return products whose current price is at or below this value, in US dollars. Applied after extraction on the parsed price; products with no visible price are dropped when this is set. Filtered products are not billed. Leave empty for no maximum.

## `minRating` (type: `integer`):

Drop products whose average star rating (0–5) is below this value, or whose rating is unknown when this is set. Applied after extraction; filtered products are not billed. Useful to keep only well-reviewed items. Leave empty to keep all ratings.

## `enrichProductDetails` (type: `boolean`):

When scraping from keyword/listing sources, also open each product's detail page to add the item number, brand, breadcrumbs, full specifications, description, and the high-res image gallery (slower: one extra request per product). Product Start URLs always return full detail regardless of this flag. Default false keeps listing runs fast and cheap; each enriched product is still billed once.

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

Optional proxy settings for the browser fallback. Costco.com is protected by Akamai, so the Actor first uses its managed US JavaScript-unlocker route and only then tries user-provided or residential browser proxies. Leave the default enabled unless you have a tested Costco-compatible proxy. This is not required to supply an API key.

## Actor input object example

```json
{
  "searchQuery": "robot vacuum",
  "startUrls": [],
  "maxResults": 1,
  "enrichProductDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

All product records found across the search/listing/product pages. Download as JSON, CSV, Excel, HTML, or RSS.

## `output` (type: `string`):

Compact outcome, item counts, billable-event counts, and warnings for this run.

## `runSummary` (type: `string`):

Detailed processing, route, validation, and billing diagnostics for this run.

# 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": "laptop",
    "startUrls": [],
    "maxResults": 1,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/costco-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": "laptop",
    "startUrls": [],
    "maxResults": 1,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/costco-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": "laptop",
  "startUrls": [],
  "maxResults": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call khadinakbar/costco-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Costco Scraper — Prices, Item Numbers, Ratings & Specs",
        "description": "Scrape Costco.com by keyword or product/category URL: prices, item numbers, brand, ratings, availability, images, and optional specs. Uses a managed JavaScript unlocker with browser-proxy fallback and transparent run outcomes. Pay per event. MCP-ready.",
        "version": "1.4",
        "x-build-id": "a7hxlWeC2hZZmqWXx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~costco-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-costco-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/khadinakbar~costco-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-costco-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/khadinakbar~costco-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-costco-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": {
                    "searchQuery": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Free-text keyword to search Costco.com (e.g. 'laptop', 'olive oil', 'patio set'). The Actor opens Costco's CatalogSearch results and collects product cards across pages up to your Max results cap. Leave empty if you instead paste Start URLs. NOT a single product URL — for one product, paste a .product. link into Start URLs."
                    },
                    "startUrls": {
                        "title": "Start URLs (search, category, or product pages)",
                        "type": "array",
                        "description": "Optional list of Costco.com URLs: search pages (/CatalogSearch?keyword=...), category/department pages (e.g. /laptops.html), or product detail pages (/.../<slug>.product.<id>.html). Each URL's type is auto-detected — listing URLs are paginated for product cards; product URLs return one full detail record. Plain https strings only; non-Costco URLs are skipped.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results (products)",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of product records to return across all sources. The Actor auto-paginates listing pages until this cap is hit, then stops, so it doubles as your product cost ceiling (each product returned is one billable event). Defaults to 100. Products dropped by your price/rating filters are not counted or billed.",
                        "default": 100
                    },
                    "minPrice": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return products whose current price is at or above this value, in US dollars. Applied after extraction on the parsed price; products with no visible price (member-only 'Sign In For Price') are dropped when this is set. Filtered products are not billed. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return products whose current price is at or below this value, in US dollars. Applied after extraction on the parsed price; products with no visible price are dropped when this is set. Filtered products are not billed. Leave empty for no maximum."
                    },
                    "minRating": {
                        "title": "Minimum star rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Drop products whose average star rating (0–5) is below this value, or whose rating is unknown when this is set. Applied after extraction; filtered products are not billed. Useful to keep only well-reviewed items. Leave empty to keep all ratings."
                    },
                    "enrichProductDetails": {
                        "title": "Enrich with product detail pages",
                        "type": "boolean",
                        "description": "When scraping from keyword/listing sources, also open each product's detail page to add the item number, brand, breadcrumbs, full specifications, description, and the high-res image gallery (slower: one extra request per product). Product Start URLs always return full detail regardless of this flag. Default false keeps listing runs fast and cheap; each enriched product is still billed once.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings for the browser fallback. Costco.com is protected by Akamai, so the Actor first uses its managed US JavaScript-unlocker route and only then tries user-provided or residential browser proxies. Leave the default enabled unless you have a tested Costco-compatible proxy. This is not required to supply an API key.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
