# Walmart Product Reviews Scraper (`reviewly/walmart-product-reviews-scraper`) Actor

Scrape Walmart.com reviews & product data: star rating, title, text, date, reviewer name, verified-purchase & Walmart badges, helpful votes, variant reviewed, plus price, seller, category, availability, star breakdown, Walmart's AI summary & sub-scores. Sort or filter by rating.

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

## Pricing

from $1.80 / 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.
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 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 Product Reviews Scraper — Export Every Walmart Review to Excel, CSV or JSON

**Turn any Walmart.com product page into a clean spreadsheet of every customer review — full text, star rating, date, reviewer, verified-purchase flag and the brand's own replies — in seconds.**

Paste a Walmart link. Get structured review data. No browser automation, no login, no API key, no code.

- ⚡ **Fast** — a 179-review product finishes in **under 7 seconds**
- 🎯 **Complete** — pages through the entire review history, not just page one
- 💬 **Brand replies included** — the manufacturer's public response to each complaint, which most scrapers drop entirely
- 🧠 **Walmart's own AI analysis** — the review summary and per-topic sub-scores like "Ease of setup: 4.1"
- 🔒 **Bot-wall handled** — Walmart runs PerimeterX and Akamai; this Actor gets through without a browser
- 📊 **One-click export** — Excel, CSV, JSON, XML or Google Sheets

👉 **[Try it now](#-how-to-use)** — paste one URL and hit Start.

***

### 📌 What this Actor does

This **Apify Actor** is a **Walmart reviews scraper**: give it one or more Walmart product URLs and it returns one clean record per product, with every review nested inside, ready to export.

It solves a problem Walmart creates on purpose. The site shows ten reviews at a time behind a paginator, offers no export button, has no public reviews API, and sits behind a bot wall that blocks most **web scraping** tools outright. Reading 500 reviews by hand is a wasted afternoon; reading 10,000 is impossible.

#### Who it's for

| You are… | You use it to… |
|---|---|
| **Brand or marketplace seller** | Monitor your own reviews and your competitors', and catch quality complaints in days instead of quarters |
| **Product researcher / sourcing team** | Validate a product with real buyer feedback before committing to inventory |
| **Market researcher or analyst** | Mine thousands of genuine customer opinions across a whole category |
| **Customer-experience team** | Find unanswered complaints, and see how rivals reply to theirs |
| **Agency or consultant** | Deliver review-based competitive audits without manual copy-paste |
| **Developer or data team** | Feed a clean, de-duplicated, dated review feed into dashboards, BI tools or LLM pipelines |

#### Real-world examples

- Pull all 1-star reviews of your top three competitors and rank their most common complaints.
- Track a product's rating weekly and alert when new negative reviews appear.
- Export 2,000 reviews of a category leader as training or evaluation data for a sentiment model.
- Harvest 5-star reviews with buyer names for social proof on a landing page.

***

### ✨ Key features

- **Every reachable review, not a sample.** Pages through the full history automatically — up to 10,000 per product, which is Walmart's own limit (see [FAQ](#-faq-and-troubleshooting)).
- **Brand and seller replies.** Walmart lets manufacturers answer reviews publicly, and those replies are real competitive intelligence. On the router used to build this Actor, 21 of 179 reviews carried one.
- **Walmart's own review analysis, included free.** The AI-written summary shown above the review list, the "customers mention" topics with a count each, and the per-topic sub-scores out of 5.
- **Filter to one star rating.** Pull only 1-star reviews to find product problems, or only 5-star for testimonials — and it's also how you scrape past the 10,000 ceiling.
- **Five sort orders.** Most relevant, newest, oldest, highest rated, lowest rated.
- **Full product context in the same record.** Name, image, price, seller, category breadcrumb, availability, average rating and the complete 1–5 star breakdown with percentages.
- **Syndicated reviews are labelled, not disguised.** Walmart mixes in reviews syndicated from manufacturer sites; `syndicatedFrom` tells you exactly which came from where.
- **Honest coverage reporting.** Every record carries `reviewsAvailable`, `reviewsCollected` and a `partial` flag, so you always know whether an export is complete.
- **Any link format works.** Full product URLs, slug-less URLs, reviews-page URLs, or a bare item ID. Share links with tracking parameters paste in as-is.
- **Batch friendly.** Queue a whole competitor catalogue in one run.
- **Scheduling ready.** Run daily with newest-first sorting and a small cap to collect only what's new.

***

### 🧠 Why this Actor is different

Walmart is one of the harder retail sites to scrape. It runs **PerimeterX** *and* **Akamai Bot Manager**, and its internal review API is sealed shut. Most Walmart scrapers either drive a headless browser (slow and expensive) or quietly return partial data. Here's what this one does differently — all of it measured during development, not claimed.

**1. No browser, so it's genuinely fast and cheap.** Competing Actors launch Chrome to get past the bot wall, which burns memory and compute on every single page. This one is a plain HTTP client. A 179-review product completes in **6.7 seconds across 4 requests**.

**2. It doesn't depend on the API everyone else fails on.** Walmart's own review endpoint is a GraphQL persisted query that returns **456 Forbidden** to every request — with a complete browser header set, with warmed cookies, from residential IPs. It also depends on a hash that changes with every Walmart release, so scrapers built on it break repeatedly. This Actor reads the server-rendered reviews page instead: same data, no cookies, nothing to rot.

**3. It doesn't fall into Walmart's pagination trap.** Past page 200, Walmart serves **page 1 again** instead of stopping. Any scraper that follows the "next page" link loops forever re-collecting the same 50 reviews and reports success. This Actor bounds the sweep and de-duplicates by review ID.

**4. It requests 50 reviews per page, not 10.** Walmart's page defaults to 10 and silently ignores any request above 50 — ask for 100 and you get 10, meaning five times the requests for identical data. This Actor pins the real maximum.

**5. It tells you when Walmart's ordering cost you reviews.** Walmart's default "most relevant" order is not stable between requests. On a large product, a 200-page sweep received 10,000 rows of which only **8,503 were distinct** — later pages re-served rows earlier ones had already given, and each duplicate displaced a review that was never shown. This Actor measures that, flags the record `partial`, and tells you to re-run with newest-first sorting, which paged the same product with **zero** overlap. Most tools report the truncated pull as complete.

**6. The dates are correct.** Walmart publishes `10/24/2025`. Naive date parsing turns that into `2025-10-23` for anyone in a timezone west of UTC — a silent off-by-one-day bug across an entire dataset. This Actor parses it explicitly.

**7. It's tested and transparent.** 68 automated tests run against real captured Walmart payloads. Known limits are documented in the [FAQ](#-faq-and-troubleshooting) rather than hidden.

***

### ⚙️ Input configuration

#### Minimal example

One URL is all you need:

```json
{
  "startUrls": [
    { "url": "https://www.walmart.com/ip/ASUS-RT-AX1800S-Router/889126122" }
  ]
}
```

#### Full example

```json
{
  "startUrls": [
    { "url": "https://www.walmart.com/ip/ASUS-RT-AX1800S-Router/889126122" },
    { "url": "https://www.walmart.com/reviews/product/1363183437" },
    { "url": "10450114" }
  ],
  "maxReviews": 500,
  "sortBy": "submission-desc",
  "ratingFilter": "all",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

#### Input fields

| Field | Type | Default | What it does |
|---|---|---|---|
| `startUrls` | array | — | **Required.** The Walmart products to scrape. Accepts product URLs, reviews-page URLs and bare item IDs (see below). |
| `maxReviews` | integer | `0` | Stop after this many reviews **per product**. `0` collects everything available. |
| `sortBy` | string | `relevancy` | `relevancy` (site default), `submission-desc` (newest), `submission-asc` (oldest), `rating-desc` (highest), `rating-asc` (lowest). |
| `ratingFilter` | string | `all` | `all`, or `5` / `4` / `3` / `2` / `1` to collect one star rating only. |
| `proxyConfiguration` | object | Apify Residential, US | Strongly recommended. See [Advanced tips](#-advanced-tips). |

#### Accepted URL formats

All four of these point at the same product and all four work:

```
https://www.walmart.com/ip/ASUS-RT-AX1800S-Router/889126122
https://www.walmart.com/ip/889126122
https://www.walmart.com/reviews/product/889126122
889126122
```

Query strings are ignored, so a copied share link such as
`.../889126122?athAsset=eyJhdGhjcGlkIjoi...&athena=true` can be pasted without cleaning it up.

#### 💡 Tips for best results

- **Keep the residential proxy on.** This is the single biggest factor in whether a run succeeds. During development a bare IP was hard-blocked by PerimeterX after roughly 30 requests; a residential IP served 24 back-to-back requests with no trouble.
- **Keep the proxy country set to US.** walmart.com is the US storefront.
- **For very popular products, set `sortBy` to `submission-desc`.** It is a stable order; `relevancy` is not (see difference #5 above).
- **For scheduled monitoring, combine `submission-desc` with a small `maxReviews`.** `maxReviews: 50` costs one request per product and catches everything new since the last run.
- **A `partial: true` record usually just needs a re-run.** Fresh proxy IPs normally pick up the rest.

***

### 📤 Output format

One dataset record per product: the product's own fields at the top level, with every review nested under `reviews`. Export from the **Dataset** tab as Excel, CSV, JSON, XML or straight to Google Sheets.

#### Sample output

```json
{
  "itemId": "889126122",
  "productUrl": "https://www.walmart.com/ip/ASUS-RT-AX1800S-Router/889126122",
  "reviewsUrl": "https://www.walmart.com/reviews/product/889126122",
  "name": "ASUS RT-AX1800S Dual Band WiFi 6 (802.11ax) Router Supporting MU-MIMO and OFDMA Technology",
  "productType": "Network Routers",
  "imageUrl": "https://i5.walmartimages.com/seo/ASUS-RT-AX1800S-Router_7a94aa00.jpeg",
  "categoryPath": [
    { "name": "Electronics", "url": "https://www.walmart.com/cp/electronics/3944" },
    { "name": "Networking", "url": "https://www.walmart.com/cp/networking/126297" },
    { "name": "Routers", "url": "https://www.walmart.com/cp/routers/1073784" }
  ],
  "category": "Routers",
  "sellerName": "KAISER",
  "sellerId": "F239A65F520D4E65AB9CB7AF12C323EE",
  "offerId": "84C7E13ADA5233378A68707E35D3F0FA",
  "price": 99.3,
  "currency": "USD",
  "availabilityStatus": "IN_STOCK",
  "rating": 4.2,
  "ratingRounded": 4.2,
  "reviewCount": 225,
  "reviewsWithTextCount": 179,
  "ratingBreakdown": { "1": 25, "2": 8, "3": 8, "4": 29, "5": 155 },
  "ratingPercentages": { "1": 11, "2": 4, "3": 4, "4": 13, "5": 69 },
  "recommendedPercentage": 85,
  "aiSummary": {
    "title": "Router offers impressive speed, range, and value for money",
    "text": "Customers are highly satisfied with the router's exceptional speed, impressive range, and strong connection…"
  },
  "aspects": [
    { "id": "81", "name": "Ease Of Setup", "snippetCount": 46 },
    { "id": "13266", "name": "Connection Reliability", "snippetCount": 24 }
  ],
  "reviewFeatures": [
    { "id": "81", "name": "Ease of setup", "score": 4.1, "polarity": "Positive" },
    { "id": "184", "name": "Internet speed", "score": 5, "polarity": "Positive" }
  ],
  "topPositiveReviewId": "1203803250",
  "topNegativeReviewId": "1196730135",
  "sortBy": "relevancy",
  "ratingFilter": "all",
  "reviewsAvailable": 179,
  "reviewsCollected": 179,
  "partial": false,
  "scrapedAt": "2026-08-12T14:52:03.114Z",
  "reviews": [
    {
      "reviewId": "1196730135",
      "rating": 1,
      "title": "V2 GUI has a problem with aimesh mapping",
      "text": "Very disappointed with the V2 RT-AX1800S. I was replacing a 1800S V1 that had performed well…",
      "date": "2025-07-08",
      "reviewerName": "Oldwizard",
      "reviewerId": "a0yasg2ayec363btkmz90wriw",
      "verifiedPurchase": true,
      "badges": ["Verified Purchase", "Seller Verified Purchase"],
      "helpfulVotes": 1,
      "unhelpfulVotes": 0,
      "recommended": null,
      "photos": [],
      "language": "English",
      "externalSource": "bazaarvoice",
      "syndicatedFrom": "https://www.asus.com",
      "sellerResponse": [
        {
          "author": "CLM",
          "text": "Dear Oldwizard, Thank you for your comment. We do understand your disappointment…",
          "date": null,
          "logoUrl": null
        }
      ],
      "variantName": "ASUS RT-AX1800S Router",
      "variantImageUrl": "https://i5.walmartimages.com/seo/ASUS-RT-AX1800S-Router_7a94aa00.jpeg",
      "aspects": [{ "id": "481", "name": "For Home Use", "polarity": "Negative" }],
      "status": "APPROVED"
    }
  ]
}
```

#### Product fields

| Field | Description |
|---|---|
| `itemId` | Walmart's item ID. |
| `productUrl` / `reviewsUrl` | Canonical product page and reviews page. |
| `name`, `productType`, `imageUrl` | Product name, Walmart's product type, main image. |
| `categoryPath`, `category` | Full breadcrumb from root to leaf, plus the leaf on its own. |
| `sellerName`, `sellerId`, `offerId` | Whoever currently holds the buy box — Walmart itself or a marketplace seller. |
| `price`, `currency`, `availabilityStatus` | Current price as a number, and stock status. |
| `rating`, `ratingRounded` | Average rating out of 5. |
| `reviewCount` | **Every rating Walmart holds**, including star-only ratings with no written text. |
| `reviewsWithTextCount` | The subset that has written text — the only kind Walmart serves. |
| `ratingBreakdown`, `ratingPercentages` | Counts and percentages per star. |
| `recommendedPercentage` | Share of reviewers who would recommend the product. |
| `aiSummary` | Walmart's own AI-written `{ title, text }` digest of the reviews. |
| `aspects` | The "customers mention" topics, each with a `snippetCount`. |
| `reviewFeatures` | Per-topic sub-scores out of 5, with a sentiment polarity. |
| `topPositiveReviewId`, `topNegativeReviewId` | The two reviews Walmart features. |
| `sortBy`, `ratingFilter` | The query this record was pulled under — so a multi-run dataset is self-describing. |
| `reviewsAvailable` / `reviewsCollected` | What this query could reach vs what was actually collected. |
| `partial` | `true` when the run stopped short of everything available. |
| `scrapedAt` | ISO timestamp of the pull. |

#### Review fields

| Field | Description |
|---|---|
| `reviewId` | Walmart's review ID — stable, so use it to de-duplicate across runs. |
| `rating` | 1–5. |
| `title`, `text` | Review headline and body. |
| `date` | `YYYY-MM-DD`. Walmart publishes the day only, with no time. |
| `reviewerName`, `reviewerId` | Display name and Walmart's author ID. |
| `verifiedPurchase` | `true` when Walmart confirms the reviewer bought the product. |
| `badges` | The readable labels Walmart shows on the review. |
| `helpfulVotes`, `unhelpfulVotes` | "Was this helpful?" counts. |
| `recommended` | Whether the reviewer recommends the product, when asked. |
| `photos` | Customer photo URLs. |
| `language` | Language the review was written in. |
| `externalSource`, `syndicatedFrom` | Set when the review was syndicated from a manufacturer's site rather than left on Walmart. |
| `sellerResponse` | The brand's or seller's public reply, when there is one. |
| `variantName`, `variantImageUrl` | The exact variant reviewed — reviews are shared across a product's variants. |
| `aspects` | Walmart's own topic tags for this review, with names resolved. |
| `status` | Walmart's moderation status, e.g. `APPROVED`. |

***

### ▶️ How to use

#### On the Apify platform (no code required)

1. Click **Try for free** at the top of this page.
2. Paste one or more Walmart product URLs into **Start URLs**.
3. *(Optional)* Set **Max reviews per product**, choose a **Sort** order, or pick a single **star rating**.
4. Leave **Proxy configuration** on Apify Residential / US.
5. Click **Start** and watch the log.
6. Open the **Dataset** tab and click **Export** — Excel, CSV, JSON, XML or Google Sheets.

#### Where to find a product URL

Open any product on walmart.com and copy your browser's address bar. That's it — no cleaning up required.

#### Run it on a schedule

Use Apify **Schedules** to run daily or weekly:

1. Create a schedule and attach this Actor.
2. Set `sortBy` to `submission-desc` and `maxReviews` to something small, e.g. `50`.
3. Each run then costs one request per product and returns only recent reviews.
4. De-duplicate against your own store on `reviewId`.

#### Call it from code

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

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

const run = await client.actor('YOUR_USERNAME/walmart-product-reviews-scraper').call({
    startUrls: [{ url: 'https://www.walmart.com/ip/ASUS-RT-AX1800S-Router/889126122' }],
    sortBy: 'submission-desc',
    maxReviews: 200,
});

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

console.log(`${items[0].name}: ${items[0].reviews.length} reviews`);
```

Python, cURL and other language snippets are on the Actor's **API** tab.

***

### 📈 Use cases

**1. Competitive review monitoring.** Queue your rivals' bestsellers, run weekly, and track how their ratings and complaint themes move. Because `reviewId` is stable, you can diff runs to see exactly what's new.

**2. Quality alerts on your own catalogue.** Run daily with `ratingFilter: "1"` and route new 1-star reviews to your support queue. You find the defect from real buyers before it becomes a returns spike.

**3. Reply-gap auditing.** `sellerResponse` shows which complaints your competitors answer publicly and which they ignore — a direct read on their customer-experience operation, and an easy differentiator to pitch.

**4. Pre-sourcing product validation.** Before you buy inventory, export every review of the category leaders and read what buyers actually complain about. `reviewFeatures` gives you Walmart's own sub-scores per topic, so you can see whether the weakness is setup, durability or value.

**5. Sentiment analysis and LLM pipelines.** Thousands of real reviews, already de-duplicated, dated and labelled with verified-purchase status, is high-quality input for a sentiment model or a RAG index.

**6. Marketing social proof.** Pull `ratingFilter: "5"` for testimonials, complete with reviewer names and the specific variant purchased.

***

### 🛠️ Advanced tips

#### Scrape past Walmart's 10,000-review limit

Walmart paginates at most 200 pages of 50 reviews — 10,000 — for any one query. Some products have far more: Great Value Whole Milk has around 359,000 ratings, 25,372 of them with text.

The workaround is the star filter, because **each star rating is paged separately and gets its own 10,000-review allowance**. Run the Actor five times on the same product with `ratingFilter` set to `5`, `4`, `3`, `2` and `1`, and you reach up to 50,000 reviews. Use `ratingBreakdown` in the output to see how many exist per star before you commit.

#### Proxy configuration

- **Residential, not datacenter.** Walmart's PerimeterX wall is far more tolerant of residential exit IPs.
- **Country: US.** walmart.com is the US storefront.
- **Blocks are an IP problem, not a settings problem.** The Actor detects a block, rotates to a fresh proxy session automatically, and retries up to five times per page. If a whole run fails, re-running usually lands on cleaner IPs.
- **Running without a proxy works for a handful of requests, then stops.** Expect a hard block after a few dozen.

#### Performance and cost tuning

- **Set `maxReviews`.** It's the most effective lever there is: a product's first 100 newest reviews cost 2 requests instead of 200.
- **Prefer `submission-desc` for large products.** Stable ordering means no wasted requests re-reading pages you already have.
- **Batch products into one run** rather than one run each — the Actor reuses the same proxy session across products until one gets blocked.
- **Memory:** 512 MB–1 GB is plenty. There's no browser, so more memory buys nothing.

#### Incremental scraping

Because `reviewId` is stable and `date` is a plain `YYYY-MM-DD`, incremental collection is simple: run with `submission-desc`, and stop merging once you hit a `reviewId` you already have.

***

### ❓ FAQ and troubleshooting

#### Why did I get fewer reviews than the product page shows?

Almost always because **Walmart only serves reviews that have written text**. A product showing "225 reviews" may have only 179 with text — the other 46 are star-only ratings that no tool can retrieve, because Walmart never sends them. Both numbers are in every record: compare your count against `reviewsWithTextCount`, not `reviewCount`.

#### What does `partial: true` mean?

The run stopped short of everything available. Three possible reasons, all named in the run log:

1. A page failed on every retry — usually proxy blocks. **Re-run.**
2. The product is past Walmart's 10,000-review ceiling. **Use the star-filter workaround above.**
3. Walmart's `relevancy` ordering re-served rows and displaced others. **Re-run with `sortBy: "submission-desc"`.**

#### Can it scrape more than 10,000 reviews from one product?

Not in a single run — that's Walmart's limit, not the Actor's. Use the [star-filter workaround](#scrape-past-walmarts-10000-review-limit) to reach up to 50,000.

#### "No reviews were collected" — what now?

PerimeterX blocked every proxy IP the run was given. Enable the Apify Residential proxy if it's off, then re-run to get fresh IPs. The run log will say whether it received the block page.

#### "Walmart served no product for item …"

That item ID doesn't exist or has been delisted. Walmart answers a bogus ID with an empty-but-valid page rather than an error, so the Actor checks explicitly instead of writing a record full of nulls. Confirm the URL opens in a browser.

#### "Could not find an item id in …"

The URL isn't a product or reviews page. Search, category and browse URLs aren't supported — open the individual product and copy that URL instead.

#### Does it need a login or an API key?

No. It uses no cookies, no session and no Walmart credentials.

#### How much does a run cost?

The Actor is priced per result — one event per product plus one per review — so cost scales with the data you actually receive, and a failed product bills nothing. Set `maxReviews` to cap spend, and use Apify's per-run maximum charge if you want a hard ceiling. The Actor stops cleanly when it hits that ceiling instead of scraping data it can't charge for.

#### How fast is it?

A 179-review product finishes in about 7 seconds (4 requests). A 433-review product takes 9 requests. A full 10,000-review sweep is 200 requests and runs for a few minutes.

#### Are review photos included?

The field is there (`photos`), but Walmart's reviews page returned empty photo arrays for every product sampled. Don't build a workflow that depends on it.

#### Are the reviews really from Walmart?

Some are syndicated from manufacturer websites — Walmart mixes them in, and on the router example 157 of 179 came from asus.com via Bazaarvoice. Rather than hiding that, the Actor labels every such review with `externalSource` and `syndicatedFrom` so you can filter them out if you only want Walmart-native reviews.

#### Can I get reviews from Walmart Canada or Mexico?

Not currently. This Actor targets walmart.com, the US storefront.

#### Is scraping Walmart reviews legal?

This Actor collects only publicly visible data, with no login and no access to personal accounts. Reviewer display names are published by Walmart itself. You are responsible for how you use the data — if you process personal data of people in the EU or California, review your GDPR/CCPA obligations. See Apify's guide on [ethical web scraping](https://blog.apify.com/is-web-scraping-legal/).

#### Something else is broken

Run it again with the **Log** tab open and send us the run ID — see Support below. The log names the exact failure for every product.

***

### 📞 Support

- **Questions, bug reports and feature requests:** open a ticket on the Actor's **Issues** tab, and include the **run ID** plus the input you used. That's the fastest route to a fix.
- **Direct contact:** **<me@ahmedhrid.com>**
- **Custom scraping work:** if you need a different Walmart dataset — search results, product catalogues, price tracking, or another retailer — email the address above.

Engineering notes, including how the bot wall was diagnosed and every measured limit, are in [`docs/how-it-works.md`](docs/how-it-works.md).

***

#### Related searches

walmart scraper · walmart reviews scraper · walmart product reviews api · export walmart reviews to excel · walmart review data · scrape walmart product data · walmart web scraping · apify actor walmart · e-commerce review scraper · product review scraping tool · walmart competitor analysis · retail sentiment analysis · customer review dataset · walmart marketplace research

# Actor input Schema

## `startUrls` (type: `array`):

Walmart items to scrape. Every URL shape works — https://www.walmart.com/ip/<slug>/<itemId>, the slug-less https://www.walmart.com/ip/<itemId>, and the reviews page https://www.walmart.com/reviews/product/<itemId> — and so does a bare item id on its own, e.g. 889126122. Query strings are ignored, so a share link with ?athAsset=... can be pasted as-is.

## `maxReviews` (type: `integer`):

Stop after this many reviews per item. 0 means collect every review Walmart will serve, which is up to 10,000 per item — see the note on Only this star rating for how to reach past that.

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

Most relevant is what the reviews page shows by default. Pick Newest first for two reasons: it is the order you want for scheduled runs that track new reviews, and it is a stable order. Most relevant is not — Walmart reshuffles it between requests, so a sweep of a very popular product can re-read some pages and miss others (6-15% of rows lost on a 25,000-review item, versus 0% for Newest first). It depends on the product's churn rather than its size: items with 179 and 433 reviews both came back complete under Most relevant. The actor measures this either way and flags the record partial if it happens.

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

Collect only reviews with this many stars. Leave on All ratings to collect everything. This is also how to get past Walmart's 10,000-review ceiling on very popular items: each star is paged separately and gets its own 10,000-review allowance, so five runs — one per star — reach up to 50,000. The per-star counts are in the record's ratingBreakdown.

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

Strongly recommended, and residential rather than datacenter. Walmart is fronted by PerimeterX: a bare IP was hard-blocked after roughly 30 requests during development, and once blocked it stays blocked for a while. Keep the country on US — walmart.com is the US storefront.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.walmart.com/ip/ASUS-RT-AX1800S-Router/889126122"
    }
  ],
  "maxReviews": 0,
  "sortBy": "relevancy",
  "ratingFilter": "all",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

Each record is one item. Top level: itemId, productUrl and reviewsUrl, name, productType, imageUrl, categoryPath\[] as the breadcrumb from root to leaf plus the leaf on its own as category, sellerName / sellerId / offerId, price with currency, availabilityStatus, rating out of 5 with ratingRounded, reviewCount (every rating Walmart holds, including the star-only ones with no text), reviewsWithTextCount (the subset that can actually be paged through), ratingBreakdown and ratingPercentages by star, recommendedPercentage, aiSummary as Walmart's own {title, text} digest of the reviews, aspects\[] as the "customers mention" topics with a snippetCount each, reviewFeatures\[] as the per-topic sub-scores out of 5, topPositiveReviewId and topNegativeReviewId, the sortBy and ratingFilter the pull ran under, plus the coverage pair reviewsAvailable / reviewsCollected, a `partial` flag that is true when the sweep stopped short of everything available — because a page failed, because the item is past Walmart's 10,000-review ceiling, or because Walmart's unstable `relevancy` ordering re-served rows and displaced others — and scrapedAt. Nested `reviews[]`: reviewId, rating out of 5, title, text, date as YYYY-MM-DD (Walmart publishes the day only), reviewerName, reviewerId, verifiedPurchase, badges\[] as the readable labels Walmart shows on the review, helpfulVotes and unhelpfulVotes, recommended, photos\[], language, externalSource and syndicatedFrom for reviews syndicated from a manufacturer's site, sellerResponse, the variantName and variantImageUrl of the exact variant reviewed, aspects\[] as Walmart's own topic tags with resolved names, and status. Only reviews with text are served by Walmart — star-only ratings are counted in reviewCount but are not retrievable — and any one query reaches at most 10,000 reviews.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.walmart.com/ip/ASUS-RT-AX1800S-Router/889126122"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("reviewly/walmart-product-reviews-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.walmart.com/ip/ASUS-RT-AX1800S-Router/889126122" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("reviewly/walmart-product-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 '{
  "startUrls": [
    {
      "url": "https://www.walmart.com/ip/ASUS-RT-AX1800S-Router/889126122"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call reviewly/walmart-product-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,reviewly/walmart-product-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/GVEwIAkwosw8uvWrF/builds/sj8vCUPwKwhitnfjJ/openapi.json