# CVS Product Reviews Scraper (`automation-lab/cvs-product-reviews-scraper`) Actor

Extract public CVS product reviews with ratings, text, verified-purchase signals, quality dimensions, helpful votes, media, and merchant replies.

- **URL**: https://apify.com/automation-lab/cvs-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.01 / 1,000 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

## CVS Product Reviews Scraper

Collect public CVS customer reviews as clean, structured records.

Enter CVS product URLs, `-reviews` URLs, or numeric CVS product IDs.
The Actor returns one dataset row per review with exact IDs, timestamps, ratings, review text, reviewer signals, product context, helpful votes, media, and merchant replies.

Use the output for voice-of-customer research, quality monitoring, brand reputation, retail intelligence, and competitor benchmarking.
No CVS account or browser automation is required.

### What does CVS Product Reviews Scraper do?

CVS Product Reviews Scraper turns public review pages such as:

`https://www.cvs.com/shop/...-prodid-358135-reviews`

into export-ready JSON, CSV, Excel, XML, or RSS records.

It can:

- 🛍️ process one or many CVS products per run;
- ⭐ collect ratings and written reviews;
- ✅ identify verified-purchase reviews;
- 👍 capture recommendations and helpful votes;
- 📊 return Value, Meets expectations, Quality, and other dimensions;
- 💬 preserve merchant or supplier replies;
- 🖼️ expose review photo and video URLs;
- 🗓️ filter by exact review dates;
- 🔁 support scheduled monitoring with stable review IDs.

### Who is it for?

**Brand and product teams** use CVS feedback to find recurring complaints, packaging issues, perceived value gaps, and customer language.

**Manufacturers and suppliers** monitor how products perform after launch and whether merchant replies resolve customer concerns.

**Retail intelligence analysts** compare ratings, review volume, verified-purchase share, and recommendation signals across CVS SKUs.

**Agencies** collect repeatable evidence for client reputation, product-positioning, and consumer-insight reports.

**Data teams** load normalized reviews into warehouses, BI tools, NLP pipelines, spreadsheets, and alerting systems.

### Why use this CVS reviews scraper?

CVS product pages are useful to shoppers but awkward for bulk analysis.
This Actor gives every review a stable row and preserves the source context needed for audits.

Benefits include:

- no manual copy and paste;
- no CVS login or user-supplied cookies;
- direct structured extraction rather than fragile visual scraping;
- deterministic limits and filters;
- typed fields suitable for databases;
- stable `productId` and `reviewId` values for deduplication;
- predictable pay-per-result billing.

### What CVS review data can I extract?

| Field | Meaning |
|---|---|
| `productId` | CVS product identifier parsed from the URL or input |
| `productName` | CVS product name |
| `brand` | Product brand |
| `category` | CVS category identifier |
| `productUrl` | Canonical CVS product URL |
| `productImageUrl` | Main product image URL |
| `upc` | First available UPC |
| `reviewId` | Stable public review identifier |
| `rating` | Overall star rating |
| `title` | Review title, when supplied |
| `body` | Written review text, when supplied |
| `reviewerName` | Public reviewer nickname |
| `verifiedPurchase` | Whether CVS marks the review as verified |
| `recommended` | Reviewer recommendation flag |
| `ratingsOnly` | Whether the entry has ratings but no written text |
| `reviewDate` | Exact ISO submission timestamp |
| `helpfulVotes` | Positive helpful-vote count |
| `dimensions` | All secondary rating dimensions |
| `valueRating` | Value score |
| `meetsExpectationsRating` | Meets expectations score |
| `qualityRating` | Quality score |
| `merchantReplies` | Public merchant or supplier responses |
| `mediaUrls` | Review photo and video URLs |
| `incentivized` | Promotion/incentive badge signal |
| `totalProductReviews` | Product-level review count |
| `averageProductRating` | Product-level average rating |
| `sourceUrl` | CVS reviews page for verification |
| `scrapedAt` | UTC extraction timestamp |

Optional values remain `null` rather than being guessed.

### Input

You can combine URL and ID inputs.
Duplicate products are processed once.

```json
{
  "startUrls": [
    {
      "url": "https://www.cvs.com/shop/cvs-ibuprofen-pain-reliever-fever-reducer-nsaid-200-mg-24-coated-tablets-prodid-358135-reviews"
    }
  ],
  "productIds": ["247031"],
  "maxReviewsPerProduct": 50,
  "sort": "newest",
  "includeRatingsOnly": true
}
````

At least one URL or product ID is required.

### Input options

| Option | Type | Default | Description |
|---|---|---:|---|
| `startUrls` | array | sample CVS URL | CVS product or `-reviews` URLs containing `prodid-<ID>` |
| `productIds` | string array | `[]` | Numeric CVS product IDs |
| `maxReviewsPerProduct` | integer | `50` | Maximum matching rows saved per product |
| `sort` | string | `newest` | `newest`, `oldest`, `highest_rating`, `lowest_rating`, or `most_helpful` |
| `rating` | integer | none | Return only 1, 2, 3, 4, or 5-star reviews |
| `fromDate` | string | none | Inclusive `YYYY-MM-DD` start date |
| `toDate` | string | none | Inclusive `YYYY-MM-DD` end date |
| `includeRatingsOnly` | boolean | `true` | Include star ratings without title/body text |

Invalid URLs and dates fail closed with a clear error.

### Output example

```json
{
  "productId": "358135",
  "productName": "CVS Ibuprofen Pain Reliever & Fever Reducer (NSAID) 200 mg, 24 Coated Tablets",
  "brand": "CVS",
  "reviewId": "252332286",
  "rating": 5,
  "title": "Perfect amount at a great price",
  "body": "CVS brand ibuprophen tablets are small and easy to swallow.",
  "reviewerName": "Alice",
  "verifiedPurchase": false,
  "recommended": true,
  "ratingsOnly": false,
  "reviewDate": "2026-06-29T18:42:01.000+00:00",
  "helpfulVotes": 0,
  "valueRating": 5,
  "meetsExpectationsRating": 5,
  "qualityRating": 5,
  "merchantReplies": [],
  "mediaUrls": [],
  "sourceUrl": "https://www.cvs.com/shop/...-prodid-358135-reviews"
}
```

Fields omitted from this short example remain available in the dataset.

### How to scrape CVS product reviews

1. Open the Actor input page.
2. Paste one or more CVS product URLs or review URLs.
3. Alternatively, enter numeric CVS product IDs.
4. Choose a low `maxReviewsPerProduct` for your first run.
5. Select ordering and optional filters.
6. Click **Start**.
7. Open the **Dataset** tab.
8. Export or integrate the records.

The default prefill is intentionally small enough for a quick first run.

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

The Actor uses pay-per-event pricing.
A small one-time start charge covers run initialization, and each saved CVS review is charged as one review event.

The initial local configuration is:

- start: **$0.005** per run;
- CVS review at BRONZE: **$0.000024795** per saved row;
- CVS review tiers range from **$0.000028515** on FREE to **$0.00001** on PLATINUM and DIAMOND.

The Console shows the exact maximum charge before a run starts.
Filters that reduce saved rows also reduce per-result charges.

### Filtering CVS reviews

Set `rating` to focus on a star segment.
For example, `rating: 1` surfaces critical customer feedback.

Set `fromDate` and `toDate` for a reporting period:

```json
{
  "productIds": ["358135"],
  "fromDate": "2026-01-01",
  "toDate": "2026-06-30",
  "sort": "newest",
  "maxReviewsPerProduct": 500
}
```

Date boundaries are inclusive and evaluated against exact UTC review timestamps.

### Ratings-only reviews

CVS contains entries where a shopper submitted stars and dimensions without written text.
These are valid rating records and are included by default.

Set `includeRatingsOnly` to `false` when your NLP or sentiment workflow requires written title/body content.
The `ratingsOnly` field lets downstream workflows distinguish both record types even when they are collected together.

### Tips for reliable monitoring

- Start with 10–50 rows while validating a product ID.
- Sort by `newest` for scheduled monitoring.
- Use `reviewId` as the deduplication key.
- Store the latest `reviewDate` and reuse it as the next `fromDate`.
- Keep `productId` in warehouse joins; product names can change.
- Preserve `sourceUrl` for analyst verification.
- Use `includeRatingsOnly: false` only if written feedback is mandatory.
- Split very large multi-product portfolios into scheduled batches.

### Integrations

Send results to:

- **Google Sheets** for review triage and weekly reporting;
- **Slack** for one-star review alerts;
- **Zapier** or **Make** for no-code workflows;
- **Airtable** for product-level issue tracking;
- **BigQuery** or **Snowflake** for historical analysis;
- **Amazon S3** for a review data lake;
- **webhooks** for near-real-time ingestion;
- **language models** for themes and summarization.

A useful alert workflow filters `rating <= 2`, checks `reviewId` against previously seen records, and posts the title, body, dimensions, and source link to the product owner.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/cvs-product-reviews-scraper').call({
  productIds: ['358135'],
  maxReviewsPerProduct: 100,
  sort: 'newest',
  includeRatingsOnly: false,
});

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

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/cvs-product-reviews-scraper").call(run_input={
    "productIds": ["358135"],
    "maxReviewsPerProduct": 100,
    "sort": "most_helpful",
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### cURL API example

```bash
curl "https://api.apify.com/v2/acts/automation-lab~cvs-product-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "productIds": ["358135"],
    "maxReviewsPerProduct": 50,
    "sort": "newest"
  }'
```

Read the resulting default dataset after the run succeeds.

### Use with Apify MCP

Connect AI assistants through the Apify MCP server:

`https://mcp.apify.com?tools=automation-lab/cvs-product-reviews-scraper`

#### Claude Code

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

#### Claude Desktop and Cursor

Add this to the Claude Desktop or Cursor MCP configuration and provide your token through the client authentication flow:

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

#### VS Code

Open the VS Code MCP configuration, add an HTTP server named `apify`, and use the same scoped URL above.

Example prompts:

- “Collect the newest 50 CVS reviews for product 358135.”
- “Find one-star written CVS reviews since January and summarize recurring quality problems.”
- “Compare Value and Quality dimensions for these three CVS product IDs.”
- “Show reviews with merchant replies and link each one to its source.”

### Data quality and deduplication

Every record uses CVS/Bazaarvoice source identifiers rather than generated hashes.
`reviewId` is the preferred unique key.

The Actor deduplicates repeated review IDs during a run.
It also deduplicates product IDs when the same product appears as both URL and direct ID input.

Product-level counts and averages come from the same public review response as the rows.
The Actor does not infer sentiment, demographics, or reviewer identity.

### Limitations

- CVS can change its public storefront or review integration.
- A CVS page slug may change while its numeric product ID remains stable.
- Some older URLs may point to a product variant whose visible `prodid` has no active review record.
- Optional fields are absent when the reviewer or merchant did not submit them.
- Ratings-only entries do not contain text for NLP analysis.
- Deleted or moderated reviews are not returned by the public source.
- Very broad date filters may require reading multiple API pages.

The Actor is designed for public review data, not account-only content, prescriptions, orders, or customer profiles.

### Troubleshooting

**Why did my run save zero rows?**

Confirm the URL contains `prodid-<ID>`, remove date/rating filters, and keep `includeRatingsOnly` enabled.
Some CVS product variants have no public review records.

**Why are some titles or bodies null?**

CVS accepts ratings without written text.
Set `includeRatingsOnly: false` if your workflow requires text.

**Why was my URL rejected?**

Only `cvs.com` product URLs containing a numeric `prodid-<ID>` are accepted.
Search/category URLs do not identify a single review collection.

**How do I avoid duplicate alerts?**

Persist `reviewId` and alert only for IDs not seen in previous scheduled runs.

### Is scraping CVS reviews legal?

The Actor collects public product-review content without logging in.
Review data can still contain user-generated text and public nicknames.

You are responsible for your use case and applicable laws, contracts, and platform terms.
Avoid attempts to identify reviewers, do not use the data for harassment or sensitive profiling, and retain only what your workflow needs.
For regulated or high-risk use cases, obtain legal advice.

### Related scrapers

Build a wider retail voice-of-customer workflow with:

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

Use each source-specific Actor independently and join records in your warehouse by product mapping.

### FAQ

**Can I submit a normal product URL instead of a `-reviews` URL?**

Yes. The Actor extracts the numeric `prodid` from either form.

**Can I enter only a numeric ID?**

Yes. Add it to `productIds` as a string such as `"358135"`.

**Does this Actor need a residential proxy?**

No. It uses CVS's public structured review delivery path directly.

**Can I sort by helpfulness?**

Yes. Use `sort: "most_helpful"`.

**Are date filters inclusive?**

Yes. Both `fromDate` and `toDate` include the specified calendar day.

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

Yes. Open the dataset and select any Apify-supported export format.

**Can I schedule recurring runs?**

Yes. Use Apify Schedules, store the last review date/IDs, and deliver new rows through a webhook or integration.

### Support

If a valid CVS product unexpectedly returns no reviews, include:

- the CVS URL or product ID;
- the Actor run URL;
- the input used;
- the approximate review count visible on CVS;
- the expected versus actual result.

This evidence makes source changes and variant mismatches faster to diagnose.

# Actor input Schema

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

CVS product or product review URLs. URLs must contain prodid-<ID>.

## `productIds` (type: `array`):

Numeric CVS product IDs, such as 358135. Duplicate IDs and URLs are processed once.

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

Stop after saving this many matching reviews for each CVS product.

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

Ordering used while collecting reviews.

## `rating` (type: `integer`):

Optionally return only reviews with this star rating.

## `fromDate` (type: `string`):

Inclusive start date in YYYY-MM-DD format.

## `toDate` (type: `string`):

Inclusive end date in YYYY-MM-DD format.

## `includeRatingsOnly` (type: `boolean`):

When enabled, include CVS ratings that have stars and dimensions but no title or written body.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.cvs.com/shop/cvs-ibuprofen-pain-reliever-fever-reducer-nsaid-200-mg-24-coated-tablets-prodid-358135-reviews"
    }
  ],
  "productIds": [],
  "maxReviewsPerProduct": 10,
  "sort": "newest",
  "includeRatingsOnly": true
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.cvs.com/shop/cvs-ibuprofen-pain-reliever-fever-reducer-nsaid-200-mg-24-coated-tablets-prodid-358135-reviews"
        }
    ],
    "maxReviewsPerProduct": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/cvs-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 = {
    "startUrls": [{ "url": "https://www.cvs.com/shop/cvs-ibuprofen-pain-reliever-fever-reducer-nsaid-200-mg-24-coated-tablets-prodid-358135-reviews" }],
    "maxReviewsPerProduct": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/cvs-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 '{
  "startUrls": [
    {
      "url": "https://www.cvs.com/shop/cvs-ibuprofen-pain-reliever-fever-reducer-nsaid-200-mg-24-coated-tablets-prodid-358135-reviews"
    }
  ],
  "maxReviewsPerProduct": 10
}' |
apify call automation-lab/cvs-product-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CVS Product Reviews Scraper",
        "description": "Extract public CVS product reviews with ratings, text, verified-purchase signals, quality dimensions, helpful votes, media, and merchant replies.",
        "version": "0.1",
        "x-build-id": "qyxq8idav6I8mJnWz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~cvs-product-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-cvs-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~cvs-product-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-cvs-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~cvs-product-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-cvs-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",
                "properties": {
                    "startUrls": {
                        "title": "🛍️ CVS product URLs",
                        "type": "array",
                        "description": "CVS product or product review URLs. URLs must contain prodid-<ID>.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "productIds": {
                        "title": "CVS product IDs",
                        "type": "array",
                        "description": "Numeric CVS product IDs, such as 358135. Duplicate IDs and URLs are processed once.",
                        "items": {
                            "type": "string",
                            "pattern": "^\\d+$"
                        },
                        "default": []
                    },
                    "maxReviewsPerProduct": {
                        "title": "Maximum reviews per product",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many matching reviews for each CVS product.",
                        "default": 50
                    },
                    "sort": {
                        "title": "Sort reviews",
                        "enum": [
                            "newest",
                            "oldest",
                            "highest_rating",
                            "lowest_rating",
                            "most_helpful"
                        ],
                        "type": "string",
                        "description": "Ordering used while collecting reviews.",
                        "default": "newest"
                    },
                    "rating": {
                        "title": "⭐ Rating filter",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Optionally return only reviews with this star rating."
                    },
                    "fromDate": {
                        "title": "Reviews on or after",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Inclusive start date in YYYY-MM-DD format."
                    },
                    "toDate": {
                        "title": "Reviews on or before",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Inclusive end date in YYYY-MM-DD format."
                    },
                    "includeRatingsOnly": {
                        "title": "Include ratings without text",
                        "type": "boolean",
                        "description": "When enabled, include CVS ratings that have stars and dimensions but no title or written body.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
