# Walmart Intelligence Scraper (`jdtpnjtp/walmart-intelligence-scraper`) Actor

Extract Walmart products, prices and reviews: title, brand, price, rollback, rating, review count, stock, seller, specs and review text. Search, category, bestsellers, deals, product detail and reviews in one Actor. Pay per result.

- **URL**: https://apify.com/jdtpnjtp/walmart-intelligence-scraper.md
- **Developed by:** [Data Forge](https://apify.com/jdtpnjtp) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 93.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.10 / 1,000 product results

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 Scraper

Scrape Walmart products, prices and reviews at scale. **Products from $1 / 1,000, reviews from $0.60 / 1,000, full product detail $3.60 / 1,000.** Search the catalog, browse categories, pull best sellers and rollback deals, get full product detail and collect reviews, then export thousands of clean rows in a single run. Pay only for the rows you keep.

No setup, no browser, no infrastructure to manage. Pick what you need under **What to scrape**, press **Start**, and get flat tables out: **Products** and **Reviews**.

> Prefer a single-purpose tool? Data Forge also ships the focused **Walmart Product Scraper** and **Walmart Reviews Scraper**.

### Why this Actor?

One umbrella Actor covers 6 Walmart data surfaces and can combine them in a single run, so you skip wiring separate tools together and joining their output by hand. Winning cells are in bold.

| Capability | This Actor | Typical single-purpose Walmart actors |
|---|---|---|
| Walmart surfaces in one Actor | **6: search, product detail, best sellers, deals, category URLs, reviews** | 1 surface per actor |
| Product detail + reviews in one run | **Yes - the Product 360 mode below** | Run 2 actors, then join the output yourself |
| Search-to-detail enrichment | **1 toggle - `includeProductDetails`** | Not offered |
| Sort orders on search and deals | **5: best match, price low, price high, best seller, newest** | Limited or none |
| Best sellers and rollback deals by category | **Both, category-scoped** | Separate actors, or missing |
| Combined product + review intelligence | **1 dataset, 6 row types** | 2 datasets to reconcile |
| Billing | **Pay per result, $5 free monthly credit** | Often per-run or a subscription |

### What does the Walmart Scraper do?

It turns a keyword, a product ID, a category or a deals list into structured Walmart data. Tick 1 or more data types and the Actor pulls exactly that:

| Data type | What it returns |
|---|---|
| 🔎 **Search** | Products matching your keyword, paginated. |
| 📦 **Product detail** | A full record for specific products (specs, images, model, brand, seller). |
| 🏆 **Best sellers** / 🔥 **Deals** | Best-seller and rollback / clearance lists by category. |
| 🗂 **Category** | Browse a Walmart category. |
| ⭐ **Reviews** | Product reviews, sorted and paginated. |

The dataset opens on ready-made views (**Products**, **Reviews**), so the right columns are in front of you.

### What data can you get from Walmart?

**Per product:** item ID, title, brand, price, was-price, rollback flag, rating, review count, in-stock status, seller name, model number, UPC, images and the product URL.

**Per review:** reviewer name, star rating, review title, review text, date, helpful votes and verified-purchase flag.

Each row also carries the raw source object under a `data` field, so nothing the page exposes is dropped.

### Input modes

4 published example tasks map 1:1 to the common jobs below. Copy a JSON block into the input editor, or open the matching example task and press **Start**.

#### 1. Product 360 - detail plus reviews in one run

Sellers and product teams: pull a product's full spec sheet and up to 100 recent reviews for the same item in a single run.

```json
{
  "productIds": ["18533160127"],
  "dataTypes": ["product", "reviews"],
  "maxReviewsPerProduct": 100
}
```

#### 2. Market snapshot - search enriched with full details

Category managers: map a keyword's top 40 listings and enrich each one with a full product-detail record.

```json
{
  "searchQueries": ["air fryer"],
  "dataTypes": ["search"],
  "includeProductDetails": true,
  "maxResultsPerType": 40
}
```

#### 3. Category intelligence with details

Merchandisers: walk a Walmart category page and enrich the first 40 items with full detail.

```json
{
  "categoryUrls": ["https://www.walmart.com/browse/electronics/3944"],
  "dataTypes": ["category"],
  "includeProductDetails": true,
  "maxResultsPerType": 40
}
```

#### 4. Best-sellers deep-dive

Trend and sourcing analysts: rank a category's best sellers and enrich the top 40 with full detail.

```json
{
  "dataTypes": ["bestsellers"],
  "bestsellersDealsCategory": "electronics",
  "includeProductDetails": true,
  "maxResultsPerType": 40
}
```

### How to scrape Walmart

1. Under **What to scrape**, tick the data types you want. **Search** is prefilled, so the Actor runs on the first click.
2. Fill the matching input: keywords for Search, item IDs or product URLs for Product detail / Reviews, a category URL for Category. Product input is adaptive: an item ID or a product URL both resolve.
3. Set the sort, deals category and reviews options in the collapsible sections.
4. Press **Start**. Export to JSON, CSV, Excel or Google Sheets, or pull from the Apify API.

#### Input example

```json
{
  "dataTypes": ["search"],
  "searchQueries": ["air fryer"],
  "sort": "best_seller",
  "maxResultsPerType": 40,
  "includeProductDetails": true
}
```

### Output

Each dataset item has a `row_type` field, so the 6 surfaces stay easy to filter and split.

| `row_type` | What it is | Key fields |
|---|---|---|
| `search_result` | 1 listing from a keyword search | name, brand, price, rating, seller\_name, in\_stock, url |
| `category_result` | 1 listing from a category browse | name, brand, price, rating, in\_stock, url |
| `product_detail` | Full detail record for 1 product | name, brand, price, model\_number, upc, rating, review\_count, image\_url |
| `bestseller` | 1 item from a category best-sellers list | name, brand, price, rating, url |
| `deal` | 1 rollback / clearance item | name, brand, price, original\_price, url |
| `review` | 1 product review | author, rating, title, text, date, verified\_purchase, helpful\_count |

#### Output examples

Search-result row:

```json
{
  "query": "air fryer",
  "row_type": "search_result",
  "us_item_id": "967557625",
  "name": "Ninja AF101 Air Fryer, 4 Qt",
  "brand": "Ninja",
  "price": 89.0,
  "original_price": 119.0,
  "rating": 4.8,
  "review_count": 38400,
  "seller_name": "Walmart.com",
  "in_stock": true,
  "url": "https://www.walmart.com/ip/967557625"
}
```

Product-detail row:

```json
{
  "query": "18533160127",
  "row_type": "product_detail",
  "us_item_id": "18533160127",
  "name": "Ninja AF101 Air Fryer, 4 Qt, Black and Grey",
  "brand": "Ninja",
  "price": 89.0,
  "original_price": 119.0,
  "rating": 4.8,
  "review_count": 38400,
  "model_number": "AF101",
  "upc": "622356561105",
  "url": "https://www.walmart.com/ip/18533160127"
}
```

Review row:

```json
{
  "query": "18533160127",
  "row_type": "review",
  "review_id": "a1b2c3d4",
  "author": "Jamie R.",
  "rating": 5,
  "title": "Works great",
  "text": "Crispy results each time, easy to clean.",
  "date": "2026-05-22",
  "verified_purchase": true,
  "helpful_count": 12
}
```

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

You pay per result, billed by Apify, with no subscription. With the **$5 free monthly credit** you can pull, for example:

- **~8,300 reviews** (reviews from $0.60 / 1,000), or
- **~5,000 product listings** (products from $1 / 1,000), or
- **~1,380 full product details** ($3.60 / 1,000).

Detail fan-out is opt-in, so a default search run stays cheap. Failed items (a product that no longer exists, an out-of-stock region) are returned for visibility and are **never charged**.

### What can you use Walmart data for?

- **Price and assortment monitoring** - track price, rollback status and availability across a catalog.
- **Competitor and market research** - compare brands, ratings and price bands in a category.
- **Best-seller and deal tracking** - watch what is rising and discounted by category.
- **Product intelligence** - specs, images, model and seller for catalog enrichment.
- **Review mining and sentiment** - feed product reviews into NLP for CX insight.
- **Reseller and arbitrage sourcing** - spot clearance and rollback opportunities at scale.
- **MAP and pricing compliance** - monitor seller prices against policy.

### Is it legal to scrape Walmart?

Scraping publicly available Walmart data is legal in most jurisdictions when you collect only public information and respect personal-data laws such as GDPR and CCPA. This Actor returns only data a visitor can see on Walmart.com. You are responsible for how you use the output, so consult a lawyer for your specific case.

### FAQ

**Can I run just 1 data type?** Yes. Tick only what you need under **What to scrape**; the rest stays idle and uncharged.

**Can I get product detail and reviews for the same item in 1 run?** Yes - that is the Product 360 mode. Pass `productIds` and set `dataTypes` to `["product", "reviews"]`; both surfaces land in the same dataset, keyed by `us_item_id`.

**When should I use this Actor vs the split actors?** Use this umbrella when you want 2 or more surfaces, or a product + review combo, in a single run. Reach for **Walmart Product Scraper** or **Walmart Reviews Scraper** when you only need 1 surface at high volume and want the leanest input form.

**What happens with a bad product ID or a dead listing?** The Actor writes a free error row (with `error_code` and `error_message`), then keeps going with the next item. You are not charged for error rows, and 1 bad input does not stop the run.

**How fresh is the data?** Rows are fetched live from Walmart on each run, so prices, stock and ratings reflect the moment the Actor runs.

**How many reviews can I get per product?** Up to the `maxReviewsPerProduct` cap you set (1 to 1,000), in your chosen sort order.

**Can I enrich a search or category with full detail?** Yes. Turn on `includeProductDetails` and each listing row is enriched with a product-detail record (adds a product-detail charge per enriched row).

**Can I call it from code?** Yes. Run it via the Apify API, the Apify client SDKs, or an MCP server, and read results from the dataset.

### Related actors

Part of the Data Forge Walmart and marketplace fleet:

- **[Walmart Product Scraper](https://apify.com/jdtpnjtp/walmart-product-scraper)** - focused product search, category, best sellers, deals and detail.
- **[Walmart Reviews Scraper](https://apify.com/jdtpnjtp/walmart-reviews-scraper)** - focused, high-volume review extraction.
- **[Amazon Scraper](https://apify.com/jdtpnjtp/amazon)** - products, prices and reviews across Amazon marketplaces.

***

### Support

Built and maintained by **Data Forge**. Need custom fields, higher volume or a quick answer?

[![Telegram](https://img.shields.io/badge/Telegram-Chat-26A5E4?style=for-the-badge\&logo=telegram\&logoColor=white)](https://t.me/j4dtpnj2tp)
[![WhatsApp](https://img.shields.io/badge/WhatsApp-Message-25D366?style=for-the-badge\&logo=whatsapp\&logoColor=white)](https://wa.me/380686031542)
[![Email](https://img.shields.io/badge/Email-Contact-EA4335?style=for-the-badge\&logo=gmail\&logoColor=white)](mailto:jdtpnjtp@gmail.com)

# Actor input Schema

## `dataTypes` (type: `array`):

Which verticals to run. Search needs queries, Product/Reviews need product ids, Category needs URLs. Bestsellers / Deals run only when explicitly selected.

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

Keyword searches (e.g. `laptop`, `4k tv`).

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

Walmart products by ID (catalog id or numeric item id) or product URL. Used by Product detail and Reviews.

## `categoryUrls` (type: `array`):

Walmart category paths or URLs (e.g. `/browse/electronics/3944`).

## `maxResultsPerType` (type: `integer`):

Upper bound on results per vertical / input item (1-500).

## `includeProductDetails` (type: `boolean`):

When on, every listing row is enriched with a full product-detail call (adds a product-detail charge per result).

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

Order of search and deals results.

## `bestsellersDealsCategory` (type: `string`):

Optional Walmart category ID to scope bestsellers and deals.

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

Sort order for the Reviews vertical.

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

Cap on reviews per product for the Reviews vertical (1-1000).

## Actor input object example

```json
{
  "dataTypes": [
    "search"
  ],
  "searchQueries": [
    "laptop"
  ],
  "productIds": [],
  "categoryUrls": [],
  "maxResultsPerType": 20,
  "includeProductDetails": false,
  "sort": "best_match",
  "reviewsSort": "relevancy",
  "maxReviewsPerProduct": 40
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset; row\_type discriminates search\_result / category\_result / bestseller / deal / product\_detail / review. Full payload under data. Views: Overview / Products / Reviews.

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

OUTPUT key: data\_types, product\_results, product\_details, reviews, errors, total\_rows, estimated\_cost\_usd, limit\_reached, actor\_version.

# 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 = {
    "dataTypes": [
        "search"
    ],
    "searchQueries": [
        "laptop"
    ],
    "productIds": [],
    "categoryUrls": [],
    "maxResultsPerType": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("jdtpnjtp/walmart-intelligence-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 = {
    "dataTypes": ["search"],
    "searchQueries": ["laptop"],
    "productIds": [],
    "categoryUrls": [],
    "maxResultsPerType": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("jdtpnjtp/walmart-intelligence-scraper").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 '{
  "dataTypes": [
    "search"
  ],
  "searchQueries": [
    "laptop"
  ],
  "productIds": [],
  "categoryUrls": [],
  "maxResultsPerType": 20
}' |
apify call jdtpnjtp/walmart-intelligence-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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