# Costco Product Reviews Scraper (`automation-lab/costco-product-reviews-scraper`) Actor

Extract public Costco reviews, ratings, text, reviewer details, helpfulness, media, product metadata, and aggregate statistics for monitoring and analysis.

- **URL**: https://apify.com/automation-lab/costco-product-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 costco review extracteds

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/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 Product Reviews Scraper

Extract public customer reviews from Costco US product pages into clean, structured data.

Provide Costco product URLs or product IDs and get one dataset row per review, including ratings, review text, reviewer context, helpfulness, badges, media, product metadata, and aggregate rating statistics.

Use the Actor for recurring reputation monitoring, product research, quality alerts, competitor analysis, and sentiment pipelines—without browser automation or a Costco account.

### What does Costco Product Reviews Scraper do?

The Actor turns Costco product review pages into export-ready records.

It can:

- 🛒 Process one or many Costco products in one run
- ⭐ Extract one through five-star customer reviews
- 📝 Return review titles and full review text
- 👤 Capture public reviewer nickname and location
- ✅ Identify verified-purchaser badges when available
- 👍 Include helpful and unhelpful vote totals
- 🖼️ Preserve public review photos and videos
- 📊 Add product-level average rating and rating distribution
- 📅 Filter by submission date
- ↕️ Sort by newest, highest rated, or lowest rated
- 🔁 Follow offset pagination automatically
- 📦 Export JSON, CSV, Excel, XML, RSS, or JSONL through Apify

### Who is it for?

#### Brands and manufacturers

Track customer feedback about products sold through Costco and detect recurring quality complaints.

#### Marketplace and ecommerce teams

Compare ratings, recommendation rates, and review themes across competing products.

#### Reputation and customer-experience teams

Schedule review ingestion and feed new reviews into dashboards, alerts, or ticketing workflows.

#### Data and research teams

Build longitudinal datasets for sentiment analysis, category research, or product benchmarking.

#### Agencies and consultants

Deliver structured Costco review intelligence without manual copying or custom scraper maintenance.

### Why use this Costco review extractor?

Costco product pages are designed for shoppers, not bulk analysis.

This Actor provides:

- Repeatable structured output
- Multi-product processing
- Stable review and product identifiers
- User-controlled limits
- Source-side sorting and filtering
- Automatic pagination
- Built-in Apify scheduling
- Dataset exports and API access
- Zapier, Make, Google Sheets, and webhook integrations

The implementation uses Costco's public review-data integration rather than fetching protected product-page HTML.

### Quick start

1. Open the Actor input.
2. Add one or more Costco product URLs or numeric product IDs.
3. Set the total and per-product review limits.
4. Optionally select ratings, dates, or sorting.
5. Click **Start**.
6. Open the **Dataset** tab to preview or export reviews.

A low-cost first run can use product ID `100737171` with a limit of 20 reviews.

### Input

| Field | Type | Default | Description |
|---|---|---:|---|
| `productUrlsOrIds` | string[] | sample product | Costco US URLs or numeric product IDs |
| `maxReviews` | integer | 100 | Global review-row limit |
| `maxReviewsPerProduct` | integer | 100 | Limit for each product |
| `sort` | string | `newest` | `newest`, `highest-rated`, or `lowest-rated` |
| `ratings` | integer[] | all | Optional ratings from 1 to 5 |
| `dateFrom` | string | none | Inclusive ISO start date/datetime |
| `dateTo` | string | none | Inclusive ISO end date/datetime |

### Example input

```json
{
  "productUrlsOrIds": [
    "https://www.costco.com/p/-/kirkland-signature-platinum-performance-ultrashine-dishwasher-detergent-pacs-115-count/100737171",
    "100737171"
  ],
  "maxReviews": 50,
  "maxReviewsPerProduct": 50,
  "sort": "newest",
  "ratings": [1, 2],
  "dateFrom": "2026-01-01"
}
````

Duplicate product IDs are processed only once.

### Supported Costco URLs

The Actor supports Costco US product URLs whose host is `costco.com` or a Costco subdomain.

It extracts the numeric product ID from the URL path.

You may also provide the numeric ID directly.

Non-Costco URLs fail closed instead of silently producing unrelated data.

Costco Business Center search/category URLs are outside this Actor's scope.

### Sorting and filters

Use `newest` for monitoring recently submitted reviews.

Use `highest-rated` to collect positive customer language.

Use `lowest-rated` to prioritize complaints and product risks.

The `ratings` filter accepts any combination of integers 1–5.

`dateFrom` and `dateTo` accept ISO dates or timestamps.

When both dates are supplied, `dateFrom` must not be after `dateTo`.

### Output

Each dataset item is one public customer review.

```json
{
  "reviewId": "252764979",
  "productId": "100737171",
  "rating": 5,
  "ratingRange": 5,
  "title": "Superior cleaning",
  "reviewText": "This product cleans as well as the name brands",
  "userNickname": "Ljr1",
  "userLocation": "St Louis MO",
  "submissionTime": "2026-07-13T13:02:09.000+00:00",
  "isRecommended": true,
  "isVerifiedPurchaser": true,
  "helpfulVotes": 0,
  "photos": [],
  "videos": [],
  "productName": "Kirkland Signature Platinum Performance UltraShine Dishwasher Detergent Pacs, 115-count",
  "averageRating": 4.58,
  "totalReviewCount": 1644,
  "scrapedAt": "2026-07-20T00:00:00.000Z"
}
```

### Data fields

| Field group | Included data |
|---|---|
| Identity | `reviewId`, `productId`, `authorId` |
| Review | `rating`, `ratingRange`, `title`, `reviewText` |
| Reviewer | `userNickname`, `userLocation`, `contentLocale` |
| Time | `submissionTime`, `lastModificationTime`, `scrapedAt` |
| Signals | `isRecommended`, `isVerifiedPurchaser`, `isSyndicated` |
| Feedback | `helpfulVotes`, `unhelpfulVotes`, `totalFeedbackCount` |
| Rich context | `badges`, `contextData`, `secondaryRatings`, `photos`, `videos` |
| Product | `productName`, `productUrl`, `productImageUrl`, `productBrand` |
| Statistics | `averageRating`, `totalReviewCount`, `ratingDistribution` |

Optional source values are represented as empty arrays/objects or `null`, not invented values.

### How much does it cost to scrape Costco product reviews?

The Actor uses pay-per-event pricing.

- A small start fee is charged once per run.
- A result event is charged for each review saved.
- Per-review prices decrease by Apify subscription tier.

The exact active prices are shown in the Actor's pricing panel before a run starts.

Control spend with `maxReviews` and `maxReviewsPerProduct`.

Start with 20 reviews, inspect the output, then increase the limit for production workflows.

### Scheduling review monitoring

Use an Apify schedule to run daily or weekly.

Recommended monitoring input:

```json
{
  "productUrlsOrIds": ["100737171"],
  "maxReviews": 100,
  "maxReviewsPerProduct": 100,
  "sort": "newest",
  "dateFrom": "2026-07-01"
}
```

Send the completed dataset to a webhook or downstream automation.

Deduplicate across scheduled runs by `reviewId`.

### Quality-alert workflow

To focus on negative reviews:

1. Set `ratings` to `[1, 2]`.
2. Set sorting to `lowest-rated` or `newest`.
3. Schedule the Actor daily.
4. Route new `reviewId` values to Slack, email, or a ticket queue.
5. Group complaints by product and recurring phrases.

This creates an actionable quality-monitoring feed rather than a manual review-page check.

### Sentiment and analytics workflow

Export review text to your preferred NLP or BI system.

Useful metrics include:

- Rating distribution over time
- Negative-review share
- Recommendation rate
- Verified-purchaser share
- Helpful-vote leaders
- Complaint topics by product
- Review velocity after a launch or packaging change

Use `submissionTime` for trends and `scrapedAt` for pipeline auditing.

### Integrations

#### Google Sheets

Use an Apify integration or Make scenario to append new dataset items to a sheet.

#### Zapier

Trigger a Zap after a successful run and route low ratings to Slack or email.

#### Make

Schedule multi-product extraction, filter by `rating`, and update a product dashboard.

#### Webhooks

Attach a run-succeeded webhook to notify your ingestion service when data is ready.

#### Cloud storage and databases

Fetch dataset items through the API and load them into BigQuery, Snowflake, PostgreSQL, S3, or a data lake.

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~costco-product-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"productUrlsOrIds":["100737171"],"maxReviews":20}'
```

Use the returned run ID to inspect status and the default dataset.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/costco-product-reviews-scraper').call({
  productUrlsOrIds: ['100737171'],
  maxReviews: 20,
  sort: 'newest',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/costco-product-reviews-scraper').call(run_input={
    'productUrlsOrIds': ['100737171'],
    'maxReviews': 20,
    'sort': 'newest',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with Apify MCP and AI agents

#### Claude Code

```bash
claude mcp add --transport http apify https://mcp.apify.com?tools=automation-lab/costco-product-reviews-scraper
```

#### Claude Desktop, Cursor, and VS Code setup

Use this `mcpServers` JSON in Claude Desktop or Cursor. VS Code users can add the same HTTP MCP server through the MCP configuration panel.

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/costco-product-reviews-scraper"
    }
  }
}
```

Example prompts:

- “Extract the 50 newest reviews for Costco product 100737171.”
- “Collect one- and two-star reviews for these Costco product URLs.”
- “Compare negative-review themes across these three Costco products.”
- “Schedule a weekly Costco review monitor and summarize new complaints.”

For Claude Desktop, add the Apify MCP server using your Apify token and enable this Actor tool.

### Performance and limits

The Actor uses lightweight HTTP requests and does not launch a browser.

It requests up to 100 reviews per source page and follows offsets automatically.

A run can process up to:

- 100 submitted products
- 10,000 total review rows
- 5,000 review rows per product

Source availability and the selected filters determine the actual result count.

### Reliability and errors

Requests use a 30-second timeout and bounded exponential-backoff retries.

The Actor deduplicates review IDs inside each run.

Invalid inputs fail with a clear message.

A complete source-request failure makes the run fail instead of reporting misleading success.

An empty dataset can be valid when a product has no matching non-rating-only reviews or filters exclude all records.

### Tips for best results

- Use numeric product IDs when you already store them in a catalog.
- Keep first-run limits low.
- Use newest sorting for recurring monitors.
- Use explicit date windows to reduce repeated extraction.
- Deduplicate scheduled exports by `reviewId`.
- Preserve `productId` as the stable join key.
- Check both `totalReviewCount` and returned rows: aggregate counts can include ratings-only submissions excluded from textual reviews.
- Avoid submitting search or category URLs; this Actor expects product URLs.

### Troubleshooting

#### Why is the returned count lower than Costco's displayed rating count?

Costco's aggregate count can include ratings-only submissions. This Actor returns public reviews with review content and excludes ratings-only records.

#### Why did my URL fail validation?

Only Costco US product URLs on `costco.com` and direct numeric product IDs are accepted. Search URLs, unsupported country sites, and unrelated hosts fail closed.

#### Why did I receive no rows?

Check the product ID and remove rating/date filters. The product may have no public text reviews matching the selected range.

#### Why are some reviewer or media fields empty?

Those fields are optional source data. Not every customer publishes a location, photo, video, or secondary rating.

### Data freshness

Results reflect the public Costco review data available when the run executes.

`submissionTime` is the review's source timestamp.

`lastModificationTime` shows the latest public modification when supplied.

`scrapedAt` records when the Actor transformed the record.

Schedule repeated runs when you need ongoing freshness.

### Legal and ethical use

The Actor extracts publicly accessible product-review data.

You are responsible for using output in accordance with applicable laws, Costco's terms, Bazaarvoice terms, and privacy requirements.

Do not use public reviewer information for harassment, discrimination, identity resolution, or unsolicited outreach.

Collect only what your workflow needs, secure exported datasets, and apply suitable retention policies.

This Actor is not affiliated with or endorsed by Costco or Bazaarvoice.

### Related scrapers

Explore other ecommerce and review tools from Automation Lab:

- [Walmart Reviews Scraper](https://apify.com/automation-lab/walmart-reviews-scraper)
- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper)
- [Steam Reviews Scraper](https://apify.com/automation-lab/steam-reviews-scraper)
- [Costco Business Center Product Scraper](https://apify.com/automation-lab/costco-business-center-product-scraper)

Use the Business Center actor for product search, prices, stock, and catalog cards. Use this Actor when individual Costco.com customer reviews are the primary output.

### FAQ

#### Does it require a Costco account?

No. The supported review scope uses public review data.

#### Does it use a proxy or browser?

No proxy or browser is required for the current public review route.

#### Can I scrape several products?

Yes. Add multiple URLs or IDs to `productUrlsOrIds` and control per-product and total limits independently.

#### Can I filter for negative reviews?

Yes. Set `ratings` to `[1, 2]` and choose newest or lowest-rated sorting.

#### Can I export to CSV or Excel?

Yes. Open the dataset and select CSV, Excel, JSON, XML, RSS, or JSONL.

#### Can I run it on a schedule?

Yes. Apify schedules can run the same input hourly, daily, weekly, or with a custom cron expression.

#### Are aggregate statistics included?

Yes. Rows include the average overall rating, total aggregate review count, and rating distribution when supplied by the source.

#### Are review images included?

Yes. Public photo and video metadata is preserved when a review contains media.

#### Is every aggregate rating a text review?

No. Aggregate counts may include ratings-only submissions. Dataset rows represent non-rating-only public reviews.

### Support

If a valid Costco US product stops returning expected public reviews, open an Actor issue with:

- The product URL or ID
- The approximate expected count
- Your input without secrets
- The run ID
- The relevant log message

That evidence makes source changes easier to reproduce and fix.

# Actor input Schema

## `productUrlsOrIds` (type: `array`):

Costco.com product URLs or numeric product IDs. One product per line.

## `maxReviews` (type: `integer`):

Global maximum number of review rows across all products.

## `maxReviewsPerProduct` (type: `integer`):

Maximum review rows saved for each Costco product.

## `sort` (type: `string`):

Sort reviews by newest submission or rating.

## `ratings` (type: `array`):

Optional star ratings to include. Leave empty for all ratings.

## `dateFrom` (type: `string`):

Optional ISO date or datetime, for example 2026-01-01.

## `dateTo` (type: `string`):

Optional ISO date or datetime, for example 2026-12-31.

## Actor input object example

```json
{
  "productUrlsOrIds": [
    "100737171"
  ],
  "maxReviews": 20,
  "maxReviewsPerProduct": 20,
  "sort": "newest",
  "ratings": []
}
```

# 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 = {
    "productUrlsOrIds": [
        "100737171"
    ],
    "maxReviews": 20,
    "maxReviewsPerProduct": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/costco-product-reviews-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 = {
    "productUrlsOrIds": ["100737171"],
    "maxReviews": 20,
    "maxReviewsPerProduct": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/costco-product-reviews-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 '{
  "productUrlsOrIds": [
    "100737171"
  ],
  "maxReviews": 20,
  "maxReviewsPerProduct": 20
}' |
apify call automation-lab/costco-product-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Costco Product Reviews Scraper",
        "description": "Extract public Costco reviews, ratings, text, reviewer details, helpfulness, media, product metadata, and aggregate statistics for monitoring and analysis.",
        "version": "0.1",
        "x-build-id": "USEGCnsVjxWhp7ZNk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~costco-product-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-costco-product-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~costco-product-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-costco-product-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~costco-product-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-costco-product-reviews-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": [
                    "productUrlsOrIds"
                ],
                "properties": {
                    "productUrlsOrIds": {
                        "title": "🛒 Costco product URLs or IDs",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Costco.com product URLs or numeric product IDs. One product per line.",
                        "default": [
                            "100737171"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Maximum reviews total",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Global maximum number of review rows across all products.",
                        "default": 100
                    },
                    "maxReviewsPerProduct": {
                        "title": "Maximum reviews per product",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum review rows saved for each Costco product.",
                        "default": 100
                    },
                    "sort": {
                        "title": "↕️ Review order",
                        "enum": [
                            "newest",
                            "highest-rated",
                            "lowest-rated"
                        ],
                        "type": "string",
                        "description": "Sort reviews by newest submission or rating.",
                        "default": "newest"
                    },
                    "ratings": {
                        "title": "Ratings",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional star ratings to include. Leave empty for all ratings.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "dateFrom": {
                        "title": "Submitted on or after",
                        "type": "string",
                        "description": "Optional ISO date or datetime, for example 2026-01-01."
                    },
                    "dateTo": {
                        "title": "Submitted on or before",
                        "type": "string",
                        "description": "Optional ISO date or datetime, for example 2026-12-31."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
