# Walmart API | Product, Seller, Price and Review Data (`johnvc/walmart-api`) Actor

Walmart API for product search, product details, customer reviews and marketplace seller offers. Built for Walmart price tracking and seller monitoring, with reliability on the seller lookup where competing tools fail most. Works as a Walmart scraper, pay per result billing, MCP ready for AI agents.

- **URL**: https://apify.com/johnvc/walmart-api.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:** E-commerce, Business, MCP servers
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 dataset item storeds

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

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

## What's an Apify Actor?

Actors are 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 API

The Walmart API turns Walmart's catalogue into clean, structured JSON. Search products by keyword, pull full product details, read customer reviews, and list every seller offering an item with their price, delivery date and return policy.

Built for price monitoring, competitive retail research, marketplace seller tracking and AI agents that need Walmart data on demand.

### Reliability is the point, especially on sellers

Seller lookup is the mode competing tools handle worst, and it is the one this Actor was built around. If you have tried Walmart seller data before and given up on it, that is the mode to test first.

The identifier handling is part of that. Walmart's endpoints do not agree on which id they take, and passing the wrong one to the reviews endpoint does not raise an error, it just quietly reports that the product has no reviews. This Actor rejects the wrong id up front with a message telling you exactly which field to copy, so you never burn a paid call on a silent empty result.

### Use cases

- **Price tracking.** Store `price` and `wasPrice` on a schedule and you have both the current price and what it was discounted from, per store.
- **Seller monitoring.** List every company offering a product, with their individual price, stock and delivery promise. This is the mode competing tools handle worst.
- **Unauthorised reseller detection.** Seller rows carry the registered legal name as well as the storefront name, which is what you need to identify who is actually behind a listing.
- **Competitive assortment research.** Search a category, filter out `sponsored` rows, and size the organic field.
- **Review mining.** Pull customer reviews with verified-purchaser status and helpfulness votes for sentiment work.
- **Catalogue matching.** Detail lookups return `upc` and `manufacturerNumber`, so you can join [Walmart](https://www.walmart.com) listings to your own product data or to other retailers.

### Input parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `search_mode` | string | yes | `search` | `search`, `product`, `reviews` or `sellers`. |
| `query` | string | in search mode | `laptop` | Keyword to search for. Ignored in the other modes. |
| `item_id` | string | in the other three modes | none | Product or sellers mode take the alphanumeric `productId`. Reviews mode takes the numeric `usItemId`. Both appear on every search row, and the wrong one is rejected before any billable call. |
| `store_id` | string | no | `1932` | Used by sellers mode. Pricing and availability are store specific; every search row returns the real `storeId`. |
| `max_results` | integer | no | `100` | Rows to return, 1 to 2000. Product mode always returns exactly one row. |

### Example output

A seller row, which is the mode worth testing first:

```json
{
  "resultType": "seller",
  "productId": "34X621REEQZQ",
  "title": "Nimo Gaming Laptop 17.3 inch",
  "position": 1,
  "usItemId": "16954719851",
  "sellerName": "Guangdong Cleamol Technology Company Limited",
  "sellerDisplayName": "Cleamol Co.,Ltd",
  "sellerType": "EXTERNAL",
  "availabilityStatus": "IN_STOCK",
  "price": 1099.59,
  "deliveryDate": "2026-08-06T21:59:00.000Z",
  "deliveryPrice": "$0.00",
  "returnPolicy": "Free 30-day returns",
  "sellerStoreUrl": "https://www.walmart.com/global/seller/101644973"
}
```

Note `sellerName` and `sellerDisplayName` genuinely differ: the first is the registered legal entity, the second is the storefront a shopper sees. Both are kept because identifying a reseller needs the legal name. Failures arrive as one `resultType: "error"` row, and a product with no reviews finishes cleanly at zero rows rather than erroring.

### Four modes, one Actor

| Mode | What it returns | Which id it needs |
|---|---|---|
| Search | Products by keyword, with both ids | none, just a query |
| Product | Full detail for one product | `productId` (alphanumeric) |
| Reviews | Customer reviews | `usItemId` (numeric) |
| Sellers | Every seller offering the item | `productId` plus an optional `storeId` |

Every search result row hands you both ids and the store id, so the chain from search to any other mode is self contained.

### What the Walmart API returns

**Products**

| Field | Description |
|---|---|
| `position` | Search rank, starting at 1 |
| `title` | Product name |
| `price` / `wasPrice` / `minPrice` | Current price, previous price, lowest variant price |
| `rating` / `reviewCount` | Average rating and how many reviews |
| `sellerName` | Who is selling it |
| `sponsored` | Whether the result was a paid placement, so you can filter to organic |
| `outOfStock`, `freeShipping`, `twoDayShipping` | Availability and shipping flags |
| `productId`, `usItemId`, `storeId` | The ids the other modes need |

**Sellers**

| Field | Description |
|---|---|
| `sellerDisplayName` | Storefront name shown to shoppers |
| `sellerName` | Registered legal name, often a different company |
| `sellerType` | Walmart itself or a marketplace seller |
| `price` | This seller's price for the item |
| `availabilityStatus` | Stock status for this specific offer |
| `deliveryDate` / `deliveryPrice` | When it arrives and what shipping costs |
| `returnPolicy` | Return terms as displayed |
| `sellerStoreUrl` | Link to the seller's storefront |

**Reviews**

| Field | Description |
|---|---|
| `title` / `text` | Review headline and full body |
| `rating` | Reviewer's rating out of 5 |
| `reviewDate` | When it was submitted |
| `authorName` | Reviewer nickname |
| `customerType` | Whether they were a verified purchaser |
| `positiveFeedback` / `negativeFeedback` | Helpfulness votes |

**Product detail** adds `upc`, `manufacturerNumber`, the `categories` path, `variantCount` and the full `ratingBreakdown`.

### How to get started

1. Run search mode with a keyword. Every row gives you `productId`, `usItemId` and `storeId`.
2. Pick a product and switch mode: product for detail, reviews for customer feedback, sellers for who is offering it.
3. Paste the matching id into the Product or item ID field and run.

[View on Apify Store](https://apify.com/johnvc/walmart-api?fpr=9n7kx3)

Prefer to start from working code? The [example repo](https://github.com/johnisanerd/Apify-Walmart-API) has a Python quick start plus MCP install walkthroughs for Claude, Cursor and ChatGPT.

### Pricing

Pay per result. Search and reviews are priced low because one upstream request returns many rows. Product detail and seller lookups cost more because each request returns a single item or a short list.

| Event | When it is charged |
|---|---|
| Product returned | Once per product row in search mode |
| Product detail returned | Once per product detail lookup |
| Review returned | Once per customer review |
| Seller returned | Once per seller offering the product |

Current per-unit prices are on the Actor's Store card and in the Console before you run.

### 🔌 Use this API from Claude (MCP)

Add this Actor as a tool in [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), or any other MCP client, via the hosted Apify MCP server. Use this Actor-specific URL:

https://mcp.apify.com/?tools=actors,docs,johnvc/walmart-api

Setup walkthrough:

https://www.youtube.com/watch?v=jREWahDGhJM

Apify MCP integration docs: https://docs.apify.com/platform/integrations/mcp

### 💸 Pay per run with crypto (x402)

The Walmart API supports agentic payments via the [x402 protocol](https://docs.apify.com/platform/integrations/x402).
AI agents and MCP clients can pay for runs in USDC (on Base) with no Apify account or API token needed:
point your agent at the [Apify MCP server](https://mcp.apify.com/?tools=actors,docs,johnvc/walmart-api) and it can
discover, pay for, and run this Actor autonomously. Read the
[Apify x402 announcement](https://apify.com/change-log/pay-for-apify-actors-with-x402?fpr=9n7kx3) for details.

### 🔌 Integrations: put Walmart monitoring on a schedule

**Tasks and Schedules first.** Save a search or a seller lookup as a Task and attach a Schedule. A daily price and seller check across your own SKUs is the highest-value setup here, and it needs no code.

**n8n, Make and Zapier.** Trigger the Actor and route rows onward: a new unauthorised seller into Slack, a competitor price drop into a pricing sheet, or fresh reviews into a sentiment step.

**Storage.** Write into Supabase, Postgres or Google Sheets through the Apify integrations tab so price history accumulates instead of being overwritten.

**MCP.** Point an AI assistant at the Actor and let it check live pricing or sellers mid-conversation. Server URL is in the MCP section above.

**Webhooks.** Fire an HTTP callback when a run finishes so your service can pick up the dataset without polling.

### 🔗 Related Tools

Retail and product intelligence across sources:

- [Google Shopping API](https://apify.com/johnvc/google-shopping-api?fpr=9n7kx3) to compare the same product across retailers
- [Google Immersive Product API](https://apify.com/johnvc/google-immersive-product-api?fpr=9n7kx3) for richer product detail pages
- [Google Lens API](https://apify.com/johnvc/google-lens-api?fpr=9n7kx3) to find a product from a photo instead of a keyword
- [Yahoo Shopping API](https://apify.com/johnvc/Yahoo-Shopping-Search-Scraper?fpr=9n7kx3) for another retail catalogue

For sellers specifically, [saswave/walmart-seller-competition-monitoring](https://apify.com/saswave/walmart-seller-competition-monitoring?fpr=9n7kx3) covers similar ground but publishes a 27 percent run success rate at around 12 users. Reliability on that mode is the reason this API exists, and its seller lookup is covered by a regression test rather than left to chance.

### FAQ

#### Which Walmart ID do I use, productId or usItemId?

Reviews mode needs the numeric `usItemId`. Product and sellers modes need the alphanumeric `productId`. Both appear on every search result row. If you pass the wrong one, this Actor stops immediately and tells you which field to copy rather than returning a confusing empty result.

#### Why does seller data matter?

Because the seller behind a Walmart listing is often not Walmart itself but a third party selling through [Walmart Marketplace](https://marketplace.walmart.com/), the platform's third party seller programme. Seller mode shows you every company offering the item, their individual prices, stock and delivery promises. That is how you track marketplace competitors, spot unauthorised resellers of your own products, or find the cheapest legitimate offer.

#### How do I track a Walmart website price over time?

Run search or product mode on a schedule and store the `price` and `wasPrice` fields. `wasPrice` is populated whenever the listing shows a markdown, so the pair tells you both the current price and what it was discounted from.

#### Can I filter out sponsored results?

Yes. Every search row carries a `sponsored` boolean. Filter to `sponsored: false` for organic-only analysis.

#### Why do prices differ between runs?

Walmart prices and availability are store specific. Every search row includes the `storeId` the data came from. Pass that same `storeId` into sellers mode to keep results consistent across runs.

#### Is this a Walmart API or a web scraper?

You use it as an API: structured JSON in, structured JSON out, with a documented schema and pay-per-result billing. It reads public [Walmart](https://www.walmart.com) listing pages, so it is not an official product and is not affiliated with, endorsed by, or connected to Walmart.

#### Can I use it as a Walmart scraper for bulk exports?

Yes. Set `max_results` high in search or reviews mode and the Actor pages until it hits your number. Billing is per result, so a bulk export costs in proportion to what you receive. For recurring exports, pair a Task with a Schedule as described in the Integrations section.

#### How do I call this from an AI agent using MCP?

Point any [Model Context Protocol](https://modelcontextprotocol.io) client at the server URL in the MCP section above. The agent reads the input schema itself and can check live prices or sellers during a conversation.

#### How do I run this on a schedule?

Save the configuration as a Task and attach a Schedule. The Integrations section above covers the downstream options.

#### What other tools work well alongside this one?

See Related Tools above. Pairing this with the [Google Shopping API](https://apify.com/johnvc/google-shopping-api-google-shopping-products-prices-deals?fpr=9n7kx3) lets you compare the same [Walmart](https://www.walmart.com) listing against other retailers, which is usually the question behind a price check.

#### What happens when a product has no reviews?

The run finishes cleanly with zero rows and a status message saying so. A product with no reviews is a real answer, not a failure, and you are not charged for rows you did not receive.

### Agent Skills

Ready-made skills for [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial) and other agents that drive this Actor. Install with `npx skills add johnisanerd/<name>`.

- [claude-skill-walmart-scraper](https://github.com/johnisanerd/claude-skill-walmart-scraper): products, sellers and reviews as structured JSON
- [claude-skill-walmart-price-tracking](https://github.com/johnisanerd/claude-skill-walmart-price-tracking): price history and buy-box monitoring on a schedule

### n8n integration

Available as an n8n community node, **[n8n-nodes-walmart-api](https://www.npmjs.com/package/n8n-nodes-walmart-api)**. In n8n: Settings, Community Nodes, install `n8n-nodes-walmart-api`, then use it in any workflow (it also works as an AI Agent tool).

### Featured Tasks

Ready-to-run examples on the Apify Store.

- [Walmart Seller Lookup: Every Seller on a Listing](https://apify.com/johnvc/walmart-api/examples/walmart-seller-lookup?fpr=9n7kx3)
- [Walmart Price History Tracking, Per Store](https://apify.com/johnvc/walmart-api/examples/walmart-price-history-tracking?fpr=9n7kx3)
- [Walmart Product Lookup API: UPC and Variants](https://apify.com/johnvc/walmart-api/examples/walmart-product-lookup-api?fpr=9n7kx3)
- [Scrape Walmart Prices by Keyword](https://apify.com/johnvc/walmart-api/examples/scrape-walmart-prices?fpr=9n7kx3)
- [Walmart Product Data in Claude via MCP](https://apify.com/johnvc/walmart-api/examples/walmart-data-claude-mcp?fpr=9n7kx3)
- [沃尔玛商品数据API：搜索、详情与卖家](https://apify.com/johnvc/walmart-api/examples/walmart-shangpin-api?fpr=9n7kx3)
- [沃尔玛价格监控：定时抓取价格历史](https://apify.com/johnvc/walmart-api/examples/walmart-jiage-jiankong?fpr=9n7kx3)

***

### 🌐 About Alpha OSINT

This Actor is part of [Alpha OSINT](https://www.alphaosint.com), toolset of financial and operations data sources and APIs.
For support or requests for this actor, please start a ticket [directly on our support page](https://apify.com/johnvc/walmart-api/issues/open?fpr=9n7kx3).

Last Updated: 2026.08.08

# Actor input Schema

## `search_mode` (type: `string`):

What to fetch. 'Search' finds products by keyword and returns both ids you need for the other modes. 'Product' returns full detail for one product. 'Reviews' returns customer reviews. 'Sellers' returns every seller offering the product, which is the mode most competing tools handle badly.

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

Required when search mode is 'search'. The keyword to search for, such as 'laptop', 'coffee maker' or 'running shoes'. Ignored in the other modes.

## `item_id` (type: `string`):

Required for product, reviews and sellers modes. IMPORTANT: the modes need different ids, and every search result row gives you both. Product and Sellers need the alphanumeric productId (like 34X621REEQZQ). Reviews needs the numeric usItemId (like 16954719851). Using the wrong one is rejected up front with a message telling you which to use.

## `store_id` (type: `string`):

Optional, used by sellers mode only. Pricing and availability are store specific. Leave blank to use the default store, or copy the storeId returned on every search result row to match a particular location.

## `max_results` (type: `integer`):

How many rows to return before stopping. Search returns up to about 50 products per upstream call and reviews returns 20 per call, so the Actor pages automatically until it reaches this number or the source runs out. Product mode always returns exactly one row.

## Actor input object example

```json
{
  "search_mode": "search",
  "query": "laptop",
  "max_results": 100
}
```

# Actor output Schema

## `allResults` (type: `string`):

Every row from this run.

## `overview` (type: `string`):

Products with price, rating and seller in a scannable table.

## `sellers` (type: `string`):

Every seller offering the product, with price, availability and delivery.

## `reviews` (type: `string`):

Customer reviews with rating, text, date and author.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "laptop"
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/walmart-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "query": "laptop" }

# Run the Actor and wait for it to finish
run = client.actor("johnvc/walmart-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "laptop"
}' |
apify call johnvc/walmart-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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