# Walmart Scraper - Products, Prices, Reviews & Sellers (`topapi/walmart-scraper`) Actor

Scrape Walmart.com products by keyword, category or link: price, was-price, unit price, rating, stock, pickup/delivery, seller, badges, variants, UPC. Add-ons: full details, customer reviews, seller contacts. No login. $0.63 per 1,000 products.

- **URL**: https://apify.com/topapi/walmart-scraper.md
- **Developed by:** [Top Api](https://apify.com/topapi) (community)
- **Categories:** E-commerce, Lead generation, Developer tools
- **Features:** Limited permissions
- **Stats:** 8 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.63 / 1,000 products

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

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

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

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

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

# README

### What does Walmart Scraper do?

**Walmart Scraper** extracts products from [Walmart.com](https://www.walmart.com). Give it search keywords, Walmart links (search, category, deals, product, seller or reviews pages), product numbers or category IDs, in any mix. Every product comes back as one row with price, was-price, unit price, rating, stock, pickup and delivery, seller, badges and variants. Full product details, customer reviews and Marketplace seller profiles are optional add-ons, each charged only when it is delivered.

Also known as: Walmart product scraper · Walmart search scraper · Walmart price scraper · Walmart reviews scraper · Walmart seller scraper · Walmart API

- **Search and category rows**: name, link, image, price, was-price, unit price, savings, variant price range, rating, rating count, stock, low-stock flag, seller, sold-by-Walmart flag, shipping / pickup / delivery with dates, Rollback / Clearance / Best seller badges, "bought since yesterday", sponsored flag, variants, category path, position and page.
- **Full product details** (add-on, and always for product links): UPC, model, manufacturer part number, description, highlights, specifications, all images, videos, warranty, the 1-5 star breakdown, every variant with its own price and stock, seller rating and storefront, return policy, every fulfillment option, other-offer count.
- **Customer reviews** (add-on): stars, title, text, date, reviewer, Verified Purchase, helpful votes, photos, the variant bought, seller responses. Sort and star filter as on Walmart.
- **Seller profiles** (add-on): display name, rating, review count, customer-service email and phone, business address and About text, as Walmart shows them.
- **Filters before the charge**: in stock, on sale, sold by Walmart, no sponsored tiles, minimum rating, minimum reviews, brands, price range. A filtered product is never charged.
- **Run it on a schedule**: monitor mode returns only products not delivered before, and optionally the ones whose price or stock changed, with the earlier values.
- **No login, no cookies, no API key**: no Walmart account is used.

### What data can you get from Walmart?

<table>
<tr><td>🏷️ Name, brand (`name`, `brand`)</td><td>💲 Price, was-price, savings (`price`, `wasPrice`, `priceInfo`)</td><td>⚖️ Unit price (`unitPrice`)</td></tr>
<tr><td>⭐ Rating, rating count, star breakdown (`averageRating`, `numberOfReviews`, `ratingCounts`)</td><td>📦 Stock, low stock (`availability`, `inStock`, `lowStock`)</td><td>🚚 Shipping, pickup, delivery with dates (`fulfillment`)</td></tr>
<tr><td>🏪 Seller, sold by Walmart (`sellerName`, `soldByWalmart`, `catalogSellerId`)</td><td>🔖 Rollback, Clearance, Best seller badges (`badges`, `rollback`, `clearance`)</td><td>📢 Sponsored tile (`isSponsored`)</td></tr>
<tr><td>🔢 UPC, model, part number (`upc`, `model`, `manufacturerProductId`)</td><td>🎨 Variants with prices and stock (`variantList`)</td><td>🗂️ Category path (`categoryPath`, `categories`)</td></tr>
<tr><td>🧾 Description, highlights, specifications</td><td>🖼️ Images, videos</td><td>↩️ Return policy, warranty</td></tr>
<tr><td>💬 Reviews with photos and variant</td><td>📇 Seller email, phone, address</td><td>📍 Location Walmart priced for (`pricedFor`)</td></tr>
</table>

Measured on real runs (2026-10-28): 500 search rows for "laptop" and "shampoo" had an id, name, link, image, price, stock, seller, fulfillment, category path and position on 500 of 500 rows; a rating on 455 (the rest are unrated), a unit price on 245, a was-price on 75, variants on 215, badges on 125 and a sponsored flag on 40. Eleven rows with details had a UPC, description, specifications, highlights, images, star breakdown and return policy on 11 of 11, a model on 10, a warranty on 6 and videos on 4. Ninety reviews had stars, text, date and the Verified Purchase check on 90 of 90, a title on 74, photos on 44 and the variant bought on 60. Three seller profiles had an email, phone and business address on 3 of 3.

### How to scrape Walmart with Walmart Scraper

1. [Create a free Apify account](https://console.apify.com/sign-up). It comes with $5 of monthly credit and no card is needed.
2. Open **Walmart Scraper** and click **Try for free**.
3. Type keywords into **Search keywords**, or paste Walmart links or product numbers into **Walmart links or product IDs**.
4. Set **Max products**, and the sort and filters you want.
5. Turn on **Full product details**, **Customer reviews** or **Seller profiles** if you want them.
6. Click **Start**. Rows appear in the dataset as they are read. Export them as JSON, CSV or Excel from the **Storage** tab, or connect a schedule.

### ⬇️ Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `searchQueries` | array | - | Keywords, one per line, as typed in Walmart's search box |
| `startUrls` | array | - | Walmart links: product (`/ip/...`), search (`/search?q=...`), category (`/browse/...`, `/cp/...`), deals (`/shop/...`), a seller's whole shelf (`/seller/<id>/cp/shopall`), seller profile (`/seller/<id>`), reviews (`/reviews/product/<id>`), or bare product numbers |
| `categoryIds` | array | - | Walmart category ids, e.g. `5440_202072_8052432` (Dog Treats) |
| `sellerIds` | array | - | Marketplace seller ids or links: one seller profile row each |
| `maxItems` | integer | 100 | Product rows in total |
| `maxItemsPerSearch` | integer | 100 | Product rows per keyword or link; in monitor mode, the window of first results checked each run |
| `maxPagesPerSearch` | integer | 25 | Result pages per keyword or link (Walmart shows 40-60 a page, at most 25 pages) |
| `sort` | string | `best_match` | `best_match`, `price_low`, `price_high`, `best_seller`, `rating_high`, `new` |
| `minPrice` / `maxPrice` | number | - | Price range in USD, sent to Walmart and checked again before the charge |
| `facets` | string | - | Walmart's own facet filter, e.g. `brand:Gildan` or `retailer_type:Walmart` (several joined with `\|\|`) |
| `inStockOnly`, `onSaleOnly`, `soldByWalmartOnly`, `excludeSponsored` | boolean | false | Drop products before they are charged |
| `minRating`, `minReviews` | number | - | Drop lower-rated or less-reviewed products before the charge |
| `brands` | array | - | Keep only these brands |
| `includeDetails` | boolean | false | Open every product page for the full record (add-on) |
| `enqueueProductVariants` | boolean | false | With details: return every variant as its own full row |
| `includeReviews` | boolean | false | Customer reviews of every product (add-on) |
| `maxReviewsPerProduct` | integer | 20 | Reviews per product (10 a page on Walmart) |
| `reviewsSort` | string | `relevancy` | `relevancy`, `helpful`, `submission-desc`, `submission-asc`, `rating-desc`, `rating-asc` |
| `reviewRating` | integer | - | Only reviews with this many stars (1-5) |
| `verifiedPurchasesOnly` | boolean | false | Only Verified Purchase reviews |
| `reviewsSince` | date | - | Only reviews on or after this date (read newest first) |
| `includeSellerDetails` | boolean | false | With details: the profile of every Marketplace seller found, once each (add-on) |
| `monitorMode` | boolean | false | Return only records earlier runs did not deliver |
| `monitorChanges` | boolean | false | In monitor mode, also return products whose price or stock changed |
| `monitorStoreName` | string | `walmart-monitor` | Name of the memory used by monitor mode (one per schedule) |
| `resetMonitor` | boolean | false | Forget earlier runs |
| `proxyMode` | string | `auto` | Product, review and seller pages once Walmart's bot check blocks the free routes: `auto` leaves them unread (never charged); `unblocker` reads them on Apify's residential proxy, then its Unblocker (see "Walmart's bot check" below) |
| `writeRunSummary` | boolean | - | `true` writes the run report `RUN_SUMMARY` on every run (left unset: runs of 50+ rows and runs with something to report) |
| `requestDelaySecs` | number | 2.5 | Pause between Walmart pages |

Field names used by other Walmart actors are accepted too (`search`, `queries`, `keywords`, `searchTerms`, `productUrls`, `itemIds`, `productIds`, `maxResults`, `maxProductsPerStartUrl`, `sortBy`, `includeProductDetails`, `reviewsSort`, `onlyChanges` and more), so switching is a copy-paste.

#### Input JSON

```json
{
    "searchQueries": ["air fryer"],
    "maxItems": 8,
    "includeDetails": true,
    "includeReviews": true,
    "maxReviewsPerProduct": 10,
    "includeSellerDetails": true
}
```

That exact input returned 8 products with details, 80 reviews and 2 seller profiles in 87 seconds.

#### One page at a time

Walmart's bot check refuses a reader that asks for pages too fast. The actor reads one page at a time with a short pause (`requestDelaySecs`, 2.5 s by default), so a search page of 40-60 products takes about 4-7 seconds and a product, review or seller page about 4 seconds. 500 search rows took 139 seconds; 8 products with details, reviews and sellers took 87 seconds.

#### Product links always come with details

A product link or product number is read from the product page itself, so its row always carries the details and is charged as a product plus the product-details add-on.

### ⬆️ Output

One row per record; `itemType` says which kind (`product`, `review`, `seller`). A real search row from the "laptop" run:

```json
{
    "itemType": "product",
    "usItemId": "20044301850",
    "productId": "1ZV37RQCWE2Q",
    "name": "SGIN 15.6\" Laptop 12GB DDR4 256GB SSD Windows 11 Laptops Computer, 4-Core Intel Celeron CPU, AI App, Office 365, 1080P FHD, Wifi 5",
    "brand": null,
    "url": "https://www.walmart.com/ip/SGIN-15-6-Laptop-12GB-DDR4-256GB-SSD-Windows-11-Laptops-Computer-4-Core-Intel-Celeron-CPU-AI-App-Office-365-1080P-FHD-Wifi-5/20044301850",
    "imageUrl": "https://i5.walmartimages.com/seo/SGIN-15-6-Laptop-12GB-DDR4-256GB-SSD-Windows-11-Laptops-Computer-4-Core-Intel-Celeron-CPU-AI-App-Office-365-1080P-FHD-Wifi-5_ce64b674-fa0f-4594-a37c-2c63bf127a1d.0a857303c6c97930a1a2307999468c78.jpeg",
    "price": 329.79,
    "wasPrice": 658.99,
    "unitPrice": null,
    "currency": "USD",
    "priceInfo": { "price": 329.79, "priceDisplay": "$329.79", "wasPrice": 658.99, "unitPrice": null, "minPrice": 329.79, "maxPrice": 499.99, "savings": 329.2, "shippingPrice": null },
    "onSale": true,
    "rollback": false,
    "clearance": false,
    "reducedPrice": false,
    "bestSeller": true,
    "averageRating": 4.3,
    "numberOfReviews": 119,
    "availability": "IN_STOCK",
    "inStock": true,
    "lowStock": false,
    "sellerName": "SGIN Official Store",
    "sellerId": "91549E334AE7410E952E6D038DF9C862",
    "soldByWalmart": false,
    "fulfillmentType": "FC",
    "fulfillment": { "shipping": true, "pickup": false, "delivery": true, "freeShipping": true, "shippingText": "Free shipping, arrives Fri, Oct 30", "pickupText": null, "deliveryText": null, "deliveryDate": "2026-10-30T21:59:00.000Z", "pickupDate": null },
    "badges": ["Best seller"],
    "flag": "Best seller",
    "isSponsored": false,
    "boughtSinceYesterday": null,
    "inCarts": null,
    "variantCount": 4,
    "variantOptions": [
        { "name": "6GB+128GB", "usItemId": "17303654113", "url": "https://www.walmart.com/ip/Foldable-Tablet-Stand-Universal-Adjustable-Desk-Stand-360-Rotation-For-Laptop/17303654113" },
        { "name": "12GB+256GB", "usItemId": "20044301850", "url": "https://www.walmart.com/ip/SGIN-15-6-Windows-11-Laptop-16GB-DDR4-512GB-SSD-Laptop-Computer-4-Core-AMD-R5-3500U-CPU-AI-App-1080P-FHD-Wifi-6/20044301850" }
    ],
    "categoryPath": "Electronics > Computers, Laptops and Tablets > Laptops > Shop Laptops by Type > AI Laptop",
    "categoryPathId": "0:3944:1089430:3951:1230091:2871426",
    "catalogProductType": "Laptop Computers",
    "condition": "New",
    "snapEligible": false,
    "preOrder": false,
    "salesUnit": "EACH",
    "position": 64,
    "page": 2,
    "pricedFor": { "postalCode": "20149", "city": "Ashburn", "state": "VA", "storeId": "2038" },
    "detailsIncluded": false,
    "searchQuery": "laptop",
    "totalResults": 24932,
    "sourceType": "search",
    "sourceInput": "laptop",
    "monitorStatus": null,
    "scrapedAt": "2026-10-28T20:50:43.437Z"
}
```

(`variantOptions` shortened from 4 entries to 2; the variant links are Walmart's own.)

A real review row (the text is shortened here):

```json
{
    "itemType": "review",
    "reviewId": "434698034",
    "usItemId": "14140820772",
    "productName": "Thyme & Table 6QT Air Fryer, with ThymeCrisp™ and Ceramic-Coated Nonstick Basket, Atlantic Blue",
    "rating": 5,
    "title": "Awesome!",
    "text": "This is the second air fryer I have owned. ...",
    "reviewDate": "2026-08-01",
    "userNickname": "Maureen",
    "isVerifiedPurchase": true,
    "badges": ["Verified Purchase"],
    "userBadges": ["reviews:25"],
    "positiveFeedback": 0,
    "media": ["https://i5.walmartimages.com/dfw/6e29e393-2ba7/k2-_3ec3ee14-791c-47dd-8974-bf5ccae7f550.v1.jpg"],
    "variant": { "Color": "Cabernet Red" },
    "sellerName": "Walmart.com",
    "fulfilledBy": "Walmart",
    "language": "English",
    "reviewUrl": "https://www.walmart.com/reviews/product/14140820772"
}
```

#### Fields

| Group | Fields |
|---|---|
| Every product row | `usItemId`, `productId`, `name`, `brand` (search rows: only where Walmart shows it), `url`, `imageUrl`, `price`, `wasPrice`, `unitPrice`, `currency`, `priceInfo`, `onSale`, `rollback`, `clearance`, `reducedPrice`, `bestSeller`, `averageRating`, `numberOfReviews`, `availability`, `inStock`, `lowStock`, `sellerName`, `sellerId`, `catalogSellerId` (search rows: where Walmart's tile carries it), `soldByWalmart`, `fulfillmentType`, `fulfillment`, `badges`, `flag`, `isSponsored`, `boughtSinceYesterday`, `boughtSinceYesterdayText`, `inCarts`, `inCartsText`, `variantCount`, `variantOptions`, `categoryPath`, `categoryPathId`, `catalogProductType`, `condition`, `snapEligible`, `preOrder`, `salesUnit`, `position`, `page`, `searchQuery`, `totalResults`, `pricedFor` |
| Product details (add-on) | `brandUrl`, `images`, `ratingCounts`, `recommendedPercentage`, `reviewsWithText`, `sellerType`, `sellerAverageRating`, `sellerReviewCount`, `sellerStoreUrl`, `sellerLogoUrl`, `shippingRestriction`, `variantList`, `categories`, `upc`, `model`, `manufacturerProductId`, `shortDescription`, `description`, `highlights`, `specifications`, `warranty`, `videos`, `returnPolicy`, `offerId`, `offerType`, `additionalOfferCount`, `transactableOfferCount`, `secondaryOfferPrice`, `orderLimit` |
| Review rows | `reviewId`, `usItemId`, `productName`, `productUrl`, `rating`, `title`, `text`, `reviewDate`, `userNickname`, `isVerifiedPurchase`, `isIncentivized`, `badges`, `userBadges`, `positiveFeedback`, `negativeFeedback`, `media`, `variant`, `sellerName`, `catalogSellerId`, `fulfilledBy`, `syndicationSource`, `sellerResponses`, `language`, `reviewUrl` |
| Seller rows | `catalogSellerId`, `sellerId`, `sellerName`, `sellerDisplayName`, `sellerType`, `status`, `averageRating`, `totalReviewCount`, `reviewsWithTextCount`, `email`, `phone`, `address`, `city`, `state`, `postalCode`, `country`, `about`, `hasSellerBadge`, `isAlcoholSeller`, `logoUrl`, `sellerUrl` |
| Every row | `itemType`, `sourceType`, `sourceInput`, `monitorStatus`, `scrapedAt`; monitor changes add `previousPrice`, `previousAvailability`; rows from a search, category or shelf link add `listingBadges`; rows from a seller's shelf link add `shopSellerId` |

#### Badges, carts and the seller on a row

- `badges` is the full list of badge texts Walmart shows on the product, as worded. An empty list means Walmart showed none: a product whose page was not read has no row at all (see "Product links that were not read").
- `bestSeller` is true when one of them is "Best seller"; `flag` is the first badge.
- `listingBadges` is the badge list of the search, category or shelf tile the row was found on. With `includeDetails` on, `badges` is the product page's list and `listingBadges` stays the tile's, so the two can be compared; without details both are the tile's.
- `inCartsText` is the badge as worded ("In 25+ people's carts") and `inCarts` its number (25, a lower bound). `boughtSinceYesterdayText` and `boughtSinceYesterday` work the same way. All four are empty when Walmart shows no such badge.
- `sellerName`, `sellerId` and `catalogSellerId` are always the seller of the offer Walmart shows for the product (on a product page: the offer its Add to cart button buys). A row found through a seller's shelf link also carries `shopSellerId`, the seller of that link, so the two can be compared.

#### A seller's whole shelf

Paste the seller's "Shop all" link (`https://www.walmart.com/seller/<id>/cp/shopall`) into `startUrls`. It is read like a search: about 40 products a page with price, stock, rating, seller and badges, up to `maxItemsPerSearch` and `maxPagesPerSearch`. A 187-product shelf is 5 pages; a 930-product shelf is 24 pages (853 unique products in 104 seconds, measured November 8, 2026: Walmart repeats some tiles across pages, and the repeats are not charged). Walmart shows at most 25 pages of any shelf, about 1,000 products; on a bigger storefront the run reads all 25 and the shelf's `RUN_SUMMARY` entry says so (`stoppedBy: "Walmart's page limit ..."`, `paginationComplete: false`) instead of claiming the catalog is complete. Sort and price parameters on a shelf link are ignored by Walmart, so the rest of such a catalog is not reachable through Shop All. Turn on `includeDetails` only if you need the product-page fields: each product then needs its own page.

Several sellers go in one run: one shelf link per seller. A product is delivered (and charged) once per run, under the first shelf it was found on; when it is also on a later shelf, that shelf's entry in the run report lists it in `alsoListedItemIds`, so every store association is kept. The run report `RUN_SUMMARY` has one entry per shelf in `searches`: `totalResults` (Walmart's count), `pages`, `read`, `delivered`, `duplicates`, `alsoListedItemIds`, `stoppedBy` (`end of results` when paging finished, otherwise why it stopped: `maxItemsPerSearch`, `maxPagesPerSearch (N)`, `maxItems`, `spending limit`, `run time limit`, `no results`, `page not found`, `Walmart refused`) and `paginationComplete`. A shelf the run stopped before reaching still gets its entry, `stoppedBy: "not reached (<why>)"`. An empty or refused shelf does not stop the others.

### How can I use Walmart data?

- **Price and promotion tracking**: watch `price` against `wasPrice`, `rollback` and `clearance` on a schedule; monitor mode returns only what changed.
- **Marketplace seller research**: see which sellers win a keyword (`sellerName`, `soldByWalmart`, `additionalOfferCount`) and read their profiles and contact details.
- **Catalog matching**: join on `upc`, `model` and `manufacturerProductId`.
- **Review analysis**: stars, text, variant bought and Verified Purchase flags for product research.
- **Search ranking**: `position`, `page` and `isSponsored` per keyword.

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

Pay per result, no start fee:

| Event | Price |
|---|---|
| Product row (search, category or product link) | $0.63 per 1,000 |
| Product details add-on (charged with a row that carries the product page's details) | $0.81 per 1,000 |
| Review | $0.36 per 1,000 |
| Seller profile | $3.00 per 1,000 |

Examples: 1,000 search rows cost $0.63. 100 products with full details cost $0.144. 100 products with details and 10 reviews each cost $0.504. Filtered products, duplicates, products already delivered in monitor mode and products Walmart no longer lists are never charged. Set a spending limit on the run and the actor stops at it.

### Integrations, API, scheduling & MCP

Run it from the Apify Console, the [Apify API](https://docs.apify.com/api/v2), the JavaScript or Python client, Make, Zapier, n8n, or an AI agent through the [Apify MCP server](https://mcp.apify.com). Results go to the run's dataset (JSON, CSV, Excel, XML).

#### Run it on a schedule

1. Save a task with your keywords, `"monitorMode": true` and, for price tracking, `"monitorChanges": true`. Give each task its own `monitorStoreName`.
2. Add an [Apify schedule](https://docs.apify.com/platform/schedules) (for example every morning).
3. Each run checks the first `maxItemsPerSearch` results of every keyword and returns only the products not delivered before, plus the products whose price or stock moved, with `previousPrice` and `previousAvailability`. A run with nothing new delivers nothing and is charged nothing.
4. Add a webhook or a Make / Zapier / n8n step to send the new rows on.

```json
{
    "searchQueries": ["lego star wars"],
    "maxItemsPerSearch": 200,
    "monitorMode": true,
    "monitorChanges": true,
    "monitorStoreName": "lego-price-watch"
}
```

### Limits & empty runs

- **Walmart's bot check.** The actor reads one page at a time from the platform's own address, then one Apify datacenter address, then one Apify residential address; when Walmart answers with its "Robot or human?" check, the run moves up one address and never asks again on the address that was refused. In the 2026-10-28 runs the first address gave 4-21 pages before the check and a datacenter address between 3 and 60 pages (60 of 60 product pages on a fresh address at the default pause), so a large run may finish its search pages over the residential address. Search, category and shelf pages are read on every address, and after the residential one on Apify's Unblocker. Product, review and seller pages are read on the residential address and the Unblocker only with `"proxyMode": "unblocker"`; by default they are left unread there, counted in the run's status, and nothing unread is charged. With `unblocker`, prices stay the same and the run reads pages on those routes while the rows it has delivered cover their cost; a page it has no room for is left unread (never charged) and, for a product link, listed in `retryStartUrls`. The Unblocker is slower: 3-18 s a product page in the 2026-11-06 tests. A run that Walmart refused everywhere before any row ends FAILED with nothing charged.
- **Product links that were not read.** When a run ends with product links it did not deliver (unread, not reached, not found or filtered), it writes the record `PRODUCT_STATUS` to its key-value store: one entry per product link (`delivered`, `not_found`, `not_read`, `filtered`, `already_delivered` or `not_attempted`, each with the reason) and `retryStartUrls`, the links still to read. Give that list to a later run as `startUrls`; only rows that run delivers are charged. With `monitorMode` on you can also give the same full list again: products an earlier run delivered are skipped before their page is read. A product an earlier monitor run delivered without its details (page not read) is not skipped when details are asked for: its page is read and the row comes back with `monitorStatus: "details"`.
- **Location.** Walmart prices pages for a location it picks from the visitor's address. `pricedFor` shows it on every row (Sacramento CA and Ashburn VA in the test runs). A ZIP code or store cannot be chosen: Walmart keeps that choice in a browser cookie and this actor sends no cookies.
- **Search depth.** Walmart shows at most 25 pages (about 1,000-1,500 products) for one search; split a large search with `sort`, a price range or `facets`.
- **Brand on search rows.** Walmart's search tiles usually carry no brand field; turn on details for the brand, or use the facet `brand:<name>`.
- **Barcode lookup.** Walmart's search finds nothing for a UPC typed as the keyword, so UPC lookup is not offered.
- **All sellers of an item.** Walmart loads the list of every seller's offer on demand in the browser; the row carries the winning offer, `additionalOfferCount` and the next offer's price.
- **Empty run.** Check the keyword on walmart.com, loosen the filters, or read the status message: it says what was filtered, refused or not found.

### FAQ

#### How many products can Walmart Scraper collect in one run?

As many as Walmart shows for your keywords and links, up to `maxItems` and 25 pages a search. Search rows come at about 40-60 per page (500 rows took 139 seconds); with details, each product needs its own page (about 4 seconds each).

#### Some of my product links were not read. How do I get the rest?

Read the run's key-value store record `PRODUCT_STATUS`: it lists every product link with its status and reason, and `retryStartUrls` holds the ones still to read. Start a later run with that list. Nothing unread was charged. How many product pages one run reads before Walmart's bot check varies (30 of 297 in one November run); search, category and seller-shelf pages carry 40-60 products each and are the reliable way to cover many products.

#### Can I get Walmart reviews only?

Yes. Paste reviews links (`https://www.walmart.com/reviews/product/<id>`) into **Walmart links or product IDs**, or search with **Customer reviews** on.

#### Can I run it on a schedule to get new products automatically?

Yes, with monitor mode: see "Run it on a schedule" above.

#### Can I use it with the Apify API or an MCP server?

Yes. Every input field above works through the API, the clients and the MCP server.

#### Do I need a Walmart account, cookies or an API key?

No. Nothing of yours is needed and no Walmart account is used.

#### Why did my run return no results?

The status message says why: nothing matched, everything was filtered, everything was already delivered (monitor mode), the product no longer exists, or Walmart's bot check refused the run. Nothing is charged for any of those.

#### How is it different from other Walmart scrapers?

One actor for search, category, product, review and seller data with the same field names as the most-used Walmart actor (`usItemId`, `priceInfo`, `averageRating`, `numberOfReviews`, `ratingCounts`, `variantList`, `sellerName`, `upc`); filters that run before the charge; seller contact details; price and stock change monitoring; no start fee.

#### Is it legal to scrape Walmart data?

The actor collects publicly available product information. If your project touches personal data, check the rules that apply to you, and read [is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/) if you are unsure.

#### Your feedback

Found a bug or want a field added? Open an issue on the **Issues** tab.

# Actor input Schema

## `searchQueries` (type: `array`):

Words to search on Walmart.com, one per line, exactly as you would type them in Walmart's search box. Each keyword is paged through Walmart's results (40-60 products a page) up to the limits below.

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

Walmart.com links, one per line: product pages (https://www.walmart.com/ip/...), search pages (/search?q=...), category and department pages (/browse/..., /cp/...), deals pages (/shop/...), a seller's whole shelf (/seller/<id>/cp/shopall, read like a search), seller profile pages (/seller/<id>) or reviews pages (/reviews/product/<id>). A bare product number (usItemId, e.g. 835951198) also works. Product links come back with full details.

## `categoryIds` (type: `array`):

Walmart category ids (the last part of a /browse/ link, e.g. 5440_202072_8052432 for Dog Treats). Each one is read like a search.

## `sellerIds` (type: `array`):

Walmart Marketplace seller ids (the number in https://www.walmart.com/seller/101113549) or seller links. Each one comes back as a seller profile row (charged as a seller profile).

## `maxItems` (type: `integer`):

Stop after this many product rows in total. Reviews and seller profiles are capped by their own settings.

## `maxItemsPerSearch` (type: `integer`):

Stop each keyword, category or listing link after this many products. In monitor mode this is the window checked each run: the first N results of the search, of which only the new (or changed) ones are returned.

## `maxPagesPerSearch` (type: `integer`):

Walmart shows 40-60 products a page and at most 25 pages for one search.

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

Walmart's own sort order for keyword and category searches.

## `minPrice` (type: `number`):

Keep only products at or above this price.

## `maxPrice` (type: `number`):

Keep only products at or below this price.

## `facets` (type: `string`):

Walmart's own facet filter, as it appears after facet= in a filtered Walmart search link, e.g. brand:Gildan or retailer_type:Walmart. Several are joined with ||, e.g. brand:Gildan||customer_rating:4 - 5 Stars.

## `inStockOnly` (type: `boolean`):

Skip products Walmart shows as out of stock (not charged).

## `onSaleOnly` (type: `boolean`):

Keep only products with a was-price, Rollback, Clearance or Reduced price badge.

## `soldByWalmartOnly` (type: `boolean`):

Skip products sold by Marketplace sellers.

## `excludeSponsored` (type: `boolean`):

Skip the sponsored (ad) tiles Walmart mixes into the results.

## `minRating` (type: `number`):

Keep only products rated at least this (1-5).

## `minReviews` (type: `integer`):

Keep only products with at least this many ratings.

## `brands` (type: `array`):

Keep only these brands (case-insensitive). On search rows Walmart often omits the brand; then the product name must start with it. For an exact brand filter at Walmart's side use the facet brand:<name>.

## `includeDetails` (type: `boolean`):

Open every product page and return the full record: UPC, model, description, specifications, highlights, all images, videos, every variant with its price and stock, the 1-5 star breakdown, seller rating and catalog seller id, return policy and every fulfillment option. Charged as a product plus a product-details add-on. Product links always come with details.

## `enqueueProductVariants` (type: `boolean`):

With details: also return each size / color / pack variant of a product as its own full product row (each charged as a product with details). Without it, the variants come in the product's variantList at no extra charge.

## `includeReviews` (type: `boolean`):

Return the customer reviews of every product found, as review rows (charged per review).

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

Walmart shows 10 reviews a page.

## `reviewsSort` (type: `string`):

Walmart's own review order.

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

1-5. Walmart filters the reviews by stars before they are read.

## `verifiedPurchasesOnly` (type: `boolean`):

Keep only reviews with Walmart's Verified Purchase badge (others are skipped, not charged).

## `reviewsSince` (type: `string`):

Keep only reviews written on or after this date (YYYY-MM-DD). The reviews are then read newest first and reading stops at the first older one.

## `includeSellerDetails` (type: `boolean`):

With details: return the profile of every Marketplace seller found (once per seller): display name, rating, review count, email, phone, business address and about text, as Walmart shows them. Charged per seller profile.

## `monitorMode` (type: `boolean`):

Remember what earlier runs delivered (in a named key-value store) and return only products, reviews and sellers not delivered before. Ideal for a scheduled run.

## `monitorChanges` (type: `boolean`):

In monitor mode: also return products delivered before whose price or availability changed since, with previousPrice and previousAvailability.

## `monitorStoreName` (type: `string`):

Name of the key-value store that remembers delivered records. Use a different name per schedule.

## `resetMonitor` (type: `boolean`):

Start the monitor memory fresh for this run.

## `proxyMode` (type: `string`):

Walmart's bot check usually stops product pages after a few to a few dozen on the free routes. By default the rest are left unread, never charged, and listed for a retry (PRODUCT_STATUS, retryStartUrls). "unblocker" keeps reading them on Apify's residential proxy and, if Walmart refuses that too, Apify's Unblocker (slower: 3-18 s a page). Same prices. A run reads pages on these routes while the rows it has delivered cover their cost; a page it has no room for is left unread, never charged, and listed for a retry. Search, category and shelf pages use every route in both settings.

## `writeRunSummary` (type: `boolean`):

Write the key-value record RUN_SUMMARY on every run: one entry per keyword, category or shelf link (Walmart's count, pages read, products delivered, why it stopped, paginationComplete, alsoListedItemIds) plus the run's totals. Left unset, it is written for runs of 50+ rows and for runs with something to report (refusals, unread pages, limits, a product on several listings).

## `requestDelaySecs` (type: `number`):

The actor reads one Walmart page at a time with this pause between pages, which keeps Walmart's bot check from refusing the run. Lower is faster but may be refused sooner.

## Actor input object example

```json
{
  "searchQueries": [
    "paper towels"
  ],
  "maxItems": 20,
  "maxItemsPerSearch": 100,
  "maxPagesPerSearch": 25,
  "sort": "best_match",
  "inStockOnly": false,
  "onSaleOnly": false,
  "soldByWalmartOnly": false,
  "excludeSponsored": false,
  "includeDetails": false,
  "enqueueProductVariants": false,
  "includeReviews": false,
  "maxReviewsPerProduct": 20,
  "reviewsSort": "relevancy",
  "verifiedPurchasesOnly": false,
  "includeSellerDetails": false,
  "monitorMode": false,
  "monitorChanges": false,
  "monitorStoreName": "walmart-monitor",
  "resetMonitor": false,
  "proxyMode": "auto",
  "requestDelaySecs": 2.5
}
```

# Actor output Schema

## `results` (type: `string`):

One item per Walmart record; the field itemType says which (product, review, seller).

# 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 = {
    "searchQueries": [
        "paper towels"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("topapi/walmart-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 = {
    "searchQueries": ["paper towels"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("topapi/walmart-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 '{
  "searchQueries": [
    "paper towels"
  ],
  "maxItems": 20
}' |
apify call topapi/walmart-scraper --silent --output-dataset

```

## MCP server setup

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

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

## OpenAPI specification

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