# Walmart Product Scraper: Price, Seller, Stock Tracker (`alexmorain/walmart-scraper`) Actor

Scrape every Walmart.com product of a search or category past the 10-page wall: 6,294 products for coffee maker against 373 in a plain read. Price, seller, stock, rating; UPC and specs by item ID; new-product and price watch.

- **URL**: https://apify.com/alexmorain/walmart-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 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.
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?

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

### Walmart Scraper: every product of a Walmart search, past the 10-page wall

Walmart Product Scraper returns every product that [Walmart.com](https://www.walmart.com) serves for a search or a category: name, price, seller, stock, rating, reviews, badges, and with product pages on, UPC, specifications, variants and seller rating. One Walmart search shows 10 pages at most, about 400 distinct products, however many it announces. This actor cuts the search into price slices (whole dollars), reads each slice in full, reads the busiest dollars under several sort orders, removes duplicates and gives you one row per product.

It works as a **Walmart API alternative** for people who need rows, not a website: no login, no browser, plain HTTP, results in a dataset you can export as JSON, CSV, Excel or XML, or read through the Apify API from Python, JavaScript or cURL. Each run writes a proof in its SUMMARY record: the count Walmart announced next to the count you received. If you only need a few products, give it item IDs or product URLs and it returns the full product page of each one.

#### How to scrape more than 400 Walmart search results

Walmart's search pages stop at page 10. Ask for "coffee maker" and Walmart says 5,609 results, then serves about 400 distinct products, because sponsored products come back on every page. The table compares a plain 10-page read with this actor on runs of 7 and 8 November 2026, full coverage on.

| Search | Walmart announces | Plain 10-page read | This actor | Run time | Run |
|---|---|---|---|---|---|
| coffee maker | 5,606 | 373 | 6,294 | 6 min 7 s | `0xXh9o9grbuxNhDRR` |
| tv | 477 | not measured | 2,125 | 59 s | `L9JlvLisb7tWFZkP2` |
| laptop (stopped by its timeout) | 26,927 | not measured | 13,607 so far | 24 min | `yYpz0Qc5X3d6QEGqO` |

The plain read of "coffee maker" is run `HiGvCGcdhuNgvLPPB`: 373 products out of 5,609 announced, with the status message "Walmart serves at most 10 pages per search: 373 of the 5609 announced products were returned".

The returned count can be higher than the announced count, and that is not a mistake: the count Walmart shows for the unfiltered search is a lower bound of what it serves once you filter by price. The price slices of "coffee maker" announce 8,442 products between them, the unfiltered search 5,606. The extra products are relevant (99 % of the names in the "coffee maker" result mention coffee, brew, espresso, pods or a similar word, and 94 % of the "tv" names say tv or television). To check coverage, compare slice by slice: Walmart announces 845 products between $20 and $30 for "coffee maker" and the dataset holds 858 in that range. Between $50 and $100: 1,857 announced, 1,896 returned. At $500 and above: 171 announced, 164 returned.

The SUMMARY record of the "coffee maker" run, trimmed to the fields that carry the proof:

```json
{
  "productsReturned": 6294,
  "inputs": [{
    "input": "coffee maker",
    "status": "ok",
    "announcedByWalmart": 5606,
    "uniqueProductsFound": 6294,
    "announcedInLeafSlices": 8442,
    "servedInLeafSlices": 6360,
    "duplicatesSkipped": 5186,
    "priceSlices": 78,
    "pagesRead": 365,
    "slicesResplit": 12
  }]
}
```

`announcedInLeafSlices` is the sum of the counts Walmart gave for each price slice read in full, `servedInLeafSlices` is how many distinct products those slices served. A slice that serves less than 80 % of its announcement is split once more, and products already seen are not charged twice. `duplicatesSkipped` counts the products served twice, by sponsored placements and by the borders shared between two slices.

### Why use a Walmart scraper

A 400-product export is not a market. A price comparison, a catalogue study or a competitor watch needs the whole result of a search.

- **Price and promotion watchers**: every product of a category with current price, struck-through price and badges such as Rollback, run daily.
- **Marketplace and brand teams**: who sells what. Each row has the seller name, seller ID and whether Walmart itself sells it, and product pages add the seller rating and review count.
- **Resellers and sourcing teams**: UPC, model and manufacturer part number from product pages, plus stock status and fulfillment options.
- **Analysts and pipelines**: deduplicated rows for a database or a notebook, or specific items read by ID.

On top of a plain search export you get:

- Full coverage past the 10-page wall, duplicates removed before they are charged.
- Whole-dollar price range, six sort orders, seller type, rating band and in-stock filters, each one checked against Walmart.com before it was added.
- Optional product page data per row: UPC, model, description, specifications, variants, images, shipping price, return policy, seller rating, rating breakdown and review topics.
- A watch mode that returns only new products, or new products plus price changes.
- A webhook when a run finishes with at least one row.
- Residential US proxies included in the price, and Apify scheduling, API access and integrations (Make, Zapier, n8n, Google Sheets).

### How to scrape Walmart products, step by step

1. Open the actor in Apify Console and go to the Input tab.
2. In **Search queries**, type what you would type in Walmart's search box: `coffee maker`, `laptop`, `air fryer`. Each query is read separately.
3. Add filters if you want a subset: a price range in whole dollars, a sort order, a seller type, a rating band.
4. Set **Max items**. Use 100 for a first test. Empty means every product Walmart serves for the query, thousands for a broad one.
5. Turn on **Read each product page** if you need UPC, specifications or the seller rating. Leave **Full coverage** on to get more than 10 pages.
6. Click **Start**. The status message ends with the announced count against the returned count.
7. Download the dataset from the Output tab as JSON, CSV or Excel, or read it through the API.

Already have a page on walmart.com? Copy the URL of the search or category page into **Walmart URLs**: the query, the price range, the sort and the filters are kept.

#### What you can feed it

- **Search queries** (`searchQueries`): keywords as typed on Walmart.com, each with its own full coverage and SUMMARY entry. The prefill is `coffee maker` with Max items 20, a run that takes seconds and costs a fraction of a cent.
- **Walmart URLs** (`startUrls`): search pages (`https://www.walmart.com/search?q=laptop&min_price=300&max_price=900&sort=rating_high`), category pages (`/browse/...` or the short form `/cp/coffee-makers/5438660`, 6,678 products announced for the coffee makers category) and product pages (`/ip/985675140`, with or without the name in the path).
- **Product IDs** (`productIds`): item IDs, the number at the end of a product URL (`985675140`), or full product URLs. Each ID returns the full product page and is charged as a detailed product. An ID that does not exist is reported as `not-found` and not charged. On 8 November 2026, 499 of 500 IDs were read (one product had been removed) in 5 min 16 s (run `n9TJgLq9OD3DzwYmT`).
- **Full coverage**: on by default. The actor reads the unfiltered search, splits it into price slices, reads each slice in full, and splits again the slices that still hold too much. A dollar-wide slice that still holds more than 350 products is read under four sort orders (best match, best seller, rating, new). Off, you get Walmart's 10 pages and a note that says how many announced products are missing.
- **Read each product page**: off by default. On, each product gets one more request and the row is charged as a detailed product instead of a product. If a page cannot be read, the row is still returned with the list data, charged as a plain product, and `detailsStatus` says `failed`.

Seller pages (`/global/seller/<id>`) are not supported, see the limits.

### Filters

Each filter was tested against Walmart.com on the "coffee maker" search (5,610 results announced) before it was added: the announced count moves and the rows read back match.

| Input | Values | What it does |
|---|---|---|
| `minPrice`, `maxPrice` | whole dollars | Price range. $20 to $30 announces 845, $30 to $50 announces 1,011. Cents are not accepted, see the limits |
| `sort` | best_match, price_low, price_high, best_seller, rating_high, new | Walmart's order. Matters with Max items. `price_low` and `price_high` are applied only when no price range is set and full coverage is off, see the limits |
| `seller` | any, walmart, proSellers, marketplaceFulfilledByWalmart | Sold by Walmart.com (297 announced), by Pro Sellers (420), or by marketplace sellers using Walmart fulfillment (429) |
| `customerRating` | any, 4to5, 3to3.9 | Products rated 4 to 5 stars (678 announced) or 3 to 3.9 stars (850) |
| `inStockOnly` | true, false | Hides products shown as out of stock |

Filters combine: sold by Walmart plus 4 to 5 stars announces 219 products. A search URL keeps its own filters, and the fields above fill what the URL does not set.

### What data does the Walmart scraper extract?

A search row carries identity, price, seller, stock, rating, badges, category and image. With **Read each product page** on, or when you read items by ID, the row also gets the product page fields. Fields that Walmart does not show for a given product come back as null, so every row has the same keys. The full list, from the dataset schema:

| Field | Type | Description |
|---|---|---|
| `usItemId` | string | Walmart item ID (the number at the end of the product URL). Unique per run |
| `productId` | string | Walmart internal product ID |
| `url` | string | Product page on Walmart.com |
| `name` | string | Product name |
| `brand` | string | Brand. Null in search results, filled only when product pages are read (includeDetails or product IDs) |
| `price` | number | Current price in the currency below. Null when Walmart shows no price (see priceDisplay) |
| `wasPrice` | number | Struck-through price when the product is discounted |
| `currency` | string | Currency code |
| `unitPrice` | string | Unit price as shown by Walmart, when there is one |
| `priceDisplay` | string | Price as displayed |
| `averageRating` | number | Average customer rating, 0 to 5. Null when the product has no reviews (same in search results and product pages) |
| `numberOfReviews` | number | Number of customer reviews, 0 when there are none (same in search results and product pages) |
| `sellerName` | string | Seller name. Walmart.com for Walmart's own offer, otherwise the marketplace seller |
| `sellerId` | string | Seller ID |
| `sellerType` | string | INTERNAL (Walmart) or EXTERNAL (marketplace seller). Null in search results, filled only when product pages are read (includeDetails or product IDs) |
| `isWalmartSeller` | boolean | True when the offer is sold by Walmart.com itself |
| `availability` | string | Stock status: IN_STOCK, OUT_OF_STOCK, LIMITED_STOCK... |
| `isOutOfStock` | boolean | True when Walmart shows the product as out of stock |
| `storeId` | number | Store the price and stock come from. Walmart picks it from the IP address, it cannot be chosen. Null for online-only offers from marketplace sellers, which have no store. Price changes are only compared between runs for the same storeId |
| `aisle` | string | Aisle location in that store, when shown (search results) |
| `fulfillment` | array | Delivery options on offer: DELIVERY, PICKUP, SHIPPING... |
| `badges` | array | Badges shown on the card or page, for example '100+ bought since yesterday', 'Overall pick' |
| `isSponsored` | boolean | True when the search result is a sponsored placement (null when a product is read by id) |
| `imageUrl` | string | Main image |
| `categoryPath` | string | Category path |
| `hasVariants` | boolean | True when the product has other colors, sizes or pack sizes |
| `searchInput` | string | What you entered: the search query, URL or product ID this row comes from |
| `position` | number | Rank among the products read for that input (null when read by id). Walmart's own order depends on the slice and sort used by full coverage |
| `scrapedAt` | string | ISO timestamp of the read |
| `previousPrice` | number | Monitoring: price returned by the previous run for this product at the same store, null for a new product |
| `priceChange` | string | Monitoring: new, up or down |
| `detailsStatus` | string | With product pages on: ok, failed, not-found or timeout. A failed read is charged as a plain product |
| `upc` | string | UPC barcode (product page) |
| `model` | string | Model number (product page) |
| `manufacturerProductId` | string | Manufacturer part number (product page) |
| `description` | string | Description as plain text (product page) |
| `shortDescription` | string | Short description as plain text (product page) |
| `images` | array | All product images (product page, 40 at most) |
| `variants` | array | Variant dimensions and their options: dimension, options (product page) |
| `specifications` | object | Specifications as name: value (product page) |
| `sellerAverageRating` | number | Average rating of the marketplace seller (product page) |
| `sellerReviewCount` | number | Number of reviews of the marketplace seller (product page) |
| `additionalOfferCount` | number | Other sellers offering the same product (product page) |
| `secondaryOffers` | array | Other offers for the same product, when Walmart lists them (product page) |
| `shippingPrice` | number | Shipping price, 0 for free shipping (product page) |
| `returnPolicy` | string | Return policy as shown (product page) |
| `ratingBreakdown` | object | Reviews per star, keys 1 to 5 (product page). Null when the product has no reviews |
| `recommendedPercentage` | number | Share of reviewers who recommend the product (product page). Null when Walmart does not show it or there are no reviews |
| `reviewAspects` | array | What reviewers talk about: name, mentions (product page). Null when the product has no reviews |

Some columns are empty by nature. `brand` and `sellerType` are null in search results on every row and are only filled with product pages on. `price` is null when Walmart hides it in the list (see the limits). A product without reviews reads the same in search results and on its page: `numberOfReviews` 0, `averageRating` null, `ratingBreakdown` null, `recommendedPercentage` null. `storeId` is null for online-only marketplace offers, which have no store.

#### Example row from a search

A real row of the "coffee maker" run of 7 November 2026, sold by Walmart with a struck-through price (image URL and category path shortened):

```json
{
  "usItemId": "13644903668",
  "productId": "4WJXBE26V34M",
  "url": "https://www.walmart.com/ip/Nespresso-Vertuo-POP-White-Coffee-and-Espresso-Maker/13644903668",
  "name": "Nespresso Vertuo Pop Coffee and Espresso Maker by Breville, Coconut White",
  "brand": null,
  "price": 84.97,
  "wasPrice": 119,
  "currency": "USD",
  "priceDisplay": "$84.97",
  "averageRating": 4.4,
  "numberOfReviews": 4605,
  "sellerName": "Walmart.com",
  "isWalmartSeller": true,
  "availability": "IN_STOCK",
  "isOutOfStock": false,
  "storeId": 1584,
  "fulfillment": ["PICKUP", "DELIVERY"],
  "badges": ["Rollback"],
  "isSponsored": true,
  "searchInput": "coffee maker",
  "position": 1,
  "scrapedAt": "2026-11-07T13:49:13+00:00"
}
```

`storeId` 1584 is the store Walmart priced this row for, picked from the proxy IP. A marketplace offer has `storeId` null and is online only.

#### Example row from a product page

A product read by ID, item 782614224, a marketplace offer, trimmed to a few specifications:

```json
{
  "usItemId": "782614224",
  "name": "Mr. Coffee® Single-Serve Frappe™, Iced, and Hot Coffee Maker and Blender, Black with 2 To-Go Tumblers, Reusable Coffee Filter",
  "brand": "Mr. Coffee",
  "price": 179.87,
  "sellerName": "Always-Quality",
  "sellerType": "EXTERNAL",
  "isWalmartSeller": false,
  "storeId": null,
  "upc": "053891157872",
  "model": "2149282",
  "manufacturerProductId": "2149282",
  "specifications": {"Product line": "Single-Serve 3-in-1 Brewer", "Number of cups": "16"},
  "sellerReviewCount": 3742,
  "shippingPrice": 0,
  "ratingBreakdown": {"1": 67, "2": 21, "3": 43, "4": 195, "5": 1026},
  "detailsStatus": "ok"
}
```

### Walmart price tracker: new products and price changes

Set **Monitoring** to New products only, or to New products and price changes, give the run a **Monitor name**, and schedule it. The actor keeps what it returned in a key-value store named `walmart-scraper-monitor` in your account. The first run returns everything. The next runs return only what changed: products not seen before, and with price changes on, products whose price moved, with `previousPrice` and `priceChange` set to up or down. Unchanged products are neither returned nor charged. On 8 November 2026 a second run with the same input skipped 148 of the 150 products the first run had returned (run `ca0ZYcCegFYNICOHg`).

A price change is compared only with a price from the same store. Walmart picks the store from the location of the IP address, and the residential proxy moves between cities from one run to the next. A grocery price from another store is not a drop: when the `storeId` differs from the one in memory, the price is updated silently and no signal is sent. Online-only offers from marketplace sellers have a null `storeId`, so their price changes are always compared.

To schedule it, create a schedule in Apify Console with a cron expression (`0 6 * * *` for every day at 6:00) and attach a saved task with Monitoring on. Use the same Monitor name every time.

**Webhook.** Paste a Slack, Discord or any HTTPS endpoint in **Webhook URL**. When the run ends with at least one product, the actor sends one POST with a JSON body carrying `actor`, `runId`, `datasetId`, `monitorMode`, `items`, `byEvent`, `inputs`, and a one-line message in `text` (Slack) and `content` (Discord). The URL is a secret field and never appears in logs. A webhook that fails is logged and does not fail the run.

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

The actor uses Apify's pay-per-event pricing. You pay for events, and the residential proxy that Walmart requires is included.

| Event | Charged when | Free | Bronze | Silver | Gold, Platinum, Diamond |
|---|---|---|---|---|---|
| Product | A unique product is returned from a search or a category | $1.00 per 1,000 | $0.85 | $0.70 | $0.50 |
| Detailed product | A product is returned with its product page data, or an item is read by ID or URL. Charged instead of Product | $3.50 per 1,000 | $3.00 | $2.60 | $2.20 |
| Actor start | The run starts, per GB of memory (512 MB by default) | $0.002 | $0.002 | $0.002 | $0.002 |

The plan tier is the one of your Apify subscription. A product found twice in a run is charged once, a product skipped by the watch because it was already returned is not charged, a product page that could not be read is charged as a plain product, and an item ID that does not exist is not charged.

Examples, start event not included: "coffee maker" in full, 6,294 products, costs $6.29 on Free and $3.15 on Gold. "tv" in full, 2,125 products, costs $2.13 and $1.06. 500 product pages by ID cost $1.75 and $1.10. The cost does not depend on how many requests the actor needs. To keep a test cheap, set **Max items** or the maximum charge per run: at a $0.05 limit a run returned 48 products and stopped cleanly (run `zp9dUb97fPfuP1YVY`).

### Scrape Walmart with Python, JavaScript or cURL

These examples use the actor `alexmorain/walmart-scraper`. Replace the token with your own and keep it in an environment variable.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("alexmorain/walmart-scraper").call(run_input={
    "searchQueries": ["coffee maker"],
    "minPrice": 20,
    "maxPrice": 200,
    "seller": "walmart",
    "customerRating": "4to5",
    "maxItems": 500,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["usItemId"], item["price"], item["sellerName"], item["storeId"])

summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("SUMMARY")["value"]
print(summary["inputs"][0]["announcedByWalmart"], summary["productsReturned"])
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('alexmorain/walmart-scraper').call({
    startUrls: ['https://www.walmart.com/browse/home/coffee-makers/4044_90548_90546_1115306_5438660'],
    includeDetails: true,
    maxItems: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0].upc, items[0].specifications);
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/alexmorain~walmart-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"productIds": ["985675140", "782614224"]}'
```

The call returns the run object. Read the items with `GET https://api.apify.com/v2/datasets/<defaultDatasetId>/items?format=json`.

### Limits of this Walmart scraper, written plainly

- **No price or stock by store, ZIP code or city.** Walmart chooses the store from the location of the IP address, and neither a URL parameter nor a cookie changes it (tested: `stores=`, store cookies, the store page). Every row carries `storeId`, the store the price comes from. If you need the prices of a specific store, this actor is not the right tool.
- **Whole dollars only.** Walmart ignores a price with cents (20.5 to 21.5 returns the unfiltered result), so the input accepts integers and a decimal in a URL is dropped with a warning. Cents are still in the data: a slice $20 to $21 holds products priced $20.00 to $21.00.
- **Seller pages are not supported.** `/global/seller/<id>` serves no product list on the server side, the list is loaded by JavaScript. To look at what a seller sells, search for the product type and filter the dataset on `sellerName`.
- **Price sort with a price range.** Walmart answers `sort=price_low` together with a price range with an empty list (laptop between $300 and $350: 0 products for 779 announced) and `price_high` with a truncated one. The actor does not send them together: with a price range, or with full coverage which slices by price, products are read in best match order and the status message says so. Sort the dataset by price afterwards.
- **Empty slices.** Walmart sometimes announces products for a price slice and serves an empty list, on every IP. After three tries on new IPs the actor accepts the page as empty (`emptyPagesAccepted` in the SUMMARY), splits the slice once to recover what it can, and does not call it a refusal.
- **Hidden prices.** Walmart gives a price of 0 in the list for some marketplace offers (3.7 % of the "coffee maker" result, 231 of 6,294 with a null price). The actor returns `price: null`, never 0. **Read each product page** fills the real price: item 5053368406 shows no price in the list and $99.90 on its page.
- **The announced count is an estimate.** It moves by half a percent between two requests (5,599, 5,611 and 5,603 for the same search).
- **Very large searches take long.** The reading speed is about 1.4 requests per second, whatever the number of parallel connections. "laptop" announces about 27,000 products and needs about 48 minutes: raise the run timeout, or set Max items, a maximum charge or a price range.
- **About 6 % of requests are refused** by Walmart's protection. The actor changes IP and tries again, up to 10 tries per page. A page still refused after 10 tries is counted as `pagesLost` in the SUMMARY and named in the status message, never dropped silently. A run where every input fails ends with the status Failed.
- **Reviews**: you get the rating, the review count, the breakdown by stars and the topics mentioned, not the text of individual reviews.
- **Walmart.com in the US only.**

### Walmart scraper FAQ

#### How to scrape Walmart prices?

Put a search in **Search queries**, or paste a Walmart search or category URL, and start the actor. Each row has `price`, `wasPrice` when the product is discounted, `priceDisplay` and `unitPrice`. For marketplace products priced 0 in the list, turn on **Read each product page**. Schedule the run to get the prices every day.

#### How to scrape more than 400 results from a Walmart search?

A Walmart search serves 10 pages at most, about 400 distinct products, whatever the announced total. To get more, the search has to be split into smaller searches, each under the limit, and the results merged without duplicates. That is what full coverage does, by price slices in whole dollars. "coffee maker" announced 5,606 and returned 6,294 (run `0xXh9o9grbuxNhDRR`), against 373 for a plain read.

#### Can I track Walmart price drops?

Yes. Set **Monitoring** to New products and price changes, use a **Monitor name**, and schedule the run. A price is compared only with a price from the same store.

#### Can I scrape the products of one Walmart seller?

Not from a seller page, which Walmart does not serve as a list. Every row tells you who sells it (`sellerName`, `sellerId`, `isWalmartSeller`), and with product pages on you also get `sellerType`, `sellerAverageRating` and `sellerReviewCount`. The **Seller** filter limits a search to Walmart itself, to Pro Sellers or to marketplace sellers fulfilled by Walmart.

#### Can I get the UPC of a Walmart product?

Yes, with **Read each product page** on, or by reading item IDs. `upc`, `model` and `manufacturerProductId` come from the product page. They are null when Walmart does not publish them for that product, as for some store brands.

#### How does this compare to Walmart's own APIs?

This actor does not use an official Walmart API. It reads the public site and gives you the rows a visitor would see, in a dataset or through the Apify API. It is a scraper, so it depends on the structure of the site and on Walmart's protections, and you should expect to rerun or adjust if Walmart changes them.

#### How do I check that I got everything?

Open the SUMMARY record of the run and compare `announcedInLeafSlices` with `servedInLeafSlices`. `dollarSlicesStillOverLimit`, when present, tells you how many dollar-wide slices still held more than the actor could read.

#### Is it legal to scrape Walmart?

This is not legal advice. The data this actor reads is what Walmart shows to any visitor of its public pages: no login, no private account data. Whether collecting it is allowed depends on what you do with it, where you are and Walmart's terms of use, which limit automated access and the reuse of its content. Read them before building a product on the data. The data is about products and sellers, not shoppers, but seller names are business names that can sometimes be a person's name, so the GDPR and US state privacy laws may apply to what you keep. Keep only what you need, and ask a lawyer if the use is commercial and at scale. This actor is not affiliated with or endorsed by Walmart.

### Support

Something wrong or missing? Use the Issues tab of this actor. Send the run id and the input. The API tab has the endpoints and ready-made code to start the actor from your own tools.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Walmart Scraper page](https://alexis.morain.fr/en/scrapers/walmart-scraper/) of my site. The [E-commerce family page](https://alexis.morain.fr/en/scrapers/families/ecommerce/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

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

Keywords as you would type them on Walmart.com: <code>coffee maker</code>, <code>laptop</code>. Each query returns every product Walmart serves for it, past the 10-page wall.

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

Pages copied from walmart.com: a search (<code>/search?q=...</code>, its price range, sort and filters are kept), a category (<code>/browse/...</code> or <code>/cp/...</code>) or a product (<code>/ip/...</code>, read as a product page). Seller pages (<code>/global/seller/...</code>) are not supported: Walmart serves no product list for them.

## `productIds` (type: `array`):

Walmart item IDs to read one by one, such as <code>985675140</code> (the number at the end of a product URL), or product URLs. Each one returns the full product page (UPC, specifications, variants, seller rating) and is charged as a Detailed product. Meant for pipelines that already hold a list of IDs.

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

In US dollars, whole dollars only (Walmart ignores cents).

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

In US dollars, whole dollars only.

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

Walmart's order. It changes which products come first, and with <b>Max items</b> which ones you get.

## `seller` (type: `string`):

<b>Walmart</b>: sold by Walmart.com. <b>Pro sellers</b>: Walmart's Pro Sellers program. <b>Marketplace fulfilled by Walmart</b>: marketplace sellers using Walmart fulfillment. Leave empty for all sellers.

## `customerRating` (type: `string`):

Only products rated 4 to 5 stars, or 3 to 3.9 stars. Leave empty for any rating.

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

Hide products Walmart shows as out of stock.

## `fullCoverage` (type: `boolean`):

Walmart shows at most 10 pages per search, about 400 unique products, whatever the announced count (5,600 for <code>coffee maker</code>). On, the search is split by price range and sort until each slice fits, so every product is returned and the SUMMARY record shows announced against returned. Off, you get the 10 pages and a note on how many are missing.

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

Adds UPC, model, description, specifications, variants, seller rating and rating breakdown to each product (Detailed product event, higher price).

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

Stops after this many products in total. Empty or 0 = every product Walmart serves for the searches: thousands for a broad query, so set a limit or a maximum charge per run when you test.

## `monitorMode` (type: `string`):

<b>New products only</b> returns only products not returned by an earlier run with the same input (and monitor name). <b>New products and price changes</b> also returns products whose price moved, with <code>previousPrice</code> and <code>priceChange</code> (up / down). Walmart picks the store from the IP address and it changes between runs, so a price is only compared with the previous price for the same <code>storeId</code>. Unchanged products are neither returned nor charged. The first run returns everything. State is kept in a store named <code>walmart-scraper-monitor</code> in your account.

## `monitorName` (type: `string`):

Optional. Runs with the same name and the same input share one memory; change it to start a separate watch on the same search.

## `webhookUrl` (type: `string`):

Optional. A JSON summary is POSTed here when the run ends with at least one product. Slack and Discord incoming webhooks work. Redirects are not followed (except 307 / 308).

## Actor input object example

```json
{
  "searchQueries": [
    "coffee maker"
  ],
  "sort": "best_match",
  "seller": "any",
  "customerRating": "any",
  "inStockOnly": false,
  "fullCoverage": true,
  "includeDetails": false,
  "maxItems": 20,
  "monitorMode": "off"
}
```

# Actor output Schema

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

All products in the default dataset.

## `summary` (type: `string`):

Status of each query, URL or product ID: products returned, count announced by Walmart, products served by the price slices, slices and pages read, duplicates skipped, products skipped by monitoring, requests, refusals and IP rotations.

# 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": [
        "coffee maker"
    ],
    "maxItems": 20
};

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

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

```

## MCP server setup

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