# Walmart Scraper (`scraptivo/walmart-scraper`) Actor

Walmart.com product listings from search, category, or product pages, with optional product details and customer reviews. Includes ZIP-based pickup and delivery context.

- **URL**: https://apify.com/scraptivo/walmart-scraper.md
- **Developed by:** [Scraptivo](https://apify.com/scraptivo) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 product scrapeds

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** collects product listings from [Walmart.com](https://www.walmart.com) — search results, category pages, and individual product pages — and turns them into structured data for competitive intelligence, repricing, and assortment research. Provide search queries or URLs, and export names, prices, ratings, availability, sellers, and store context, with optional product details and nested customer reviews, to JSON, CSV, Excel, or your integration. Use it to monitor prices, track sellers, and analyze reviews at scale. Pricing starts at **$1.50 per 1,000 products**, with optional details and reviews billed separately.

### What can you automate with Walmart Scraper?

- **Build product catalogs** — from search keywords like `tomatoes` or pasted search, category, and product URLs.
- **Monitor prices, ratings, and availability** — track listings on a schedule for competitive and repricing workflows.
- **Set store context by ZIP code** — reflect pickup, delivery, or shipping availability for a US ZIP.
- **Enrich with full product details** — add descriptions, images, and category information when enabled.
- **Attach customer reviews to the same record** — no separate dataset rows per review.
- **Feed retail analytics pipelines** — one JSON row per product for dashboards, BI tools, and automation.

### Who is this scraper for?

| Team | Workflow |
|---|---|
| Competitive intelligence teams | Tracking competitor prices, ratings, and sellers across categories. |
| Pricing and repricing teams | Monitoring price changes to adjust their own listings. |
| Market researchers | Comparing assortment, brands, and price points at scale. |
| Data engineering teams | Feeding structured product and review data into warehouses and ML pipelines. |

### What data can you collect from Walmart.com?

| Data group | Example fields | How it helps |
|---|---|---|
| Product identity | `name`, `brand`, `usItemId`, `url`, `imageUrl` | Identify and deduplicate records with the stable `usItemId`. |
| Pricing | `price`, `currency`, `unitPrice` | Compare current and per-unit pricing. |
| Ratings | `averageRating`, `numberOfReviews` | Qualify products by aggregate review signals. |
| Availability and seller | `availabilityStatus`, `sellerName` | Track stock status and marketplace sellers. |
| Store context | `zipCode`, `storeName` | See pickup/delivery context when a ZIP is set. |
| Enrichment | `description`, `reviews` | Optional full descriptions and a nested review list. |

The `description` and `reviews` fields appear only when **Scrape product details** and **Scrape product reviews** are enabled respectively. Listing-level data is always returned.

### How to use Walmart Scraper

1. Open the [Walmart Scraper](https://apify.com/scraptivo/walmart-scraper) on Apify.
2. Enter `searchQueries` and/or `startUrls`, and set a `zipCode` if you need local store context.
3. Choose a `fulfillmentMethod` (Pickup, Delivery, or Shipping) and set limits with `maxItems` and `maxPages`.
4. Optionally enable **Scrape product details** and **Scrape product reviews**, and cap reviews with `maxReviews`.
5. Run the Actor and export the dataset to JSON, CSV, or Excel, or connect it to your workflow.

```json
{
    "searchQueries": ["tomatoes"],
    "zipCode": "72076",
    "fulfillmentMethod": "Pickup",
    "scrapeProductDetails": true,
    "scrapeProductReviews": true,
    "maxReviews": 20,
    "maxItems": 20,
    "maxPages": 0,
    "maxConcurrency": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
```

### Example workflow

#### Track competitor prices on a weekly basis

1. Schedule a run each Monday with your `searchQueries` for key categories.
2. Set `zipCode` and `fulfillmentMethod` to match your customers' pickup or delivery context.
3. Keep only products where `availabilityStatus` and `sellerName` match your monitoring criteria.
4. Send new rows to a database or repricing service via webhook, deduplicating on `usItemId`.

### Automate and integrate your results

- **Schedules** — set daily or weekly price checks; create one schedule per query for fast-moving categories.
- **Webhooks** — trigger a webhook on run completion to push fresh data into a warehouse, Slack, or repricing service.
- **Exports and API** — download JSON, CSV, Excel, or HTML from the Console, or call the Actor from the API. One cURL example:

```shell
curl "https://api.apify.com/v2/acts/scraptivo/walmart-scraper/runs?token=YOUR-APIFY-TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["tomatoes"],
    "zipCode": "72076",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
  }'
```

- **Deduplication** — each run produces a new dataset; dedupe on `usItemId` (or `url`) when merging results across runs.

### Input reference

| Field | Type | Required | Default | What it controls |
|---|---:|---|---|---|
| `searchQueries` | Array of strings | No\* | — | Keywords to search on Walmart.com (e.g. "tomatoes"). |
| `startUrls` | Array of URLs | No\* | — | Walmart search, category (`/browse`, `/cp`), or product (`/ip`) URLs. |
| `zipCode` | String | No | — | US ZIP for pickup/delivery store context (e.g. `72076`). |
| `fulfillmentMethod` | String | No | — | `Pickup`, `Delivery`, or `Shipping` filter after a ZIP is set. |
| `scrapeProductDetails` | Boolean | No | `false` | Fetch full product details for each item. Charged as `product-details`. |
| `scrapeProductReviews` | Boolean | No | `false` | Attach a reviews list on each product row. Charged as `product-reviews` per review. |
| `maxReviews` | Integer | No | `20` | Maximum reviews per product (`0` = all). |
| `maxItems` | Integer | No | `0` | Maximum product records (`0` = unlimited). |
| `maxPages` | Integer | No | `0` | Maximum listing pages per query or URL (`0` = unlimited). |
| `maxConcurrency` | Integer | No | `5` | Parallel workers for details and reviews (1–20). |
| `proxyConfiguration` | Proxy object | No | Residential Apify proxy | Proxy settings. Residential proxies are recommended. |

\* Provide at least one `searchQueries` entry or `startUrls` entry.

### Output example

Each dataset item is one product. With details and reviews enabled, a record looks like this:

```json
{
    "sourceQuery": "tomatoes",
    "usItemId": "123456789",
    "name": "Fresh Roma Tomatoes, 1 lb",
    "brand": "Marketside",
    "url": "https://www.walmart.com/ip/123456789",
    "imageUrl": "https://i5.walmartimages.com/example.jpg",
    "price": 2.98,
    "currency": "USD",
    "unitPrice": "$2.98/lb",
    "averageRating": 4.6,
    "numberOfReviews": 342,
    "availabilityStatus": "In stock",
    "sellerName": "Walmart.com",
    "zipCode": "72076",
    "storeName": "Walmart Supercenter",
    "description": "Fresh Roma tomatoes, ideal for sauces and salads.",
    "reviewsScraped": 20,
    "reviews": [
        { "title": "Great quality", "rating": 5, "text": "Very fresh and well packaged." }
    ]
}
```

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

The Actor uses pay-per-event pricing with three chargeable events, each **$1.50 per 1,000**:

- **`product`** — each product row scraped.
- **`product-details`** — each product where details are fetched (when enabled).
- **`product-reviews`** — each individual review attached to a product (when enabled).

Apify plan discounts apply automatically: Bronze **$1.40**, Silver **$1.30**, Gold **$1.20** per 1,000 events. Platform usage is not charged separately. Details and reviews are off by default; the default `maxReviews` is **20** per product (set `0` for all).

### Reliability and responsible use

- **Proxy requirement** — the Actor defaults to the Apify residential proxy, which is recommended for consistent Walmart results.
- **Conditional fields** — `description` and `reviews` appear only when their toggles are enabled; some fields are nullable on the platform.
- **Public data** — the Actor collects publicly visible product and review information from Walmart.com.
- **Responsible use** — only use the data in ways that comply with Walmart.com's terms of service and applicable law.

### Frequently asked questions

#### Can I scrape Walmart.com by keyword and by URL?

Yes. Use `searchQueries` for keyword search and/or `startUrls` for search, category, or product URLs. You can combine both in a single run.

#### Can I schedule the Walmart Scraper to run automatically?

Yes. Use the **Scheduler** tab in Apify Console to run daily or weekly, and create one schedule per query for fast-moving categories.

#### What counts as one result?

A product row counts as one `product` event ($1.50 per 1,000). Enabling details adds a `product-details` event per product, and each attached review adds a `product-reviews` event.

#### Why are some fields empty?

`description` and `reviews` appear only when their toggles are enabled. Store-context fields such as `zipCode` and `storeName` require a ZIP. Some fields are also nullable on Walmart.com itself.

#### How do I avoid duplicate records?

Dedupe on the stable `usItemId` (or `url`) when merging results across runs; each run appends to a new dataset.

#### Do I need a proxy?

The Actor works out of the box with the default Apify residential proxy, which is recommended for consistent results.

### Related Scraptivo automations

- **[Alibaba Scraper](https://apify.com/scraptivo/alibaba-scraper)** — collect Alibaba.com product listings with supplier and review data.
- **[Nike Scraper](https://apify.com/scraptivo/nike-scraper)** — collect Nike.com product listings across marketplaces.
- **[H\&M Scraper](https://apify.com/scraptivo/h-and-m-scraper)** — collect H\&M product catalogs with pricing and composition details.

### Support and custom workflows

Need a different field, source, or delivery workflow? Contact Scraptivo at scraptivo@gmail.com. Include the Actor name, sample URL, required fields, and expected volume so we can assess the request.

# Actor input Schema

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

Keywords to search on Walmart.com, e.g. tomatoes or wireless mouse. Use this or start URLs (or both).

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

Walmart search, category (/browse or /cp), or product (/ip) URLs. e.g. https://www.walmart.com/search?q=tomatoes

## `zipCode` (type: `string`):

US ZIP used to set store pickup/delivery context, e.g. 72076. Leave empty for default shipping results.

## `fulfillmentMethod` (type: `string`):

Optional fulfillment filter applied to listings after a ZIP is set.

## `scrapeProductDetails` (type: `boolean`):

When enabled, fetch full product details for each item (charged as product-details).

## `scrapeProductReviews` (type: `boolean`):

When enabled, attach a reviews list on each product row. Each review is charged as product-reviews. Reviews are never stored as separate dataset rows.

## `maxReviews` (type: `integer`):

Maximum reviews to attach per product. 0 = all reviews. Default is 20. Each attached review is billed as a product-reviews event.

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

Maximum number of product records to scrape (0 = unlimited)

## `maxPages` (type: `integer`):

Maximum search/category pages per query or URL (0 = unlimited)

## `maxConcurrency` (type: `integer`):

Parallel workers for product details and reviews. Each worker rotates proxies.

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

Proxy settings for anti-bot protection. Residential proxies are recommended.

## Actor input object example

```json
{
  "searchQueries": [
    "tomatoes"
  ],
  "zipCode": "72076",
  "scrapeProductDetails": false,
  "scrapeProductReviews": false,
  "maxReviews": 20,
  "maxItems": 20,
  "maxPages": 0,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing scraped Walmart products

## `runStats` (type: `string`):

Key-value store record with scrape counts and timestamps

# 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": [
        "tomatoes"
    ],
    "zipCode": "72076",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraptivo/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": ["tomatoes"],
    "zipCode": "72076",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scraptivo/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": [
    "tomatoes"
  ],
  "zipCode": "72076",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scraptivo/walmart-scraper --silent --output-dataset

```

## MCP server setup

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