# 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:** 62 total users, 25 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet
## Pricing
from $1.20 / 1,000 search result rows
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/actors/running/actors-in-store.md#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 Price Tracker & Data API — No API Key 🛒
[](https://apify.com/sian.agency?fpr=sian) [](https://apify.com/sian.agency/amazon-influencer-deals-scraper?fpr=sian) [](https://apify.com/sian.agency/taobao-tmall-product-scraper?fpr=sian) [](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
### 🔎 What is the Walmart Scraper — and when should you use it?
The **Walmart Scraper** turns a keyword, a category path or a product ID into clean, structured rows you can filter, export and feed straight into a spreadsheet, database or AI agent. No Walmart account, no developer-portal API key, no browser automation to maintain.
**Use it when you need:** Walmart prices, list prices and rollback savings, stock, ratings and review counts, specs, variants, UPCs and images, every third-party seller offer, or paginated review text.
**Use something else when:** you want the same price and stock picture from a different US big-box retailer. Use [Target Product Scraper](https://apify.com/sian.agency/target-product-scraper?fpr=sian) for Target, or [Costco Scraper](https://apify.com/sian.agency/costco-data-scraper?fpr=sian) for warehouse-club pricing. This actor covers walmart.com and walmart.ca only.
### 🤖 Use with AI agents
Already connected to the [Apify MCP server](https://mcp.apify.com)? Just ask for this Actor by name: sian.agency/walmart-data-scraper
**Your agent can pay for its own runs.** This Actor is eligible for [agentic payments](https://docs.apify.com/platform/actors/publishing/monetize), so an agent can discover it, run it and settle the bill over [x402](https://www.x402.org/) (USDC on Base) or [Skyfire](https://www.skyfire.xyz/) — without an Apify account or API token of its own. Billing is the same either way: per successful row, never for errors.
Otherwise copy this prompt into Claude, ChatGPT, Cursor or any MCP-enabled assistant:
```text
I want to track Walmart prices and stock for a list of products using the Apify Actor `sian.agency/walmart-data-scraper`.
Use it when I need: Walmart prices, list prices and savings, stock status, ratings and review counts, product specs and variants, third-party seller offers, or customer review text.
Don't use it when: I ask about a different retailer — use `sian.agency/target-product-scraper` for Target or `sian.agency/costco-data-scraper` for Costco instead.
How to call it: pick ONE `operation` per run.
- "search" takes `queries` (a list of keywords) and returns product listings.
- "productsByCategory" takes `categoryIds` (underscore-joined breadcrumb paths like 3944_1089430).
- "productDetails" takes `productIds` and returns the full spec sheet.
- "productOffers" takes `productIds` and returns one row per third-party seller.
- "productReviews" takes `productIds` and returns paginated review text.
Start with this input:
{
"operation": "search",
"queries": ["office chair", "standing desk"],
"domain": "us",
"maxPages": 3
}
Ask me which products or keywords to watch, then run the Actor and summarise the results as a table sorted by price.
```
**Things you can ask your agent for:**
- *"Pull every seller offer for these five Walmart product IDs and tell me who is undercutting the buy box."*
- *"Run a Walmart search for 'air fryer' across three pages, then flag anything where the price dropped below its list price."*
- *"Scrape the last two pages of reviews for this Walmart product and summarise the three complaints that come up most."*
Machine-readable API, MCP config and OpenAPI definition for this Actor are published at [apify.com/sian.agency/walmart-data-scraper.md](https://apify.com/sian.agency/walmart-data-scraper.md).
### 📋 Overview
**Walmart price tracking without the API paperwork.** 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.
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, hand it a single item or a whole list, and 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.
**What you get:**
- ⚡ **5 operations in one actor**: search · products by category · product details · seller offers · customer reviews. Pick one per run; the dataset shape is the same across all five.
- 🏷️ **Per-offer seller rows**: every third-party offer on a product as its own row (seller, price, shipping, WFS, returns), so you can sort and filter sellers directly.
- 📎 **Batch anything, pay one start fee**: pass a list of product IDs, keywords, or category IDs and one run covers them all. Monitoring 100 products costs **one** actor start, not 100 — that's where the money goes on scheduled, repeated lookups.
- 💰 **Built for price tracking**: capture `price`, `listPrice`, `savingsAmount`, and stock status on a schedule, then diff the dataset to catch price moves and rollbacks
- 🎯 **87 fields on a product row**: curated camelCase aliases (`productId`, `price`, `rating`, `seller`, `verifiedPurchase`) plus the raw Walmart fields spread alongside — readable in a spreadsheet, complete enough to build on
- 💎 **Pay only for successful rows**: failed lookups land as `status:"error"` rows at zero cost — you're never billed for a hiccup
- ✅ **Walmart API alternative, zero setup**: no API key, no developer registration, no seller account — paste an input and run
- 🏬 **Store-level results**: pass `storeId` or `state` on search and category runs to see what a *specific* Walmart store shows, rather than the national default
### ✨ 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, and state 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
Pick an operation, fill the matching input, click Run. Rows land in the dataset ready to export or pull over the API.
```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 — but as many *items* as you like: use the batch fields (`Product IDs`, `Search Queries`, `Category IDs`) to cover a whole list in a single run and a single start fee.
#### Step 2: Fill the Matching Input
- **Search** → a `query` (e.g. `coffee maker`) — or `queries` for a whole list
- **Products by Category** → a `categoryId` (e.g. `3944` = Electronics) — or `categoryIds`. Sub-categories need the full underscore path: `3944_1089430`, not `1089430` ([details](#category-id-format))
- **Product Details / Offers / Reviews** → a `productId` — or `productIds` for a batch
The batch fields take priority when filled, and duplicates and blanks are dropped for you. Up to 500 items per run; note that `maxPages` applies *per item*, so the two multiply.
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
- 87 fields on a product-details row: curated camelCase aliases plus the raw Walmart 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`) |
| queries | array | search | **Batch** — many keywords in one run. Wins over `query`. |
| categoryId | string | productsByCategory | Walmart category ID. Top-level = one number (`3944` = Electronics); sub-categories = full underscore path (`3944_1089430`). See [Category ID format](#category-id-format). |
| categoryIds | array | productsByCategory | **Batch** — many categories in one run. Wins over `categoryId`. Same format rule. |
| productId | string | productDetails, productOffers, productReviews | Numeric `us_item_id` **or** alphanumeric `product_id` |
| productIds | array | productDetails, productOffers, productReviews | **Batch** — many products in one run, one start fee. Wins over `productId`. |
| 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 | string | No (search / category) | Localize availability and shipping |
| zip | string | No | ⚠️ Accepted but **ignored by the data source** — use `storeId` or `state` |
| 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",
"categoryIds": ["3944", "3944_1089430_3951"],
"sortBy": "best_seller",
"maxPages": 2
}
```
> `3944` is a top-level department. `3944_1089430_3951` is Electronics › Computers, Laptops and Tablets › Laptops — sub-categories need the full path. See [Category ID format](#category-id-format).
**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 **up to 87 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 Walmart 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 product rows carry up to 87):
**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 drops, rollbacks, and restocks, then power alerts and historical 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.
#### 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 near-zero 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.0005** | One-time per run — and a batch run of 500 items still pays it **once** |
| 🔍 `search-result` | **$0.0015** / row | Product Search |
| 🗂️ `category-result` | **$0.0015** / row | Products by Category |
| 📦 `product-detail-result` | **$0.002** / product | Product Details |
| 🏷️ `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.0005 start = **~$1.50**
- **500 category products** → $0.75 + $0.0005 = **~$0.75**
- **A full product detail lookup** → $0.002 + $0.0005 = **a quarter of a cent**
- **All seller offers for a product** (e.g. 5 offers) → $0.04 + $0.0005 = **~$0.04**
- **1,000 customer reviews** → $2.00 + $0.0005 = **~$2.00**
- **100 products in one batch run** → $0.20 + $0.0005 = **~$0.20** — one start fee, not 100
💰 **The start fee is where repeated small lookups get expensive.** Ours is $0.0005, and a batch run pays it once however many items it covers. That is what the batch fields are for.
🔗 [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?**
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.
**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`.
**Products by Category returns 0 rows and no error**
- Almost always the category ID format. **Top-level departments** are a single number (`3944` Electronics, `976759` Cell Phones, `4044` Home). **Everything below a department needs the full path joined with `_`** — a bare sub-category number is accepted but matches nothing, so the run finishes clean with an empty dataset.
| Category | Correct ID | Empty result |
|---|---|---|
| Electronics | `3944` | — |
| …› Computers, Laptops and Tablets | `3944_1089430` | `1089430` |
| …› Laptops | `3944_1089430_3951` | `3951` |
- **Building the path:** run Product Details on any product in the category and read `categories[]`. Each entry's `url` ends in one number — join them in order with underscores, down to the depth you want:
```
.../cp/electronics/3944 → 3944
.../cp/computers-laptops-tablets/1089430 → 3944_1089430
.../cp/laptops/3951 → 3944_1089430_3951
```
- Taking only the last number is the single most common cause of an empty category run.
### 🧰 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
[](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
- 📧
- ⭐ 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.
## `queries` (type: `array`):
🔍 **Batch form of `Search Query`** — one run, many keywords, **one actor-start fee** instead of one per keyword.
Takes priority over `Search Query` when non-empty.
💡 **TIP:** every keyword gets its own full pagination pass, so `Max pages` multiplies — 10 keywords × 5 pages = 50 fetches.
## `categoryId` (type: `string`):
🗂️ **Required for `Products by Category`.**
Top-level departments are a single number: `3944` Electronics · `976759` Cell Phones · `4044` Home.
⚠️ **Sub-categories need the FULL path joined with `_`** — `3944_1089430` ✅, bare `1089430` ❌ returns **zero products and no error**.
💡 Build it from any Product Details result: take the number ending each `categories[].url` and join them in order → `3944_1089430_3951`.
⚠️ **Ignored** for all other operations.
## `categoryIds` (type: `array`):
🗂️ **Batch form of `Category ID`** — many categories in one run, **one actor-start fee** for all of them. Takes priority over `Category ID` when non-empty.
⚠️ Same format rule: sub-categories need the full underscore path (`3944_1089430`), not the bare number — a bare ID returns zero products with no error.
💡 `Max pages` applies per category, so 3 categories × 5 pages = 15 fetches.
## `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.
## `productIds` (type: `array`):
📦 **Batch form of `Product ID`** — the cheap way to monitor a catalogue. One run over 100 products pays **one** actor-start fee instead of 100, which is where most of the cost sits on small repeated lookups.
Takes priority over `Product ID` when non-empty. Accepts either ID form, mixed freely.
💡 **TIP:** this is the field to use for scheduled price tracking — run `Product Search` first to collect IDs, then paste them here and schedule it.
## `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`):
⚠️ **Not currently honored by the data source** — accepted, then ignored, so results come back nationally localized.
Use **Store ID** (exact store) or **State** instead — both work. Kept so existing saved tasks keep running.
## `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 Walmart item with curated camelCase aliases (productId, productTitle, price, rating, reviewCount, seller, offerId, reviewId, reviewBody, …) plus the raw Walmart fields spread alongside.
## `report` (type: `string`):
HTML run report: headline row counts, a preview of your first results, any failed items with a one-click retry input, and an itemized statement of what this run cost — written even on a 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 '' with your token
const client = new ApifyClient({
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 '' with your token.
client = ApifyClient("")
# 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(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 '{
"query": "coffee maker",
"categoryId": "3944",
"productId": "609040889"
}' |
apify call sian.agency/walmart-data-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,sian.agency/walmart-data-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 ` 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/G9kbfpMQWUZx5XwlD/builds/Le7KRfq4AqunHsMek/openapi.json