# Warehouse & Grocery Review Intelligence Scraper (`thescrapelab/warehouse-grocery-review-intelligence-scraper`) Actor

Scrape product reviews, ratings, prices, metadata, and AI buyer-warning insights from warehouse, grocery, pet, health, beauty, and retail ecommerce sites.

- **URL**: https://apify.com/thescrapelab/warehouse-grocery-review-intelligence-scraper.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Categories:** E-commerce, Business, Marketing
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

<p align="center">
  <img src="assets/logo.png" alt="Warehouse & Grocery Review Intelligence Scraper logo" width="180">
</p>

## Warehouse & Grocery Review Intelligence Scraper

Scrape product reviews, ratings, prices, and product metadata from major warehouse, grocery, pet, health, beauty, and retail ecommerce sites, then turn customer feedback into complaint, praise, buyer-warning, and brand-opportunity insights.

Use this Apify Actor as a multi-retailer review scraper and product search tool for Costco, Kroger, Sam's Club, BJ's Wholesale Club, Target, Chewy, iHerb, Sephora, and Ulta. It is built for brands, ecommerce sellers, agencies, private-label researchers, market researchers, and retail analysts who need normalized product review data without maintaining separate scrapers for every retailer.

### What You Can Do With It

- Monitor product complaints across major retailers.
- Search for matching product pages from product names or keywords.
- Compare customer sentiment for competing products.
- Find recurring quality, packaging, delivery, freshness, value, and durability issues.
- Extract product ratings, review counts, prices, images, SKUs, brands, categories, and availability where public.
- Build buyer-warning lists from negative reviews.
- Discover brand opportunities from praise and complaints.
- Analyze beauty, pet, wellness, grocery, household, and warehouse-club reviews with optional AI.
- Export clean review rows, review signals, product summaries, errors, and run summaries from the Apify Dataset.

### Supported Retailers

This Actor supports direct product URLs from:

- Costco review scraping
- Kroger review scraping
- Sam's Club review scraping
- BJ's Wholesale Club review scraping
- Target review scraping
- Chewy review scraping
- iHerb review scraping
- Sephora review scraping
- Ulta Beauty review scraping

Planned future sources include Home Depot, Lowe's, Walmart, Best Buy, Petco, PetSmart, CVS, Walgreens, GNC, and Vitamin Shoppe.

### Input

Paste direct product URLs into **Product URLs**, enter keywords in **Search terms**, or use both. Search terms discover matching public product pages first, then the Actor scrapes reviews from the discovered product URLs.

```json
{
  "productUrls": [
    "https://www.target.com/p/tide-original-he-turbo-clean-liquid-laundry-detergent/-/A-89685864",
    "https://www.chewy.com/instinct-raw-boost-puppy-whole-grain/dp/245971",
    "https://www.iherb.com/pr/california-gold-nutrition-gold-c-usp-grade-vitamin-c-1-000-mg-60-veggie-capsules/61864",
    "https://www.sephora.com/product/natural-radiant-longwear-foundation-P427301",
    "https://www.ulta.com/p/lash-princess-false-lash-effect-mascara-xlsImpprod12741009"
  ],
  "searchTerms": [
    "protein powder",
    "mascara"
  ],
  "maxReviewsPerProduct": 100,
  "outputMode": "raw_reviews_and_summary",
  "includeOpenRouterAnalysis": false
}
````

Visible inputs:

- `productUrls`: direct product page URLs to scrape.
- `searchTerms`: product names or keywords to search for across supported retailers.
- `maxReviewsPerProduct`: review cap per product.
- `outputMode`: choose raw reviews, summaries, review signals, or raw reviews plus summaries.
- `includeOpenRouterAnalysis`: enable optional AI-powered review intelligence.

Everything else is handled automatically with safe defaults.

### Quick-Start Examples

Use these examples as small, affordable first runs before scaling to larger product lists.

#### Fast Ulta Review Intelligence Test

This is the best first run. It uses one direct product URL, avoids search discovery, keeps AI disabled, and usually returns product, review, summary, and status rows quickly.

```json
{
  "productUrls": [
    "https://www.ulta.com/p/lash-princess-false-lash-effect-mascara-xlsImpprod12741009"
  ],
  "searchTerms": [],
  "maxReviewsPerProduct": 10,
  "outputMode": "raw_reviews_and_summary",
  "includeOpenRouterAnalysis": false
}
```

#### Beauty Complaint And Buyer-Warning Summary

Use this when you want review intelligence signals, complaint categories, buyer warnings, and brand opportunities without exposing every raw review row.

```json
{
  "productUrls": [
    "https://www.ulta.com/p/lash-princess-false-lash-effect-mascara-xlsImpprod12741009"
  ],
  "searchTerms": [],
  "maxReviewsPerProduct": 25,
  "outputMode": "review_signals_and_summary",
  "includeOpenRouterAnalysis": false
}
```

#### Supplement Review Summary

Use this for health and wellness review themes such as taste, capsule size, value, packaging, and reviewer-reported concerns.

```json
{
  "productUrls": [
    "https://www.iherb.com/pr/california-gold-nutrition-gold-c-usp-grade-vitamin-c-1-000-mg-60-veggie-capsules/61864"
  ],
  "searchTerms": [],
  "maxReviewsPerProduct": 25,
  "outputMode": "raw_reviews_and_summary",
  "includeOpenRouterAnalysis": false
}
```

#### Product Search Discovery

Use search terms when you do not already know product URLs. Search discovery can vary by retailer, so direct product URLs are still the most predictable input for production runs.

```json
{
  "productUrls": [],
  "searchTerms": [
    "mascara"
  ],
  "maxReviewsPerProduct": 10,
  "outputMode": "summary_only",
  "includeOpenRouterAnalysis": false
}
```

### Output

The Actor writes results to the default Apify Dataset. Output can include product rows, review rows, review signal rows, product review summaries, search discovery status rows, source status rows, error rows, and a run summary.

#### Review Row

```json
{
  "itemType": "review",
  "source": "ulta",
  "productTitle": "Lash Princess False Lash Effect Mascara - Black",
  "brand": "essence",
  "productId": "xlsImpprod12741009",
  "reviewId": "ulta_582848920",
  "reviewHash": "sha256...",
  "reviewRating": 5,
  "reviewTitle": "Great mascara",
  "reviewText": "Review text is included for raw review outputs.",
  "reviewDate": "2026-06-24T16:20:39.989Z",
  "reviewerName": "Reviewer",
  "verifiedPurchase": false,
  "helpfulVotes": 0,
  "wouldRecommend": true,
  "reviewProvider": "powerreviews",
  "scrapedAt": "2026-07-02T21:35:24.000Z"
}
```

#### Product Review Summary

```json
{
  "itemType": "product_review_summary",
  "source": "iherb",
  "productTitle": "California Gold Nutrition, Gold C, USP Grade Vitamin C",
  "brand": "California Gold Nutrition",
  "reviewsScraped": 100,
  "reviewsAnalyzed": 100,
  "reviewsAnalyzedWithOpenRouter": 80,
  "reviewsAnalyzedWithFallback": 20,
  "sentimentBreakdown": {
    "positive": 82,
    "neutral": 10,
    "negative": 8,
    "mixed": 0,
    "unknown": 0
  },
  "topComplaints": [
    {
      "topic": "capsule size",
      "count": 6,
      "severity": "medium",
      "summary": "Some reviewers mention capsule size or swallowing difficulty."
    }
  ],
  "topBuyerWarnings": [
    "Some review themes mention capsule size or reviewer-reported digestive discomfort."
  ],
  "executiveSummary": "Reviews are mostly positive, with recurring reviewer-reported themes around value and capsule usability.",
  "generatedAt": "2026-07-02T21:35:24.000Z"
}
```

#### Error Row

```json
{
  "itemType": "error",
  "source": "costco",
  "productUrl": "https://www.costco.com/.product.1491084.html",
  "errorType": "BLOCKED",
  "message": "Product page request was blocked after retries.",
  "details": "Request blocked - received 403 status code.",
  "detectedAt": "2026-07-02T21:35:24.000Z"
}
```

### Extracted Product Data

Product metadata can include:

- retailer source
- product URL and canonical URL
- product ID, SKU, item number, TCIN, DPCI, UPC, or GTIN where visible
- product title and brand
- product description
- category path and breadcrumbs
- price and currency
- availability
- average rating and review count
- image URLs
- variants such as size, flavor, color, shade, weight, or pack size
- autoship fields for pet products where visible
- supplement, ingredient, beauty, skin, hair, and pet attributes where visible
- scrape timestamp

### Extracted Review Data

Review rows can include:

- retailer source
- product context
- native or generated review ID
- stable review hash for deduplication within the run
- rating, title, and review text
- review date
- public reviewer display name
- verified purchase flag where visible
- incentivized review flag where visible
- helpful and not-helpful votes
- review images as URLs
- variant, shade, size, flavor, pet, skin, hair, and beauty attributes where visible
- review provider where visible
- scrape timestamp

### Review Intelligence

The Actor can produce review signal rows and product-level summaries for:

- sentiment
- complaint topic
- issue type
- priority
- buyer warning
- brand opportunity
- top complaints
- top praise
- recurring quality issues
- packaging issues
- delivery issues
- freshness issues
- pricing and value objections
- repeat-purchase signals
- executive summary

Retail-specific intelligence includes:

- grocery and warehouse: quality, packaging, freshness, value, bulk buying, delivery, and buyer-warning themes
- pet products: pet refusal, taste acceptance, digestive complaints, allergy or sensitivity mentions, autoship complaints, durability, and sizing
- health and wellness: taste, smell, texture, ingredient concerns, dosage confusion, expiration issues, and reviewer-reported side-effect mentions
- beauty and haircare: shade match, oxidation, texture, scent, irritation mentions, breakout mentions, wear time, transfer, pilling, hair dryness, frizz, applicator issues, and hype mismatch

Health, skin, hair, pet, and wellness summaries are reviewer-reported themes only. They are not medical, dermatological, or veterinary advice.

### Output Modes

- `raw_reviews`: product metadata and review rows.
- `summary_only`: product-level summaries only, plus status or error rows when needed.
- `review_signals_and_summary`: review signal rows plus product summaries.
- `raw_reviews_and_summary`: product metadata, raw reviews, source status, and product summaries.

### Optional OpenRouter AI Analysis

OpenRouter is optional. When AI analysis is disabled, the Actor does not call OpenRouter and uses local fallback classification.

To enable AI review analysis:

1. Make sure the Actor has an `OPENROUTER_API_KEY` secret configured.
2. Set `includeOpenRouterAnalysis` to `true`.

Cost control behavior:

- The default AI model is `openai/gpt-4o-mini`.
- The default AI analysis cap is `500` reviews per run.
- Extra reviews use local fallback classification after the cap is reached.
- Invalid or failed OpenRouter responses fall back to local classification.
- The Actor never logs the OpenRouter API key.
- OpenRouter results are not stored between runs.

### Recommended Run Sizes

| Run size | Product URLs | Reviews per product | Suggested output |
| --- | ---: | ---: | --- |
| First test | 1-5 | 10-25 | Raw reviews and summary |
| Small run | 10-50 | 50-100 | Raw reviews and summary |
| Medium run | 50-150 | 100-200 | Summary only or raw reviews and summary |
| High-volume run | 150+ | 200-500 | Summary only |
| AI analysis run | Any | 30-100 | Review signals and summary |
| Search-heavy run | 5+ search terms | 10-50 | Summary only or raw reviews and summary |

To keep costs low:

- Test with 1-5 product URLs first.
- Use search terms to discover products, but expect search-heavy runs to cost more than direct URL runs.
- Use `summary_only` when you only need product-level insights.
- Keep `maxReviewsPerProduct` bounded.
- Keep OpenRouter disabled until review extraction quality is confirmed.
- Let the Actor use its default speed, delay, and networking settings.

Recommended Apify memory:

- 2048 MB default for mixed, search, and raw-review runs.
- 1024 MB can work for small direct-URL runs.
- 4096 MB is reserved for unusually large runs or sources that require heavier fallback behavior.

### Source Reliability Notes

Retailer blocking and public review availability can vary by region, network, product, and time. The Actor is designed to fail gracefully by returning status or error rows instead of crashing the whole run.

In production testing on July 2-3, 2026:

- Ulta and iHerb extracted public reviews reliably in Apify cloud smoke and OpenRouter stress tests.
- Target extracted public review text in selected cloud tests.
- Target, BJ's, and Chewy sometimes returned metadata or source status rows without review text from Apify cloud.
- Costco, Kroger, Sam's Club, Sephora, and Chewy showed blocking or rate limiting in some local or Apify cloud runs.

Use smaller batches for high-volume runs. Treat high-blocking sources as best-effort because public review availability can vary by retailer and run environment.

### Limitations

- Direct product URLs only.
- Product search from keywords is included. Category crawling is not included.
- Search discovery depends on public retailer search pages and may return partial results when a retailer blocks or changes search pages.
- Review availability depends on the product and retailer.
- Some products show ratings but no accessible public review text.
- Price, availability, shipping, currency, autoship, membership, club, selected store, and fulfillment fields may vary by location, account state, region, or delivery destination.
- Public pages can change, and source reliability can vary over time.
- Network reachability can vary by source and run environment.
- The Actor does not use login sessions.
- The Actor does not bypass CAPTCHAs, human verification, paywalls, or access controls.
- The Actor does not use paid third-party scraping APIs.
- OpenRouter is optional and requires an Actor-level OpenRouter secret to be configured.
- Health, skin, hair, pet, and wellness insights are reviewer-reported themes only, not medical or veterinary advice.

### Compliance

This Actor scrapes only public product pages and public frontend data. It does not log in, use customer accounts, bypass access controls, store previous-run review history, or create named persistent storage. It is not an official integration with Costco, Kroger, Sam's Club, BJ's Wholesale Club, Target, Chewy, iHerb, Sephora, Ulta, or any other retailer.

### How To Run

1. Open the Actor in Apify Console.
2. Paste direct product URLs, enter search terms, or use both.
3. Set **Reviews per product**.
4. Choose a **Result type**.
5. Keep AI analysis off for the first scraping test.
6. Start the run.
7. Open the Dataset tab to download JSON, CSV, Excel, or connect through the API.

### Python API Example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

actor_client = client.actor("thescrapelab/warehouse-grocery-review-intelligence-scraper")

run_input = {
    "productUrls": [
        "https://www.ulta.com/p/lash-princess-false-lash-effect-mascara-xlsImpprod12741009",
        "https://www.iherb.com/pr/california-gold-nutrition-gold-c-usp-grade-vitamin-c-1-000-mg-60-veggie-capsules/61864"
    ],
    "searchTerms": [
        "protein powder"
    ],
    "maxReviewsPerProduct": 25,
    "outputMode": "review_signals_and_summary",
    "includeOpenRouterAnalysis": False
}

run = actor_client.call(run_input=run_input)

dataset_client = client.dataset(run["defaultDatasetId"])

for item in dataset_client.iterate_items():
    print(item)
```

### Troubleshooting

- `BLOCKED` or `RATE_LIMITED`: reduce review caps, try fewer URLs, and retry later.
- `REVIEWS_NOT_FOUND`: the product may expose ratings but not public review text in the current run environment.
- Partial product metadata: price and availability may depend on store, club, location, membership, or fulfillment context.
- OpenRouter did not run: check that AI analysis is enabled and the Actor-level OpenRouter secret is configured.
- OpenRouter costs too high: keep AI disabled for large runs or use fewer reviews per product.
- Large runs are slow: split the input into smaller batches.

### FAQ

**Is this a Costco review scraper?**\
Yes, and more. It supports Costco plus Kroger, Sam's Club, BJ's Wholesale Club, Target, Chewy, iHerb, Sephora, and Ulta in one normalized review intelligence Actor.

**Does it require retailer accounts?**\
No. The Actor does not use login sessions or customer accounts.

**Does it store review history?**\
No. It is stateless and writes current-run output to the default Apify Dataset.

**Can it crawl search results or category pages?**\
It supports product search from keywords and direct product URLs. Category crawling is not included.

**Can it extract every review from every product?**\
Not always. Review availability depends on each retailer, product, network environment, and public frontend behavior.

**Should I enable OpenRouter for every run?**\
No. First confirm scraping output, then enable AI with a conservative review limit.

**Can I use it for competitive intelligence?**\
Yes. Common use cases include complaint tracking, product comparison, brand monitoring, private-label research, review mining, and buyer-warning analysis.

# Actor input Schema

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

Optional. Paste direct product URLs, one per line. Supported: Costco, Kroger, Sam's Club, BJ's, Target, Chewy, iHerb, Sephora, and Ulta.

## `searchTerms` (type: `array`):

Optional. Enter product names or keywords. The Actor finds matching public product pages, then scrapes reviews.

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

Maximum reviews to collect for each product. Start with 25-100 for testing.

## `outputMode` (type: `string`):

Choose whether you want reviews, summaries, or both.

## `includeOpenRouterAnalysis` (type: `boolean`):

Optional. Classifies complaints, praise, buyer warnings, and brand opportunities when AI is configured.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.ulta.com/p/lash-princess-false-lash-effect-mascara-xlsImpprod12741009"
  ],
  "searchTerms": [],
  "maxReviewsPerProduct": 10,
  "outputMode": "raw_reviews_and_summary",
  "includeOpenRouterAnalysis": false
}
```

# Actor output Schema

## `results` (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 = {
    "productUrls": [
        "https://www.ulta.com/p/lash-princess-false-lash-effect-mascara-xlsImpprod12741009"
    ],
    "searchTerms": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("thescrapelab/warehouse-grocery-review-intelligence-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": ["https://www.ulta.com/p/lash-princess-false-lash-effect-mascara-xlsImpprod12741009"],
    "searchTerms": [],
}

# Run the Actor and wait for it to finish
run = client.actor("thescrapelab/warehouse-grocery-review-intelligence-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": [
    "https://www.ulta.com/p/lash-princess-false-lash-effect-mascara-xlsImpprod12741009"
  ],
  "searchTerms": []
}' |
apify call thescrapelab/warehouse-grocery-review-intelligence-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Warehouse & Grocery Review Intelligence Scraper",
        "description": "Scrape product reviews, ratings, prices, metadata, and AI buyer-warning insights from warehouse, grocery, pet, health, beauty, and retail ecommerce sites.",
        "version": "0.1",
        "x-build-id": "4o3nsoR693VF33URj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thescrapelab~warehouse-grocery-review-intelligence-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thescrapelab-warehouse-grocery-review-intelligence-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/thescrapelab~warehouse-grocery-review-intelligence-scraper/runs": {
            "post": {
                "operationId": "runs-sync-thescrapelab-warehouse-grocery-review-intelligence-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/thescrapelab~warehouse-grocery-review-intelligence-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-thescrapelab-warehouse-grocery-review-intelligence-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": {
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Optional. Paste direct product URLs, one per line. Supported: Costco, Kroger, Sam's Club, BJ's, Target, Chewy, iHerb, Sephora, and Ulta.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Optional. Enter product names or keywords. The Actor finds matching public product pages, then scrapes reviews.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "Reviews per product",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum reviews to collect for each product. Start with 25-100 for testing.",
                        "default": 10
                    },
                    "outputMode": {
                        "title": "Result type",
                        "enum": [
                            "raw_reviews",
                            "summary_only",
                            "review_signals_and_summary",
                            "raw_reviews_and_summary"
                        ],
                        "type": "string",
                        "description": "Choose whether you want reviews, summaries, or both.",
                        "default": "raw_reviews_and_summary"
                    },
                    "includeOpenRouterAnalysis": {
                        "title": "Use AI review analysis",
                        "type": "boolean",
                        "description": "Optional. Classifies complaints, praise, buyer warnings, and brand opportunities when AI is configured.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
