# Lowe's Product Reviews Scraper (`automation-lab/lowes-product-reviews-scraper`) Actor

Track public Lowe's customer feedback with paginated reviews, rating totals, recommendation and purchase signals, responses, helpful votes, and media.

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

## Lowe's Product Reviews Scraper

Export **public Lowe's customer reviews** from product URLs or product IDs.
Get review text, star ratings, authors, dates, verified-purchase signals,
recommendations, helpfulness, customer media, merchant responses, and product rating totals.
No Lowe's login or private API key is required.

Use the results in JSON, CSV, Excel, XML, RSS, or HTML,
or connect the Actor to a scheduled review-monitoring workflow through the Apify API.

### What does Lowe's Product Reviews Scraper do?

Lowe's Product Reviews Scraper turns Lowe's product review feeds into one clean dataset row per review.
Add a product URL such as `https://www.lowes.com/pd/BLACK-DECKER-12-Volt-Lithium-Ion-3-8-in-Cordless-Drill-with-Battery/3285414`,
or provide its numeric product ID directly.
The Actor follows Lowe's public paginated review data rather than stopping at the few reviews visible in initial page state.

For each review, it can extract:

- ⭐ Review rating, title, text, and submission date
- 👤 Public reviewer nickname and submission timestamp
- ✅ Verified-purchase, recommended, incentivized, syndicated, and ratings-only signals
- 👍 Helpful and not-helpful vote counts
- 📷 Public customer photo and video URLs when exposed
- 💬 Merchant or brand responses attached to a review
- 🧮 Aggregate average, total review count, and 1–5 star distribution
- 🛍️ Product ID, title, brand, and source URL when available

The primary route is HTTP-based and runs with 256 MB of memory,
keeping scheduled review exports lighter than a browser-only workflow.

### Who is it for?

**Ecommerce brands and marketplace sellers**

- Monitor feedback on owned products sold at Lowe's.
- Detect recurring quality, fit, packaging, or value complaints.
- Compare launch sentiment before and after merchandising changes.

**Consumer-insights and research teams**

- Export review text for sentiment, topic, and language analysis.
- Compare rating distributions across competing product cohorts.
- Study verified-purchase feedback separately from other reviews.

**Product and quality teams**

- Route one-star reviews into issue-tracking or alert workflows.
- Track secondary ratings such as comfort, quality, or value.
- Build evidence for product iteration and supplier discussions.

**Data engineers and agencies**

- Schedule repeatable review collection through Apify.
- Deliver typed JSON or CSV to warehouses and dashboards.
- Trigger webhooks whenever a monitoring run finishes.

### Why use this Lowe's reviews extractor?

- **Full pagination:** collect beyond the small initial set embedded in a product page.
- **No login:** use only anonymous public Lowe's product-review surfaces.
- **Flexible product input:** mix normal Lowe's product URLs and numeric product IDs.
- **Useful filters:** select star ratings, date cutoffs, rating-only records, and sort order.
- **Monitoring-ready:** every row includes stable review and product identifiers plus timestamps.
- **Response-aware:** merchant replies and syndicated review sources remain attached to each row.
- **Resilient HTTP:** anonymous public HTTP requests use bounded retries and sequential pagination.
- **Apify-native:** schedule runs, export datasets, call an API, and connect integrations without managing servers.

### What Lowe's review data can you extract?

| Category | Fields |
|---|---|
| Product | `productId`, `productTitle`, `productBrand`, `productUrl` |
| Review identity | `reviewId`, `source`, `syndicated` |
| Review content | `reviewTitle`, `reviewText`, `rating`, `submittedAt` |
| Reviewer | `author` |
| Trust signals | `verifiedPurchaser`, `isRecommended`, `incentivizedReview`, `ratingsOnly` |
| Engagement | `helpfulVotes`, `notHelpfulVotes` |
| Responses and media | `merchantResponses`, `photoUrls`, `videoUrls` |
| Product totals | `aggregateRating`, `totalReviewCount`, `ratingDistribution` |
| Monitoring | `locale`, `scrapedAt` |

Fields that Lowe's does not expose for a particular product or review are omitted.
Boolean and count fields remain typed for filtering and downstream analysis.

### How much does it cost to scrape Lowe's product reviews?

This Actor uses **pay-per-event pricing**.
A run has a $0.005 start charge, then charges per review saved.
Platform compute and proxy use are included.

| Apify plan | Price per review | 1,000 reviews plus start |
|---|---:|---:|
| Free | $0.000098664 | about $0.10 |
| Starter / Bronze | $0.000085795 | about $0.09 |
| Scale / Silver | $0.000066920 | about $0.07 |
| Business / Gold | $0.000051477 | about $0.06 |
| Platinum | $0.000034318 | about $0.04 |
| Diamond | $0.000024022 | about $0.03 |

A small 10-review test costs about $0.01 on the Free tier.
Apify's free platform credit can cover many small validation runs before you scale.
Always start with one product and a low review limit.

### How to scrape Lowe's product reviews

1. Open Lowe's Product Reviews Scraper in the Apify Store.
2. Paste one or more Lowe's product URLs, or enter numeric product IDs.
3. Set **Maximum reviews per product** to a small value for the first run.
4. Optionally choose star ratings, a date cutoff, rating-only handling, or sort order.
5. Click **Start** and wait for the run to finish.
6. Open the dataset and export JSON, CSV, Excel, XML, RSS, or HTML.
7. Save the task and add a schedule if you want recurring monitoring.

A minimal input:

```json
{
  "productUrls": ["https://www.lowes.com/pd/BLACK-DECKER-12-Volt-Lithium-Ion-3-8-in-Cordless-Drill-with-Battery/3285414"],
  "maxReviewsPerProduct": 10,
  "sort": "newestFirst"
}
````

A written-review export by product ID:

```json
{
  "productIds": ["3285414"],
  "maxReviewsPerProduct": 100,
  "includeRatingsOnly": false,
  "sort": "newestFirst"
}
```

A low-rating monitor:

```json
{
  "productUrls": [
    "https://www.lowes.com/pd/BLACK-DECKER-12-Volt-Lithium-Ion-3-8-in-Cordless-Drill-with-Battery/3285414",
    "https://www.lowes.com/pd/-/5013606417"
  ],
  "maxReviewsPerProduct": 50,
  "ratings": ["1"],
  "sort": "newestFirst"
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---:|---|
| `productUrls` | string\[] | prefilled sample | Lowe's product URLs containing a product ID |
| `productIds` | string\[] | empty | Numeric Lowe's product IDs |
| `maxReviewsPerProduct` | integer | `20` | Maximum matching rows saved per unique product; range 1–500 |
| `sort` | string | `newestFirst` | Relevance, date, rating, helpfulness, or photo ordering |
| `ratings` | string\[] | empty | Keep only selected 1–5 star ratings; JSON/API inputs use strings such as `["1", "2"]` |
| `newerThan` | string | empty | Keep reviews on or after an ISO date, such as `2026-01-01` |
| `includeRatingsOnly` | boolean | `true` | Keep star-only records when exposed |

At least one valid product URL or product ID is needed to produce data.
Duplicates are processed once.

### Output example

```json
{
  "productId": "3285414",
  "productTitle": "BLACK & DECKER 12-volt Max 3/8-in Drill (Charger Included)",
  "productBrand": "BLACK & DECKER",
  "productUrl": "https://www.lowes.com/pd/BLACK-DECKER-12-Volt-Lithium-Ion-3-8-in-Cordless-Drill-with-Battery/3285414",
  "reviewId": "ab2e3c42-3ea7-512e-8ad4-fba0f6787cd1",
  "reviewTitle": null,
  "reviewText": null,
  "author": "Thunder_Dan71",
  "rating": 5,
  "submittedAt": "2026-01-09T19:09:29.000Z",
  "isRecommended": true,
  "verifiedPurchaser": false,
  "incentivizedReview": false,
  "syndicated": true,
  "ratingsOnly": true,
  "helpfulVotes": 0,
  "notHelpfulVotes": 0,
  "source": "blackanddecker.com",
  "merchantResponses": [],
  "photoUrls": [],
  "videoUrls": [],
  "aggregateRating": 4.2,
  "totalReviewCount": 64,
  "ratingDistribution": [{ "rating": 5, "count": 37 }],
  "scrapedAt": "2026-07-14T07:30:00.000Z"
}
```

The exact fields vary because reviewers may omit a nickname, title, text, recommendation,
secondary rating, or media.

### Sort and filter Lowe's reviews

Use `newestFirst` for launch monitoring and incremental feedback collection.
Use `helpfulness` when researching the feedback other shoppers found most useful.
Use `highestToLowest` or `lowestToHighest` to inspect product strengths and weaknesses.

Star, date, and rating-only filters are applied while paging through Lowe's public review feed.
This keeps output focused while preserving source ordering.
The Actor continues pagination until it saves the requested number of matching rows
or Lowe's reports the last available page.

### Tips for reliable review exports

- 🧪 Begin with 10 reviews from one known product.
- 🔢 Prefer product IDs when your catalog already stores Lowe's product IDs.
- 🕐 Schedule recent-review runs daily or weekly rather than repeatedly collecting full history.
- ⭐ Use a star filter for complaint or advocacy workflows.
- ✅ Set `includeRatingsOnly` to `false` when written feedback is required.
- 📷 Use `sort: "photoReviews"` for user-generated-content research.
- 📉 Split very large product cohorts into tasks for easier retries and monitoring.
- 🔗 Keep `reviewId` as the deduplication key in your destination system.

### Review monitoring workflow

For recurring monitoring, save an Actor task with `sort: "newestFirst"`.
Add a daily or weekly schedule,
then send finished dataset items to your warehouse or automation platform.
Deduplicate on `reviewId` and compare `submittedAt` with your last successful collection window.

For complaint alerts, use `ratings: ["1", "2"]`.
A downstream automation can send product title, review text, verification status,
and canonical Lowe's URL to Slack or an issue tracker.

### Integrations

**Lowe's reviews → Google Sheets**

Export a product cohort into a worksheet for category managers and research teams.
Use `reviewId` as a stable key and refresh the sheet on a schedule.

**Lowe's reviews → Slack or Discord**

Run a one-star monitor and post newly observed complaints with product context.

**Lowe's reviews → Make or Zapier**

Trigger a sentiment-analysis step after each run,
then route negative topics to product or supplier owners.

**Lowe's reviews → data warehouse**

Use a webhook after successful runs,
fetch dataset items through the API,
and load typed review rows into BigQuery, Snowflake, or PostgreSQL.

### API usage

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/lowes-product-reviews-scraper').call({
    productIds: ['3285414'],
    maxReviewsPerProduct: 25,
    sort: 'newestFirst',
});

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

### Using the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/lowes-product-reviews-scraper').call(run_input={
    'productUrls': ['https://www.lowes.com/pd/BLACK-DECKER-12-Volt-Lithium-Ion-3-8-in-Cordless-Drill-with-Battery/3285414'],
    'maxReviewsPerProduct': 25,
    'includeRatingsOnly': True,
})

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

### Using the Apify API with cURL

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

After the run succeeds, use its `defaultDatasetId` to download items from the dataset API.

### Use Lowe's reviews with AI agents via MCP

Lowe's Product Reviews Scraper can be called by AI assistants through
[Apify's Model Context Protocol integration](https://docs.apify.com/platform/integrations/mcp).

For Claude Code:

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

For Claude Desktop, Cursor, or VS Code, add:

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

Example prompts:

- "Use `automation-lab/lowes-product-reviews-scraper` to export the 50 newest reviews for Lowe's product ID 3285414."
- "Collect verified one-star reviews from these Lowe's product URLs and summarize recurring quality complaints."
- "Monitor this Lowe's product cohort weekly and prepare a table of new reviews, recommendation status, and helpful votes."

Your MCP client authenticates with Apify and receives normal Actor run and dataset links.

### Legality

This Actor extracts information publicly visible without a Lowe's login.
Public availability does not remove every legal or contractual obligation.
Use the data for legitimate purposes,
respect Lowe's terms and applicable rate limits,
and avoid collecting more personal data than your workflow needs.

Review text may be user-generated content.
Do not republish it in a misleading way,
profile reviewers,
or use public reviewer identifiers for unsolicited contact.
If your organization handles personal data,
apply relevant privacy, retention, and data-subject procedures such as GDPR or CCPA requirements.
Seek legal advice for your specific use case.

### Limitations

- Lowe's can change its product page or public review service without notice.
- Some reviews do not contain a title, text, nickname, recommendation, or secondary scores.
- Product context enrichment can be absent while complete review rows still succeed.
- Ratings-only records may not include written feedback.
- Lowe's may syndicate reviews from another source; inspect `isSyndicated` when provenance matters.
- Deleted, moderated, or newly submitted reviews can change totals between runs.
- The Actor accepts product URLs and product IDs, not Lowe's search queries. Use Lowe's Product Scraper to discover products first.

### Troubleshooting

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

Check that the URL ends in a numeric Lowe's product ID or provide the product ID directly.
The chosen star, date, or rating-only filter may also have no matching reviews.
Test the same product without filters and with a limit of 10.

**Why is `productTitle` missing?**

Lowe's product-page context request can occasionally be blocked while the review endpoint remains available.
The row still includes the product ID and stable Lowe's URL,
and review extraction continues by design.

**Why are there fewer rows than `maxReviewsPerProduct`?**

The limit is a maximum, not a promise.
Lowe's may expose fewer matching public records after filters,
or the review feed may reach its last page.

### FAQ

**Does the Actor require a Lowe's account or API key?**

No. It uses anonymous public Lowe's product and review surfaces.

**How fast is it?**

Small one-product exports usually finish quickly because the primary route is direct HTTP.
Runtime grows with products, pages, filters, and temporary retry needs.

**Can it retrieve all historical reviews?**

Set `maxReviewsPerProduct` up to 500.
The Actor paginates until that maximum or Lowe's last available matching page.

**How are duplicate reviews handled?**

The Actor deduplicates on Lowe's public review ID across every input in the same run.
Deduplicate again on `reviewId` when combining scheduled runs.

**Is this the same as Lowe's Product Scraper?**

No. Lowe's Product Scraper discovers products and returns search-result product details and aggregate counts.
This Actor returns the individual customer-review records for known products.

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

Yes. Open the run dataset and select CSV or Excel,
or request the format through the Apify dataset API.

### Related actors

- [Lowe's Product Scraper](https://apify.com/automation-lab/lowes-product-scraper) — discover Lowe's products, prices, images, ratings, and counts.
- [Walmart Reviews Scraper](https://apify.com/automation-lab/walmart-reviews-scraper) — collect individual Walmart customer reviews.
- [Walmart Scraper](https://apify.com/automation-lab/walmart-scraper) — discover Walmart product records.
- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper) — export Amazon product feedback.
- [Best Buy Reviews Scraper](https://apify.com/automation-lab/best-buy-reviews-scraper) — collect electronics retailer reviews.
- [Ulta Product Reviews Scraper](https://apify.com/automation-lab/ulta-product-reviews-scraper) — analyze beauty-product feedback.
- [Google Maps Reviews Scraper](https://apify.com/automation-lab/google-maps-reviews-scraper) — export location and business reviews.

Combine Lowe's Product Scraper for product discovery with Lowe's Product Reviews Scraper for review depth.

# Actor input Schema

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

Full Lowe's product page URLs. The numeric product ID is read from each URL.

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

Numeric Lowe's product IDs, such as 3285414.

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

Stop after saving this many matching reviews for each product.

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

Controls the order in which Lowe's reviews are collected.

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

Optional list of ratings to keep. Leave empty to include 1–5 stars.

## `newerThan` (type: `string`):

Optional ISO date, for example 2026-01-01. Useful for recurring review monitoring.

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

Keep reviews that have a star rating but no written title or text.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.lowes.com/pd/BLACK-DECKER-12-Volt-Lithium-Ion-3-8-in-Cordless-Drill-with-Battery/3285414"
  ],
  "productIds": [],
  "maxReviewsPerProduct": 20,
  "sort": "newestFirst",
  "ratings": [],
  "newerThan": "",
  "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 = {
    "productUrls": [
        "https://www.lowes.com/pd/BLACK-DECKER-12-Volt-Lithium-Ion-3-8-in-Cordless-Drill-with-Battery/3285414"
    ],
    "maxReviewsPerProduct": 20,
    "sort": "newestFirst"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/lowes-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": ["https://www.lowes.com/pd/BLACK-DECKER-12-Volt-Lithium-Ion-3-8-in-Cordless-Drill-with-Battery/3285414"],
    "maxReviewsPerProduct": 20,
    "sort": "newestFirst",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/lowes-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": [
    "https://www.lowes.com/pd/BLACK-DECKER-12-Volt-Lithium-Ion-3-8-in-Cordless-Drill-with-Battery/3285414"
  ],
  "maxReviewsPerProduct": 20,
  "sort": "newestFirst"
}' |
apify call automation-lab/lowes-product-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lowe's Product Reviews Scraper",
        "description": "Track public Lowe's customer feedback with paginated reviews, rating totals, recommendation and purchase signals, responses, helpful votes, and media.",
        "version": "0.1",
        "x-build-id": "XbSFp8DZ03StjKH5V"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~lowes-product-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-lowes-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~lowes-product-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-lowes-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~lowes-product-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-lowes-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": {
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Full Lowe's product page URLs. The numeric product ID is read from each URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productIds": {
                        "title": "Product IDs",
                        "type": "array",
                        "description": "Numeric Lowe's product IDs, such as 3285414.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxReviewsPerProduct": {
                        "title": "Maximum reviews per product",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Stop after saving this many matching reviews for each product.",
                        "default": 20
                    },
                    "sort": {
                        "title": "Sort reviews",
                        "enum": [
                            "relevancy",
                            "newestFirst",
                            "oldestFirst",
                            "highestToLowest",
                            "lowestToHighest",
                            "helpfulness",
                            "photoReviews"
                        ],
                        "type": "string",
                        "description": "Controls the order in which Lowe's reviews are collected.",
                        "default": "newestFirst"
                    },
                    "ratings": {
                        "title": "Star ratings",
                        "type": "array",
                        "description": "Optional list of ratings to keep. Leave empty to include 1–5 stars.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "newerThan": {
                        "title": "Only reviews on or after",
                        "type": "string",
                        "description": "Optional ISO date, for example 2026-01-01. Useful for recurring review monitoring.",
                        "default": ""
                    },
                    "includeRatingsOnly": {
                        "title": "Include rating-only reviews",
                        "type": "boolean",
                        "description": "Keep reviews that have a star rating but no written title or text.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```