# Walmart Scraper — Products, Prices & Reviews (`tortuga/walmart-scraper`) Actor

Scrape Walmart.com search results, category pages, product pages and reviews: price, was-price, rating, seller, availability, fulfillment, images and specifications. Any keyword or URL.

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

## Pricing

from $2.00 / 1,000 product scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

Scrape Walmart.com search results, browse and category pages, product pages and customer reviews into a clean dataset: price, was-price, savings, unit price, rating, review count, seller, availability, shipping / pickup / delivery, badges (Best seller, Rollback, Clearance, Overall pick), rank on the page and sponsored flag. Turn on details for the description, specifications, every image, every variant with its own price and stock, UPC, seller profile and return policy, and turn on reviews for the review texts.

No headless browser and no login: the Actor reads the JSON Walmart embeds in its own pages, so one request returns 40+ products. Download the results as JSON, CSV or Excel, or pull them through the API into your own app, Google Sheets or an LLM pipeline. You pay per item you get.

### What data does Walmart Scraper extract?

Every product from a search, browse or category page (the `result` event):

| Field | Description |
|---|---|
| `type` | `"product"` |
| `usItemId`, `productId` | Walmart item id (the number in `/ip/.../18901811909`) and internal product id |
| `name`, `url`, `imageUrl` | Product title, canonical product URL, full-size main image |
| `brand` | Brand, when the result tile carries it (always filled with details on) |
| `price`, `wasPrice`, `savingsAmount`, `currency` | Current price, strike-through price, the difference, `USD` |
| `priceText` | Price as displayed (`$99.00`, or `See price in cart`; the number is still in `price`) |
| `unitPrice` | Unit price text, e.g. `$84.97/count`, `2.9 ¢/fl oz` |
| `variantPriceMin`, `variantPriceMax` | "Options from $x" / "$x - $y" across variants and conditions |
| `shippingPrice`, `subscriptionPrice` | Shipping fee shown on the tile; subscribe-and-save price |
| `rating`, `reviewCount` | Average rating (0-5) and number of ratings |
| `sellerName`, `sellerId` | Seller (Walmart.com or the marketplace seller) |
| `isSponsored` | `true` for sponsored tiles (ads). A product shown as an ad and as an organic result is saved once, as organic |
| `availability`, `inStock` | `IN_STOCK` / `OUT_OF_STOCK` / `UNKNOWN` and a boolean (`null` when Walmart shows no offer) |
| `fulfillment` | `{type, shipping, pickup, delivery, freeShipping, shippingText, pickupText, deliveryText}`, e.g. `"Free shipping, arrives today"` |
| `badges` | `Best seller`, `Rollback`, `Clearance`, `Reduced price`, `Overall pick`, `Deal`, `Low stock`, `Only 4 left`, `100+ bought since yesterday`, ... |
| `category`, `categoryPath`, `productType` | Walmart's primary shelf for the product (leaf and full path) and its product type. For some items the primary shelf is a merchandising shelf such as "View in 3D"; `productType` (`Headphones`, `Air Fryers`) is the stable classification |
| `variantCount`, `additionalOfferCount` | Variants shown on the tile; other offers for the same product |
| `shortDescription` | Short description when the tile has one |
| `position`, `page` | Rank among the product tiles of the page (ads included, in display order) and page number |
| `location` | Store context Walmart priced the page for: `{zipCode, city, state, storeId}` |
| `searchTerm`, `sourceUrl`, `scrapedAt` | Provenance |
| `changeType`, `previousValues` | Only with **Only new or changed items** on: `new` or `changed`, and for changed products the old values of the fields that changed (review items get `changeType: "new"`) |

With **Include product details** on, or for product URLs (the extra `detail` event), each product also gets:

| Field | Description |
|---|---|
| `description`, `shortDescription` | Full description and summary as plain text |
| `specifications` | Specification table as a dict (`{"Battery life": "50 h", ...}`) |
| `images` | All product images, full size |
| `variantOptions`, `variants` | Option dimensions (`[{name: "Color", values: [...]}]`) and every variant: `{usItemId, productId, options: {Color: "Black", "Clothing Size": "M"}, price, wasPrice, availability, inStock, url}` |
| `upc`, `gtin`, `model`, `manufacturer`, `manufacturerPartNumber` | Identifiers (each `null` when Walmart does not publish it) |
| `seller` | `{id, catalogSellerId, name, legalName, type, rating, reviewCount, url, logoUrl, isProSeller, fulfilledByWalmart}` |
| `returnPolicy` | `{returnable, freeReturns, windowDays, text}` |
| `warranty`, `warrantyUrl` | Warranty text and link when present |
| `ratingCounts`, `reviewsWithText`, `recommendedPercentage` | 1-5 star breakdown, number of written reviews, "would recommend" share |
| `reviewAspects` | What reviewers talk about: `[{name: "Sound Quality", mentions: 125}, ...]` |
| `condition`, `conditionOffers` | `New` / `Open Box` / ... and the price of each condition on offer |
| `offerType`, `secondaryOfferPrice` | `ONLINE_AND_STORE` / `ONLINE_ONLY` / `STORE_ONLY`; price of the next seller's offer when there is one |
| `ingredients`, `directions`, `warnings` | Grocery, health and safety texts when present |
| `fulfillment` | Adds `shippingPrice`, `deliveryPrice`, `arrivesBy`, `shippingRestricted` and full sentences such as `"Free pickup, today at Sacramento Supercenter"` |
| `primaryUsItemId`, `orderLimit` | Parent item of the variant group; maximum order quantity |

With **Include reviews** on, or for review-page URLs (the `review` event), one item per review:

| Field | Description |
|---|---|
| `type` | `"review"` |
| `usItemId`, `productName`, `productUrl` | Product the review belongs to |
| `reviewId`, `rating`, `title`, `text`, `submittedAt` | Review id, stars (1-5), title, text, ISO date |
| `positiveFeedback`, `negativeFeedback` | Helpful / not helpful votes |
| `verifiedPurchase`, `recommended`, `badges` | Verified purchase flag, "would recommend", badge texts |
| `photosCount`, `photos` | Customer photos |
| `sellerResponse`, `sellerResponseDate` | Seller reply when present |
| `soldBy`, `fulfilledBy`, `variant`, `reviewedItemId` | Which seller and variant the reviewer bought |
| `language`, `syndicatedFrom`, `scrapedAt` | Review language, original source for syndicated reviews |
| `reviewerName` | Reviewer's nickname as Walmart shows it ("Richard"; reviewers who chose to stay anonymous show as "anonymous"); `null` when the review has no nickname (Walmart then prints "Walmart customer") |
| `reviewerId` | Always `null`: Walmart shows no reviewer id or public profile on review cards (kept for the same shape as the other review Actors) |
| `reviewerLocation` | Reviewer location when Walmart publishes one; `null` otherwise (rare: none was set in our samples) |

Walmart shows no reviewer photos or avatars, so there is no image field for reviewers.

### How to use Walmart Scraper

1. Type one or more **Search terms** (one per line) and/or paste **Start URLs**: search pages, `/browse/` pages, `/cp/` category pages, product pages (`/ip/...`) or review pages (`/reviews/product/...`). Filters you applied on walmart.com stay in the URL and are respected.
2. Pick **Sort by** and, if you want, a **Min / Max price**.
3. Set **Max items** to cap the run (and the cost). Products and reviews both count.
4. Turn on **Include product details** and/or **Include reviews** only if you need them: each costs extra requests and events (see below).
5. Click **Start**. Results appear in the **Dataset** tab; export from there or use the API.

### Input example

```json
{
  "searchTerms": ["headphones"],
  "startUrls": [
    { "url": "https://www.walmart.com/browse/electronics/over-ear-on-ear-headphones/3944_133251_1095191_1230614_1230477" },
    { "url": "https://www.walmart.com/ip/18901811909" }
  ],
  "maxItems": 200,
  "maxPagesPerSearch": 5,
  "sortBy": "best_seller",
  "minPrice": 20,
  "maxPrice": 150,
  "includeSponsored": true,
  "includeDetails": false,
  "includeReviews": false,
  "maxReviewsPerProduct": 20,
  "reviewSort": "newest",
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["UNBLOCKER"] }
}
```

### Output example

A product from a search page:

```json
{
  "type": "product",
  "usItemId": "17705823295",
  "productId": "2X5KX5MXYEUT",
  "name": "Bluetooth Headphones Over Ear, 65Hrs Playtime Wireless Headphones,Bass Boosted by 90%,Lightweight Headset with Deep Bass, Clear Call with 4 Noise Cancelling Mics,Low Latency for Travel Work Cellphone",
  "url": "https://www.walmart.com/ip/Bluetooth-Headphones-4-Mic-Noise-Cancelling-Calls-Wireless-Earbuds-2200mAh-Charging-Case-Support-Wireless-Charging-Compatible-iPhone-13-Pro-Max-XS-XR/17705823295",
  "brand": null,
  "price": 19.89,
  "wasPrice": 169.97,
  "priceText": "$19.89",
  "currency": "USD",
  "unitPrice": null,
  "savingsAmount": 150.08,
  "shippingPrice": null,
  "variantPriceMin": 19.59,
  "variantPriceMax": null,
  "subscriptionPrice": null,
  "rating": 4.2,
  "reviewCount": 3922,
  "sellerName": "VEATOOL",
  "sellerId": "4FBDDE46B58946639B681AE74E2E7F72",
  "isSponsored": true,
  "availability": "IN_STOCK",
  "inStock": true,
  "fulfillment": {
    "type": "FC",
    "shipping": true,
    "pickup": false,
    "delivery": false,
    "freeShipping": false,
    "shippingText": "Shipping, arrives Sun, Oct 4",
    "pickupText": null,
    "deliveryText": null
  },
  "badges": ["Best seller"],
  "imageUrl": "https://i5.walmartimages.com/seo/Bluetooth-Headphones-4-Mic-Noise-Cancelling-Calls-Wireless-Earbuds-2200mAh-Charging-Case-Support-Wireless-Charging-Compatible-iPhone-13-Pro-Max-XS-XR_51533b6e-c49e-4459-9787-3c45d26de3ec.6ad6cf413848b8ff85c27d97aca66841.jpeg",
  "category": "Over-Ear and On-Ear Headphones",
  "categoryPath": ["Electronics", "Audio", "Headphones", "Shop Headphones by Type", "Over-Ear and On-Ear Headphones"],
  "productType": "Headphones",
  "variantCount": 0,
  "additionalOfferCount": null,
  "shortDescription": null,
  "position": 2,
  "page": 1,
  "location": { "zipCode": "95829", "city": null, "state": "CA", "storeId": "3081" },
  "searchTerm": "headphones",
  "sourceUrl": null,
  "scrapedAt": "2026-10-02T20:23:58+00:00"
}
```

With `includeDetails: true` the same item additionally carries, for example:

```json
{
  "brand": "VEAT00L",
  "model": "BT1632",
  "upc": null,
  "description": "【Bluetooth 5.4&Dual-Connections】Equipped with the latest Bluetooth 5.4 tech, ...",
  "specifications": { "Headphone style": "Over-Ear", "Battery life": "65 h", "Wireless": "Y" },
  "images": ["https://i5.walmartimages.com/seo/...6ad6cf413848b8ff85c27d97aca66841.jpeg", "..."],
  "variantOptions": [{ "name": "Actual Color", "values": ["Blue", "Gold", "Orange", "Pink", "Purple", "Silver", "black gray"] }],
  "variants": [
    { "usItemId": "2312754100", "productId": "6MLYJ0VM9OEE", "options": { "Actual Color": "Blue" }, "price": 21.59, "wasPrice": 179.97, "availability": "IN_STOCK", "inStock": true, "url": "https://www.walmart.com/ip/.../2312754100" }
  ],
  "seller": {
    "id": "4FBDDE46B58946639B681AE74E2E7F72",
    "catalogSellerId": "101133098",
    "name": "VEATOOL",
    "legalName": "Shenzhen Dexinyue Trading Co., Ltd.",
    "type": "Marketplace seller",
    "rating": 4.35,
    "reviewCount": 11092,
    "url": "https://www.walmart.com/global/seller/101133098",
    "isProSeller": true,
    "fulfilledByWalmart": true
  },
  "returnPolicy": { "returnable": true, "freeReturns": true, "windowDays": 30, "text": "Free Holiday returns until Jan 31" },
  "ratingCounts": { "1": 464, "2": 168, "3": 230, "4": 383, "5": 2677 },
  "reviewsWithText": 700
}
```

A review:

```json
{
  "type": "review",
  "usItemId": "18901811909",
  "reviewId": "437018039",
  "rating": 5,
  "title": "very happy with the headphones",
  "text": "These headphones are fantastic! The sound is just as good as headphones that cost twice as much. Definitely worth it!",
  "submittedAt": "2026-08-15",
  "positiveFeedback": 0,
  "negativeFeedback": 0,
  "verifiedPurchase": true,
  "recommended": null,
  "badges": ["Verified Purchase"],
  "photosCount": 1,
  "photos": ["https://i5.walmartimages.com/dfw/6e29e393-c66d/k2-_d5dbf8a8-fa57-4e29-aecc-a04e496c7aad.v1.jpg"],
  "sellerResponse": null,
  "sellerResponseDate": null,
  "soldBy": "COZZY SHOPPING INC",
  "fulfilledBy": "Seller",
  "variant": { "Color": "Black" },
  "reviewedItemId": "5530776824",
  "language": "English",
  "syndicatedFrom": null,
  "reviewerName": "anonymous",
  "reviewerId": null,
  "reviewerLocation": null,
  "productName": "Skullcandy Crusher XT Wireless Foldable Over-Ear Headphones, Krazy Pink",
  "productUrl": "https://www.walmart.com/ip/Skullcandy-Crusher-XT-Wireless-Over-Ear-Krazy-Pink/18901811909",
  "scrapedAt": "2026-10-02T20:24:59+00:00"
}
```

### Proxy note

Walmart answers datacenter and most residential proxy traffic with a "Robot or human?" challenge, so this Actor uses **Apify's Unblocker proxy** (group `UNBLOCKER`) by default. Unblocker is billed to your Apify account per answered request: 10 Unblocker units, about **$0.0015 on the free plan** and less on paid plans. Requests the proxy cannot complete are free; a page that no longer exists (HTTP 404) still counts. One request returns either a search / browse page (40 products plus sponsored tiles), one product page, or 10 reviews.

The Actor is built around that price: it requests a further result page only when **Max items** still needs it, opens product and review pages only when you ask for them, and reuses the 10 reviews a product page already contains instead of fetching them again. The `SUMMARY` record in the run's key-value store reports `successfulRequests`, so you can check the proxy cost of every run. You can switch to another proxy group in the input; the Actor then retries challenge pages on fresh IPs and reports them as `blockedPages`.

### How much does it cost?

Pay per event, no subscription: **$0.002 per product**, **+ $0.003 per product page opened** (details), **$0.0008 per review**, plus the proxy requests above and a few cents of platform usage per thousand items. Worked example for 100 products from one search, on the free plan:

| Run | Requests (proxy cost) | Events | Total |
|---|---|---|---|
| 100 products, search data only | 2 search pages ($0.003) | 100 x $0.002 = $0.20 | about $0.20 |
| + product details | + 100 product pages ($0.15) | + 100 x $0.003 = $0.30 | about $0.65 |
| + 20 reviews per product, most relevant first (set Max items to 2,100) | + 100 review pages ($0.15; 200 pages for other sort orders) | + 2,000 x $0.0008 = $1.60 | about $2.40 |

Search data alone is by far the cheapest per product: one $0.0015 request brings 40-60 products. Turn details and reviews on only for the products you need them for, for example by running a second pass on product URLs you selected from the first dataset.

### How to scrape Walmart search results by keyword

Put the keywords into **Search terms**. Each term is searched on Walmart.com and paginated automatically, 40 organic products per page plus the sponsored tiles Walmart mixes in (`isSponsored`; turn **Include sponsored products** off for organic results only). Walmart serves 11 to 25 pages per query, so one term yields roughly 500 to 1,200 products; use several terms, category (`/browse/`) URLs or price ranges to go deeper. `position` and `page` give the rank of every product, which makes the output usable for share-of-search and rank tracking. All six sort orders of the site are supported. One quirk of the site: "Price: low to high" together with a minimum price returns an empty list on Walmart itself, so that combination is collected in best-match order within the price range.

### How to track Walmart prices and stock

Schedule the Actor (daily for fast-moving items) with the same search terms, browse URLs or product URLs and compare `price`, `wasPrice`, `availability` and `badges` (`Rollback`, `Clearance`, `Reduced price`) between runs, joining on `usItemId`, or let the Actor do the comparison with **Only new or changed items** (see "Monitor changes on a schedule" below). Product URLs can be passed in bulk in **Start URLs**; each returns one fully detailed item including every variant's own price and stock.

### How to scrape Walmart product reviews

Either turn on **Include reviews** (reviews for every product found), or paste review-page URLs such as `https://www.walmart.com/reviews/product/18901811909` to get reviews only. **Max reviews per product** caps each product; **Sort reviews** picks most relevant, newest, most helpful, highest or lowest rating. Walmart lists only reviews that have text, 10 per request; star-only ratings are included in `reviewCount` and `ratingCounts` but have nothing to scrape. To collect only fresh reviews, set **Only reviews newer than** (`7 days`, `24 hours` or a date such as `2026-10-01`): reviews are then read newest first and the Actor stops at the first review page that is entirely older, or turn on **Only new or changed items** to get only reviews that earlier runs have not returned.

### Monitor changes on a schedule

Turn on **Only new or changed items** and the Actor remembers what earlier runs of the same input returned: each run outputs only products that are new in the results or whose price, was price, stock status, star rating or seller changed. Unchanged products are dropped before anything is saved and before any product or review page is requested, so they cost neither events nor Unblocker requests (a monitored search costs one proxy request per 40 products checked). **Max items** becomes the watched window: the first products of the listing are checked every run (for example 40 = one search page); turn **Include sponsored products** off so rotating ads do not show up as new products. Save the input as a task and add a Schedule to it in Apify Console (Schedules → Create new, daily). Every output item carries `changeType` (`new` or `changed`), and changed products carry `previousValues`, e.g. `{"price": 24.99, "availability": "IN_STOCK"}` for a product that dropped to $19.99 and sold out. With reviews on, only reviews not returned before are output (newest first); to watch the reviews of a product without paying for the product item, monitor its reviews URL (`/reviews/product/<id>`) or set **Only reviews newer than** to `1 day`. **Monitoring key** keeps several schedules on the same search separate.

### Which store and ZIP code do the prices come from?

Walmart prices and availability can differ by store. The Actor does not select a store: Walmart assigns one to each request, and through the Unblocker proxy that has consistently been its default store (Sacramento, CA, store 3081). Every item carries the store context it was priced for in `location`, so you can verify it. Choosing a ZIP code is not supported yet.

### Does it work without login or a browser?

Yes. Everything comes from public pages as an anonymous visitor sees them, read with plain HTTP requests and Chrome TLS fingerprinting. No account, no cookies, no headless browser, which keeps runs fast (a page typically takes 1-5 seconds through the proxy) and cheap. Member-only prices (Walmart+) and "sign in to see price" offers are not available.

### Integrations and API

Use the run in Zapier, Make, n8n, Google Sheets, or call it from Python/Node with the Apify client. See the **API** tab for ready-made snippets.

### Is it legal to scrape Walmart?

This Actor collects only data that Walmart shows publicly to logged-out visitors: product listings, prices, seller business profiles, and customer reviews with their text, rating and the reviewer's nickname as shown (plus the reviewer location when Walmart publishes one). It does not log in and collects no photos, avatars, contact details or hidden reviewer ids; reviewers shown as "anonymous" get no location. Reviewer nicknames and locations, and review texts, can be personal data under GDPR and similar laws: make sure you have a lawful basis for processing them, and do not use them to contact or profile individuals. You are responsible for how you use the data and for complying with Walmart's terms and applicable law.

### Support

Found a bug or need a field added? Open an issue in the **Issues** tab; it is usually answered within a day.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search on Walmart.com, one per line (e.g. "headphones", "air fryer"). Each term is searched separately and paginated automatically: one request returns 40 products plus sponsored tiles.

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

Walmart.com URLs to scrape instead of (or in addition to) search terms: search pages (https://www.walmart.com/search?q=lego), browse pages (https://www.walmart.com/browse/electronics/3944_133251_1095191), category pages (https://www.walmart.com/cp/headphones/1095191), product pages (https://www.walmart.com/ip/18901811909, returned with full details) or review pages (…/reviews/product/18901811909, returns reviews only). Filters you set on the site are kept: copy the URL from your browser.

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

Stop after this many dataset items in total. Products and reviews both count, so with reviews on raise it accordingly (100 products with 20 reviews each = 2,100 items). Keeps cost predictable.

## `maxPagesPerSearch` (type: `integer`):

How many result pages to open per search term or listing URL (40 products each, one proxy request per page). Walmart itself stops at 11-25 pages per query.

## `sortBy` (type: `string`):

Result order for search terms and search / browse URLs, as on Walmart's own "Sort by" menu. Walmart returns an empty list for "Price: low to high" combined with a minimum price, so that combination is collected in best-match order within the price range.

## `minPrice` (type: `integer`):

Only products at or above this price (Walmart's own price filter). Sponsored tiles ignore Walmart's filter, so products outside the range are dropped before saving and never charged.

## `maxPrice` (type: `integer`):

Only products at or below this price (Walmart's own price filter).

## `includeSponsored` (type: `boolean`):

Walmart mixes sponsored tiles into the results (about a third of the first page). They are saved with isSponsored = true. Turn this off to keep organic results only.

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

Also open every product page to get the description, specifications, all images, every variant with its own price and stock, UPC, model, brand, seller profile (rating, review count, storefront), return policy, warranty, rating breakdown and shipping / pickup / delivery options. One extra proxy request and one extra `detail` charge per product (see pricing).

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

Also collect customer reviews for every product, as separate items with type = "review". Walmart serves 10 reviews per request; with details on, the first 10 come from the product page at no extra request. Each review includes the reviewer nickname as Walmart shows it.

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

Cap on reviews per product (also applies to review-page start URLs). Only reviews with text are listed by Walmart; star-only ratings are counted in reviewCount but have nothing to scrape.

## `reviewSort` (type: `string`):

Order in which reviews are collected (matters when a cap is set). "Newest" is best for monitoring; "Lowest rating" surfaces complaints.

## `reviewsNewerThan` (type: `string`):

Only reviews newer than: a date (YYYY-MM-DD) or a period such as '7 days' or '24 hours'. Reviews are then read newest first and reading stops at the first review page that is entirely older, so a daily schedule with '1 day' costs about one review request per product. Applies when reviews are collected (Include reviews on, or reviews URLs).

## `onlyNewOrChanged` (type: `boolean`):

Remember what earlier runs of this search returned and output only new items or items whose price/status changed. Use with a Schedule; unchanged items are not charged. With this on, Max items is the watched window: the first products of the listing are checked every run (each counted with the reviews it would bring), so a run never digs deeper than the first one. Price, was price, stock status, star rating and seller are compared (with reviews on, the review count too, and only reviews not seen before are output, newest first). Turn off sponsored products for a stable watch: ads rotate between visits.

## `monitoringKey` (type: `string`):

Name for this watch, so several schedules on the same search stay separate; defaults to a key derived from the search input.

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

Walmart shows a "Robot or human?" challenge to datacenter and residential proxies, so the default is Apify's Unblocker proxy (group UNBLOCKER). It is billed to your Apify account per successful request: 10 Unblocker units, about $0.0015 on the free plan and less on paid plans. One request returns a search page with 40+ products, one product page, or 10 reviews.

## Actor input object example

```json
{
  "searchTerms": [
    "headphones"
  ],
  "startUrls": [],
  "maxItems": 100,
  "maxPagesPerSearch": 10,
  "sortBy": "best_match",
  "includeSponsored": true,
  "includeDetails": false,
  "includeReviews": false,
  "maxReviewsPerProduct": 20,
  "reviewSort": "relevancy",
  "onlyNewOrChanged": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "UNBLOCKER"
    ]
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "searchTerms": [
        "headphones"
    ],
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "UNBLOCKER"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tortuga/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 = {
    "searchTerms": ["headphones"],
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["UNBLOCKER"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("tortuga/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 '{
  "searchTerms": [
    "headphones"
  ],
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "UNBLOCKER"
    ]
  }
}' |
apify call tortuga/walmart-scraper --silent --output-dataset

```

## MCP server setup

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