# Walmart Product & Reviews Scraper (`sian.agency/walmart-data-scraper`) Actor

Scrape Walmart.com at scale: product search, category listings, full product details, every seller offer, and customer reviews. 5 operations, one clean JSON dataset. Built for price monitoring, competitor catalog mapping, marketplace seller intel and review analysis.

- **URL**: https://apify.com/sian.agency/walmart-data-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** E-commerce, Business, Marketing
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Walmart Price Tracker & Data API — No API Key 🛒

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Store-Amazon Influencer & Deals](https://img.shields.io/badge/Store-Amazon%20Influencer%20%26%20Deals-FF9900)](https://apify.com/sian.agency/amazon-influencer-deals-scraper?fpr=sian) [![Store-Taobao & Tmall](https://img.shields.io/badge/Store-Taobao%20%26%20Tmall-FF4F00)](https://apify.com/sian.agency/taobao-tmall-product-scraper?fpr=sian) [![Store-TikTok Shop](https://img.shields.io/badge/Store-TikTok%20Shop-25F4EE)](https://apify.com/sian.agency/tiktok-shop-scraper?fpr=sian)

#### 🎉 Track Walmart prices, stock, and reviews on autopilot — the Walmart API alternative that needs no API key, no approval, and no developer account
##### Built for price-tracking SaaS founders, e-commerce ops teams, market researchers, and marketplace sellers who need clean Walmart.com data on a schedule

### 📋 Overview

**Walmart price tracking made ridiculously simple.** Point this actor at a product, a category, or a search term — click Run — and get clean, query-ready rows back. No login, no proxy setup, and no waiting on a Walmart API key or seller-account approval. It's the Walmart data API you can actually use today.

Most Walmart scrapers on the Store do one thing — search *or* product *or* reviews. This actor bundles **five operations** behind a single dropdown: keyword product search, full category listings, deep product details, **every third-party seller offer (one row per offer)**, and paginated customer reviews. Pick one operation per run, get one tidy dataset out. Perfect for building a Walmart price monitor, mapping competitor catalogs, mining voice-of-customer review data, and benchmarking your buy-box position against marketplace sellers.

**Why thousands of professionals choose us:**
- ✅ **Walmart API alternative, zero setup**: no API key, no developer registration, no seller account — paste an input and run
- 💰 **Built for price tracking**: capture `price`, `listPrice`, `savingsAmount`, and stock status on a schedule, then diff the dataset to catch price moves and rollbacks
- ⚡ **5 operations in one actor**: search · products by category · product details · seller offers · customer reviews
- 🏷️ **Per-offer seller rows — a SIÁN exclusive**: the full third-party marketplace for any product (seller, price, shipping, WFS, returns), one row per offer — no other Walmart actor exposes this cleanly
- 🎯 **80+ structured fields**: curated camelCase aliases (`productId`, `price`, `rating`, `seller`, `verifiedPurchase`) plus raw upstream fields spread alongside — analyst-friendly and engineer-complete
- 💎 **Pay only for successful rows**: failed lookups land as `status:"error"` rows at zero cost — you're never billed for a hiccup

### ✨ Features

- 🔍 **Product Search**: keyword search across Walmart.com, paginated (~40 products/page) with sort and price filters — your Walmart search API alternative
- 🗂️ **Products by Category**: list an entire Walmart category by ID, paginated, for share-of-shelf and assortment analysis
- 📦 **Product Details**: deep single-product scrape — price, specs, variants, breadcrumbs, UPC, ratings, and full HTTPS image gallery
- 🏷️ **Product Offers**: every seller offer for a product, one row each — seller name, price, shipping, WFS, return policy, fulfillment type
- ⭐ **Product Reviews**: paginated customer reviews with text, rating, author, verified-purchase flag, and helpful-vote counts — returns **all ratings by default**
- 💲 **Price & Stock Capture**: `price`, `listPrice`, `savingsAmount`, `availability`, and `outOfStock` on every product row — ready for a price-tracking pipeline
- 🌍 **US + Canada marketplaces**: query `walmart.com` (`us`) or `walmart.ca` (`ca`) with one setting per run
- ↕️ **Native Sort & Filter**: best match, price low/high, best seller, top rated — plus min/max price, store ID, state, and ZIP localization
- 🖼️ **HTTPS-Normalized URLs**: every product image and link arrives ready to embed
- 📊 **Single Clean Dataset Shape**: one flat row per item, filterable by `_operation` and `status` — same export pipeline works across all five operations

### 🎬 Quick Start

So simple, no training needed! Pick an operation, fill the matching input, click Run.

```bash
## Or use the API — one line
curl -X POST https://api.apify.com/v2/acts/sian.agency~walmart-data-scraper/runs?token=YOUR_TOKEN \
-d '{"operation":"search","query":"coffee maker","sortBy":"best_match","maxPages":3}'
````

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Pick an Operation

Choose one of five operations from the dropdown: Product Search, Products by Category, Product Details, Product Offers, or Product Reviews. One run = one operation.

#### Step 2: Fill the Matching Input

- **Search** → a `query` (e.g. `coffee maker`)
- **Products by Category** → a `categoryId` (e.g. `3944` = Electronics)
- **Product Details / Offers / Reviews** → a `productId`

Optionally set `domain` (`us` / `ca`), `sortBy`, price filters, and `maxPages`.

#### Step 3: Click Run

One click and we scrape, flatten, normalize, and push clean rows to your dataset. An HTML run report lands in the key-value store. Export to JSON, CSV, or Excel from the Apify console — or pull via API.

**That's it! In seconds, you'll have:**

- Clean flat rows from any of five Walmart endpoints — same shape, ready to export
- 80+ curated camelCase fields per row plus raw upstream data spread alongside
- Price, list price, savings, rating, and stock status on every product row
- Per-offer seller rows ready to filter on `wfsEnabled`, `freeShipping`, or `seller`
- HTTPS image and product URLs ready to embed
- Error rows for failed inputs — never billed

### 📥 Input Configuration

One operation per run. Each operation has its own required field (validated before charging). The optional `domain` and pagination/filter fields apply where relevant.

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| operation | enum | Yes | One of: `search`, `productsByCategory`, `productDetails`, `productOffers`, `productReviews` |
| query | string | search | Keyword to search Walmart (e.g. `coffee maker`) |
| categoryId | string | productsByCategory | Walmart category ID (e.g. `3944` = Electronics) |
| productId | string | productDetails, productOffers, productReviews | Numeric `us_item_id` **or** alphanumeric `product_id` |
| domain | enum | No | `us` (walmart.com, default) or `ca` (walmart.ca) |
| sortBy | enum | No (search / category) | `best_match`, `price_low`, `price_high`, `best_seller`, `top_rated` |
| reviewSort | enum | No (reviews) | `relevancy`, `recent`, `rating_high_low`, `rating_low_high` |
| reviewRating | integer | No (reviews) | Return only reviews with this star rating (1–5); blank = all ratings |
| reviewLimit | integer | No (reviews) | Reviews per page (1–50, default 10) |
| minPrice / maxPrice | integer | No (search / category) | Price filters |
| storeId / state / zip | string | No (search / category) | Localize availability and shipping |
| maxPages | integer | No | 1–50, controls paginated runs (default 5) |

**Example — Product Search:**

```json
{
  "operation": "search",
  "query": "coffee maker",
  "sortBy": "best_match",
  "maxPages": 3
}
```

**Example — Products by Category:**

```json
{
  "operation": "productsByCategory",
  "categoryId": "3944",
  "sortBy": "best_seller",
  "maxPages": 2
}
```

**Example — Product Details (single product):**

```json
{
  "operation": "productDetails",
  "productId": "609040889"
}
```

**Example — Product Offers (every seller, one row each):**

```json
{
  "operation": "productOffers",
  "productId": "609040889"
}
```

**Example — Product Reviews (all ratings, newest first):**

```json
{
  "operation": "productReviews",
  "productId": "609040889",
  "reviewSort": "recent",
  "maxPages": 5
}
```

💡 **Workflow tip:** Run Search or Products by Category to discover product IDs, then loop Details / Offers / Reviews per product.

### 📤 Output

One flat row per item, saved to the Apify dataset with **80+ fields**. Search and category rows carry product fields; offers carry seller fields; reviews carry review fields. Curated camelCase aliases land on every row alongside the raw upstream data. Filter by `_operation` to split modes, or by `status` to separate success from error rows.

| Field | Type | Description |
|-------|------|-------------|
| productId / usItemId | string | Walmart product IDs (alphanumeric + numeric) |
| productTitle | string | Product display title |
| price / listPrice | number | Current price and list price |
| savingsAmount | number | Rollback / markdown savings |
| currency / currencySymbol | string | `USD`, `$` |
| rating / reviewCount | number / integer | Average rating and review count |
| ratingBreakdown | object | Star distribution (five/four/three/two/one) |
| brand / model / upc | string | Catalog identifiers |
| availability / outOfStock | string / boolean | Stock status |
| seller / sellerType | string | Seller name and type |
| wfsEnabled / freeShipping / twoDayShipping | boolean | Fulfillment flags |
| returnReturnable / returnFree / returnWindowDays | boolean / integer | Return policy |
| categories / specifications / variants | array | Breadcrumbs, specs, variant options |
| image / images / productUrl | string / array | HTTPS image gallery and product URL |
| offerId / sellerName / shippingPrice | string | Per-offer seller fields (Product Offers) |
| reviewId / reviewBody / reviewRating / verifiedPurchase | string / integer / boolean | Review fields (Product Reviews) |
| \_operation / \_fetchedAt / \_page / status | metadata | Always-present row metadata |

All four examples below are **real captured output** (June 2026; trimmed to the most useful fields — actual rows carry 80+):

**Example — Product Details (Restored MacBook Air):**

```json
{
  "_operation": "productDetails",
  "productId": "4SZSM8SXAAJT",
  "usItemId": "609040889",
  "productTitle": "Restored MacBook Air 13.3\" Laptop - Apple M1 chip - 8GB Memory - 256GB SSD - Space Gray",
  "brand": "Apple",
  "model": "MGN63LL/A",
  "upc": "194252048955",
  "productType": "Laptop Computers",
  "price": 399,
  "listPrice": null,
  "currency": "USD",
  "priceDisplay": "$399.00",
  "rating": 4.2,
  "reviewCount": 6406,
  "ratingBreakdown": { "five": 4671, "four": 424, "three": 193, "two": 137, "one": 936 },
  "recommendedPercentage": 78,
  "availability": "In stock",
  "outOfStock": false,
  "condition": "New",
  "seller": "Nebsys Corp",
  "sellerType": "EXTERNAL",
  "fulfillmentType": "MARKETPLACE",
  "returnReturnable": true,
  "returnFree": true,
  "returnWindowDays": 30,
  "categories": [
    { "name": "Electronics", "url": "https://www.walmart.com/cp/electronics/3944" },
    { "name": "Laptops", "url": "https://www.walmart.com/cp/laptops/3951" }
  ],
  "specifications": [
    { "name": "Processor", "value": "Apple M1" },
    { "name": "RAM memory", "value": "8 GB" },
    { "name": "Data storage", "value": "256 GB" }
  ],
  "image": "https://i5.walmartimages.com/asr/806127b8-4e03-497a-a1d0-eb6b395f6d17.4870b2f40b01e60ec3286e524eca6686.jpeg",
  "productUrl": "https://www.walmart.com/ip/Apple-MacBook-Air-13-3-inch-Laptop-Space-Gray-M1-Chip-8GB-RAM-256GB-storage/609040889",
  "status": "success",
  "_fetchedAt": "2026-06-05T10:14:22.913Z"
}
```

**Example — Product Search row:**

```json
{
  "_operation": "search",
  "productId": "4JWKYM3HL0LE",
  "usItemId": "5254334127",
  "productTitle": "Keurig K-Express Essentials Plus, Iced and Hot Single-Serve K-Cup Pod Coffee Maker, Black",
  "price": 69,
  "listPrice": 79,
  "currency": "USD",
  "rating": 4.3,
  "reviewCount": 25489,
  "seller": "Walmart.com",
  "freeShipping": true,
  "productUrl": "https://www.walmart.com/ip/Keurig-K-Iced-Essentials-Iced-and-Hot-Single-Serve-K-Cup-Pod-Coffee-Maker-Black/5254334127",
  "status": "success"
}
```

**Example — Product Offer row (one per seller):**

```json
{
  "_operation": "productOffers",
  "productId": "4SZSM8SXAAJT",
  "offerId": "EEA013B1F09D347B9C6BCB34246F7113",
  "sellerName": "Coretek Enterprises, LLC",
  "sellerType": "EXTERNAL",
  "storefrontUrl": "https://www.walmart.com/seller/7A9124E7AF31494EA9EC37A862AC98ED",
  "price": 469,
  "priceDisplay": "$469.00",
  "currency": "USD",
  "condition": "New",
  "wfsEnabled": false,
  "returnReturnable": true,
  "returnWindowDays": 15,
  "inStock": true,
  "status": "success"
}
```

**Example — Product Review row:**

```json
{
  "_operation": "productReviews",
  "productId": "609040889",
  "reviewId": "410161011",
  "reviewTitle": "It's basically a $600 paperweight",
  "reviewRating": 1,
  "reviewBody": "I've bought two different ones and neither battery will charge beyond 1%...",
  "reviewDate": "12/25/2025",
  "reviewAuthor": "anonymous",
  "positiveFeedback": 4,
  "verifiedPurchase": true,
  "status": "success"
}
```

### 💼 Use Cases & Examples

#### 1. Price-Tracking SaaS — Build a Walmart Price Monitor

**For SaaS founders building a Walmart price tracker without waiting on official API access.**

**Input:** Schedule `productDetails` (or `search`) across your watched product IDs on a daily cron
**Output:** `price`, `listPrice`, `savingsAmount`, `priceDisplay`, and `availability` per product, per run
**Use:** Diff consecutive datasets to detect price drops, rollbacks, and restocks — power "price dropped" alerts and historical price charts for your subscribers.

#### 2. E-commerce Ops — Competitor Catalog & Assortment Mapping

**For e-commerce ops teams tracking competitor SKUs and pricing on Walmart.com.**

**Input:** Run `productsByCategory` on your category IDs weekly with `sortBy: "best_seller"`
**Output:** Full category listings with prices, ratings, badges, and seller info (~40/page)
**Use:** Map competitor assortment, catch new SKU launches, and benchmark price points across your segment.

#### 3. Marketplace Seller Intelligence — Buy-Box & Offer Mapping

**For Walmart Marketplace sellers benchmarking their position against third-party offers.**

**Input:** Run `productOffers` on products you compete on
**Output:** Every seller offer as its own row — seller name, price, shipping, WFS status, return policy
**Use:** See exactly who's undercutting you, which offers are WFS-fulfilled, and where you can win the buy box. No other Walmart actor exposes per-offer rows this cleanly.

#### 4. Market Researcher — Category Share-of-Shelf

**For market researchers and consultancies sizing Walmart categories for client briefs.**

**Input:** `productsByCategory` paginated to `maxPages: 10`, plus `search` on the category keyword
**Output:** Hundreds of category + search rows with prices, ratings, sponsored flags, and badge distribution
**Use:** Calculate brand share-of-shelf, average price points, sponsored-placement density, and ratings distribution for client-ready reports.

#### 5. Voice-of-Customer — Review Mining & Sentiment Analysis

**For brand teams and product researchers mining Walmart review sentiment at scale.**

**Input:** `productReviews` paginated across competitor product IDs, all ratings by default
**Output:** Reviews with full text, star rating, `verifiedPurchase` flag, author, and helpful-vote counts, plus product-level `ratingBreakdown`
**Use:** Feed into sentiment models to surface complaints, feature requests, and competitor weaknesses — segment by rating with `reviewRating`.

#### 6. Catalog Enrichment — Specs, Variants & Images

**For teams building or enriching a product database from Walmart data.**

**Input:** `productDetails` on a list of product IDs (numeric or alphanumeric)
**Output:** Specs, variants, breadcrumbs, UPC, brand, model, and full HTTPS image gallery
**Use:** Enrich your own catalog with structured, query-ready rows, or build a competitive product database with images ready to embed.

### 🔌 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

// Discover product IDs, then track their prices
const search = await client.actor('sian.agency/walmart-data-scraper').call({
  operation: 'search',
  query: 'coffee maker',
  maxPages: 2
});

const { items } = await client.dataset(search.defaultDatasetId).listItems();
const ids = items.filter(i => i.status === 'success').map(i => i.productId);
console.log(`${ids.length} product IDs to track`);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

## Daily price snapshot for a watched product
run = client.actor('sian.agency/walmart-data-scraper').call(
    run_input={'operation': 'productDetails', 'productId': '609040889'}
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    if item.get('status') == 'success':
        print(f"{item['productTitle']} — {item['priceDisplay']} ({item['availability']})")
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~walmart-data-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"operation":"productOffers","productId":"609040889"}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger**: Schedule (daily price refresh) or webhook (new SKU added to your tracker)
2. **HTTP Request**: Call the actor API with `operation` and the per-op input fields
3. **Process**: Diff against yesterday's `price`, filter offers on `wfsEnabled`, or score review sentiment
4. **Action**: Push price-drop alerts to Slack, sync rows to Google Sheets, or update your price-tracking database

### 📈 Performance & Pricing

Transparent **pay-per-event** — you're charged only for **successful rows**, plus a small one-time start fee per run. Failed lookups land as `status:"error"` rows and cost **$0**. Higher Apify plans get automatic volume discounts on every event.

| Event | Price | Applies to |
|-------|-------|------------|
| `apify-actor-start` | **$0.006** | One-time per run |
| 🔍 `search-result` | **$0.0015** / row | Product Search |
| 🗂️ `category-result` | **$0.0015** / row | Products by Category |
| 📦 `product-detail-result` | **$0.002** / product | Product Details — **half the price of any paid alternative** |
| 🏷️ `product-offer-result` | **$0.008** / offer | Product Offers (one per seller) |
| ⭐ `product-review-result` | **$0.002** / review | Product Reviews |

**Cost examples:**

- **1,000 search results** → $1.50 + $0.006 start = **~$1.51**
- **500 category products** → $0.75 + $0.006 = **~$0.76**
- **A full product detail lookup** → $0.002 + $0.006 = **less than a cent**
- **All seller offers for a product** (e.g. 5 offers) → $0.04 + $0.006 = **~$0.05**
- **1,000 customer reviews** → $2.00 + $0.006 = **~$2.01**

💰 **Bulk search and reviews are priced at a fraction of a cent per row** — cheaper than maintaining your own proxies and parsers, with no Walmart API approval to wait on.

🔗 [View current pricing](https://apify.com/sian.agency/walmart-data-scraper?fpr=sian)

### ❓ Frequently Asked Questions

**Q: Does Walmart have an API?**
A: Walmart's official APIs (Marketplace, Affiliate, Content) are gated behind seller or partner approval and don't cover open product search, full category listings, per-seller offers, or customer reviews. This actor is the practical Walmart API alternative — it returns clean JSON for all of those, with no approval process.

**Q: How do I get a Walmart API key?**
A: You don't need one. This actor requires **no Walmart API key, no developer registration, and no seller account** — just an Apify token. Paste your input, click Run, get structured data back.

**Q: Where is the Walmart API documentation I should follow?**
A: There's no Walmart developer documentation to wade through here. Your "documentation" is the **Input** tab on the actor page: pick an operation, fill the matching field, and read the output schema below. That's the whole integration.

**Q: Can I use this as a Walmart price tracker?**
A: Yes — that's a core use case. Schedule `productDetails` or `search` on a cron and diff the dataset run-to-run to capture price drops, rollbacks (`savingsAmount`), and restocks. Every product row carries `price`, `listPrice`, and `availability`.

**Q: What does Product Offers return that other scrapers don't?**
A: One row per third-party seller offer — seller name, price, shipping, WFS status, and return policy. It maps the full marketplace behind any product so you can benchmark your buy-box position. No other Walmart actor on the Store exposes per-offer rows this cleanly.

**Q: Which marketplaces are supported?**
A: US (`walmart.com`, `domain: "us"`) and Canada (`walmart.ca`, `domain: "ca"`). One setting per run, applied to every row.

**Q: How does review filtering work?**
A: Product Reviews returns **all ratings by default**. Set `reviewRating` (1–5) to return only one star level, `reviewSort` to control order, and `reviewLimit` for page size. Pagination is controlled by `maxPages` and stops automatically at the last page.

**Q: What output formats are available?**
A: JSON, CSV, and Excel — export directly from the Apify dataset console, or pull via API.

**Q: How am I billed, and what about failed lookups?**
A: Pay-per-event — only successful rows are charged, plus a one-time start fee. Failed lookups land as `status:"error"` rows at **$0**.

### 🐛 Troubleshooting

**A run returns `status:"error"` with "temporarily unavailable"**

- The data source hit a transient hiccup. The actor retries automatically with backoff. Re-run after a moment — error rows are never charged.

**Paginated runs stop early before `maxPages`**

- The actor stops pagination when the data source reports the last page (`total_pages`). This is correct behavior, not a bug — you're not billed for empty pages.

**Product Details / Offers / Reviews returns "not found"**

- Confirm the `productId`. Either the numeric `us_item_id` (e.g. `609040889`) or the alphanumeric `product_id` (e.g. `4SZSM8SXAAJT`) works — both appear in any Search or Category row and in product URLs.

**Search or Category returns fewer rows than expected**

- Thin coverage for a query returns fewer than ~40 rows/page. Broaden the query, relax `minPrice`/`maxPrice`, or paginate deeper with `maxPages`.

**Category ID isn't returning the right products**

- Category IDs appear in the `categories[].url` of any Product Details result (e.g. `.../cp/electronics/3944` → `3944`) and in Walmart's site navigation URLs.

### 🧰 More by SIÁN Agency

- [Amazon Influencer & Deals Scraper](https://apify.com/sian.agency/amazon-influencer-deals-scraper?fpr=sian) — Amazon search, products, deals & reviews
- [Taobao & Tmall Product Scraper](https://apify.com/sian.agency/taobao-tmall-product-scraper?fpr=sian) — Chinese e-commerce products & search
- [TikTok Shop Scraper](https://apify.com/sian.agency/tiktok-shop-scraper?fpr=sian) — TikTok Shop products, search & sellers
- [Browse all SIÁN actors →](https://apify.com/sian.agency?fpr=sian)

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or feature requests, open an issue in the actor's repository or use the **Issues** tab on the actor page
- Check [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>
- ⭐ If this saves you time, a 5-star review helps us ship more features.

***

### ⚠️ Trademark Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Walmart Inc.** "Walmart" and related marks are trademarks of their respective owners and are used here only to describe the data this tool helps you collect. Use this actor responsibly and in compliance with applicable laws, Walmart's terms of service, and data-protection regulations (including GDPR and CCPA where applicable). You are responsible for how you use the data you extract.

### Legal

Scrape only publicly available data and use it lawfully. For guidance on ethical and compliant web scraping, see Apify's [guide to web scraping legality](https://blog.apify.com/is-web-scraping-legal/). Do not collect personal data in violation of GDPR, CCPA, or other applicable privacy laws.

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `operation` (type: `string`):

🎯 **PICK ONE OPERATION PER RUN.** Each run produces one clean dataset matching the chosen mode.

- **🔍 Product Search** — keyword search across Walmart products, paginated (~40 results/page)
- **🗂️ Products by Category** — all products in a Walmart category ID, paginated (~40 results/page)
- **📦 Product Details** — deep scrape of a single product (price, specs, variants, breadcrumbs, ratings)
- **🏷️ Product Offers** — every seller offer for a product (price, seller, shipping, returns) — one row per offer
- **⭐ Product Reviews** — paginated customer reviews for a product (text, rating, author, verified-purchase)

💡 **TIP:** Use Product Search or Products by Category to discover product IDs, then drill into Details, Offers, and Reviews per product.

## `query` (type: `string`):

🔍 **Required for `Product Search` operation.**

Any Walmart product search query.

- `coffee maker`
- `nike running shoes`
- `4k tv 55 inch`

💡 **TIP:** Long-tail queries return higher-relevance results. Use the `sortBy` field to control ranking.

⚠️ **Ignored** for all other operations.

## `categoryId` (type: `string`):

🗂️ **Required for `Products by Category` operation.**

The Walmart category ID.

- `3944` — Electronics
- `976759` — Cell Phones
- `4044` — Home

💡 **TIP:** Category IDs appear in the `categories[].url` of any Product Details result (e.g. `.../cp/electronics/3944` → `3944`), or in Walmart's site navigation URLs.

⚠️ **Ignored** for all other operations.

## `productId` (type: `string`):

📦 **Required for `Product Details`, `Product Offers`, and `Product Reviews` operations.**

The Walmart product identifier. Either form works:

- The numeric `us_item_id` (e.g. `609040889`)
- The alphanumeric `product_id` (e.g. `4SZSM8SXAAJT`)

Both appear in any Product Search or Products by Category result row, and in product URLs: `https://www.walmart.com/ip/.../{us_item_id}`.

💡 **TIP:** Run `Product Search` first to discover product IDs, then loop through Details / Offers / Reviews per product.

⚠️ **Ignored** for Search and Category operations.

## `domain` (type: `string`):

🌍 Which Walmart marketplace to query. `us` = walmart.com (default), `ca` = walmart.ca.

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

Sort order for `Product Search` and `Products by Category`.

- `best_match` (default)
- `price_low` — lowest price first
- `price_high` — highest price first
- `best_seller`
- `top_rated`

Ignored for Details, Offers, and Reviews.

## `reviewSort` (type: `string`):

Sort order for `Product Reviews`.

- `relevancy` (default)
- `recent` — newest first
- `rating_high_low`
- `rating_low_high`

Ignored for all other operations.

## `reviewRating` (type: `integer`):

Optional. For `Product Reviews` only — return only reviews with this star rating (1–5). Leave blank for all ratings.

## `reviewLimit` (type: `integer`):

Optional. For `Product Reviews` only — number of reviews per page (1–50). Default is 10.

## `minPrice` (type: `integer`):

Optional price filter for `Product Search` / `Products by Category`. Minimum product price. Must be lower than Max Price if both are set.

## `maxPrice` (type: `integer`):

Optional price filter for `Product Search` / `Products by Category`. Maximum product price. Must be higher than Min Price if both are set.

## `storeId` (type: `string`):

Optional. For `Product Search` / `Products by Category` — a Walmart store ID to filter results by a specific store's availability.

## `state` (type: `string`):

Optional. US state code (e.g. `CA`, `NY`) to localize search/category results — availability and shipping options.

## `zip` (type: `string`):

Optional. ZIP/postal code to localize search/category results — availability and shipping options.

## `maxPages` (type: `integer`):

📄 **Applies to paginated operations** (Search, Products by Category, Product Reviews). Ignored for single-record operations (Product Details, Product Offers).

- **Search / Category:** ~40 products per page
- **Product Reviews:** up to `reviewLimit` reviews per page (default 10)

💡 **TIP:** Start small (1–3 pages) to preview results before scaling up. Pagination stops automatically when the data source reports the last page.

⚠️ Hard cap: 50 pages to prevent runaway runs.

## Actor input object example

```json
{
  "operation": "search",
  "query": "coffee maker",
  "categoryId": "3944",
  "productId": "609040889",
  "domain": "us",
  "sortBy": "best_match",
  "reviewSort": "relevancy",
  "reviewLimit": 10,
  "state": "CA",
  "zip": "90210",
  "maxPages": 5
}
```

# Actor output Schema

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

Per-row results — one flat row per upstream item with curated camelCase aliases (productId, productTitle, price, rating, reviewCount, seller, offerId, reviewId, reviewBody, …) plus the raw upstream fields spread alongside.

## `report` (type: `string`):

HTML report with run status, success/error row counts, success rate, pages fetched, duration, and the inputs used — written even on fatal crash.

# 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 = {
    "query": "coffee maker",
    "categoryId": "3944",
    "productId": "609040889"
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/walmart-data-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 = {
    "query": "coffee maker",
    "categoryId": "3944",
    "productId": "609040889",
}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/walmart-data-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 '{
  "query": "coffee maker",
  "categoryId": "3944",
  "productId": "609040889"
}' |
apify call sian.agency/walmart-data-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Walmart Product & Reviews Scraper",
        "description": "Scrape Walmart.com at scale: product search, category listings, full product details, every seller offer, and customer reviews. 5 operations, one clean JSON dataset. Built for price monitoring, competitor catalog mapping, marketplace seller intel and review analysis.",
        "version": "1.0",
        "x-build-id": "NYJJRuQksDDDfvlbl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~walmart-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-walmart-data-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/sian.agency~walmart-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-walmart-data-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/sian.agency~walmart-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-walmart-data-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": [
                    "operation"
                ],
                "properties": {
                    "operation": {
                        "title": "🎯 Operation — what do you want to scrape?",
                        "enum": [
                            "search",
                            "productsByCategory",
                            "productDetails",
                            "productOffers",
                            "productReviews"
                        ],
                        "type": "string",
                        "description": "🎯 **PICK ONE OPERATION PER RUN.** Each run produces one clean dataset matching the chosen mode.\n\n- **🔍 Product Search** — keyword search across Walmart products, paginated (~40 results/page)\n- **🗂️ Products by Category** — all products in a Walmart category ID, paginated (~40 results/page)\n- **📦 Product Details** — deep scrape of a single product (price, specs, variants, breadcrumbs, ratings)\n- **🏷️ Product Offers** — every seller offer for a product (price, seller, shipping, returns) — one row per offer\n- **⭐ Product Reviews** — paginated customer reviews for a product (text, rating, author, verified-purchase)\n\n💡 **TIP:** Use Product Search or Products by Category to discover product IDs, then drill into Details, Offers, and Reviews per product.",
                        "default": "search"
                    },
                    "query": {
                        "title": "🔍 Search Query (for Product Search)",
                        "type": "string",
                        "description": "🔍 **Required for `Product Search` operation.**\n\nAny Walmart product search query.\n- `coffee maker`\n- `nike running shoes`\n- `4k tv 55 inch`\n\n💡 **TIP:** Long-tail queries return higher-relevance results. Use the `sortBy` field to control ranking.\n\n⚠️ **Ignored** for all other operations."
                    },
                    "categoryId": {
                        "title": "🗂️ Category ID (for Products by Category)",
                        "type": "string",
                        "description": "🗂️ **Required for `Products by Category` operation.**\n\nThe Walmart category ID.\n- `3944` — Electronics\n- `976759` — Cell Phones\n- `4044` — Home\n\n💡 **TIP:** Category IDs appear in the `categories[].url` of any Product Details result (e.g. `.../cp/electronics/3944` → `3944`), or in Walmart's site navigation URLs.\n\n⚠️ **Ignored** for all other operations."
                    },
                    "productId": {
                        "title": "📦 Product ID (for Details / Offers / Reviews)",
                        "type": "string",
                        "description": "📦 **Required for `Product Details`, `Product Offers`, and `Product Reviews` operations.**\n\nThe Walmart product identifier. Either form works:\n- The numeric `us_item_id` (e.g. `609040889`)\n- The alphanumeric `product_id` (e.g. `4SZSM8SXAAJT`)\n\nBoth appear in any Product Search or Products by Category result row, and in product URLs: `https://www.walmart.com/ip/.../{us_item_id}`.\n\n💡 **TIP:** Run `Product Search` first to discover product IDs, then loop through Details / Offers / Reviews per product.\n\n⚠️ **Ignored** for Search and Category operations."
                    },
                    "domain": {
                        "title": "🌍 Domain (Walmart marketplace)",
                        "enum": [
                            "us",
                            "ca"
                        ],
                        "type": "string",
                        "description": "🌍 Which Walmart marketplace to query. `us` = walmart.com (default), `ca` = walmart.ca.",
                        "default": "us"
                    },
                    "sortBy": {
                        "title": "↕️ Sort Order (Search / Category)",
                        "enum": [
                            "best_match",
                            "price_low",
                            "price_high",
                            "best_seller",
                            "top_rated"
                        ],
                        "type": "string",
                        "description": "Sort order for `Product Search` and `Products by Category`.\n\n- `best_match` (default)\n- `price_low` — lowest price first\n- `price_high` — highest price first\n- `best_seller`\n- `top_rated`\n\nIgnored for Details, Offers, and Reviews.",
                        "default": "best_match"
                    },
                    "reviewSort": {
                        "title": "↕️ Review Sort Order",
                        "enum": [
                            "relevancy",
                            "recent",
                            "rating_high_low",
                            "rating_low_high"
                        ],
                        "type": "string",
                        "description": "Sort order for `Product Reviews`.\n\n- `relevancy` (default)\n- `recent` — newest first\n- `rating_high_low`\n- `rating_low_high`\n\nIgnored for all other operations.",
                        "default": "relevancy"
                    },
                    "reviewRating": {
                        "title": "⭐ Review Rating Filter",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Optional. For `Product Reviews` only — return only reviews with this star rating (1–5). Leave blank for all ratings."
                    },
                    "reviewLimit": {
                        "title": "🔢 Reviews per page",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Optional. For `Product Reviews` only — number of reviews per page (1–50). Default is 10.",
                        "default": 10
                    },
                    "minPrice": {
                        "title": "💲 Min Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional price filter for `Product Search` / `Products by Category`. Minimum product price. Must be lower than Max Price if both are set."
                    },
                    "maxPrice": {
                        "title": "💲 Max Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional price filter for `Product Search` / `Products by Category`. Maximum product price. Must be higher than Min Price if both are set."
                    },
                    "storeId": {
                        "title": "🏬 Store ID",
                        "type": "string",
                        "description": "Optional. For `Product Search` / `Products by Category` — a Walmart store ID to filter results by a specific store's availability."
                    },
                    "state": {
                        "title": "📍 State",
                        "type": "string",
                        "description": "Optional. US state code (e.g. `CA`, `NY`) to localize search/category results — availability and shipping options."
                    },
                    "zip": {
                        "title": "📮 ZIP / Postal Code",
                        "type": "string",
                        "description": "Optional. ZIP/postal code to localize search/category results — availability and shipping options."
                    },
                    "maxPages": {
                        "title": "📄 Max pages to fetch",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "📄 **Applies to paginated operations** (Search, Products by Category, Product Reviews). Ignored for single-record operations (Product Details, Product Offers).\n\n- **Search / Category:** ~40 products per page\n- **Product Reviews:** up to `reviewLimit` reviews per page (default 10)\n\n💡 **TIP:** Start small (1–3 pages) to preview results before scaling up. Pagination stops automatically when the data source reports the last page.\n\n⚠️ Hard cap: 50 pages to prevent runaway runs.",
                        "default": 5
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
