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

Extract Walmart product prices, ratings, availability and categories in the US, Canada and Mexico, plus US sellers and reviews. Pay per delivered row, with a separate start fee.

- **URL**: https://apify.com/lentic_clockss/walmart-scraper.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 48 total users, 18 monthly users, 79.2% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.20 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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

**Extract Walmart product prices, categories, sellers and reviews from the US, Canada and Mexico as rows you can export.**

- Product names, prices, ratings, availability and Walmart links.
- Keyword searches, category listings and product details.
- US seller contacts and customer reviews where published.
- Optional variant and review rows, with a row limit for each input.
- $3.00 per 1,000 rows on the Free plan, plus a $0.005 start fee.

### What does Walmart Scraper do?

Walmart Scraper collects publicly visible data from `walmart.com`, `walmart.ca` and `walmart.com.mx`. Use it for price monitoring, assortment comparisons and review analysis. Each run uses one market and one mode.

- `search`, `browse` and `catalog` return product listings.
- `product` returns details for product URLs or item IDs.
- `departments` and `categoryHub` return categories.
- `sellers` and `reviews` return US seller and review rows.
- `enrichDetails` adds product details to search or browse rows; it is off by default.
- `expandVariants` is off by default. Product-page review previews are off with `maxReviews: 0`. Available secondary offers become separate rows without an extra switch. Products, offers, variants and reviews share the input's row limit; each delivered row has the same price.

### What data can you extract from Walmart?

Fields depend on the mode and what Walmart publishes. `rowType` identifies the entity; `entityKey` identifies its row. Where present, `parentUsItemId` links a child row to its product; paginated review rows use `itemId`.

#### Product rows

| Field | Description | Example |
| --- | --- | --- |
| `rowType` | Entity type | `product` |
| `entityKey` | Row identity | `product:14628565544` |
| `usItemId` | Walmart item ID | `14628565544` |
| `name` | Product name | `Paper towels` |
| `productUrl` | Walmart product link | `https://www.walmart.com/ip/14628565544` |
| `price` | Current displayed price | `27.66` |
| `currency` | Price currency | `USD` |
| `averageRating` | Average customer rating | `4.7` |
| `availabilityStatus` | Published stock status | `IN_STOCK` |
| `sellerName` | Seller name | `Walmart.com` |
| `pricedForPostalCode` | Postal code used for the displayed price, when confirmed | `72712` |
| `locationStatus` | `applied` when the page agreed on the requested location, else `walmartDefaultStore:<storeId>` | `applied` |

#### Variant rows

| Field | Description | Example |
| --- | --- | --- |
| `parentUsItemId` | Parent product ID | `604342441` |
| `variantId` | Variant ID | `123456789` |
| `variantOptions` | Size, color or other options | `{"color":"White"}` |

#### Offer rows

| Field | Description | Example |
| --- | --- | --- |
| `offerId` | Seller's offer ID | `example-offer-id` |
| `sellerName` | Seller making this offer | `Example Store` |
| `price` | Offer price, when shown | `29.99` |

#### Review rows

| Field | Description | Example |
| --- | --- | --- |
| `reviewId` | Review ID | `example-review-id` |
| `itemId` | Product ID in paginated reviews | `604342441` |
| `rating` | Customer's score | `5` |
| `reviewText` | Review text | `Fits as expected.` |
| `verifiedPurchase` | Purchase verification, when shown; empty when the review shows no badges | `true` |
| `reviewSource` | Which surface produced the row (see below) | `ssr_reviews_paginator` |

Reviews come from two surfaces that share field names but cover different
amounts. `reviewSource` says which produced the row: `ssr_reviews_paginator`
is the `reviews` mode, which walks review pages to the full set;
`app_pdp_first_page` is the first review page bundled in a product
collection — treat it as a sample sized by `maxReviews`.

#### Category rows

| Field | Description | Example |
| --- | --- | --- |
| `categoryId` | Category ID | `3944` |
| `categorySlug` | Category URL name | `electronics` |
| `name` | Category name | `Electronics` |

#### Seller rows

| Field | Description | Example |
| --- | --- | --- |
| `catalogSellerId` | Numeric storefront ID | `101174524` |
| `sellerDisplayName` | Storefront name | `Example Store` |
| `phones` | Published seller phone entries | `[{"value":"+1 555 0100","type":"seller"}]` |
| `emails` | Published seller email entries | `[{"value":"name@example.com","type":"seller"}]` |
| `leadAbsences` | Reasons contact fields are empty | `{"person":"Not on this site (no contact person)"}` |

#### Full field surface and App-only fields

Product and search rows carry two objects beyond the named columns above:

- `appOnly` — values the App returns that the server-rendered page never populated.
- `appSurface` — the research report's field catalogue projected onto the row, keyed by entity and report JSON path, for example `appSurface.item["data.contentLayout.pageMetadata.location.city"]`.

The App channel answers four sibling frames inside one response. A product
response is `{product, contentLayout, idml, reviews}`: `contentLayout` carries
layout modules and page metadata, `idml` carries descriptions, specifications
and nutrition facts, and `reviews` carries the review summary and aspects. A
search response is `{search, contentLayout}`. All four are projected. Paths
under `__NEXT_DATA__` belong to the server-rendered page and never appear on
these rows.

Array paths arrive as a bounded digest (`count`, plus a sample when it is light).
Heavy nested samples and oversized container paths collapse to a shape marker
(`oversized` with a key or entry count), because each leaf is already delivered
as its own path. Nothing is dropped silently: if a row would exceed the
delivery cap, whole entities are trimmed and every trim is recorded in the run
diagnostics.

`appSurface` is deliberately wide. Ignore it when the named columns are enough;
use it when auditing coverage against a field report. It honours the same
sub-entity switches as the named columns: `maxReviews: 0` collapses
review-shaped paths to `{"count": N, "dropped": "reviews_disabled"}`;
`expandVariants: false` collapses variant paths to
`{"count": N, "dropped": "variants_disabled"}`. `appSurfaceDiag` records
`requested` / `present` / `absent` plus `dropped`, so nothing is silently lost.

### How to scrape Walmart

1. Open [Walmart Scraper](https://apify.com/lentic_clockss/walmart-scraper) in Apify Console.
2. Enter one target, such as `keyword`, and choose `market`.
3. Set `maxResults` to `3` for a small first run.
4. Click **Start** and wait for completion.
5. Download the dataset or read it through the API.

Empty input starts the form's example search for `wireless earbuds`, limited to 3 rows. Normal start and row charges apply. With `mode: "auto"`, filling one target selects its mode. If you mix target types, product URLs take priority over item IDs, seller URLs, seller IDs, keywords, categories and seller shards. Check `INPUT_REPORT` for ignored fields.

#### Search

Fill `keyword` or `keywords`. Use separate runs for different markets. Choose `sort`, price bounds or `excludeSponsored` to narrow listing rows.

#### Browse

Fill `categoryId`; `categorySlug` is optional. This returns products, not category rows.

#### Catalog

Choose `mode: "catalog"` and supply `categoryId`. `facetCrawl` adds category filter slices; it does not guarantee every product in a category.

#### Departments

Choose `mode: "departments"`. No target is needed, and this does not become the example search.

#### Category hub

Choose `mode: "categoryHub"` with `categoryId` or `categorySlug` to collect category links. A slug alone also selects this mode automatically.

#### Product

Fill `productUrls` or `usItemIds`. `productUrls` takes `walmart.com`, `walmart.ca` or `walmart.com.mx` product page links (`/ip/.../<item id>`) and `{"url": "<link>"}` objects; `requestsFromUrl` remote lists and `walmrt.us` short links are not fetched — open them and paste the full product link. Separate links in one entry with whitespace or a comma directly before the next `http(s)://` link; commas in query parameters stay. Optional variants, secondary offers and review previews consume the same row allowance as the product.

#### Sellers

Use `catalogSellerIds`, `sellerUrls`, or `slpShard` with `mode: "sellers"`. This mode is US-only. `slpOffset` skips entries within a chosen seller sitemap shard.

#### Reviews

Choose `mode: "reviews"` with product URLs or item IDs and `market: "US"`. It reads review pages rather than just the product-page preview. Here, `maxReviews: 0` uses the remaining `maxResults` allowance; it does not disable reviews.

#### Home

Choose `mode: "home"` with `market: "US"` and no target field. It reads the App home layout: the merchandised shelves and their items. Each row names its shelf (`shelfModuleId`, `shelfModuleType`, `shelfZone`) and carries `shelfScope: "home_layout_not_catalogue"`. A home page is mostly banners, so a run can fill rows from one shelf; `modulesRead`, `modulesWithItems` and `emptyZones` separate an empty shelf from an unread one. The layout does not paginate.

### What to fill in

| Field | What to enter | Default |
| --- | --- | --- |
| `mode` | A mode described above | `auto` |
| `keyword` / `keywords` | One term or up to 10 terms; use one field | Empty; form example `wireless earbuds` |
| `productUrls` / `usItemIds` | Product page links or numeric item IDs; `{"url": ...}` objects OK | Empty |
| `catalogSellerIds` / `sellerUrls` | Numeric seller IDs or US storefront links | Empty |
| `categoryId` / `categorySlug` | Category number and optional URL name | Empty |
| `market` | `US`, `CA` or `MX` | `US` |
| `maxResults` | Rows per input, from 1 to 500 | `70`; form prefill `3` |
| `postalCode` / `storeId` | Requested postal code or store number | Empty |
| `sort` | `best_match`, `price_low`, `price_high`, `best_seller`, `highest_rated`, `new` | `best_match` |
| `facet` | Listing filter such as `brand:Apple` | Empty |
| `minPrice` / `maxPrice` | Nonnegative price bounds | Empty |
| `excludeSponsored` | Exclude sponsored listing rows | `false` |
| `enrichDetails` / `enrichLimit` | Add search/browse details; limit 1–50 products | `false` / `5` |
| `facetCrawl` / `facetCrawlMaxFacets` | Add catalog filter slices; limit 1–100 slices | `false` / `15` |
| `expandVariants` | Return available variants as separate rows | `false` |
| `maxReviews` | Review cap, 0–500; see the reviews mode above | `0` |
| `reviewSort` | Review order, for example `newest` | `relevancy` |
| `slpShard` / `slpOffset` | Seller shard 1–4 and starting offset | Empty / `0` |

#### Search input

```json
{
  "keyword": "wireless earbuds",
  "maxResults": 3
}
```

#### Browse input

```json
{
  "categoryId": "3944",
  "maxResults": 3
}
```

#### Catalog input

```json
{
  "mode": "catalog",
  "categoryId": "3944",
  "facetCrawl": true,
  "facetCrawlMaxFacets": 2,
  "maxResults": 5
}
```

#### Departments input

```json
{
  "mode": "departments",
  "maxResults": 3
}
```

#### Category hub input

```json
{
  "mode": "categoryHub",
  "categoryId": "3944",
  "categorySlug": "electronics",
  "maxResults": 3
}
```

#### Product input

```json
{
  "usItemIds": ["604342441"],
  "expandVariants": true,
  "maxResults": 3
}
```

#### Sellers input

```json
{
  "catalogSellerIds": ["101174524"],
  "maxResults": 1
}
```

#### Reviews input

```json
{
  "mode": "reviews",
  "usItemIds": ["604342441"],
  "maxReviews": 3,
  "maxResults": 3
}
```

`maxItems` and `limit` alias `maxResults`. Misspelled fields are corrected, unknown ones ignored, bad filter choices dropped. `productUrls` takes `{"url": ...}` objects and mobile, review or affiliate links, skipping non-product ones. Without `mode`, search, category or seller links run in their mode. Unusable targets stop the run before rows are charged (`INVALID_INPUT: ...` names the entry position and problem category); the start fee can still apply. The `INPUT_REPORT` record shows how the input was read.

### Output example

Illustrative product row; prices and ratings are not a current quote.

```json
{
  "source": "walmart",
  "type": "product",
  "rowType": "product",
  "entityKey": "product:14628565544",
  "mode": "search",
  "market": "US",
  "usItemId": "14628565544",
  "name": "Paper towels",
  "price": 27.66,
  "currency": "USD",
  "averageRating": 4.7,
  "availabilityStatus": "IN_STOCK",
  "sellerName": "Walmart.com",
  "productUrl": "https://www.walmart.com/ip/14628565544"
}
```

Export the dataset as JSON, CSV, Excel, XML, RSS or an HTML table. `RUN_SUMMARY` contains row counts and warnings; failed runs can also write `ERROR_SUMMARY`.

### Why use this Walmart scraper?

- **Pay per delivered row.** Pages tried are not result charges; the start fee is separate.
- **Keep delivered results.** Rows already written remain in the dataset after a stop or timeout. Unfinished collection is not guaranteed to be delivered.
- **Understand failures.** Input errors identify the field to fix.
- **See missing data.** Unavailable fields remain empty; contact fields include absence reasons.
- **Use several inputs.** Collect multiple keywords, product URLs or seller IDs in one run.
- **No proxy setup.** You do not need to set up proxies or supply a Walmart login.

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

Pay-per-event pricing includes a **$0.005 start event** plus delivered rows. Start billing is one event per allocated GB, with a minimum of one; the default memory uses one event. Platform usage is included.

| Apify plan | Price per row | Price per 1,000 rows |
| --- | --- | --- |
| Free | $0.003 | $3.00 |
| Starter | $0.003 | $3.00 |
| Scale | $0.0026 | $2.60 |
| Business | $0.0022 | $2.20 |
| Platinum | $0.002 | $2.00 |
| Diamond | $0.0016 | $1.60 |

`maxResults` applies to each keyword, product URL/item ID, seller URL/ID, browse, catalog, departments, category hub or seller-shard input (default 70, collected in parts of 70 up to 500; shared across row types).

Free Apify plan runs are capped at 200 rows per run and 10 runs of this Actor. The whole run is capped by **Maximum cost per run** (`maxTotalChargeUsd` in the API).

Example: 3 keywords × 50 rows = 150 rows → `150 × $0.003 + $0.005 = $0.455` on the Free plan.

- The Apify Free plan includes **$5.00** in monthly usage credit (about **1,666 rows** at `$0.003` per row across Free-plan runs capped at 200 rows per run).

### What happens when the run timeout is too short

With automatic resume, a long collection can pause: the run shows `ABORTED`
with a "Queued on the collection backend" message and resumes once results
are ready, finishing `SUCCEEDED`. Rows already written are not delivered
twice. The pause can occur up to 3 times per run; the default 3600-second
timeout reduces the need for it. Synchronous API endpoints wait at most 300
seconds and can return an empty dataset during a pause — for larger requests,
start asynchronously and read the dataset after `SUCCEEDED`.

### Use with AI agents and the API

#### Apify MCP server

Add `https://mcp.apify.com?tools=lentic_clockss/walmart-scraper` to a client
with remote MCP support. Sign in via OAuth or `Authorization: Bearer <YOUR_APIFY_TOKEN>`; the tool returns run and dataset IDs for
`get-dataset-items`. Example prompt: "Find 3 Walmart US products for
wireless earbuds and return their names, prices and product links."

- **Agent execution note:** Set `maxResults` to `5`–`20` on exploratory calls and read `RUN_SUMMARY` / `INPUT_REPORT`. Wait for auto-resumed `ABORTED` runs to finish as `SUCCEEDED`.

#### Apify API

```python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("lentic_clockss/walmart-scraper").call(
    run_input={"keyword": "wireless earbuds", "maxResults": 3})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

For async HTTP, `POST` the input to
`https://api.apify.com/v2/acts/lentic_clockss~walmart-scraper/runs` with
`Authorization: Bearer`, then `GET
https://api.apify.com/v2/datasets/<datasetId>/items?format=json` once it
succeeds. Connect Google Sheets, Make, Zapier, n8n, Slack, Airtable or a
webhook via **Integrations**; use **Schedules** for recurring runs.

### FAQ

#### Is it legal to scrape Walmart?

Only collect data you have a lawful right to access. You are responsible for Walmart's terms and applicable data-protection law. Publicly visible personal data still needs a lawful basis for collection and use.

#### Why did my run end as ABORTED?

It may be waiting for automatic resume. Check for the queued-and-resume status message above; not every `ABORTED` run is a resumable pause.

#### How many results can I get?

Request 1–500 rows per input. Availability, filters, the run's cost limit and Free-plan limits can reduce delivery. A row limit is not a promise of that many matches.

#### Why are some fields empty?

Walmart may omit a field, hide seller contacts or show different details by market. `leadAbsences` explains missing contact data. Missing business values are not invented.

#### Can I get prices for my postal code?

Canada supports nearest-store selection. US prices may reflect a nearby or default Walmart location rather than the exact ZIP code. Check `pricedForPostalCode`; `postalCode` is included only when confirmed. Mexico does not apply postal-code selection. Check `RUN_SUMMARY` for location warnings. When the code did not take, rows still deliver and carry `locationStatus: walmartDefaultStore:<storeId>` naming Walmart's chosen store.

#### Can I collect seller contacts outside the US?

No. Seller collection is US-only. Published contacts can appear on US seller rows and enriched product rows; visibility exemptions can leave them empty. Ordinary listing rows do not provide full seller contacts.

#### Does product mode collect every review?

No. Product mode and search/browse enrichment provide only available product-page previews when `maxReviews` is positive. Use US `reviews` mode for pagination, within your row limits.

#### Is this Walmart's official API?

No. This Actor collects public storefront data. It does not access accounts, carts or order history.

### Limitations

- Only `US`, `CA` and `MX` markets are supported; `sellers` and `reviews` modes are US-only.
- Listings, stock, prices and fields vary by location and collection time.
- Category slices and pagination do not guarantee a complete catalog.
- Variant and offer availability depends on the product page; child rows reduce the number of parent products within a row limit.
- Seller contact people, coordinates and external websites are not supplied; a Walmart storefront link is not a seller-owned website.
- An interrupted run may have no dataset rows if delivery has not started.

### Related scrapers

More e-commerce and marketplace scrapers from the same publisher:

- [Temu Scraper](https://apify.com/lentic_clockss/temu-scraper)
- [Allegro Scraper](https://apify.com/lentic_clockss/allegro-scraper)
- [Shopee Scraper](https://apify.com/lentic_clockss/shopee-search-scraper)
- [Amazon Scraper](https://apify.com/lentic_clockss/amazon-search-results-collector)
- [Rakuten Scraper](https://apify.com/lentic_clockss/rakuten-scraper)
- [TikTok Shop Scraper](https://apify.com/lentic_clockss/tiktok-shop-scraper)
- [Stealth Web Scraper](https://apify.com/lentic_clockss/stealth-web-scraper)
- [Email Validator](https://apify.com/lentic_clockss/email-risk-validator)

Browse all of our scrapers at [apify.com/lentic_clockss](https://apify.com/lentic_clockss).

### Support

Report problems or request fields through the **Issues** tab of this Actor's page. Include the run ID and the input you used.

# Actor input Schema

## `mode` (type: `string`):

Auto selects a mode from your target fields; choose a mode explicitly for catalogs, departments, category hubs or paginated reviews. Sellers and reviews modes support only the US market. `home` reads the App home layout: the merchandised shelves and their items, US only. It is a selection, not the full catalogue.

## `keywords` (type: `array`):

Up to 10 search terms, each with its own maxResults allowance. Use this instead of keyword for several searches.

## `keyword` (type: `string`):

One search term; use keywords instead for several terms. With no target, the Actor runs the small form example.

## `productUrls` (type: `array`):

Walmart product page links for product or reviews mode: walmart.com, walmart.ca or walmart.com.mx with /ip/.../<item id>. Apify {"url": "<link>"} request objects are accepted; remote lists such as requestsFromUrl and walmrt.us short links are not fetched — open them and paste the full product link. One entry may hold several links separated by whitespace or by a comma directly before the next http(s):// link. Each input shares its maxResults allowance across its product, offers and requested variant or review rows.

## `usItemIds` (type: `array`):

Walmart numeric item IDs for product or reviews mode. Each ID has its own maxResults allowance.

## `sellerUrls` (type: `array`):

US Walmart storefront links, such as https://www.walmart.com/seller/101174524, for sellers mode. Each URL counts as one input.

## `catalogSellerIds` (type: `array`):

Numeric Walmart seller IDs, such as 101174524, for sellers mode. Each ID counts as one input.

## `categoryId` (type: `string`):

Category number for browse or catalog mode, such as 3944 for electronics. Also accepted by categoryHub mode.

## `categorySlug` (type: `string`):

Category name from a Walmart URL, such as electronics. Optional with a category ID, or usable alone to select categoryHub mode.

## `maxResults` (type: `integer`):

Maximum rows per keyword, product URL/item ID or seller URL/ID; other modes count as one input, and product, offer, variant and review rows share its allowance. Default 70, larger values are collected in parts of 70, and total delivery also follows your cost limit and the Free-plan limits of 200 rows per run and 10 runs.

## `market` (type: `string`):

Choose US (walmart.com), CA (walmart.ca) or MX (walmart.com.mx). Sellers and reviews modes require US.

## `postalCode` (type: `string`):

Request local pricing with a Canadian postal code or US ZIP code; Mexico does not apply this setting. Check pricedForPostalCode and RUN_SUMMARY for the actual pricing location, because the requested code is not always applied. When it is not applied, rows still deliver and carry `locationStatus: walmartDefaultStore:<id>` plus the store Walmart priced for.

## `storeId` (type: `string`):

Optional Walmart store number, such as 5260, for location-dependent listings. Check the returned location before treating prices as store-specific.

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

Listing sort order: best match, price ascending or descending, best seller, highest rated, or new. Default best_match.

## `facet` (type: `string`):

Optional listing filter expression copied from Walmart, such as brand:Apple.

## `minPrice` (type: `number`):

Optional minimum listing price, in the selected market currency.

## `maxPrice` (type: `number`):

Optional maximum listing price, in the selected market currency. Must be at least minPrice.

## `excludeSponsored` (type: `boolean`):

Exclude sponsored product rows from listings when Walmart marks them as sponsored.

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

Review order in reviews mode, such as relevancy or newest. Default relevancy.

## `slpShard` (type: `integer`):

Choose seller sitemap shard 1–4 for sellers mode. Use slpOffset to skip entries and maxResults to limit delivered rows.

## `slpOffset` (type: `integer`):

Number of seller entries to skip in the selected slpShard. Default 0.

## `enrichDetails` (type: `boolean`):

Add product-page details to search or browse rows, including available US seller contacts. Off by default; enrichLimit controls how many products receive details.

## `enrichLimit` (type: `integer`):

Maximum search or browse products to enrich when enrichDetails is true. Default 5, from 1 to 50.

## `facetCrawl` (type: `boolean`):

Include category filter slices in catalog mode. Off by default; this does not guarantee complete category coverage.

## `facetCrawlMaxFacets` (type: `integer`):

Maximum category filter slices to try when facetCrawl is true. Default 15, from 1 to 100.

## `expandVariants` (type: `boolean`):

Return available product variants as separately billed rows within the input row limit. Off by default.

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

Maximum review rows: product pages and enriched listings provide only their available review preview, disabled at 0. In reviews mode, 0 uses the remaining maxResults allowance; a positive value adds a review cap.

## Actor input object example

```json
{
  "mode": "auto",
  "keyword": "wireless earbuds",
  "maxResults": 3,
  "market": "US",
  "sort": "best_match",
  "excludeSponsored": false,
  "reviewSort": "relevancy",
  "slpOffset": 0,
  "enrichDetails": false,
  "enrichLimit": 5,
  "facetCrawl": false,
  "facetCrawlMaxFacets": 15,
  "expandVariants": false,
  "maxReviews": 0
}
```

# Actor output Schema

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

Delivered product, variant, offer, review, category and seller rows in the default dataset.

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

Row count, completion details and warnings saved in RUN_SUMMARY.

## `inputEcho` (type: `string`):

Input settings used by the run, saved in INPUT_ECHO.

## `errorSummary` (type: `string`):

Failure details saved in ERROR_SUMMARY when the run records an error.

# 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 = {
    "keyword": "wireless earbuds",
    "maxResults": 3,
    "reviewSort": "relevancy",
    "enrichDetails": false,
    "facetCrawl": false,
    "expandVariants": false,
    "maxReviews": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/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 = {
    "keyword": "wireless earbuds",
    "maxResults": 3,
    "reviewSort": "relevancy",
    "enrichDetails": False,
    "facetCrawl": False,
    "expandVariants": False,
    "maxReviews": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/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 '{
  "keyword": "wireless earbuds",
  "maxResults": 3,
  "reviewSort": "relevancy",
  "enrichDetails": false,
  "facetCrawl": false,
  "expandVariants": false,
  "maxReviews": 0
}' |
apify call lentic_clockss/walmart-scraper --silent --output-dataset

```

## MCP server setup

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