# Chewy Product Reviews Scraper (`automation-lab/chewy-product-reviews-scraper`) Actor

🐾 Export public Chewy customer reviews, full text, rating summaries, star distributions, dates, and helpfulness for product and sentiment monitoring.

- **URL**: https://apify.com/automation-lab/chewy-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

Pay per event

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 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

## Chewy Product Reviews Scraper

Export public Chewy product reviews into clean JSON, CSV, Excel, XML, or RSS without copying review cards by hand.

The actor accepts regular Chewy product URLs and `/product-reviews/` URLs. It returns full review text together with product context, ratings, reviewer names, dates, helpful votes, and the complete five-star distribution.

Use it for recurring pet-brand sentiment monitoring, product quality research, competitive analysis, and launch tracking.

- 🐾 Extract real customer review records from Chewy product pages.
- ⭐ Keep the aggregate score, counts, and rating distribution beside every review.
- 📅 Filter by date and order newest reviews first for scheduled monitoring.
- 🔎 Select one or more star ratings to focus on critical or enthusiastic feedback.
- 🔗 Send the dataset to Google Sheets, webhooks, cloud storage, or your own API.

### What does Chewy Product Reviews Scraper do?

Chewy Product Reviews Scraper turns public customer feedback into analysis-ready records.

For every saved review, it captures the review rating, title, complete body, reviewer name, submission date, helpful vote count, contributor badge, and incentive flag when Chewy exposes them.

The same row also contains the product name, brand, product identifiers, canonical URLs, image, average rating, total rating count, customer-review count, and five-star distribution.

Cursor pagination continues until the requested review limit or the end of the selected review set.

### Who is it for?

#### Pet brands and manufacturers

Track fresh feedback about taste, packaging, ingredients, product consistency, delivery condition, and pet acceptance.

#### Marketplace sellers and category managers

Compare customer language, rating movement, and recurring complaints across competing pet products.

#### Product and reputation teams

Schedule a newest-first run and route negative feedback into triage workflows.

#### Pet-industry researchers

Build structured review corpora for trend, sentiment, and product-positioning studies.

#### Data teams and agencies

Deliver repeatable Chewy review exports without maintaining a scraper or reverse engineering pagination.

### Why use this Chewy reviews scraper?

Manual review collection is slow and loses important product context.

This actor is designed for repeat workflows:

- ✅ Stable review IDs support deduplication between scheduled runs.
- ✅ Date and star filters keep monitoring datasets focused.
- ✅ Full text supports keyword, topic, and sentiment analysis.
- ✅ Typed numeric fields are ready for charts and BI tools.
- ✅ Canonical source links preserve traceability.
- ✅ Failed extraction does not silently become an empty successful run.

### What Chewy review data can I extract?

| Field group | Included data |
|---|---|
| Review identity | `reviewId`, `contentId` |
| Product identity | `productId`, `productPartNumber`, `productName`, `productBrand` |
| Product links | `productUrl`, `productImageUrl`, `sourceUrl` |
| Rating summary | `averageRating`, `ratingCount`, `reviewCount` |
| Distribution | Count and percentage for ratings 1 through 5 |
| Review content | `rating`, `title`, `reviewText` |
| Reviewer | `reviewerName`, `contributorBadge` |
| Timing | `reviewDate`, `scrapedAt` |
| Engagement | `helpfulVotes` |
| Disclosure | `isIncentivized` |
| Run context | `sort` |

All displayed dataset fields are primitives, so CSV and spreadsheet exports remain easy to use.

### How to scrape Chewy product reviews

1. Open this actor in Apify Console.
2. Add one or more Chewy product or product-reviews URLs.
3. Choose a maximum number of reviews.
4. Select newest or most helpful/relevant ordering.
5. Optionally add star ratings or an ISO date range.
6. Click **Start**.
7. Open the Dataset tab and export the results.

The prefilled example requests only 10 reviews and is suitable for a quick first run.

### Input parameters

| Parameter | Type | Required | Default | Purpose |
|---|---|---:|---:|---|
| `productUrls` | array | Yes | Example Chewy URL | Product or product-reviews URLs |
| `maxReviews` | integer | No | 50 | Global cap across all products |
| `sort` | string | No | `newest` | `newest` or `helpful` |
| `ratings` | integer array | No | All | Ratings from 1 to 5 |
| `dateFrom` | string | No | — | Inclusive ISO lower date bound |
| `dateTo` | string | No | — | Inclusive ISO upper date bound |

URLs must use the `chewy.com` domain and include a numeric product ID.

### Input example

```json
{
  "productUrls": [
    { "url": "https://www.chewy.com/purina-pro-plan-shredded-blend-adult/product-reviews/114029" }
  ],
  "maxReviews": 50,
  "sort": "newest",
  "ratings": ["1", "2"],
  "dateFrom": "2026-01-01"
}
````

This example collects up to 50 recent one-star and two-star reviews submitted on or after January 1, 2026.

### Output example

```json
{
  "reviewId": "UmV2aWV3OjE3ODI3NTk4",
  "contentId": "UkVWSUVXOjI3ODE4NzAyNA==",
  "productId": "114029",
  "productPartNumber": "86252",
  "productName": "Purina Pro Plan Shredded Blend Adult Small Breed Chicken & Rice Formula Dry Dog Food",
  "productBrand": "Purina Pro Plan",
  "averageRating": 4.6914,
  "ratingCount": 6899,
  "reviewCount": 2336,
  "rating": 5,
  "reviewerName": "stephen",
  "reviewDate": "2026-07-20T23:28:39.000Z",
  "title": "proplan",
  "reviewText": "He has been on this his entire life recommended by the vet when we adopted him",
  "helpfulVotes": 0,
  "isIncentivized": false,
  "sort": "newest",
  "sourceUrl": "https://www.chewy.com/purina-pro-plan-shredded-blend-adult/product-reviews/114029"
}
```

Values change as Chewy customers add reviews and rate products.

### Rating and date filters

Leave `ratings` empty to include every star rating.

Choose one value such as `["1"]` for critical feedback, or combine values such as `["4", "5"]` for positive-feedback research.

`dateFrom` and `dateTo` accept ISO dates or datetimes. Boundaries are inclusive.

Examples:

- `2026-01-01`
- `2026-01-01T00:00:00Z`
- `2026-06-30T23:59:59Z`

Invalid dates and reversed date windows fail clearly instead of returning misleading data.

### Sorting and pagination

`newest` uses Chewy's newest-first review order. It is the best choice for scheduled monitoring and incremental collection.

`helpful` uses Chewy's most relevant order, which is the closest public ordering to the helpful-review experience on the product page.

The actor follows Chewy's cursor pagination in batches of 10 and deduplicates stable review IDs.

The global `maxReviews` limit stops output across all supplied products, which keeps run cost and dataset size predictable.

### How much does it cost to scrape Chewy reviews?

The actor uses pay-per-event pricing: a small **$0.005 start fee** plus a tiered fee for each saved review.

The BRONZE per-review rate is **$0.000059184**. Calculate a run as the $0.005 start fee plus the per-review rate multiplied by the number of saved reviews.

Higher Apify plans receive automatic volume discounts. The current live pricing shown in Apify Console is authoritative.

You are charged for saved review rows, not Chewy pages that contain no qualifying output.

### Monitoring workflows

Schedule the actor daily or weekly with `sort: "newest"` and a recent `dateFrom` value.

A practical workflow is:

1. Run the actor for your monitored products.
2. Deduplicate on `reviewId` in your destination.
3. Flag ratings at or below two stars.
4. Group review text by quality, flavor, packaging, delivery, or service themes.
5. Send new critical reviews to the responsible team.

Stable IDs and timestamps make incremental pipelines straightforward.

### Sentiment and quality analysis

The actor returns raw customer language rather than a generated sentiment label.

That gives your team control over the analysis method. You can:

- Count recurring phrases.
- Classify product, shipping, packaging, or service issues.
- Compare topics by star rating.
- Measure positive versus critical review volume.
- Summarize changes after a formulation or packaging update.
- Build a labeled dataset for an internal model.

Always retain `sourceUrl` and `reviewId` for verification.

### Export and integrations

Apify datasets export to JSON, CSV, Excel, XML, and RSS.

Useful integration patterns include:

- **Google Sheets:** append new review rows for category managers.
- **Slack or Microsoft Teams:** alert when a new one-star review appears.
- **Airtable:** maintain a tagged product-feedback repository.
- **BigQuery or Snowflake:** join Chewy reviews with product and sales data.
- **Make or Zapier:** trigger a workflow after a scheduled run finishes.
- **Webhooks:** send run completion events to your own service.
- **Amazon S3 or Google Cloud Storage:** archive periodic snapshots.

### Run from the Apify API with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/chewy-product-reviews-scraper').call({
  productUrls: [{ url: 'https://www.chewy.com/purina-pro-plan-shredded-blend-adult/product-reviews/114029' }],
  maxReviews: 20,
  sort: 'newest'
});

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

### Run from the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/chewy-product-reviews-scraper').call(run_input={
    'productUrls': [{'url': 'https://www.chewy.com/purina-pro-plan-shredded-blend-adult/product-reviews/114029'}],
    'maxReviews': 20,
    'sort': 'newest',
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### Run from the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~chewy-product-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "productUrls": [{"url": "https://www.chewy.com/purina-pro-plan-shredded-blend-adult/product-reviews/114029"}],
    "maxReviews": 20,
    "sort": "newest"
  }'
```

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

### Use with Apify MCP and AI assistants

Connect the actor to Claude Code:

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

For Claude Desktop, Cursor, or VS Code, add an HTTP MCP server:

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

Example prompts:

- “Collect the newest 30 reviews for this Chewy product and summarize recurring complaints.”
- “Extract only one-star Chewy reviews since January and group them by quality issue.”
- “Compare rating distributions and recent review themes for these three products.”

### Tips for reliable Chewy review extraction

- 🧪 Start with 10 reviews while validating a new product URL.
- 📆 Use `newest` with `dateFrom` for scheduled monitoring.
- ⭐ Query selected ratings when the workflow only needs critical or positive feedback.
- 🔢 Raise `maxReviews` only after confirming expected source volume.
- 🔗 Keep canonical Chewy URLs rather than shortened or redirect links.
- 🆔 Deduplicate recurring exports by `reviewId`.
- 🕒 Store `scrapedAt` separately from the customer’s `reviewDate`.

### Error handling and troubleshooting

The actor validates inputs before extraction and retries bounded transient requests.

It skips an individual invalid or unavailable product in a multi-product batch, then continues with the remaining products.

If every product fails or no rows match the filters, the run fails rather than producing an unexplained empty success.

#### Why did my run return no reviews?

Check that the URL is a public Chewy product URL with a numeric product ID. Also remove restrictive ratings or date boundaries to confirm the product has qualifying reviews.

#### Why is the review count larger than my output?

`reviewCount` reports all customer reviews visible for the product. `maxReviews`, rating filters, and date filters intentionally limit saved rows.

#### Why do rating count and review count differ?

Chewy can include rating-only submissions in `ratingCount`, while `reviewCount` represents full customer reviews available to the review connection.

### Data freshness and limitations

The actor extracts public fields Chewy exposes at run time.

Review counts, average ratings, ordering, and helpfulness can change after a run.

Chewy may rename fields, alter its page, or change review ranking. The actor reports extraction failures clearly so scheduled workflows do not confuse a blocked page with zero reviews.

The actor does not create reviews, access customer accounts, expose private profile data, or infer reviewer identity.

### Is scraping Chewy reviews legal?

This actor extracts publicly accessible product-review information.

Whether a particular use is lawful depends on your jurisdiction, purpose, volume, contractual obligations, and handling of personal data.

Use reasonable request volumes, follow applicable laws and platform terms, and avoid using reviewer information for harassment, discrimination, or unwanted contact.

You are responsible for deciding whether your use case is compliant.

### Frequently asked questions

#### Can I use regular Chewy product URLs?

Yes. Both product URLs and `/product-reviews/` URLs are accepted when they contain the product ID.

#### Can I scrape several products in one run?

Yes. Add up to 100 URLs. The global `maxReviews` cap applies across the batch.

#### Can I export one-star reviews only?

Yes. Set `ratings` to `["1"]`.

#### Can I retrieve reviews from a date window?

Yes. Set `dateFrom`, `dateTo`, or both with ISO-formatted values.

#### Does the output contain full review text?

Yes. `reviewText` contains the full text returned by Chewy’s public review service.

#### Does it support pagination?

Yes. The actor follows cursor pagination until it reaches the source end or your review limit.

#### Can I schedule it?

Yes. Use an Apify schedule and deduplicate downstream by `reviewId`.

#### Does it require Chewy login cookies?

No. The actor does not require a Chewy account or user-provided cookies.

### Related scrapers

Build broader retail and review-monitoring workflows with other automation-lab actors:

- [Walmart Reviews Scraper](https://apify.com/automation-lab/walmart-reviews-scraper)
- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper)
- [Target Product Reviews Scraper](https://apify.com/automation-lab/target-product-reviews-scraper)
- [Costco Product Reviews Scraper](https://apify.com/automation-lab/costco-product-reviews-scraper)
- [IKEA Product Reviews Scraper](https://apify.com/automation-lab/ikea-product-reviews-scraper)

### Support

For a reproducible issue, include:

- The public Chewy product URL.
- The input JSON with secrets removed.
- The run ID.
- The expected and observed behavior.
- Whether the problem affects all products or one product.

This information makes source changes and filter edge cases faster to diagnose.

# Actor input Schema

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

Chewy product or product-reviews URLs. Add one URL per row.

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

Maximum review rows to save across all supplied products.

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

Use newest for monitoring or helpful for Chewy's relevance-ranked reviews.

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

Optional ratings from 1 to 5. Leave empty to include every star rating.

## `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
{
  "productUrls": [
    {
      "url": "https://www.chewy.com/purina-pro-plan-shredded-blend-adult/product-reviews/114029"
    }
  ],
  "maxReviews": 10,
  "sort": "newest",
  "ratings": []
}
```

# Actor output Schema

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

Open the default dataset table with review text, ratings, reviewer details, product context, and source links.

# 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 = {
    "productUrls": [
        {
            "url": "https://www.chewy.com/purina-pro-plan-shredded-blend-adult/product-reviews/114029"
        }
    ],
    "maxReviews": 10,
    "sort": "newest"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/chewy-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 = {
    "productUrls": [{ "url": "https://www.chewy.com/purina-pro-plan-shredded-blend-adult/product-reviews/114029" }],
    "maxReviews": 10,
    "sort": "newest",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/chewy-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 '{
  "productUrls": [
    {
      "url": "https://www.chewy.com/purina-pro-plan-shredded-blend-adult/product-reviews/114029"
    }
  ],
  "maxReviews": 10,
  "sort": "newest"
}' |
apify call automation-lab/chewy-product-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Chewy Product Reviews Scraper",
        "description": "🐾 Export public Chewy customer reviews, full text, rating summaries, star distributions, dates, and helpfulness for product and sentiment monitoring.",
        "version": "0.1",
        "x-build-id": "1pn5S0PhpcU9tj2N7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~chewy-product-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-chewy-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~chewy-product-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-chewy-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~chewy-product-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-chewy-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": [
                    "productUrls"
                ],
                "properties": {
                    "productUrls": {
                        "title": "🐾 Chewy product URLs",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Chewy product or product-reviews URLs. Add one URL per row.",
                        "default": [
                            {
                                "url": "https://www.chewy.com/purina-pro-plan-shredded-blend-adult/product-reviews/114029"
                            }
                        ],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxReviews": {
                        "title": "Maximum reviews",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum review rows to save across all supplied products.",
                        "default": 50
                    },
                    "sort": {
                        "title": "↕️ Review order",
                        "enum": [
                            "newest",
                            "helpful"
                        ],
                        "type": "string",
                        "description": "Use newest for monitoring or helpful for Chewy's relevance-ranked reviews.",
                        "default": "newest"
                    },
                    "ratings": {
                        "title": "Star ratings",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional ratings from 1 to 5. Leave empty to include every star rating.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "dateFrom": {
                        "title": "Reviewed on or after",
                        "type": "string",
                        "description": "Optional ISO date or datetime, for example 2026-01-01."
                    },
                    "dateTo": {
                        "title": "Reviewed 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```