# Walmart Products Scraper: Prices, Sellers, Ratings & Images (`hyperbach/walmart-scraper`) Actor

Scrape Walmart products by search words, search or category URL, or product URL: item id, name, brand, price, was-price, unit price, availability, seller, rating and review count, image URLs, category path, UPC and specifications. Several searches per run, a max per search. No login. Misses free.

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

## Pricing

from $2.50 / 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.
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 Products Scraper: Prices, Sellers, Ratings & Images

**Walmart products, logged out: search words, Walmart search or category URLs, or product URLs in, one row per product out — the item id and URL, name and brand, the price with the was-price and the unit price, availability, the seller, the rating with the review count and the five rating counts, every image URL, the category path, the UPC and model number, the specifications and the variant options — several searches in one run, a max per search.** One free `search` row per input carries a completeness verdict: COMPLETE (Walmart's own end of the list), CAPPED (your limit), TRUNCATED (Walmart's own depth limit of about 500 products a list, with its count) or PARTIAL. No login, no API key, no browser, proxies handled for you.

**$5.00 per 1,000 `product` rows on the Free plan, $4.25 on Starter.** A run start is $0.0009. The default input returns about 10 rows for about $0.0509. A value that names nothing is a free row that says why.

### Why this Walmart scraper

- **Searches, categories and products in one run.** Give search words (`air fryer`), search URLs from your browser with the sort and filters you set there, category URLs, or product URLs and item ids. Each search gets its own cap (`maxItemsPerSearch`), and the run's cap sits on top (`maxItems`).
- **Each product's own page, included.** With `includeDetails` on (the default) every product of a search is also read from its own page: every image URL, the UPC and model number, the five rating counts, the specifications, the variant options and the seller's type, at no extra charge. Off, a run reads the search cards only, about ten times faster.
- **Prices as Walmart shows them.** The current price, the was-price when Walmart strikes one through, and the unit price (`$4.60/count`), with the availability and the seller (Walmart.com or the Marketplace seller).
- **Deep lists, checked.** Walmart's own order, page after page, to Walmart's own end of the list. Walmart shows a reader about 10 pages of a search and about 20 of a category (about 500 products) whatever its count says (measured 2026-10-23); the free `search` row says so (TRUNCATED, with Walmart's count). A product a later page or another search repeats is delivered and charged once.
- **Honest runs.** A product Walmart does not know is a free `not_found` row, checked twice; a URL that is not walmart.com a free `invalid` row. Every input gets a row, and a product whose page Walmart did not serve keeps its search card's fields and says so (`details_status`).

### Who it's for

- **Brands and sellers** — how their products and their competitors' sit in Walmart's search for their words: the price, the was-price, the rating, the review count and who sells it.
- **Price and assortment analysts** — a category's products with prices, unit prices, availability and sellers, read again every day to see markdowns and stock-outs.
- **Catalog and data teams** — product data by item id: the UPC, the model number, every image, the specifications and the category path, to enrich or match a catalog.

### Quick start

**The first 100 products of a search**

```json
{
  "searchQueries": [
    "air fryer"
  ],
  "maxItemsPerSearch": 100
}
```

**A search URL with its sort, cards only, fast**

```json
{
  "startUrls": [
    "https://www.walmart.com/search?q=laptop&sort=price_low"
  ],
  "maxItemsPerSearch": 200,
  "includeDetails": false
}
```

**Two products by URL and by item id**

```json
{
  "startUrls": [
    "https://www.walmart.com/ip/BLANCA-NIEVES-Laundry-Detergent-70-54-Ounce/16935510",
    "820167152"
  ]
}
```

### Output

One row per product (and one free search row per input):

| field | meaning |
|---|---|
| `row_type` | `product` (one product, charged) or `search` (the input's row with the walk's verdict; free). |
| `input_index` | The 1-based position of the input this row answers: `startUrls` first, then `searchQueries`. |
| `input_value` | The input as you gave it (the URL or the search words). |
| `input_kind` | Which input it came from: `url` (`startUrls`) or `query` (`searchQueries`). |
| `search_url` | The list (or the product) on walmart.com, as a URL you can open. |
| `status` | A search row: `ok`, `not_found`, `invalid`, `duplicate`, `failed` or `not_read` (see the FAQ). A product row: `ok`. |
| `status_detail` | Why a search row is not `ok`, in a sentence. |
| `scraped_at` | When the row was read (UTC). |
| `position` | The product's place among this search's delivered products (1 = first); 1 for a product URL. |
| `page` | The list page the product was on (empty for a product URL). |
| `item_id` | Walmart's item id (`usItemId`, the number in the product URL). |
| `product_id` | Walmart's product id (`productId`, letters and digits). |
| `url` | The product's page on walmart.com. |
| `name` | The product's title. |
| `brand` | The brand Walmart shows (empty on a category card when the product's page is not read). |
| `price` | The current price, in `currency` (the lowest option's price when the product has a price range). |
| `currency` | The price's currency (`USD`). |
| `was_price` | The struck-through earlier or list price, when Walmart shows one. |
| `unit_price` | The price per unit as Walmart writes it (`$4.60/count`, `$1.02/lb`), when it shows one. |
| `availability` | `IN_STOCK` or `OUT_OF_STOCK` (Walmart's own status, for its default location). |
| `seller_name` | The seller's name (`Walmart.com`, or a Marketplace seller's shop name). |
| `seller_id` | Walmart's id of the seller. |
| `seller_type` | `INTERNAL` (Walmart itself) or `EXTERNAL` (a Marketplace seller), from the product's page. |
| `fulfillment_type` | How Walmart fulfils the offer (`FC` fulfilment centre, `STORE`, `MARKETPLACE`, …). |
| `rating` | The average star rating (1-5). |
| `review_count` | The number of ratings and reviews. |
| `rating_counts` | How many ratings of each star: `{"1": …, "5": …}` (from the product's page). |
| `image_url` | The main image, full size. |
| `image_urls` | Every image of the product, full size (one image when the product's page is not read). |
| `category_path` | Walmart's category path, top level first (`Electronics > Laptops > …`). |
| `upc` | The product's UPC barcode number, from its page. |
| `model_number` | The manufacturer's part or model number, from its page. |
| `short_description` | The product's short description as text. |
| `specifications` | The specifications table: a list of `{name, value}`. |
| `variant_options` | The variant choices: `{"Size": ["S", "M", …], "Color": […]}`. |
| `variants_count` | How many variants the product has. |
| `sponsored` | True when the search card was a sponsored placement (empty for a product URL). |
| `details_status` | `read` (the product's page was read), `not_asked` (`includeDetails` off: the search card's fields only), `refused` (Walmart did not serve the page: the card's fields only) or `not_found` (the page answered no product). |
| `first_seen_at` | With `onlyNew`: the day this memory first saw the product. |
| `last_seen_at` | With `onlyNew`: the day this memory last saw the product. |
| `times_seen` | With `onlyNew`: how many runs of this memory saw the product. |
| `items_count` | A search row: Walmart's own count of products for the list, as the server that answered page 1 gave it. Walmart's servers give different counts for the same list (for one search on 2026-10-23: from 383 to 361,614), so read it as a size class, not an exact figure. |
| `items_delivered` | A search row: the product rows this input delivered. |
| `pages_read` | A search row: the list pages read. |
| `repeats_skipped` | A search row: products skipped because an earlier page or another input of the run already delivered them. |
| `skipped_seen` | A search row, with `onlyNew`: products an earlier run of this memory delivered, skipped free in this run (their pages not read). |
| `verdict` | A search row: `COMPLETE` (Walmart's own end of the list), `CAPPED` (your limit), `TRUNCATED` (the list ended far below Walmart's count: Walmart shows a reader about 500 products of a list) or `PARTIAL` (a refusal or the time limit stopped it). |
| `verdict_detail` | A search row: the verdict in a sentence, with the counts. |

Example record:

```json
{
  "row_type": "product",
  "input_index": 1,
  "input_value": "https://www.walmart.com/search?q=tshirt",
  "input_kind": "url",
  "search_url": "https://www.walmart.com/search?q=tshirt",
  "status": "ok",
  "status_detail": null,
  "scraped_at": "2026-10-23T02:38:40Z",
  "position": 3,
  "page": 1,
  "item_id": "785086468",
  "product_id": "6LR9CAZX7OTK",
  "url": "https://www.walmart.com/ip/Undershirts-T-Shirt-Pack-10-Pack-V-Neck-Cotton-Tees-for-Men-Moisture-Wicking-White/785086468",
  "name": "Undershirts T-Shirt Pack, 10-Pack, V-Neck Cotton Tees for Men, Moisture-Wicking, White",
  "brand": "Hanes",
  "price": 23.98,
  "currency": "USD",
  "was_price": 32.98,
  "unit_price": "$2.40/count",
  "availability": "IN_STOCK",
  "seller_name": "Walmart.com",
  "seller_id": "F55CDC31AB754BB68FE0B39041159D63",
  "seller_type": "INTERNAL",
  "fulfillment_type": "FC",
  "rating": 4.5,
  "review_count": 29569,
  "rating_counts": {
    "1": 1918,
    "2": 674,
    "3": 1218,
    "4": 2663,
    "5": 23096
  },
  "image_url": "https://i5.walmartimages.com/seo/Undershirts-T-Shirt-Pack-10-Pack-V-Neck-Cotton-Tees-for-Men-Moisture-Wicking-White_f05d1bf0-6bf3-4dce-a33a-da7452c55e65.a6a43f5f2f4b5f9ea646db00e1719907.jpeg",
  "image_urls": [
    "https://i5.walmartimages.com/seo/Undershirts-T-Shirt-Pack-10-Pack-V-Neck-Cotton-Tees-for-Men-Moisture-Wicking-White_f05d1bf0-6bf3-4dce-a33a-da7452c55e65.a6a43f5f2f4b5f9ea646db00e1719907.jpeg",
    "https://i5.walmartimages.com/asr/c2546c61-4ba5-4525-9c89-77fd339f9e69.54ab1cb864ffaeda7ec2dcba1ba70303.jpeg",
    "https://i5.walmartimages.com/asr/4c92e4ce-f600-4f3a-b1b9-acc9928ec346.92c0ff0c2f43f279cfac83ec9286842c.jpeg",
    "https://i5.walmartimages.com/asr/c6b85aaa-4bca-4faf-88f2-09b1996175fa.f70c6164b8e51b3ccb97124a576676cf.jpeg",
    "https://i5.walmartimages.com/asr/d7e2a752-3953-48f3-9272-e1cddc44ffa9.93fcdb8bd0641eeaee87d4d1f389d4e1.jpeg",
    "https://i5.walmartimages.com/asr/ea39f42e-7ab3-4a76-8b25-d930244cb46e.e7a647b2a63e61448545cf85efbdeea8.jpeg",
    "https://i5.walmartimages.com/asr/5ac819c5-1477-491c-83f6-ddec56cdada2.7b48c50355dda05c8b68e39ec8fc1ed8.jpeg",
    "https://i5.walmartimages.com/asr/2d9172ce-7845-4941-afe7-08799adacb0c.f25946a509b90f685ada28483110e02f.jpeg",
    "https://i5.walmartimages.com/asr/90a05fa9-4738-49f8-8db9-a1f371acb0ad.282720838774aa8065fe41c818bcdc5d.jpeg"
  ],
  "category_path": "Clothing > Fashion Brands > Hanes > Hanes Men > Hanes Mens Tank Tops",
  "upc": "738994933768",
  "model_number": "777Z10",
  "short_description": "Leave it to Hanes to take a classic cotton basic to an all-new level. Crafted with ComfortSoft® 100% cotton fabric, this men's V-neck undershirt now features a longer length and all-day flex fabric that moves with you and maintains the fit you expect. The long length means these essential cotton t-shirts stay tucked in, making them the ideal layering piece. Moisture-wicking technology keeps you cool, and we know you'll appreciate the smooth, tag-free interior. Stock up on these Hanes-best cotton V-neck tees in a convenient 10-pack and start wearing a better-than-basic undershirt.",
  "specifications": [
    {
      "name": "Clothing size",
      "value": "L"
    },
    {
      "name": "Clothing fit",
      "value": "Regular"
    },
    {
      "name": "Brand",
      "value": "Hanes"
    },
    {
      "name": "Clothing neck style",
      "value": "V-Neck"
    },
    {
      "name": "Sleeve length style",
      "value": "Short Sleeve"
    },
    {
      "name": "Top style",
      "value": "Pullover"
    },
    {
      "name": "Fabric content",
      "value": "100% Cotton"
    },
    {
      "name": "Clothing feature",
      "value": "Moisture-Wicking"
    },
    {
      "name": "Count per pack",
      "value": "10"
    },
    {
      "name": "Pack quantity",
      "value": "10"
    },
    {
      "name": "Piece count",
      "value": "10"
    },
    {
      "name": "Total count",
      "value": "10"
    },
    {
      "name": "Fabric material name",
      "value": "Cotton"
    },
    {
      "name": "Fabric material percentage",
      "value": "100"
    },
    {
      "name": "Pattern",
      "value": "Solid Print"
    },
    {
      "name": "Sleeve style",
      "value": "Casual"
    },
    {
      "name": "Clothing style",
      "value": "Casual"
    },
    {
      "name": "Fabric care",
      "value": "Machine wash cold with like colors."
    },
    {
      "name": "Fastener type",
      "value": "Pull-On"
    },
    {
      "name": "Fabric construction",
      "value": "Knit"
    },
    {
      "name": "Product line",
      "value": "Super Value Pack"
    },
    {
      "name": "Retail packaging",
      "value": "Single Piece"
    },
    {
      "name": "Color category",
      "value": "White"
    }
  ],
  "variant_options": {
    "Color": [
      "White"
    ],
    "Clothing Size": [
      "S",
      "M",
      "L",
      "XL"
    ]
  },
  "variants_count": 4,
  "sponsored": true,
  "details_status": "read",
  "first_seen_at": null,
  "last_seen_at": null,
  "times_seen": null,
  "items_count": null,
  "items_delivered": null,
  "pages_read": null,
  "repeats_skipped": null,
  "skipped_seen": null,
  "verdict": null,
  "verdict_detail": null
}
```

### Pricing

**Pay for the products a run delivers**, plus one run start; no platform usage is billed to you. The product price falls with your Apify plan.

| event | unit | Free | Starter | Scale | Business |
|---|---|---|---|---|---|
| Product (`product`) | per 1,000 | $5.00 | $4.25 | $3.50 | $2.50 |
| Run start (`start`) | per run | $0.0009 | $0.0009 | $0.0009 | $0.0009 |

A product is **$5.00 per 1,000** on the Free plan ($0.005 a product), with its page's details (every image, the UPC, the rating counts, the specifications) included. Each run that delivers a charged product also pays the **run start, $0.0009 once**; a run that delivers no charged product pays nothing at all. So one search of 100 products costs $0.5009 on the Free plan, and several searches in one run share one start. The free `search` row of every input, a value that is not a walmart.com URL (`invalid`), a product Walmart does not know (`not_found`), a repeated input (`duplicate`), an input left at the cap or the time limit (`not_read`) and a refusal the run could not pass (`failed`) are never charged. A product is charged once a run, also when several searches list it. A run that stops early (a timeout, an abort) is charged for the products it delivered. `maxItems` counts the charged rows; before the first request the log names the price of each row at your plan and the most the run can cost. Enterprise plans have their own rates: the Actor's Pricing tab shows the price for your plan.

### Usage patterns

- **A schedule** — Save a task with your searches or category URLs and `onlyNew` (and a `stateStoreName` to name the memory), and schedule it: each run reads the list and delivers only the products no earlier run of that memory delivered; a product skipped this way is free, and its page is not read. `first_seen_at`, `last_seen_at` and `times_seen` ride every delivered product row, and the free search row counts the products skipped (`skipped_seen`). The caps bound the depth read, so a weekly run with `maxItemsPerSearch` 100 reads the same first 100 of the list every week. Ready-made: [Walmart search monitor: weekly, only the new products](https://apify.com/hyperbach/walmart-scraper/examples/walmart-search-monitor-weekly-only-new-products).
- **Searches, categories and products** — `searchQueries` takes words, one search a line. `startUrls` takes search URLs as your browser shows them (the `sort=` and `facet=` filters they carry are kept), category URLs (`/browse/…`, `/cp/…`) and product URLs (`/ip/…/<item id>`) or bare item ids. walmart.com (US) only.
- **What a row is** — `row_type` = `product`: one product, in Walmart's order (`position`, and the `page` it was on). `row_type` = `search`: the free row of one input value — `items_count` (Walmart's own count, which differs between Walmart's servers), `items_delivered`, `pages_read`, `repeats_skipped`, the `verdict` with its `verdict_detail`, and the `status` with its reason.
- **How far a search goes** — `maxItemsPerSearch` (default 100; 0 = every product the list serves) stops each search after that many new products. Walmart shows a reader about 10 pages of a search and about 20 of a category, about 500 products, whatever its count says; a run that reaches that end says TRUNCATED with Walmart's count, and a sort or a filter in a search URL reads other products of the same words. `maxItems` caps the charged rows of the whole run.

### Input configuration

| field | type | default | what it does |
|---|---|---|---|
| `startUrls` | `array` |  | Walmart pages to read, one a line: a search URL (`https://www.walmart.com/search?q=tshirt`, with any `sort=` or `facet=` you set in your browser), a category URL (`https://www.walmart.com/browse/…` or `/cp/…`), or a product URL (`https://www.walmart.com/ip/…/<item id>`, or the item id alone). A search or category URL is one list, read page after page; a product URL is one product. A URL that is not walmart.com gets a free `invalid` row; a URL given twice a free `duplicate` row. |
| `searchQueries` | `array` |  | Words to search on walmart.com, one search a line (`air fryer`, `running shoes`), as you would type them in Walmart's search box. Each line is one list, like a search URL. Words Walmart matches with nothing give a free row with no product. |
| `maxItemsPerSearch` | `integer` | `100` | Stop each search or category list after this many new products. 0 = every product the list serves: Walmart shows a reader about 10 pages of a search (about 500 products) and about 20 pages of a category (about 500), whatever its count says. Product URLs are not counted here. |
| `includeDetails` | `boolean` | `true` | On: every product of a list is read from its own page too, for all the image URLs, the UPC and model number, the five rating counts, the specifications, the variant options, the page's seller and category path. Off: the search card's fields only (price, was-price, unit price, availability, seller, rating, one image, category path), about ten times faster. Product URLs are always read from their page. |
| `onlyNew` | `boolean` | `false` | Remember every product delivered under this memory (stateStoreName, or a name derived from the inputs) and skip it free in the next run, before its page is read: a scheduled task delivers only what is new in the list. The search row counts the skipped (skipped_seen). A product asked by URL is always delivered. |
| `stateStoreName` | `string` | `""` | The name of the onlyNew memory, so several tasks can share one or keep theirs apart. Empty: a name derived from the inputs. |
| `maxItems` | `integer` | `0` | Stop the whole run after this many product rows (the charged rows). 0 = no run cap; each search still stops at its own limit above. |

### Errors

**A run does not fail because of your input.** When an input cannot be used — a date that is not a date, an id in the wrong form, two settings that contradict each other — the run ends **Succeeded**, charges nothing, and says what to change:

- the status message starts with `INPUT REJECTED`;
- the dataset holds one row, `{"error": true, "code": "…", "message": "…"}`, and no results;
- the key-value store record `ERROR` holds the same object.

From code, check `error` on the first row before reading results.

A URL that is not a walmart.com search, category or product URL (an account page, walmart.ca, another site) is not an error: it gets one free `search` row with `status` invalid that says why, and the run goes on with the others. A run that ends **Failed** is a fault on our side, never your input; it charges nothing, and we are alerted.

### FAQ

**Which status is which?**

A search row's `status` is `ok` (products served), `not_found` (Walmart has no product with that item id; checked on two connections), `invalid` (an empty value, or a URL that is not a walmart.com search, category or product URL), `duplicate` (the same search or product again in the input: read once; or a product another input already delivered), `failed` (Walmart refused every try; free) or `not_read` (left at `maxItems`, the charge limit or the run's time limit). A product row's `status` is `ok`.

**Does it return each variant as its own row?**

No. A product row carries its variant options (`{"Size": ["S", "M"], …}`) and the variant count; a variant's own price and stock are on its own product URL, which you can give as an input.

**Why does a search stop at about 500 products?**

Walmart shows a reader about 10 pages of a search and about 20 pages of a category, whatever its count says (the next page is empty, measured 2026-10-23). Sort the same words another way (`sort=price_low`, `sort=best_seller`) or add a filter in a search URL: each is its own list.

**Does it give reviews, store stock by ZIP code or walmart.ca?**

No. The row has the rating, the review count and the five rating counts, not the reviews' texts; availability is Walmart's own status for its default location; walmart.ca and walmart.com.mx are other sites.

**Does it need a Walmart account or API key?**

No. Everything is read from Walmart's public pages, logged out.

### Integration

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('hyperbach/walmart-scraper').call({"searchQueries": ["air fryer"], "maxItemsPerSearch": 100});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('hyperbach/walmart-scraper').call(run_input={'searchQueries': ['air fryer'], 'maxItemsPerSearch': 100})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

#### CLI

```bash
apify call hyperbach/walmart-scraper --input '{"searchQueries": ["air fryer"], "maxItemsPerSearch": 100}'
```

#### REST

```bash
curl -X POST "https://api.apify.com/v2/acts/hyperbach~walmart-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H 'Content-Type: application/json' -d '{"searchQueries": ["air fryer"], "maxItemsPerSearch": 100}'
```

#### AI agents and MCP

Apify's MCP server offers this Actor as a tool to Claude, Cursor, VS Code and any other MCP client. Connect `https://mcp.apify.com?tools=hyperbach/walmart-scraper` and ask, for example: "Get the first 100 Walmart products for air fryer with prices and ratings". The agent fills the input from the table above and reads the rows from the run's dataset. The input names are the ones in the table above.

#### n8n, Make and Zapier

The Apify node in n8n, the Apify app in Make and the Apify integration in Zapier run this Actor on a schedule or from a trigger and read its dataset. A webhook on the run's end (Integrations on the Actor page) sends the rows on to your own endpoint. Nothing to install on our side.

### Support

**Disagree with a charge?** Write to apify@hyperbach.com with the run ID. We will ask Apify to compensate you, and the charge comes back to your Apify account as platform credit.

**Did it do the job?** A short [review on the Store](https://apify.com/hyperbach/walmart-scraper/reviews), at any rating, helps the next buyer choose.

### See also

- **[Amazon Product Details Scraper](https://apify.com/hyperbach/amazon-product-details-scraper)** — Amazon products by ASIN, URL or UPC / EAN / ISBN on 21 Amazon stores: the buy-box price, every best-seller rank, the rating and the review summary.
- **[AliExpress Product Details Scraper](https://apify.com/hyperbach/aliexpress-product-details-scraper)** — AliExpress products by URL or item id: every SKU with its own price and stock, in the country and currency you choose.
- **[Shopify Store Scraper](https://apify.com/hyperbach/shopify-products-scraper)** — every product of a Shopify store, with its variants, prices and images.
- **[Alibaba Products Scraper](https://apify.com/hyperbach/alibaba-scraper)** — the products of an Alibaba.com search: price range, minimum order and the supplier with its country and verification.
- **[Coles Scraper](https://apify.com/hyperbach/coles-scraper)** — Coles Australia products and specials, with the price, the was-price and the unit price.
- **[Woolworths Scraper](https://apify.com/hyperbach/woolworths-scraper)** — Woolworths Australia products and specials, with the barcode, the unit price and nutrition.

*This page is generated from the Actor's schemas and a live sample — it cannot describe a field the Actor does not have.*

# Actor input Schema

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

Walmart pages to read, one a line: a search URL (`https://www.walmart.com/search?q=tshirt`, with any `sort=` or `facet=` you set in your browser), a category URL (`https://www.walmart.com/browse/…` or `/cp/…`), or a product URL (`https://www.walmart.com/ip/…/<item id>`, or the item id alone). A search or category URL is one list, read page after page; a product URL is one product. A URL that is not walmart.com gets a free `invalid` row; a URL given twice a free `duplicate` row.

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

Words to search on walmart.com, one search a line (`air fryer`, `running shoes`), as you would type them in Walmart's search box. Each line is one list, like a search URL. Words Walmart matches with nothing give a free row with no product.

## `maxItemsPerSearch` (type: `integer`):

Stop each search or category list after this many new products. 0 = every product the list serves: Walmart shows a reader about 10 pages of a search (about 500 products) and about 20 pages of a category (about 500), whatever its count says. Product URLs are not counted here.

## `includeDetails` (type: `boolean`):

On: every product of a list is read from its own page too, for all the image URLs, the UPC and model number, the five rating counts, the specifications, the variant options, the page's seller and category path. Off: the search card's fields only (price, was-price, unit price, availability, seller, rating, one image, category path), about ten times faster. Product URLs are always read from their page.

## `onlyNew` (type: `boolean`):

Remember every product delivered under this memory (stateStoreName, or a name derived from the inputs) and skip it free in the next run, before its page is read: a scheduled task delivers only what is new in the list. The search row counts the skipped (skipped_seen). A product asked by URL is always delivered.

## `stateStoreName` (type: `string`):

The name of the onlyNew memory, so several tasks can share one or keep theirs apart. Empty: a name derived from the inputs.

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

Stop the whole run after this many product rows (the charged rows). 0 = no run cap; each search still stops at its own limit above.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.walmart.com/search?q=tshirt"
  ],
  "maxItemsPerSearch": 10,
  "includeDetails": true,
  "onlyNew": false,
  "stateStoreName": "",
  "maxItems": 50
}
```

# Actor output Schema

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

All scraped records in the default dataset. One row per product (and one free search row per input):

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

How the run went: product rows charged, products delivered without their page's details, free rows, inputs by status, the walk per search (products delivered, pages read, repeated products skipped, the verdict), the source counters (calls, served, refused, exits, rotations, bytes) and the memory watch.

# 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 = {
    "startUrls": [
        "https://www.walmart.com/search?q=tshirt"
    ],
    "maxItemsPerSearch": 10,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("hyperbach/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 = {
    "startUrls": ["https://www.walmart.com/search?q=tshirt"],
    "maxItemsPerSearch": 10,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("hyperbach/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 '{
  "startUrls": [
    "https://www.walmart.com/search?q=tshirt"
  ],
  "maxItemsPerSearch": 10,
  "maxItems": 50
}' |
apify call hyperbach/walmart-scraper --silent --output-dataset

```

## MCP server setup

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