# Walmart Price & Stock Monitor — Products, Sellers, Buy Box (`mochiboo/walmart-product-price-monitor`) Actor

Track Walmart product prices, rollbacks, stock status and marketplace-seller competition. Give it your own item IDs or URLs and re-run on a schedule to watch prices move — or discover products from Walmart's own sitemaps. Unit prices, discounts, buy-box offer counts. Company-level data only.

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

## Pricing

from $3.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

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

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

# README

## Walmart Price & Stock Monitor — Products, Sellers & Buy Box

Track **Walmart.com prices, rollbacks, stock status and marketplace-seller competition** — on your own watch-list of products, on a schedule.

Give the actor a list of Walmart product URLs or item IDs, run it daily or weekly, and you get one clean row per product every time: current price, was-price, discount, unit price, in-stock status, who is selling it, and how many other sellers are competing for the same listing. Diff two runs and you have a price-and-availability history.

No API key. No login. No browser automation — the actor reads the structured product data Walmart already embeds in each page, so runs are fast and cheap.

***

### What it is for

| You want to… | How this actor does it |
|---|---|
| **Watch competitor prices** | Feed your competitors' item IDs, schedule a daily run, diff `currentPrice` between runs |
| **Catch rollbacks and clearance** | `priceFlags` / `isRollback` mark promotional pricing the moment it appears |
| **Monitor MAP compliance** | `sellerName` + `sellerType` + `additionalOfferCount` show who else is listing your product and whether a marketplace seller undercut you |
| **Track stock-outs** | `availabilityStatus` / `inStock` on every run |
| **Compare across pack sizes** | `unitPrice` + `unitPriceMeasure` normalise to $/oz, $/ct, etc. |
| **Build a product dataset** | Discover products from Walmart's own sitemaps when you don't have a list yet |

The data **changes constantly**, which is the point — this is a monitoring tool, not a one-off catalogue dump.

***

### Input

Everything is optional. Running with **empty input** discovers 20 popular products from Walmart's sitemap so you can see the output shape immediately.

| Field | Type | Default | What it does |
|---|---|---|---|
| `productUrls` | array | `[]` | Walmart product-page URLs, e.g. `https://www.walmart.com/ip/Redken-Extreme-Length-Shampoo-10-1-oz/620196775` |
| `itemIds` | array | `[]` | Bare item IDs, e.g. `620196775` — the number at the end of a product URL |
| `discoverFromSitemap` | boolean | `true` | When no URLs/IDs are given, discover products from Walmart's published sitemaps |
| `sitemapType` | select | `high-interest` | `high-interest` (popular items) or `long-tail` (broad catalogue) — see the note below, they behave very differently |
| `maxResults` | integer | `20` | Max product pages per run |
| `onlyInStock` | boolean | `false` | Skip unavailable products |
| `minDiscountPercent` | integer | `0` | Only return products at least this % below their was-price |
| `proxyConfiguration` | object | Apify Proxy on | Recommended — see *Reliability* below |

#### Example — monitor a watch-list

```json
{
  "itemIds": ["620196775", "39263624", "125113428"],
  "onlyInStock": false
}
```

#### Example — find discounted popular products

```json
{
  "discoverFromSitemap": true,
  "sitemapType": "high-interest",
  "maxResults": 200,
  "minDiscountPercent": 20
}
```

***

### Output

One row per product:

```json
{
  "itemId": "125113428",
  "name": "Intex 10722 Hose Conversion Adapters Kit - 2 Pack",
  "brand": "Intex",
  "productType": "Outdoor Spa Accessories",
  "upc": "018100963675",
  "modelNumber": "10722",
  "productUrl": "https://www.walmart.com/ip/Intex-10722-Hose-Conversion-Adapters-Kit-2-Pack/125113428",
  "currentPrice": 8.99,
  "currency": "USD",
  "wasPrice": 10.99,
  "discountAmount": 2,
  "discountPercent": 18.2,
  "unitPrice": null,
  "unitPriceMeasure": null,
  "priceFlags": [],
  "isRollback": false,
  "availabilityStatus": "IN_STOCK",
  "inStock": true,
  "fulfillmentType": "MARKETPLACE",
  "sellerName": "MyQuickBuy",
  "sellerType": "EXTERNAL",
  "isMarketplaceSeller": true,
  "catalogSellerId": 364,
  "additionalOfferCount": 0,
  "hasCompetingOffers": false,
  "averageRating": 4.6,
  "reviewCount": 13,
  "categoryPath": ["Patio & Garden", "Hot Tubs", "Hot Tub Accessories", "Hot Tub Parts"],
  "category": "Hot Tub Parts",
  "imageUrl": "https://i5.walmartimages.com/seo/...jpeg",
  "imageCount": 2,
  "source": "walmart.com",
  "discoveredVia": "sitemap:high-interest",
  "scrapedAt": "2026-08-02T02:20:11.821Z"
}
```

`sellerType` is `INTERNAL` when Walmart itself sells the item and `EXTERNAL` when a marketplace seller does. `additionalOfferCount` is how many **other** sellers offer the same listing — the buy-box competition signal.

Three dataset views are provided: **Products** (everything), **Price watch** (price fields only) and **Seller & buy box**.

***

### Honest notes on coverage

These are measured numbers from real runs, not estimates. They matter because they tell you what to expect.

**Field fill depends heavily on how popular the product is.** Two samples of 40 products each:

| | High-interest sitemap | Long-tail sitemap |
|---|---|---|
| Sold by a marketplace (3P) seller | **43%** | ~0% |
| Carries a rating | **95%** | 9% |
| Has competing offers from other sellers | **24%** | 3% |
| Carries a was-price at that moment | 19% | 12% |

So: `wasPrice`, `discountPercent`, `averageRating` and `additionalOfferCount` are frequently `null` on obscure products, and usually present on popular ones. A `null` was-price means the item simply isn't on promotion right now — it is not a scrape failure. `additionalOfferCount` normalises to `0` (not `null`) when there is no competing offer.

**Sitemap entries go stale.** Roughly **8–10%** of URLs in Walmart's own sitemaps return HTTP 404 (delisted products). These are reported in the run log as *delisted*, not written as empty rows. If you supply your own item IDs this does not affect you.

**Out-of-stock items may have no price.** That is Walmart's behaviour, and the row is still written — `availabilityStatus: "OUT_OF_STOCK"` with `currentPrice: null` is meaningful data for a stock monitor.

***

### Reliability

Walmart intermittently serves a page shell without the embedded product data. Measured across 80 pages, about **20% of requests hit this on the first attempt and succeeded on a retry**, so the actor retries each page up to 3 times with backoff and rotates its proxy IP between attempts.

Every run ends with an explicit tally:

```
Done. 17 product(s) written · 3 delisted (404) · 0 unparseable after 3 attempts · 0 fetch errors · 0 filtered out.
```

If a page never yields data, you are told — the actor does not silently return short results.

**Use Apify Proxy** (the default). Without it, expect a higher miss rate.

***

### How it finds products, and what it will not do

Walmart's `robots.txt` disallows `/search` and `/api/` for all crawlers. **This actor honours that** — it never touches Walmart's search or internal APIs.

Instead it uses the **34 sitemaps that Walmart publishes in its own `robots.txt`**, which is the sanctioned way to enumerate products. Product pages (`/ip/...`) carry no crawl restriction.

Consequence to be aware of: **there is no keyword search.** You cannot ask this actor for "wireless earbuds under $50". You give it products (by URL or ID), or you let it sample Walmart's sitemaps. For the monitoring use case this is rarely a limitation, because you already know which products you care about.

***

### Data protection

Product- and company-level data only. `sellerName` is the business entity listed on the marketplace.

**Review text and reviewer identities are never fetched or emitted** — only the aggregate `averageRating` and `reviewCount`. There is no personal data in the output.

***

### Scheduling

Use Apify **Schedules** to run daily or weekly, then compare datasets between runs to build price and availability history. Pair with the *Price watch* dataset view for a compact diff.

# Actor input Schema

## `productUrls` (type: `array`):

Walmart product-page URLs to monitor, e.g. https://www.walmart.com/ip/Redken-Extreme-Length-Shampoo-10-1-oz/620196775 . This is the main way to use the actor: paste your own watch-list and re-run it on a schedule to track price and stock changes. Leave empty to discover products from Walmart's sitemap instead.

## `itemIds` (type: `array`):

Walmart item IDs (the number at the end of a product URL), e.g. 620196775. Equivalent to productUrls but shorter to store in a spreadsheet or database.

## `discoverFromSitemap` (type: `boolean`):

When no URLs or item IDs are supplied, pull products from Walmart's own published sitemaps. Walmart disallows crawling its search pages, so its sitemaps are the only sanctioned way to discover products — this actor never touches /search or /api/.

## `sitemapType` (type: `string`):

high-interest = popular items (measured: 43% sold by marketplace sellers, 95% carry ratings, 24% have competing offers). long-tail = the broad catalogue (nearly all sold by Walmart itself, ~9% carry ratings). Only used when no URLs or item IDs are supplied.

## `maxResults` (type: `integer`):

Maximum number of product pages to fetch in this run.

## `onlyInStock` (type: `boolean`):

Skip products that are out of stock or unavailable.

## `minDiscountPercent` (type: `integer`):

Only return products discounted by at least this percentage off their was-price. 0 disables the filter. Note that most Walmart items carry no was-price at any given moment, so a non-zero value here will return few rows.

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

Proxy settings. Apify Proxy is strongly recommended — Walmart intermittently serves a page shell without product data, and rotating IPs plus the actor's built-in retries keep the miss rate low.

## Actor input object example

```json
{
  "productUrls": [],
  "itemIds": [],
  "discoverFromSitemap": true,
  "sitemapType": "high-interest",
  "maxResults": 20,
  "onlyInStock": false,
  "minDiscountPercent": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("mochiboo/walmart-product-price-monitor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("mochiboo/walmart-product-price-monitor").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 '{}' |
apify call mochiboo/walmart-product-price-monitor --silent --output-dataset

```

## MCP server setup

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

```

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/tXLVYdXMBZ4iPADIG/builds/HRnYeogJ1LeW52ByL/openapi.json