# Walmart Reviews Scraper - All Reviews by URL, ID or Keyword (`khadinakbar/walmart-reviews-scraper`) Actor

Scrape Walmart.com customer reviews for any product by URL, item ID, or keyword search. Deep-paginates every review - rating, title, text, author, verified-purchase, helpful votes, photos, pros/cons, and date - plus a per-product rating summary. MCP-ready. $0.003 per review.

- **URL**: https://apify.com/khadinakbar/walmart-reviews-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 review extracteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 - All Reviews by URL, ID or Keyword

Use this Apify Actor to scrape Walmart.com customer reviews for a product selected by product URL, Walmart item ID, or keyword search. It accepts one or many product targets, deep-paginates review pages for each product up to your cap, and returns one record per review with fields such as rating, title, text, author, verified purchaser flag, helpful votes, photos, pros, cons, and submitted date. When enabled, it also adds one per-product summary row with overall rating, total review count, brand, and a 1-5 star breakdown.

The Actor is MCP-ready and usable through Apify MCP, so AI agents can work with structured review data without extra parsing.

### Best fit and connected workflows

This Actor fits workflows where the review corpus matters more than the storefront listing:

- Review monitoring for a specific Walmart product over time.
- Competitive research across product URLs, item IDs, or keyword-discovered products.
- AI workflows that need review text, star rating, verified purchase status, and engagement signals in a structured dataset.
- Downstream analysis that pairs product-level data with review-level detail.

For a broader Walmart product record first, use the related upstream Actor [Walmart Product, Price and Review Data Scraper](https://apify.com/khadinakbar/walmart-data-extractor). It provides the parent product data, then this Actor adds the review layer for the same Walmart item.

### Practical scenario

Maya, a marketplace analyst, starts with a Walmart item URL for a wireless earbuds product. She runs this Actor in `productUrls` mode, sets `maxReviewsPerProduct` to focus on recent feedback, and keeps `includeProductSummary` enabled. The dataset returns review rows with `rating`, `title`, `text`, `author`, `verifiedPurchaser`, `helpfulVotes`, and `submittedAt`, plus a summary row with `overallRating`, `totalReviewCount`, and `ratingBreakdown`.

She uses the summary row to compare sentiment at a glance, then reads the newest 1-star reviews to identify a repeated complaint. Her next step is to pass the dataset into a reporting workflow or to combine it with product metadata from the companion Walmart data extractor.

### Input

Choose the input shape that matches how you want to identify products.

| Field | Type | Description |
|---|---|---|
| `mode` | string | Selects the lookup path: `search`, `productUrls`, or `itemIds`. |
| `searchQuery` | string | Keyword search used when `mode` is `search`. The top products are resolved automatically. |
| `productUrls` | array of strings | Walmart product page URLs to scrape in `productUrls` mode. |
| `itemIds` | array of strings | Raw Walmart item IDs to scrape in `itemIds` mode. |
| `maxProducts` | integer | Upper bound on how many search results get scraped in `search` mode. |
| `maxReviewsPerProduct` | integer | Upper bound on reviews per product. |
| `sortReviews` | string | Review order: `mostRecent`, `mostHelpful`, `highestRating`, `lowestRating`, or `mostRelevant`. |
| `ratingFilter` | string | Exact star bucket to keep: `all`, `5`, `4`, `3`, `2`, or `1`. |
| `includeProductSummary` | boolean | Adds one summary row per product when enabled. |
| `proxyConfiguration` | object | Apify proxy settings, with Residential US as the default. |

Focused example:

```json
{
  "mode": "productUrls",
  "productUrls": [
    "https://www.walmart.com/ip/Apple-AirPods-Pro-2/1820546583"
  ],
  "maxReviewsPerProduct": 25,
  "sortReviews": "mostRecent",
  "ratingFilter": "all",
  "includeProductSummary": true
}
```

### Output

The dataset contains review rows and, when enabled, product summary rows. The output schema also exposes a run summary in Key-Value Store.

| Field | Type | Description |
|---|---|---|
| `_type` | string or null | Record kind: `review`, `product`, or `diagnostic`. |
| `reviewId` | string or null | Stable Walmart review ID. |
| `itemId` | string or null | Walmart numeric item ID. |
| `productName` | string or null | Product title. |
| `productUrl` | string or null | Canonical Walmart product page URL. |
| `rating` | number or null | Star rating from 1 to 5. |
| `title` | string or null | Review headline. |
| `text` | string or null | Full review body text. |
| `author` | string or null | Reviewer display name. |
| `verifiedPurchaser` | boolean or null | Walmart verified purchaser flag. |
| `helpfulVotes` | number or null | Helpful vote count. |
| `unhelpfulVotes` | number or null | Not helpful vote count. |
| `photos` | array of strings | Review photo URLs. |
| `pros` | array of strings | Structured pros when present. |
| `cons` | array of strings | Structured cons when present. |
| `syndicated` | boolean or null | Syndication flag. |
| `submittedAt` | string or null | Walmart submission time. |
| `reviewSource` | string or null | `scraped`, `serpapi`, or `diagnostic`. |
| `overallRating` | number or null | Product summary average rating. |
| `totalReviewCount` | number or null | Total review count Walmart reports. |
| `ratingBreakdown` | object or null | 1-5 star histogram. |
| `brand` | string or null | Product brand in summary rows. |
| `scrapeSource` | string or null | Summary source: `reviews-page` or `serpapi`. |
| `status` | string or null | Diagnostic status. |
| `stopReason` | string or null | Machine-readable diagnostic reason. |
| `scrapedAt` | string | ISO 8601 timestamp for the record. |

Illustrative dataset record:

```json
{
  "_type": "review",
  "reviewId": "d1f0e2a3-1234-5678-9abc-def012345678",
  "itemId": "1820546583",
  "productName": "Apple AirPods Pro (2nd Generation)",
  "productUrl": "https://www.walmart.com/ip/Apple-AirPods-Pro-2/1820546583",
  "rating": 5,
  "title": "Clear sound and fast pairing",
  "text": "The earbuds paired quickly and the sound is balanced for music and calls.",
  "author": "MusicFan22",
  "verifiedPurchaser": true,
  "helpfulVotes": 14,
  "unhelpfulVotes": 1,
  "photos": [
    "https://i5.walmartimages.com/asr/review-photo.jpeg"
  ],
  "pros": [
    "Sound quality",
    "Battery life"
  ],
  "cons": [],
  "syndicated": false,
  "submittedAt": "2026-03-14T09:22:00.000Z",
  "reviewSource": "scraped",
  "scrapedAt": "2026-06-18T07:30:00.000Z"
}
```

### How it works

The Actor uses a PlaywrightCrawler with Chromium and Apify Residential proxies pinned to the US. The live contract shows that Walmart content is handled through a review-focused crawl path, with session rotation, fingerprinting, and exponential backoff for resilient retrieval.

Three input modes route into the same review extraction flow:

- `search` resolves top products from a keyword query and scrapes their reviews.
- `productUrls` opens the supplied Walmart product pages to resolve item IDs, then reads the review surface.
- `itemIds` goes directly to the Walmart review endpoint for the numeric item ID.

Reviews are deep-paginated in the selected sort order until the cap is reached or the product runs out of reviews. A per-product summary row is available when `includeProductSummary` is enabled.

### Pricing

This Actor uses pay per event plus Apify platform usage. Review extraction is billed per review written to the dataset, and product summaries are billed per product when enabled. Apify platform usage, such as compute and proxy resources, is shown separately on the run's Pricing tab.

A simple example in words: if one execution extracts one hundred reviews and includes one product summary row, the event-based charges include one hundred review events plus one product-summary event, and Apify platform usage is added according to the live Pricing tab.

### Use with AI agents (MCP)

This Actor is available through Apify MCP as a structured Walmart review tool. The precise Actor identity is `khadinakbar/walmart-reviews-scraper`.

It returns normalized review records and optional product summary rows that an agent can sort, compare, summarize, or join with other product data. The dataset is the primary source of truth, and `scrapedAt` provides record-level provenance. When the reviews surface is paginated, the Actor keeps collecting until the configured cap is reached.

> Scrape Walmart reviews for this product URL, return the newesta bounded number of reviews, include the product summary row, and give me the dataset items so I can summarize complaints and verified-purchase patterns.

Output interpretation guidance:

- `review` rows contain the per-review evidence.
- `product` rows contain the aggregate view for a product.
- `reviewSource` and `scrapeSource` show whether the record came from live scraping or the managed fallback path.
- `submittedAt` and `scrapedAt` help distinguish the Walmart submission time from the extraction time.
- Pagination continues until the review cap for each product is reached.
- Cost scales with the number of review events and optional product-summary events, plus Apify platform usage visible in the Pricing tab.

### API example

JavaScript example using the Apify API, `APIFY_TOKEN`, and dataset readback:

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

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const run = await client.actor('khadinakbar/walmart-reviews-scraper').call({
  mode: 'itemIds',
  itemIds: ['1820546583'],
  maxReviewsPerProduct: 10,
  sortReviews: 'mostRecent',
  includeProductSummary: true,
});

const datasetId = run.defaultDatasetId;
const { items } = await client.dataset(datasetId).listItems();

console.log(items);
```

### Best results and outcome guidance

Use the narrowest input that matches your task. If you already know the product, `productUrls` or `itemIds` creates a direct review path. If you want discovery from search terms, `search` resolves the top products first. When you are comparing sentiment changes, `mostRecent` is a natural default. When you are studying review themes or vote patterns, `mostHelpful` and the star-rating filter can focus the dataset.

For larger review corpora, raise `maxReviewsPerProduct` within the live schema bounds. For lighter checks, keep it smaller and read the summary row first. If you also need product metadata, pair this Actor with the linked Walmart product extractor workflow.

### Design note

I found that the output contract includes both individual review rows and optional product summary rows, with `_type` clearly distinguishing them and `scrapedAt` required on every record. That makes it straightforward to separate row types in downstream processing.

### FAQ

#### Can I start from a keyword instead of a product URL?

Yes. Use `mode: "search"` with a `searchQuery`, and the Actor will resolve top products before scraping their reviews.

#### Can I scrape by raw Walmart item ID?

Yes. Use `mode: "itemIds"` and pass the numeric item IDs from the end of Walmart product URLs.

#### Does the dataset include a product-level summary?

Yes. Keep `includeProductSummary` enabled to receive one summary row per product with overall rating, total review count, and a star histogram.

#### How do I connect this with a broader Walmart product workflow?

Start with [Walmart Product, Price and Review Data Scraper](https://apify.com/khadinakbar/walmart-data-extractor) for product-level attributes, then use this Actor for the review corpus.

#### How are review records paginated?

Reviews are collected in the selected sort order and deep-paginated until the configured cap is reached or the product runs out of reviews.

### Responsible use

Use the data in line with Walmart's terms and applicable law. Review text can contain personal expression and context, so handle it carefully in analytics, storage, and redistribution workflows. Respect reviewer privacy, keep provenance intact, and apply appropriate safeguards when processing or publishing the data.

# Actor input Schema

## `mode` (type: `string`):

How to choose which products to pull reviews for. 'search' runs a keyword search and harvests reviews for the top products (bounded by Max products). 'productUrls' pulls reviews for the exact Walmart product URLs you supply. 'itemIds' pulls reviews for raw numeric Walmart item IDs. Defaults to 'search'.

## `searchQuery` (type: `string`):

Free-text product query run on Walmart's search engine (e.g., 'airpods pro', 'instant pot duo 7-in-1'). Used only when mode = search; the top products (up to Max products) have their reviews scraped. Leave blank for productUrls / itemIds modes. NOT a product URL — for a specific product use productUrls.

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

Walmart product detail URLs to pull reviews for (e.g., 'https://www.walmart.com/ip/Apple-AirPods-Pro-2/1820546583'). Used when mode = productUrls. Each URL's reviews are deep-paginated up to Max reviews per product. The product page is only opened to resolve the item ID — the reviews come from Walmart's reviews surface.

## `itemIds` (type: `array`):

Raw numeric Walmart item IDs to pull reviews for (e.g., '1820546583'). Used when mode = itemIds. Reviews are fetched directly from 'walmart.com/reviews/product/{itemId}'. Find the item ID at the end of a product URL. For full product fields (price, specs, variants) use the separate walmart-data-extractor actor.

## `maxProducts` (type: `integer`):

Upper bound on how many products from the keyword search have their reviews scraped. Applies only to mode = search; productUrls / itemIds modes scrape every product you supply. The prefill is intentionally small so Apify health checks finish fast — raise it for production. Hard cap 200.

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

Upper bound on reviews scraped per product (each review is $0.003). Reviews deep-paginate newest-first by default until this cap or the product runs out of reviews. Default 100, hard cap 1000. Set lower to sample recent sentiment cheaply; raise for a full review corpus.

## `sortReviews` (type: `string`):

Order in which reviews are collected per product. 'mostRecent' (default) returns newest first — best for monitoring fresh sentiment. 'mostHelpful' returns the highest-voted reviews. 'highestRating' / 'lowestRating' surface the best/worst first. 'mostRelevant' uses Walmart's default ranking.

## `ratingFilter` (type: `string`):

Keep only reviews with this exact star rating. 'all' (default) keeps every rating. '5'..'1' keep only that star bucket — useful for mining 1-star complaints or 5-star praise. Applied client-side so it is always exact regardless of Walmart's own filters.

## `includeProductSummary` (type: `boolean`):

When true (default), emit one aggregate row per product (tagged \_type='product') with the overall rating, total review count, and 1-5 star histogram, alongside the individual review rows. Charged at $0.001 per product. Turn off to receive only individual review records.

## `proxyConfiguration` (type: `object`):

Apify proxy configuration. Defaults to Apify Residential pinned to US — required because Walmart geo-locks content and runs Akamai + PerimeterX anti-bot. Override only if you have a specific reason (e.g., your own residential pool). Datacenter proxies are blocked by Walmart.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "instant pot duo 7-in-1",
  "maxProducts": 1,
  "maxReviewsPerProduct": 10,
  "sortReviews": "mostRecent",
  "ratingFilter": "all",
  "includeProductSummary": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

All scraped customer reviews (plus per-product summary rows). Download as JSON, CSV, Excel, HTML, or RSS.

## `runSummary` (type: `string`):

End-of-run JSON with review/summary counts, charges, errors, and warning samples.

## `output` (type: `string`):

Stable terminal outcome, counts, charges, and warnings for this run.

# 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 = {
    "mode": "search",
    "searchQuery": "airpods pro",
    "maxProducts": 1,
    "maxReviewsPerProduct": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "mode": "search",
    "searchQuery": "airpods pro",
    "maxProducts": 1,
    "maxReviewsPerProduct": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "mode": "search",
  "searchQuery": "airpods pro",
  "maxProducts": 1,
  "maxReviewsPerProduct": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call khadinakbar/walmart-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hOGLzO82mSVot6TK1/builds/xhxnMHo8pvjDuXVqY/openapi.json