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

Scrapes customer reviews from Walmart product pages: rating, title, text, date, verified purchase, helpful votes, photos, seller responses and the product's rating breakdown.

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

## Pricing

$0.50 / 1,000 reviews

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Walmart Reviews Scraper do?

**Walmart Reviews Scraper** collects **customer reviews from Walmart.com**
product pages: the **star rating, title, full text and date** of each review,
the reviewer's name as shown, the **Verified Purchase** and other badges,
**helpful and not-helpful votes**, **review photos**, the **seller's or
brand's response**, and where a review was **originally posted** (for example
on the brand's own site). Every row also carries the product's **average
rating, rating count and 1–5 star breakdown**.

Paste a product link from [Walmart](https://www.walmart.com), or just its
product number, and click **Start**: the prefilled product returns 20 reviews
in a few seconds. Because it runs on the Apify platform, you also get API
access, scheduled runs, integrations (Google Sheets, Make, Zapier, webhooks),
run monitoring and proxy rotation without setting anything up.

### Why scrape Walmart reviews?

- **Product research**: read what buyers love and hate about a product before
  you stock, buy or build a competing one.
- **Brand monitoring**: follow new reviews of your own products, sorted by
  most recent, and see which ones your team has already answered.
- **Complaint analysis**: pull only the 1 and 2 star reviews to find recurring
  defects, shipping problems or misleading listings.
- **Competitor benchmarking**: compare rating breakdowns and review themes
  across rival products in one dataset.
- **Sentiment and AI datasets**: export review text with ratings and dates for
  sentiment analysis, topic modelling or model training.

### How to scrape Walmart reviews

1. Open a product on walmart.com and copy the address from your browser, such
   as `https://www.walmart.com/ip/Acer-Chromebook-315/5113175776`. The number
   at the end is enough on its own.
2. Paste it into **Walmart product links**, one product per line.
3. Set **Max reviews per product**, and optionally pick a **sort order** and
   the **star ratings** you want.
4. Click **Start**, then download the reviews when the run finishes.

Tip: if you sort or filter the reviews on walmart.com first ("See all
reviews", then choose an order or a star rating), you can paste that reviews
page address instead, and the Actor keeps its order and star filter.

### Input

Everything is set on the Input tab. In JSON, the input looks like this:

```json
{
    "productUrls": [
        "https://www.walmart.com/ip/Acer-Chromebook-315/5113175776",
        "https://www.walmart.com/reviews/product/18179762800?sort=submission-desc",
        "15805256486"
    ],
    "maxReviewsPerProduct": 100,
    "sortBy": "submission-desc",
    "starRatings": ["1", "2"]
}
```

| Field | What it does |
|---|---|
| `productUrls` | Product links (`walmart.com/ip/name/123`), reviews links (`walmart.com/reviews/product/123`) or bare product numbers. Links work with or without `https://`, and API callers can pass `{"url": "..."}` objects. |
| `maxReviewsPerProduct` | Stops after this many reviews per product. Default: 100. Set `0` for every written review. |
| `sortBy` | `relevancy` (Walmart's default), `submission-desc` (most recent), `submission-asc` (oldest), `helpful` (most helpful), `rating-desc` or `rating-asc`. With `helpful` and no limit, you get the helpful-order rows first, then a newest-first top-up of the reviews Walmart skipped in that order, so pages are read about twice. |
| `starRatings` | Keep only these ratings, for example `["1", "2"]`. Empty means all ratings. |
| `proxyConfiguration` | Optional; leave it off. The Actor picks Apify Proxy addresses Walmart accepts by itself, cheapest first. |

A reviews link that already has `sort=` or `ratings=` in it uses those
instead of `sortBy` and `starRatings`.

### Output

Each review becomes one row. Here is a real one, with the brand's reply
shortened:

```json
{
    "productId": "15805256486",
    "reviewId": "272176677",
    "rating": 1,
    "title": "Hard to Use and Program.",
    "text": "[This review was collected as part of a promotion.] This TV is not like the 60 Inch Samsung that I have in the living room. …",
    "date": "2026-09-20",
    "reviewerName": "Crash",
    "isVerifiedPurchase": false,
    "badges": [],
    "positiveFeedback": 0,
    "negativeFeedback": 0,
    "photos": [],
    "variant": null,
    "syndicatedFrom": "Samsung US",
    "sellerResponse": {
        "from": "Samsung Advisor",
        "text": "Hi Crash, Thanks for your review. While Samsung remotes are designed for ease and versatility, universal remotes can also be used … ~ Samsung Advisor"
    },
    "reviewedItemId": null,
    "soldBy": null,
    "productName": "Samsung 32” Class Full HD F6000F Smart TV 2025 - UN32F6000FFXZA",
    "productUrl": "https://www.walmart.com/ip/Samsung-F6000-UN32F6000FF-32-Smart-LED-LCD-TV-2025-HDTV-High-Dynamic-Range-HDR-Black-HDR10-LED-Backlight-Bixby-Alexa-Google-Assistant-Supported-AirPl/15805256486",
    "productAverageRating": 4.2,
    "productRatingCount": 1935,
    "productReviewCount": 1234,
    "productRatingHistogram": { "1": 155, "2": 91, "3": 151, "4": 284, "5": 1254 },
    "productRecommendedPercent": 79,
    "scrapedAt": "2026-10-20T14:28:55.648957+00:00"
}
```

And a review written on Walmart itself, by a verified buyer with a photo
(the product fields are left out here):

```json
{
    "productId": "5113175776",
    "reviewId": "444250321",
    "rating": 1,
    "title": "No good",
    "text": "Stopped working the second day I got it",
    "date": "2026-10-15",
    "reviewerName": "eric",
    "isVerifiedPurchase": true,
    "badges": ["Verified Purchase"],
    "photos": ["https://i5.walmartimages.com/dfw/6e29e393-8362/k2-_37891a34-55e9-40a5-914f-33c50772c390.v1.jpg"],
    "variant": { "Hard drive capacity": "64 GB", "Color": "Pure Silver" },
    "syndicatedFrom": null,
    "sellerResponse": null,
    "reviewedItemId": "3193557250",
    "soldBy": "Walmart.com"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or
Excel.

### Data fields

| Field | Description |
|---|---|
| `productId` | The Walmart product number you asked for. |
| `reviewId` | Walmart's id for the review. Each review appears once per product. |
| `rating` | Stars given, 1 to 5. |
| `title` | The review's headline, or `null` when the reviewer left none. |
| `text` | The full review text. |
| `date` | The day the review was posted, as `YYYY-MM-DD`. Walmart shows only the day, with no time or time zone. |
| `reviewerName` | The reviewer's nickname exactly as Walmart shows it (often a first name or "anonymous"). |
| `isVerifiedPurchase` | `true` when Walmart marks the review "Verified Purchase". |
| `badges` | Every badge on the review and reviewer, for example "Verified Purchase", "International review", "Walmart Associate", "Top reviewer" or "75 reviews" (how many reviews the reviewer has written). |
| `positiveFeedback` | How many shoppers marked the review helpful. |
| `negativeFeedback` | How many marked it not helpful. |
| `photos` | Full-size links to the photos the reviewer attached. |
| `variant` | The options of the item the reviewer bought, such as `{"Color": "Pure Silver"}`, when Walmart lists them. |
| `syndicatedFrom` | Where a review was first posted when it was copied to Walmart, for example "Samsung US" or "walmart.ca". `null` for reviews written on walmart.com. |
| `sellerResponse` | The seller's or brand's public reply: `from` (who replied) and `text`. |
| `reviewedItemId` | The product number of the exact variant the reviewer bought, when Walmart knows it (reviews are shared across a product's sizes and colours). |
| `soldBy` | The seller of the reviewer's order, such as "Walmart.com", when known. |
| `productName`, `productUrl` | The product's name and page. |
| `productAverageRating` | The product's average star rating. |
| `productRatingCount` | All ratings, including star-only ratings without text. |
| `productReviewCount` | Ratings that have written text; only these can be scraped. |
| `productRatingHistogram` | How many ratings each star level has, keyed `"1"` to `"5"`. |
| `productRecommendedPercent` | The share of reviewers who would recommend the product. |
| `scrapedAt` | When the row was saved (UTC, ISO 8601). |

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

You pay per review saved; see the **Pricing** tab for the exact price.
Products without reviews, unknown product numbers and links that are not
Walmart products are never charged: they are listed in the run's
`FAILED_INPUTS` record in the key-value store instead.

The Actor reads Walmart's pages over plain HTTP with no browser, ten reviews
per request, so runs are fast and use little platform time: 1,000 reviews take
about a minute. Apify's free plan is enough to try it on a few thousand
reviews.

### Tips for scraping Walmart reviews

- **Get only what you need.** With `maxReviewsPerProduct` set, the sort order
  decides which reviews you get: "Most recent" for monitoring, "Most helpful"
  for the reviews shoppers read first.
- **Monitor new reviews** by scheduling a daily run sorted by most recent with
  a small limit, such as 20.
- **Find complaints fast** with `starRatings` set to `["1", "2"]`.
- **Set a spending limit** on the run: the Actor stops cleanly once the
  maximum cost you set for the run is reached, keeping everything saved so far.
- **One product, many variants.** Walmart shares reviews across a product's
  colours and sizes, so one link per product is enough; `variant` and
  `reviewedItemId` tell you which one each reviewer bought.

### FAQ, disclaimers, and support

**Why do I get fewer reviews than the product's rating count?** Walmart counts
star-only ratings too, but lists only ratings with written text.
`productRatingCount` is the total and `productReviewCount` is the number you
can scrape.

**Does "Most helpful" return every review?** Walmart's helpful order is not
stable from page to page: the same review can show up on several pages while
others are never shown (on one product, a third of the reviews never
appeared). So after reading the helpful order, the Actor tops up from the
newest-first order, which lists each review once, until it has your limit or
every review Walmart counts. The first rows are still in helpful order; the
top-up rows follow, newest first. If a product still ends with fewer reviews
than Walmart counts, the run's status message names it with both numbers.

**What happens with a bad link?** Links that are not Walmart products,
product numbers that don't exist and products without written reviews are
skipped with a reason in the `FAILED_INPUTS` record, and the other products
still run. A run fails only when every product could not be loaded because
Walmart or the network refused it.

**Does it need a Walmart account or cookies?** No. It reads the public review
pages anyone can open without logging in.

**Is it legal to scrape Walmart reviews?** This Actor collects only publicly
visible review data. Reviews include reviewers' nicknames, which can be
personal data under laws such as the GDPR and CCPA, so only collect and store
them if you have a legitimate reason, and check Walmart's terms of use for
your use case. If you are unsure, consult a lawyer.

**Something missing or broken?** Open an issue on the **Issues** tab and it
will be looked at quickly. Need a custom Walmart scraper or a different data
source? Get in touch through the Issues tab too.

# Actor input Schema

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

Walmart product links, one per line: a product page (https://www.walmart.com/ip/product-name/5113175776), its reviews page (https://www.walmart.com/reviews/product/5113175776), or just the product number (5113175776). A reviews link copied after choosing a sort order or star filter on walmart.com keeps that order and filter.

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

Stops after this many reviews for each product. Set 0 to get every written review.

## `sortBy` (type: `string`):

The order Walmart lists the reviews in. With a limit above, this decides which reviews you get.

## `starRatings` (type: `array`):

Keeps only reviews with these ratings, for example 1 and 2 stars for complaints. Leave empty for all ratings.

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

Leave this off: the Actor picks Apify Proxy addresses that Walmart accepts on its own, cheapest first. Turn it on only to force a proxy of your own choice for every request.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.walmart.com/ip/5113175776"
  ],
  "maxReviewsPerProduct": 20,
  "sortBy": "relevancy",
  "starRatings": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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/5113175776"
    ],
    "maxReviewsPerProduct": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("mina_safwat/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/5113175776"],
    "maxReviewsPerProduct": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("mina_safwat/walmart-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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/5113175776"
  ],
  "maxReviewsPerProduct": 20
}' |
apify call mina_safwat/walmart-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mina_safwat/walmart-reviews-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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