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

Per-product reviews with aggregate distribution, sentiment aspects, top positive/negative review, plus paginated individual reviews — HTTP-only, no browser.

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

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

Pull the complete review record for any Walmart product — aggregate ratings, rating distribution, individual reviews, verified-purchase flags, and helpful vote counts — all in one run.

### Why use this actor

- **Monitor product quality trends** by tracking average rating and review velocity over time and alerting when sentiment shifts.
- **Benchmark competitors** by comparing rating distributions, recommended percentages, and review counts across brands.
- **Feed customer voice analysis** — export full review text into your NLP or sentiment pipeline for theme extraction.
- **Filter verified purchases** to strip syndicated or unverified reviews before modeling, reducing noise in your data.
- **Identify high-return-risk SKUs** by correlating low-star review text with product specifications.
- **Join SUMMARY and REVIEW rows** using the shared `productId` field to build per-product dashboards in any BI tool.

### How it works

1. You provide a list of Walmart product URLs (the `https://www.walmart.com/ip/...` format).
2. For each product, the actor first collects a SUMMARY row — aggregate rating, total review count, rating distribution, and recommended percentage.
3. It then pages through individual reviews in the sort order you choose, collecting one REVIEW row per review.
4. Pagination stops cleanly when the last page is reached or your `maxPagesPerProduct` limit is hit.
5. Both record types land in the same Default Dataset — download as JSON, CSV, or Excel, or stream via the API.

You don't need to manage any browsers or scrapers.

### Input

```json
{
  "productUrls": [
    { "url": "https://www.walmart.com/ip/Apple-AirPods-with-Charging-Case-2nd-Generation/604342441" },
    { "url": "https://www.walmart.com/ip/Samsung-Galaxy-Buds3/1234567890" }
  ],
  "maxPagesPerProduct": 5,
  "sort": "relevancy",
  "maxConcurrency": 4,
  "maxRequestRetries": 6,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
````

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `productUrls` | array of objects | Yes | — | Walmart product URLs in `{ "url": "..." }` format. |
| `maxPagesPerProduct` | integer | No | `5` | Review pages to retrieve per product (1–50). Each page holds up to 10 reviews. |
| `sort` | string | No | `"relevancy"` | Sort order: `relevancy`, `recency`, `helpful`, `rating_desc`, `rating_asc`, `pos_neg`. |
| `maxConcurrency` | integer | No | `4` | Number of parallel requests (1–16). |
| `maxRequestRetries` | integer | No | `6` | Retries per request before giving up (1–20). |
| `proxyConfiguration` | object | No | Apify RESIDENTIAL | Proxy settings. RESIDENTIAL group recommended. |

### Output

The dataset contains two record types distinguished by the `recordType` field.

**SUMMARY row** — one per product:

```json
{
  "recordType": "SUMMARY",
  "productId": "604342441",
  "title": "Apple AirPods with Charging Case (2nd Generation)",
  "averageRating": 4.7,
  "totalReviewCount": 70601,
  "reviewsWithTextCount": 33760,
  "recommendedPercentage": 44,
  "ratingDistribution": {
    "5": 59291,
    "4": 5816,
    "3": 1764,
    "2": 661,
    "1": 3069
  },
  "scrapedAt": "2026-05-30T04:23:10Z"
}
```

**REVIEW row** — one per individual review:

```json
{
  "recordType": "REVIEW",
  "productId": "604342441",
  "reviewId": "rv-8f3a2c1d",
  "rating": 5,
  "title": "Amazing sound, great fit",
  "text": "I switched from older AirPods and the improvement in sound is immediately noticeable. They pair instantly every time.",
  "authorId": "TechReviewer42",
  "badges": ["VerifiedPurchaser"],
  "verifiedPurchase": true,
  "positiveFeedback": 47,
  "negativeFeedback": 2,
  "scrapedAt": "2026-05-30T04:23:10Z"
}
```

**SUMMARY field reference:**

| Field | Type | Description |
|---|---|---|
| `recordType` | string | Always `"SUMMARY"` for aggregate rows. |
| `productId` | string | Walmart item ID — join key with REVIEW rows. |
| `title` | string | Product title. |
| `averageRating` | number | Mean customer rating (0–5). |
| `totalReviewCount` | integer | Total number of ratings submitted. |
| `reviewsWithTextCount` | integer | Reviews that include written text. |
| `recommendedPercentage` | integer | Percentage of reviewers who recommend the product. |
| `ratingDistribution` | object | Count of ratings for each star level (1–5). |
| `scrapedAt` | string | ISO 8601 timestamp of collection. |

**REVIEW field reference:**

| Field | Type | Description |
|---|---|---|
| `recordType` | string | Always `"REVIEW"` for individual review rows. |
| `productId` | string | Walmart item ID — join key with SUMMARY row. |
| `reviewId` | string | Unique review identifier. |
| `rating` | integer | Star rating given by the reviewer (1–5). |
| `title` | string | Review headline. |
| `text` | string | Full review body text. |
| `authorId` | string | Reviewer's display name or anonymized ID. |
| `badges` | array | Badges attached to the reviewer (e.g. `"VerifiedPurchaser"`). |
| `verifiedPurchase` | boolean | `true` when Walmart confirms the reviewer bought the item. |
| `positiveFeedback` | integer | Number of "helpful" votes received. |
| `negativeFeedback` | integer | Number of "not helpful" votes received. |
| `scrapedAt` | string | ISO 8601 timestamp of collection. |

### Other Walmart Scrapers

| Actor | What it does |
|---|---|
| [Walmart Search Scraper](https://apify.com/store/walmart-search-scraper) | Keyword search results — ranking, pricing, and sponsored flags across any number of queries. |
| [Walmart Product Scraper](https://apify.com/store/walmart-product-scraper) | Full product detail pages — specs, variants, images, top reviews, and fulfillment info. |
| [Walmart Reviews Scraper](https://apify.com/store/walmart-reviews-scraper) | Complete review dataset per product — aggregate summary and individual review rows. |
| [Walmart Seller Scraper](https://apify.com/store/walmart-seller-scraper) | Marketplace seller profiles — identity, ratings, contact info, and featured products. |

# Actor input Schema

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

Walmart product URLs (e.g. https://www.walmart.com/ip/<slug>/<id>) or bare item IDs.

## `maxPagesPerProduct` (type: `integer`):

Each page returns up to 10 reviews. The actor stops early when no next page is returned.

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

How to order the returned reviews (e.g. most relevant, newest, highest or lowest rating).

## `maxConcurrency` (type: `integer`):

Maximum number of inputs processed in parallel. Higher is faster but uses more proxy bandwidth.

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

How many times a failed request is retried (e.g. on a bot-wall or network error) before the input is skipped.

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

Proxy settings. A residential Apify Proxy group is strongly recommended — Walmart's bot wall flags datacenter IPs.

## Actor input object example

```json
{
  "productUrls": [
    {
      "url": "https://www.walmart.com/ip/Apple-AirPods-with-Charging-Case-2nd-Generation/604342441"
    }
  ],
  "maxPagesPerProduct": 5,
  "sort": "relevancy",
  "maxConcurrency": 4,
  "maxRequestRetries": 6,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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": [
        {
            "url": "https://www.walmart.com/ip/Apple-AirPods-with-Charging-Case-2nd-Generation/604342441"
        }
    ],
    "sort": "relevancy"
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/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": [{ "url": "https://www.walmart.com/ip/Apple-AirPods-with-Charging-Case-2nd-Generation/604342441" }],
    "sort": "relevancy",
}

# Run the Actor and wait for it to finish
run = client.actor("xtracto/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": [
    {
      "url": "https://www.walmart.com/ip/Apple-AirPods-with-Charging-Case-2nd-Generation/604342441"
    }
  ],
  "sort": "relevancy"
}' |
apify call xtracto/walmart-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Walmart Reviews Scraper",
        "description": "Per-product reviews with aggregate distribution, sentiment aspects, top positive/negative review, plus paginated individual reviews — HTTP-only, no browser.",
        "version": "0.1",
        "x-build-id": "8desM369tYqaU7Gdh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~walmart-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-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/xtracto~walmart-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-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/xtracto~walmart-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-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": "Walmart product URLs or item IDs",
                        "type": "array",
                        "description": "Walmart product URLs (e.g. https://www.walmart.com/ip/<slug>/<id>) or bare item IDs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxPagesPerProduct": {
                        "title": "Max pages per product",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Each page returns up to 10 reviews. The actor stops early when no next page is returned.",
                        "default": 5
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "relevancy",
                            "recency",
                            "helpful",
                            "rating_desc",
                            "rating_asc",
                            "pos_neg"
                        ],
                        "type": "string",
                        "description": "How to order the returned reviews (e.g. most relevant, newest, highest or lowest rating).",
                        "default": "relevancy"
                    },
                    "maxConcurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Maximum number of inputs processed in parallel. Higher is faster but uses more proxy bandwidth.",
                        "default": 4
                    },
                    "maxRequestRetries": {
                        "title": "Max retries per request",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many times a failed request is retried (e.g. on a bot-wall or network error) before the input is skipped.",
                        "default": 6
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy settings. A residential Apify Proxy group is strongly recommended — Walmart's bot wall flags datacenter IPs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
