# Walmart Product Scraper (`apt_marble/walmart-product-scraper`) Actor

Paste any Walmart product link or item ID and get the full product as clean data: title, price in USD, brand, rating, seller, every image, description, specifications and variants with price and availability.

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

## Pricing

$2.00 / 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.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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 Product Scraper

Paste any Walmart product link or item number and get the full product back as clean, structured data — title, price in USD, brand, customer rating and review count, seller, every image, long description, specifications, available variants such as color or size with their own price and availability, fulfillment options and stock status. One input row becomes one enriched product record, so you can turn a list of links from a spreadsheet, a competitor report or a category export into a dataset ready to filter and pivot. Built for anyone who needs Walmart's product pages as data: retailers enriching a catalog, analysts tracking price and availability, sourcing teams validating a shortlist, and brands watching how their listings read to shoppers.

### What you can do with it

- **Turn a link or an ID into a full record** — paste `https://www.walmart.com/ip/12345678` or just `12345678` and get back price, images, specs, description and seller in one row. Mix links and bare IDs in the same list.
- **Capture every variant** — when a product comes in multiple colors, sizes or pack counts each option is returned with its own price and availability so you can map the full offer without opening the page.
- **Track what a shopper actually sees** — title, brand, category breadcrumb, rating, review count, all images, fulfillment badges and whether the item is in stock are returned exactly as Walmart shows them right now.
- **Keep a clean list honest** — products that are no longer available are still returned with `listingStatus: UNAVAILABLE` so a removed listing is never silently dropped and your row count always matches your input count.
- **Run a list on a schedule** — re-run the same set hourly or daily and compare each fresh dataset to the last to spot price moves, stock flips and new variants.
- **Feed any workflow** — every record carries its canonical product URL and item ID, so you can join it to a search export, a price tracker or a catalog of your own.

### What you get

One row per product. Abridged sample of a single enriched product:

```json
{
  "itemId": "12345678",
  "title": "Apple AirPods Pro (2nd Generation) Wireless Earbuds",
  "price": { "amount": 189.99, "currency": "USD" },
  "originalPrice": { "amount": 249.99, "currency": "USD" },
  "onSale": true,
  "brand": "Apple",
  "categoryBreadcrumb": ["Electronics", "Headphones", "Earbuds"],
  "rating": 4.7,
  "reviewCount": 18342,
  "seller": { "name": "Walmart.com", "rating": 4.5 },
  "images": [
    "https://i5.walmartimages.com/seo/image-abc123.jpeg",
    "https://i5.walmartimages.com/seo/image-def456.jpeg"
  ],
  "description": "Active Noise Cancellation reduces unwanted background noise. Adaptive Transparency lets outside sounds in while reducing loud environmental noise…",
  "specifications": {
    "Connectivity": "Bluetooth 5.3",
    "Battery Life": "Up to 6 hours"
  },
  "variants": [
    {
      "variantId": "111",
      "title": "White — Standard",
      "price": { "amount": 189.99, "currency": "USD" },
      "availability": "IN_STOCK",
      "itemId": "12345678",
      "url": "https://www.walmart.com/ip/12345678"
    }
  ],
  "fulfillmentOptions": ["Free shipping", "Pickup"],
  "availability": "IN_STOCK",
  "url": "https://www.walmart.com/ip/12345678",
  "listingStatus": "ACTIVE",
  "scrapedAt": "2026-08-28T12:00:00.000Z"
}
```

A product shown at a discount carries both `price` (what the shopper pays) and `originalPrice` (the struck-through was-price) with `onSale: true`. When there is no discount `originalPrice` is `null` and `onSale` is `false`. A removed or no-longer-available listing is still returned, with `listingStatus: UNAVAILABLE`, `availability: OUT_OF_STOCK` and the fields Walmart no longer renders left empty rather than guessed. Every monetary figure is in USD — Walmart is a US-only marketplace.

### Input reference

| Setting | Type | Default | What it does |
| --- | --- | --- | --- |
| Product pages or item IDs | list of text | `https://www.walmart.com/ip/12345678` | Walmart product pages to scrape. Paste full links such as `https://www.walmart.com/ip/Apple-AirPods-Pro-2nd-Generation/12345678` or `https://www.walmart.com/ip/12345678`, or just the item number like `12345678`. Mix links and IDs in the same list. Each entry returns one product record. **Required.** Maximum 5,000 entries per run. |
| Include review summary | true/false | `false` | Add the product's rating and review count to each record. Useful when you need the average rating and total review volume alongside the other details. |
| Include variants | true/false | `true` | Collect available variants such as size, color or pack options when a product has them. Each variant's price and availability is included. |
| Parallel work | whole number | `5` | How many product pages to fetch at the same time. Maximum 10. |

### Output fields

| Field | Type | Description |
| --- | --- | --- |
| `itemId` | text | Walmart's item number for the product. |
| `title` | text | Product title as shown to shoppers. `null` on unavailable listings. |
| `price` | object | The price as `{ amount, currency }`, always in USD. `amount` is `null` when no price is shown. |
| `originalPrice` | object | The struck-through was-price when a discount is shown; `null` otherwise. Always in USD. |
| `onSale` | true/false | Whether the product is currently discounted (`originalPrice` above `price`). |
| `brand` | text | Brand name when shown on the page. |
| `categoryBreadcrumb` | list of text | Category trail from the site's breadcrumb (for example `["Electronics","Headphones"]`). |
| `rating` | number | Average customer rating (0–5, one decimal) when shown. |
| `reviewCount` | number | Number of customer reviews when shown. |
| `seller` | object | Seller as `{ name, rating }`. `name` is `"Walmart.com"` for Walmart-sold items; marketplace sellers show their display name. |
| `images` | list of text | All product image URLs found on the page. |
| `description` | text | Long description / product story as plain text, when the page carries one. |
| `specifications` | object | Key-value specifications (for example `{"Connectivity":"Bluetooth 5.3"}`) extracted from the specs and features sections. |
| `variants` | list of objects | Available variants when the product has them. Each entry has `variantId`, `title`, optional `axes` such as `color`/`size`, `price`, `availability` and `url`. Empty when there are no variants or when includeVariants is off. |
| `fulfillmentOptions` | list of text | Fulfillment badges such as `"Free shipping"` or `"Pickup"` when shown. |
| `availability` | text | Stock status as `IN_STOCK` or `OUT_OF_STOCK`. |
| `url` | text | Canonical link to the product page (`https://www.walmart.com/ip/ITEM_ID`). |
| `listingStatus` | text | `ACTIVE` when the listing was found and parsed, `UNAVAILABLE` when the product is no longer available. |
| `scrapedAt` | text | When the row was collected (ISO timestamp). |

### Pricing

You pay per product row, with no monthly minimum.

| What you are charged for | Price |
| --- | --- |
| Product — one product added to your dataset | **$2.00 per 1,000** |

The charge is a flat fee per row pushed to the dataset. A list of 500 products costs 500 × $0.002 = **$1.00**. A daily run of 100 products is about $0.20 per run, roughly $6 a month. Products that are no longer available are still returned as `UNAVAILABLE` rows and are charged the same as available ones because their page was still read and classified; only products that could not be read at all (and therefore produce no row) are not charged.

**Worked example.** Enriching 1,000 products costs 1,000 × $0.002 = **$2.00**. Enriching the same list daily for 30 days costs about $60 and produces 30 comparable snapshots you can diff for price and availability changes.

### Limits & what this actor cannot do

- Prices, ratings, stock, images and variants are a snapshot at the moment of collection and keep changing afterwards; Walmart may update any of them without notice.
- A product that Walmart has removed is returned as `listingStatus: UNAVAILABLE` with `availability: OUT_OF_STOCK` and empty price/spec fields — the row is still produced so your input and output counts stay aligned.
- Identical item IDs in the same run are read only once — the first occurrence produces the row and later duplicates are skipped with a warning.
- There is a practical ceiling of 5,000 products per run. To process a larger catalog, split it into multiple runs.
- Specifications are taken from the structured specs and features sections the page renders. Where a layout omits them that field comes back as an empty object rather than guessed.
- Variants are returned only when the product's own page exposes them as selectable options. A listing that shows variants only as images or free text may carry a `variants: []` until Walmart renders them structurally.
- Prices come back in USD only; a figure is never re-labelled into a different currency.
- Speed depends on the size of the job and on Walmart's own response times; no fixed throughput is promised.
- Walmart's terms govern automated access. You are responsible for using the data lawfully and in line with the source site's terms, and for handling any personal data in line with applicable privacy law.

### FAQ

**Do I need a Walmart account?**
No. The actor reads only what Walmart shows the public on its product pages.

**Does it need my login or password?**
No. There is nothing to connect and nothing to configure — paste the links or IDs and press start.

**Which link shapes do you accept?**
Both `https://www.walmart.com/ip/12345678` and `https://www.walmart.com/ip/Some-Product-Name/12345678` work, plus any of those with query strings or fragments, and bare IDs like `12345678`. The numeric ID is the only part that matters; the slug is ignored when fetching.

**Can I mix links and IDs in the same list?**
Yes. Paste a spreadsheet column that has both — the actor extracts the item ID from each entry, dedupes the list, and reads each distinct product once.

**What happens when a product is no longer available?**
It is still returned as a row with `listingStatus: UNAVAILABLE` and `availability: OUT_OF_STOCK`. That way a 100-row input always gives you 100 rows back and you can tell a removed listing from a failed read.

**Are variants included?**
Yes when they are switchable on the product page (color, size, pack count and similar axes). Each variant carries its own price and availability and its own product link when Walmart exposes one. Turn `Include variants` off to skip that section.

**Is the review rating part of the product record?**
Yes — `rating` and `reviewCount` are on every available product. Use `Include review summary` when you want to make that explicit in your workflow; the fields are still the shopper-visible average and total count.

**How many products can I run at once?**
Up to 1,000 per run. Split a larger catalog into batches and run them back-to-back.

**Can I schedule it?**
Yes. Schedule it hourly, daily or weekly from the Apify console, and each run writes a fresh dataset you can compare against the last — ideal for tracking price, stock and variant changes over time.

**Is the data complete?**
It is complete for everything Walmart shows openly on the product page. Where a layout omits a field the actor leaves it empty rather than guessing, and it reports removed listings explicitly instead of dropping them.

# Actor input Schema

## `products` (type: `array`):

Walmart product pages to scrape. Paste full Walmart links such as https://www.walmart.com/ip/Apple-AirPods-Pro-2nd-Generation/12345678 or https://www.walmart.com/ip/12345678, or just the item number (for example 12345678). Mix links and IDs in the same list. Each entry returns one product record.

## `includeReviews` (type: `boolean`):

Add the product's rating summary and review counts to each record. Useful when you need average rating and total review volume alongside the product details.

## `includeVariants` (type: `boolean`):

Collect available variants such as size, color or pack options when a product has them. Each variant's price and availability is included.

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

How many product pages to fetch at the same time. Higher is faster; lower is gentler. Leave at 5 unless you have a reason to change it.

## Actor input object example

```json
{
  "products": [
    "https://www.walmart.com/ip/FabricLA-Shaggy-Faux-Fur-Fabric-8-X-8-Inches-Pre-Cut-Use-Fake-Fur-Fabric-for-DIY-Craft-Fashion-Accessory-Home-Decoration-Hobby/1055013128"
  ],
  "includeReviews": false,
  "includeVariants": true,
  "maxConcurrency": 5
}
```

# Actor output Schema

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

Every product this run collected.

## `runSummary` (type: `string`):

What this run collected, and anything it could not read.

# 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 = {
    "products": [
        "https://www.walmart.com/ip/FabricLA-Shaggy-Faux-Fur-Fabric-8-X-8-Inches-Pre-Cut-Use-Fake-Fur-Fabric-for-DIY-Craft-Fashion-Accessory-Home-Decoration-Hobby/1055013128"
    ],
    "includeReviews": false,
    "includeVariants": true,
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("apt_marble/walmart-product-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 = {
    "products": ["https://www.walmart.com/ip/FabricLA-Shaggy-Faux-Fur-Fabric-8-X-8-Inches-Pre-Cut-Use-Fake-Fur-Fabric-for-DIY-Craft-Fashion-Accessory-Home-Decoration-Hobby/1055013128"],
    "includeReviews": False,
    "includeVariants": True,
    "maxConcurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("apt_marble/walmart-product-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 '{
  "products": [
    "https://www.walmart.com/ip/FabricLA-Shaggy-Faux-Fur-Fabric-8-X-8-Inches-Pre-Cut-Use-Fake-Fur-Fabric-for-DIY-Craft-Fashion-Accessory-Home-Decoration-Hobby/1055013128"
  ],
  "includeReviews": false,
  "includeVariants": true,
  "maxConcurrency": 5
}' |
apify call apt_marble/walmart-product-scraper --silent --output-dataset

```

## MCP server setup

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