# Walmart Reviews Scraper (`automation-lab/walmart-reviews-scraper`) Actor

Extract Walmart product reviews — ratings, review text, verified purchase status, helpfulness votes. Enter product URLs or item IDs. Export to JSON, CSV, or Excel. No API key required.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## Walmart Reviews Scraper

Extract Walmart product reviews at scale — ratings, review text, verified purchase status, helpfulness votes, reviewer details, and media. Provide product URLs or item IDs and get structured review data exported to JSON, CSV, or Excel. No API key or login required.

### 🛒 What does Walmart Reviews Scraper do?

**Walmart Reviews Scraper** pulls customer reviews from any Walmart product page using Walmart's own review data infrastructure. Enter one or more product URLs or item IDs and the scraper returns all available review fields: star rating, reviewer name, review title and full text, submission date, verified purchase badge, helpfulness votes, reviewer location, and attached photos.

The scraper accesses Walmart's server-rendered review pages, giving you the same data users see when browsing — no unofficial hacks, no API key needed. Sort reviews by relevance, helpfulness, date, or rating. Filter by specific star counts to target only 1-star complaints or 5-star praise.

### 👥 Who is Walmart Reviews Scraper for?

**E-commerce businesses and brand managers**
- Track your own product sentiment on Walmart continuously
- Monitor competitor product reviews to identify weaknesses and opportunities
- Detect sudden review spikes or drops that indicate quality issues

**Market researchers and analysts**
- Build large-scale datasets of consumer opinions for NLP/LLM training
- Analyze sentiment trends across product categories
- Compare customer satisfaction across Walmart's marketplace sellers

**Product developers and UX teams**
- Gather voice-of-customer data to inform roadmap decisions
- Extract feature requests and pain points from 1-star reviews
- Identify recurring complaints before they affect sales rank

**Agencies and consultants**
- Deliver competitive analysis reports for retail clients
- Support SEO content strategies with real review language
- Automate reputation monitoring workflows for brands selling on Walmart

### ✅ Why use Walmart Reviews Scraper?

- 🔓 **No API key or login required** — works with public Walmart review data
- 📦 **Rich review data** — 18+ fields per review including media URLs and user badges
- 🔢 **Pagination support** — scrape hundreds or thousands of reviews per product
- ⭐ **Star filter** — isolate 1-star complaints or 5-star endorsements instantly
- 🔄 **Sort options** — most relevant, most helpful, most recent, highest/lowest rated
- 🗃️ **Flexible export** — JSON, CSV, Excel, XML via Apify platform
- 📅 **Scheduled runs** — monitor review sentiment on a schedule
- 🔗 **Works with Walmart Scraper** — combine with our product listing actor for end-to-end research

### 📊 What data can you extract?

| Field | Description |
|-------|-------------|
| `itemId` | Walmart item ID |
| `productName` | Full product name |
| `productUrl` | Direct link to product page |
| `reviewId` | Unique review identifier |
| `title` | Review headline |
| `reviewText` | Full review body text |
| `rating` | Star rating (1–5) |
| `date` | Submission date (ISO format) |
| `reviewerName` | Display name of reviewer |
| `isVerifiedPurchase` | Whether purchase was verified |
| `helpfulVotes` | Positive helpfulness votes |
| `negativeFeedback` | Negative helpfulness votes |
| `totalVotes` | Total votes on the review |
| `badges` | User badges (e.g., "Verified Purchase", "Top Reviewer") |
| `userLocation` | Reviewer's self-reported location |
| `recommended` | Whether reviewer recommends the product |
| `syndicationSource` | If review was syndicated from another platform |
| `mediaUrls` | URLs to photos attached to the review |
| `scrapedAt` | ISO timestamp of when the review was scraped |

### 💰 How much does it cost to scrape Walmart reviews?

Walmart Reviews Scraper uses **pay-per-event (PPE) pricing** — you only pay for what you extract.

| Event | Cost |
|-------|------|
| Run start | $0.005 |
| Per review scraped | $0.003 |

**Real-world cost examples:**

| Use case | Reviews | Cost |
|----------|---------|------|
| Quick product snapshot | 20 | ~$0.07 |
| Standard product audit | 100 | ~$0.31 |
| Deep review analysis | 500 | ~$1.51 |
| Full review dataset | 1,000 | ~$3.01 |

**Free plan estimate:** Apify's free plan includes $5 in monthly credits. That's roughly 1,600 reviews per month at no cost.

Pricing scales down automatically for higher-volume Apify plans (Silver, Gold, Platinum). See the [Apify pricing page](https://apify.com/pricing) for plan details.

### 🚀 How to scrape Walmart product reviews

1. Go to [Walmart Reviews Scraper](https://apify.com/automation-lab/walmart-reviews-scraper) on Apify Store
2. Click **Try for free**
3. In the **Product URLs or item IDs** field, paste one or more Walmart product URLs
   - Example: `https://www.walmart.com/ip/Acer-Chromebook-315/5113175776`
   - Or just the item ID: `5113175776`
4. Set **Max reviews per product** (start with 20–50 for a quick test)
5. Optionally choose a **Sort** and **Star filter**
6. Click **Start** — results appear in the dataset tab within seconds

**Example inputs for different scenarios:**

Scrape 100 most recent reviews for a specific item:
```json
{
  "productUrls": ["https://www.walmart.com/ip/5113175776"],
  "maxReviewsPerProduct": 100,
  "sort": "submission-desc"
}
````

Scrape only 1-star reviews to find complaints:

```json
{
  "productUrls": [
    "https://www.walmart.com/ip/ProductName/5113175776",
    "https://www.walmart.com/ip/OtherProduct/1444893965"
  ],
  "maxReviewsPerProduct": 200,
  "sort": "relevancy",
  "filterByStar": 1
}
```

### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `productUrls` | String\[] | — | **Required.** List of Walmart product URLs or numeric item IDs |
| `maxReviewsPerProduct` | Integer | 50 | Max reviews to scrape per product (1–1000) |
| `sort` | String | `relevancy` | Sort order: `relevancy`, `helpful`, `submission-desc`, `rating-desc`, `rating-asc` |
| `filterByStar` | Integer | none | Filter to reviews with this star rating (1–5) |
| `maxRequestRetries` | Integer | 5 | Retry attempts per failed request |

**Supported product URL formats:**

- `https://www.walmart.com/ip/Product-Name/12345678`
- `https://www.walmart.com/ip/12345678`
- `12345678` (bare item ID)

### 📤 Output examples

**Single review object:**

```json
{
  "itemId": "5113175776",
  "productName": "Acer Chromebook 315 15.6-inch Laptop",
  "productUrl": "https://www.walmart.com/ip/5113175776",
  "reviewId": "416117133",
  "title": "Great value for the price",
  "reviewText": "I needed a basic laptop for school work and this Chromebook is perfect. Very fast, easy to set up, and the battery life is excellent.",
  "rating": 5,
  "date": "2026-02-10",
  "reviewerName": "Dionne",
  "isVerifiedPurchase": true,
  "helpfulVotes": 12,
  "negativeFeedback": 1,
  "totalVotes": 13,
  "badges": ["Verified Purchase", "Top Reviewer"],
  "userLocation": "Texas",
  "recommended": true,
  "syndicationSource": null,
  "mediaUrls": [
    "https://i5.walmartimages.com/dfw/6e29e393-df87/k2-_af02033a.jpg"
  ],
  "scrapedAt": "2026-04-03T09:41:01.751Z"
}
```

### 💡 Tips for best results

- **Start small** — test with 20 reviews before running large batches
- **Use item IDs for reliability** — extract the numeric ID from the URL (e.g., `5113175776` from `/ip/Product/5113175776`)
- **Filter by star to focus research** — `filterByStar: 1` isolates complaints, `5` shows your best-case testimonials
- **Combine with Walmart Scraper** — use [Walmart Scraper](https://apify.com/automation-lab/walmart-scraper) to find item IDs from search results, then feed them into this actor for deep review analysis
- **Schedule sentiment monitoring** — run daily or weekly on key products to detect rating changes early
- **Export to CSV for Excel analysis** — click "Export" → CSV in the dataset view for pivot tables and sentiment analysis

### 🔗 Integrations

**Walmart Reviews Scraper → Google Sheets**
Automatically sync new reviews into a Google Sheet using Apify's Google Sheets integration. Great for team dashboards tracking product sentiment without coding.

**Walmart Reviews Scraper → Slack alerts**
Set up a webhook to post 1-star reviews to a Slack channel in real time. Useful for customer success teams who want to respond quickly to public complaints.

**Walmart Reviews Scraper → Make/Zapier**
Chain the scraper into automated workflows: extract reviews → filter negative ones → create support tickets in Zendesk or Jira.

**Scheduled sentiment monitoring**
Run the scraper daily on your top 10 products. Connect the dataset to a Looker Studio dashboard showing review volume, average rating, and sentiment trends over time.

**LLM training datasets**
Use the actor's scheduling + dataset API to collect rolling review datasets for fine-tuning sentiment models or training product-specific NLP classifiers.

### 🛠️ Using the Apify API

Integrate Walmart Reviews Scraper into your workflow using the Apify API.

**Node.js example:**

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/walmart-reviews-scraper').call({
    productUrls: ['https://www.walmart.com/ip/5113175776'],
    maxReviewsPerProduct: 100,
    sort: 'submission-desc',
});

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

**Python example:**

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_API_TOKEN')

run = client.actor('automation-lab/walmart-reviews-scraper').call(run_input={
    'productUrls': ['https://www.walmart.com/ip/5113175776'],
    'maxReviewsPerProduct': 100,
    'sort': 'submission-desc',
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(f"{item['rating']}⭐ {item['title'][:60]}")
```

**cURL example:**

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~walmart-reviews-scraper/runs" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "productUrls": ["https://www.walmart.com/ip/5113175776"],
    "maxReviewsPerProduct": 50,
    "sort": "relevancy"
  }'
```

### 🤖 Use with AI agents via MCP

Walmart Reviews Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

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

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

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

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/walmart-reviews-scraper to scrape the 50 most recent reviews for Walmart item 5113175776 and summarize the main complaints"
- "Get all 1-star reviews for this Walmart product https://www.walmart.com/ip/5113175776 and identify the top 3 recurring issues"
- "Scrape 100 reviews for each of these 5 Walmart products and compare their average ratings"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### ⚖️ Is it legal to scrape Walmart reviews?

Scraping publicly visible review data is generally considered legal in most jurisdictions. Walmart product reviews are publicly accessible to any visitor — no login, subscription, or API key is required to read them.

This scraper only accesses public data and follows responsible scraping practices:

- 🐢 Rate-limited requests with delays between pages
- 🔄 Retry logic instead of hammer-and-spam
- 🚫 No login, no credentials, no private data

Always review Walmart's [Terms of Service](https://www.walmart.com/help/article/walmart-com-terms-of-use/3b75080af40340d6bbd596f116fae5a2) before large-scale scraping. For commercial use of scraped data, consult your legal team. This tool is intended for research, competitive analysis, and personal use cases.

### ❓ FAQ

**How many reviews can I scrape per product?**
Walmart products can have thousands of reviews. The `maxReviewsPerProduct` parameter controls the limit. Start with 50–100 for testing. For large-scale extractions (1,000+ reviews), set a higher limit and ensure your Apify plan has sufficient credits.

**How much does it cost to scrape 500 reviews?**
With default PPE pricing: $0.005 (start) + 500 × $0.003 (reviews) = $1.51 total. On the Apify free plan ($5 credits), you can scrape ~1,600 reviews per month.

**Can I scrape reviews for multiple products at once?**
Yes — add multiple product URLs to the `productUrls` array. The actor processes them sequentially. Each product is scraped to your `maxReviewsPerProduct` limit.

**Why are some reviews missing or the count is lower than expected?**
Walmart may not return all reviews on some products — they typically display verified purchase reviews and hide reviews flagged for policy violations. If you see fewer reviews than Walmart's total count, try different sort orders (e.g., `submission-desc`) to get different review subsets.

**Why do some items return 0 reviews?**
Brand-new products, discontinued items, or items that only recently moved to Walmart's catalog may have 0 public reviews. Items with very few reviews (1–2) may also behave differently. The actor handles these gracefully and moves on.

**I'm getting blocked / 0 results — what should I do?**
This scraper requires the Apify proxy (RESIDENTIAL group) to bypass Walmart's anti-bot protection. Make sure you're running on the Apify platform (not just triggering from a local CLI without proper proxy setup). Cloud runs use residential proxies automatically.

### 🛒 Other Walmart and e-commerce scrapers

Looking for more data? Check out our other automation-lab actors:

- [Walmart Scraper](https://apify.com/automation-lab/walmart-scraper) — Scrape Walmart product listings from search results
- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper) — Extract Amazon product reviews by ASIN
- [Google Maps Reviews](https://apify.com/automation-lab/google-maps-reviews-scraper) — Scrape local business reviews from Google Maps
- [Airbnb Reviews](https://apify.com/automation-lab/airbnb-reviews) — Extract guest reviews from Airbnb listings
- [Booking Reviews Scraper](https://apify.com/automation-lab/booking-reviews-scraper) — Scrape hotel reviews from Booking.com
- [TripAdvisor Reviews Scraper](https://apify.com/automation-lab/tripadvisor-reviews-scraper) — Extract restaurant and attraction reviews

# Actor input Schema

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

Walmart product URLs or numeric item IDs to scrape reviews for. Example URL: https://www.walmart.com/ip/Acer-Chromebook-315/5113175776. You can also enter bare item IDs like 5113175776.

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

Maximum number of reviews to collect per product. Each Walmart page returns up to 20 reviews.

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

How to sort the reviews returned from Walmart.

## `filterByStar` (type: `integer`):

Only return reviews with this star rating (1-5). Leave empty to get all ratings.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts per failed request.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.walmart.com/ip/Acer-Chromebook-315-15-6-inch-Laptop-Intel-Processor-N4500/5113175776"
  ],
  "maxReviewsPerProduct": 20,
  "sort": "relevancy",
  "maxRequestRetries": 5
}
```

# 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.walmart.com/ip/Acer-Chromebook-315-15-6-inch-Laptop-Intel-Processor-N4500/5113175776"
    ],
    "maxReviewsPerProduct": 20,
    "sort": "relevancy",
    "maxRequestRetries": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/walmart-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.walmart.com/ip/Acer-Chromebook-315-15-6-inch-Laptop-Intel-Processor-N4500/5113175776"],
    "maxReviewsPerProduct": 20,
    "sort": "relevancy",
    "maxRequestRetries": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/walmart-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.walmart.com/ip/Acer-Chromebook-315-15-6-inch-Laptop-Intel-Processor-N4500/5113175776"
  ],
  "maxReviewsPerProduct": 20,
  "sort": "relevancy",
  "maxRequestRetries": 5
}' |
apify call automation-lab/walmart-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Walmart Reviews Scraper",
        "description": "Extract Walmart product reviews — ratings, review text, verified purchase status, helpfulness votes. Enter product URLs or item IDs. Export to JSON, CSV, or Excel. No API key required.",
        "version": "0.1",
        "x-build-id": "M6LhzWgfZXxlA7IUG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~walmart-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-walmart-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~walmart-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-walmart-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~walmart-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-walmart-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "productUrls"
                ],
                "properties": {
                    "productUrls": {
                        "title": "🛒 Product URLs or item IDs",
                        "type": "array",
                        "description": "Walmart product URLs or numeric item IDs to scrape reviews for. Example URL: https://www.walmart.com/ip/Acer-Chromebook-315/5113175776. You can also enter bare item IDs like 5113175776.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect per product. Each Walmart page returns up to 20 reviews.",
                        "default": 50
                    },
                    "sort": {
                        "title": "Sort reviews by",
                        "enum": [
                            "relevancy",
                            "helpful",
                            "submission-desc",
                            "rating-desc",
                            "rating-asc"
                        ],
                        "type": "string",
                        "description": "How to sort the reviews returned from Walmart.",
                        "default": "relevancy"
                    },
                    "filterByStar": {
                        "title": "Filter by star rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only return reviews with this star rating (1-5). Leave empty to get all ratings."
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts per failed request.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```