# Walmart Scraper: Products, Prices, UPC & Sellers (`cleanpull/walmart-scraper`) Actor

Walmart product data from searches, category URLs or item ids: price, list price, discount, rating, seller and stock, plus UPC, variants, offers and delivery options from product pages. From $0.60 per 1,000 results, with Walmart sort and filters and an only-changes monitor for price drops and stock.

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

## Pricing

from $0.48 / 1,000 search 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

Walmart product data from **searches, category (browse) URLs, product URLs or item ids**: price, list price and discount, rating and reviews, seller and whether Walmart sells it, stock, sponsored flag and position, and with product details the **UPC**, model, **variants** with their prices and stock, the offer count and lowest other seller's price, delivery and pickup options, clearance and rollback flags, category path, specifications and highlights. Use Walmart's own **sort and filters**, and turn on **Only changes** to get just the price drops, rises, stock changes, new listings and seller changes since your last run. From **$0.60 per 1,000 results**.

Also known as a Walmart.com scraper, Walmart product API, Walmart price tracker, Walmart UPC lookup, Walmart search results scraper and Walmart category scraper.

### What you can do with it

- **"Show me the 200 cheapest air fryers Walmart sells itself, in stock."** Search with sort Price: low to high, Sold by Walmart only and In stock only.
- **"Get the UPC, model and every variant of these Walmart products."** Give item ids or product URLs; each row carries the UPC, model, variant options and each variant's price and stock.
- **"Tell me every morning which coffee makers dropped in price or came back in stock."** Schedule a search with Only changes: the first run is the baseline, later runs return only what changed, with the old and new value.
- **"Which sellers compete on this item, and from what price?"** Product details give the number of offers and the lowest other seller's price.
- **"Track what is new in a Walmart category."** Give a browse URL with Only changes and the New listing change type.
- **"Pull the best sellers in a category with ratings and review counts."** Sort by Best selling on a search or browse URL.

### What makes the data right

- **Read from Walmart's own page data.** Every field comes from the data Walmart's page uses to draw itself, not from screen text, so numbers, ids and flags are exact and do not depend on the page's wording.
- **A block is never "no results".** A page that comes back without Walmart's data (a challenge or an error page) is read again, up to three times, and then reported as a failure in the run summary, never as an empty search, and never charged. A search Walmart says has no results gives a free row saying so.
- **English first.** Walmart sometimes answers a visitor in Spanish. Such a page is read once more for English; if it comes back Spanish again it is kept (prices, ids and flags are the same) and its rows say `pageLanguage: "es-US"`.
- **Each price says where Walmart priced it.** Walmart prices for the area of the address a page is read from, and that area cannot be chosen: a ZIP code or store in the URL is ignored. So every row has `pricedFor` (ZIP code, store id, city, state) for the page it came from. Shipping prices are mostly the same everywhere; store pickup and some local prices can differ by area.
- **Only delivered rows are billed.** Results left out by a filter, unchanged results in Only changes mode and anything that could not be read are never charged.
- **Runs do not fail for one bad entry.** A URL that is not Walmart's, or an id that is not a number, is skipped with a warning; an empty input runs the form's example.

### Input

| Field                                  | What it does                                                                                                                                                        |
| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `searchTerms`                          | Words to search, one per line                                                                                                                                       |
| `startUrls`                            | Search URLs, browse (category) URLs and product URLs, as strings or `{ "url": … }`                                                                                  |
| `itemIds`                              | Walmart item ids (the number at the end of a product URL), read from their product pages                                                                            |
| `maxResultsPerSearch`, `maxResults`    | Results kept per search or URL (default 40, one page; pages are followed), and rows in the whole run                                                                |
| `sort`                                 | `best_match`, `price_low`, `price_high`, `best_seller`, `rating_high`, `new`: Walmart's own sort, sent in its URL                                                   |
| `minPrice`, `maxPrice`                 | Price range, sent to Walmart in its URL (`min_price`, `max_price`) and checked again on every result; in Only changes mode checked on every result only             |
| `soldByWalmartOnly`                    | Walmart's own Retailer filter, sent in its URL (`facet=retailer_type:Walmart`) and checked again on every result; in Only changes mode checked on every result only |
| `inStockOnly`, `excludeSponsored`      | Applied to the results Walmart returns (its URL has no such filters); left-out results are counted, never charged                                                   |
| `includeDetails`                       | Also read each result's product page (UPC, variants, offers, fulfilment, specs…)                                                                                    |
| `onlyChanges`, `monitorName`           | Return only what changed since the last run with the same monitor name                                                                                              |
| `changeTypes`, `minPriceChangePercent` | Which changes count, and the smallest price move to report                                                                                                          |
| `fields`                               | Keep only these fields (dotted paths for nested ones); `recordType` is always kept                                                                                  |

A Walmart URL keeps its own sort and filters; the input's are added only where the URL has none.

#### Example inputs

Cheapest in-stock air fryers sold by Walmart:

```json
{
  "searchTerms": ["air fryer"],
  "maxResultsPerSearch": 100,
  "sort": "price_low",
  "soldByWalmartOnly": true,
  "inStockOnly": true
}
```

Products by id with every detail:

```json
{ "itemIds": ["985675140", "225142139"] }
```

A daily price-drop and back-in-stock watch on two searches:

```json
{
  "searchTerms": ["coffee maker", "air fryer"],
  "onlyChanges": true,
  "monitorName": "kitchen-daily",
  "changeTypes": ["price-drop", "back-in-stock", "new-listing"],
  "minPriceChangePercent": 5
}
```

### Output

One row per product (`recordType: "product"`). Each item appears once per run, from the first search or URL that found it.

#### Fields

**Every row**

- `id` (Walmart item id), `url`, `title`, `brand` (search pages often leave it out; product details fill it), `image`
- `price`, `currency`, `listPrice` (the was-price, when above the price), `discountPercent`, `priceMax` (top of a variant price range)
- `rating` (0 to 5), `reviewCount`
- `seller`, `sellerId`, `soldByWalmart`, `inStock`, `availability`, `condition`, `additionalOfferCount`
- `sponsored`, `position` (place among every result read, ads included), `page`
- `categoryPath`, `badges` (Walmart's labels: "Best seller", "Rollback", "Overall pick"…)
- `pricedFor` (`postalCode`, `storeId`, `city`, `state`: where Walmart priced the page), `pageLanguage`
- `source` (`search`, `url` or `item`), `searchTerm`, `sourceUrl`
- `detailsIncluded`, `detailsError` (when a product page could not be read)
- `changeType` (`added`, `updated`, `removed` or null), `changes` (each with `type`, `field`, `from`, `to`, `percent`), `previous` (the last reading when something changed), `scrapedAt`

**With product details** (`includeDetails`, item ids and product URLs)

- `upc`, `model`, `manufacturerPartNumber`, `productId` (Walmart's catalog id)
- `wasPrice`, `savingsAmount`, `unitPrice`, `clearance`, `rollback`, `reducedPrice`
- `sellerType` (`INTERNAL` is Walmart), `sellerRating`, `sellerReviewCount`
- `offersCount` (every offer on the item), `otherOffersFrom` (the lowest other seller's price), `secondaryOffers` (when the page lists them)
- `fulfillment`: each of shipping, pickup and delivery with `available`, `speed`, `date`, `price`, `lowStock`, `maxOrderQuantity`
- `variantOptions` (each option with its values) and `variants` (each with `usItemId`, `url`, `options`, `price`, `inStock`, `selected`)
- `categoryPathId`, `images`, `description`, `highlights`, `specs`, `returnable`, `returnDays`, `buyBoxSuppressed`

Rows that left a list (Only changes, `removed`) carry the id, URL, title and the last reading. A run that finds nothing gives one free `recordType: "unreadable"` row per search or item, with the `reason`.

#### Sample record

A real row from a search with product details (arrays shortened):

```json
{
  "recordType": "product",
  "id": "225142139",
  "url": "https://www.walmart.com/ip/Keurig-K-elite-Brewer-Slate/225142139",
  "title": "Keurig K-Elite Single-Serve K-Cup Pod Coffee Maker, Brushed Slate",
  "brand": "Keurig",
  "price": 99.99,
  "currency": "USD",
  "listPrice": 189.99,
  "discountPercent": 47.4,
  "priceMax": 209.99,
  "rating": 4.5,
  "reviewCount": 18692,
  "sponsored": false,
  "position": 5,
  "page": 1,
  "seller": "Walmart.com",
  "sellerId": "F55CDC31AB754BB68FE0B39041159D63",
  "soldByWalmart": true,
  "inStock": true,
  "availability": "IN_STOCK",
  "condition": "New",
  "additionalOfferCount": 5,
  "categoryPath": [
    "Home",
    "Appliances",
    "Kitchen Appliances",
    "Coffee Shop",
    "Keurig Coffee Makers"
  ],
  "badges": ["500+ bought since yesterday", "Overall pick"],
  "image": "https://i5.walmartimages.com/seo/Keurig-K-Elite-Single-Serve-K-Cup-Pod-Coffee-Maker-Brushed-Slate_aa7821a3-2d13-4b4e-ae6f-66c98c1fb80c.c75fabf2dbabc10134d913ef6ca36d97.jpeg",
  "pricedFor": {
    "postalCode": "18062",
    "storeId": "2641",
    "city": "Macungie",
    "state": "PA"
  },
  "pageLanguage": "en-US",
  "productId": "3L3HD7EGQ0EL",
  "upc": "611247369425",
  "model": "5000359833",
  "manufacturerPartNumber": "5000359833",
  "wasPrice": 189.99,
  "savingsAmount": 90,
  "unitPrice": null,
  "clearance": false,
  "rollback": false,
  "reducedPrice": true,
  "sellerType": "INTERNAL",
  "sellerRating": null,
  "sellerReviewCount": null,
  "offersCount": 6,
  "otherOffersFrom": 149.99,
  "secondaryOffers": [],
  "fulfillment": [
    {
      "type": "SHIPPING",
      "available": true,
      "speed": "Tomorrow",
      "date": "2026-10-27T21:59:00.000Z",
      "price": null,
      "lowStock": false,
      "maxOrderQuantity": 99
    },
    {
      "type": "PICKUP",
      "available": true,
      "speed": "Today",
      "date": "2026-10-27T07:00:00.000-04:00",
      "price": null,
      "lowStock": false,
      "maxOrderQuantity": 6
    }
  ],
  "categoryPathId": "0:4044:90548:90546:1115306:3298657",
  "images": [
    "https://i5.walmartimages.com/seo/Keurig-K-Elite-Single-Serve-K-Cup-Pod-Coffee-Maker-Brushed-Slate_aa7821a3-2d13-4b4e-ae6f-66c98c1fb80c.c75fabf2dbabc10134d913ef6ca36d97.jpeg",
    "https://i5.walmartimages.com/asr/b53bd619-7108-4262-a88d-b3f3cc349514.2fec8f818f65d61a74700eccb7e2c89e.jpeg"
  ],
  "description": "The Keurig K-Elite® single serve coffee maker blends premium finish and programmable features together to deliver both modern design and the ultimate in beverag…",
  "highlights": [
    {
      "name": "Brand",
      "value": "Keurig"
    },
    {
      "name": "Number of preset cup sizes",
      "value": "5"
    },
    {
      "name": "Water reservoir capacity",
      "value": "75 oz"
    }
  ],
  "specs": {
    "Brand": "Keurig",
    "Compatible form": "Pods",
    "Water reservoir capacity": "75 oz",
    "Preset cup sizes": "4 oz, 6 oz, 8 oz, 10 oz, 12 oz"
  },
  "variantOptions": [
    {
      "name": "Actual Color",
      "values": ["Brushed Gold", "Brushed Silver", "Gray"]
    },
    {
      "name": "Pack Size",
      "values": ["Single"]
    }
  ],
  "variants": [
    {
      "usItemId": "225142139",
      "productId": "3L3HD7EGQ0EL",
      "url": "https://www.walmart.com/ip/Keurig-K-elite-Brewer-Slate/225142139",
      "options": {
        "Actual Color": "Gray",
        "Pack Size": "Single"
      },
      "price": 99.99,
      "inStock": true,
      "selected": true
    },
    {
      "usItemId": "564807397",
      "productId": "484OM2VOV5I1",
      "url": "https://www.walmart.com/ip/Keurig-K-Elite-Single-Serve-K-Cup-Pod-Coffee-Maker-Brushed-Silver/564807397",
      "options": {
        "Actual Color": "Brushed Silver",
        "Pack Size": "Single"
      },
      "price": 203.99,
      "inStock": true,
      "selected": false
    }
  ],
  "returnable": true,
  "returnDays": 90,
  "buyBoxSuppressed": false,
  "source": "search",
  "searchTerm": "coffee maker",
  "sourceUrl": null,
  "detailsIncluded": true,
  "changeType": "added",
  "changes": [],
  "previous": null,
  "scrapedAt": "2026-10-27T01:58:07.602Z"
}
```

The run summary (key-value store, `RUN_SUMMARY`) gives the outcome (`COMPLETE`, `PARTIAL`, `NO_CHANGES`, `EMPTY`, `FAILED`), rows, pages read, results left out by each filter, the areas Walmart priced for, charges and anything that could not be read.

### Only changes

Runs with the same `monitorName` compare against each other. The first run is the baseline and returns every row. Later runs return:

- `price-drop`, `price-rise`: with the old and new price and the percent; moves below `minPriceChangePercent` add up until they cross it
- `back-in-stock`, `out-of-stock`
- `new-listing`: an item a search or URL had not shown before
- `seller-change`: a different seller on the item
- `removed`: an item that left a search's results, or a monitored item id or product URL that Walmart now answers with "not found" (delivered free, with its last reading)

How each change is judged:

- **Each list keeps its own baseline.** A list is a search or URL together with the settings that change its results (`sort`, `minPrice`, `maxPrice`, `soldByWalmartOnly`, `inStockOnly`, `excludeSponsored`, `maxResultsPerSearch`). A search, URL or item id added to an existing monitor, or a list whose settings changed, starts its own baseline: on its first run, results and items the monitor has not read before are taken as the baseline (no rows, no new listings), with a note in the run summary's warnings; items already monitored still report their changes.
- **`removed` needs the whole list.** A result counts as removed only when the list was read to Walmart's last page and the result is not in it. A list that stopped at `maxResultsPerSearch` cannot tell an item that left from one that dropped below the cut, so a drop past the cut is no change. Ads rotate, so a gone ad has not left the list.
- **Filters never remove.** In Only changes mode the price range and `soldByWalmartOnly` are not sent to Walmart: the list is read whole and filtered after reading, so an item that crossed a filter is still seen. A result left out by `inStockOnly`, `soldByWalmartOnly`, `excludeSponsored` or the price range is still in Walmart's list, so it is never `removed`. When an item already monitored is left out because it changed (it went out of stock, or its price rose past `maxPrice`), its real change (`out-of-stock`, `price-rise`) is delivered regardless of the filter if that change type is asked for; otherwise there is no row.
- **Prices compare within one area.** Walmart prices by area, so a price is compared only when both readings were priced for the same ZIP code and store (`pricedFor`). When the area changed, the new reading becomes the baseline and no price change is reported; stock and seller changes still are.
- **A page is compared with a page.** Search results are compared on what the results page shows; item ids and product URLs on their product page. With product details on, product pages are read only for the rows whose results changed, and then the row's values, its `changes` and `previous`, and what is remembered all come from the product page, compared with the last product page reading. When there is no earlier product page reading, the changes stay those of the results page, and so do the price, stock, seller and `pricedFor` in the row.
- **An item id that is gone** (Walmart answers "not found" for an item this monitor has read before) sends one free `removed` row in Only changes mode and does not make the run partial; later runs stay quiet while it stays gone. An item id never read before that is not found, or any not-found item in a run without Only changes, is reported as not found.
- **A new listing** is a result missing from the results the list showed last time, so an item it showed before, even one a filter left out, is not new.
- **A run that stops early** (spending limit, time limit or `maxResults` with results or items left unprocessed) does not check what left its lists and keeps each list's saved results, so nothing that left goes unreported; a list new to the monitor stays new, so the results it read but did not handle become a free baseline on the next run. A run that reaches `maxResults` with everything processed is complete.
- A reading becomes the baseline only once its row is delivered.
- **With product details, the row follows one reading.** When the price, stock, seller and `pricedFor` come from the results page (no earlier product page reading), so do `listPrice`, `discountPercent`, `priceMax` and `availability`; page-only price and seller fields (`wasPrice`, `savingsAmount`, `unitPrice`, `clearance`, `rollback`, `reducedPrice`, `sellerType`, `sellerRating`, `sellerReviewCount`) are null.

### Built for AI agents

- **Compact, stable rows**: one flat record per product with the same keys every run, numbers as numbers, ISO dates, absolute URLs and Walmart's stable item ids.
- **Field selection**: `fields` returns only what the agent needs (for example `["id", "price", "inStock"]`), keeping answers small.
- **Change feed**: Only changes turns a schedule into a list of events with before and after values.
- **Clear failures**: a block or an empty search is a row or a summary entry with its reason, never a silent empty result.
- **MCP-ready**: call it from Apify's MCP server or API like any actor; the input schema documents every field with examples.

### Pricing

| Event                                                                   | Free  | Bronze | Silver | Gold and above |
| ----------------------------------------------------------------------- | ----- | ------ | ------ | -------------- |
| Listing (a search or URL result row)                                    | $1.20 | $0.60  | $0.54  | $0.48          |
| Product details (add-on to a listing, or an item id or product URL)     | $8.00 | $4.00  | $3.60  | $3.20          |
| Item checked (a product page read that delivered nothing, Only changes) | $8.00 | $4.00  | $3.60  | $3.20          |

Per 1,000. Each run also has the standard start fee. Prices on the Free plan are doubled because every page is read through a licensed data network. A search of 40 results costs $0.024 on Bronze; with product details, $0.184. Unchanged search results in Only changes mode are free. A product page read in Only changes mode that ends up delivering nothing (an unchanged item id or product URL, or, with product details, a search result whose card changed but whose product page did not) is a full page read, so its check costs the same as product details.

### Limits

- **Location cannot be chosen.** Walmart prices for the area of the address a page is read from and ignores ZIP and store parameters; every row says which area in `pricedFor`. Store-only prices and pickup availability for a chosen store are not available.
- **Other sellers' full offer list** loads in the browser after the page; the page gives the number of offers and the lowest other price, and `secondaryOffers` is filled only when the page includes the list.
- **Walmart.com (US) only.** Walmart Canada, Mexico and other countries are not read.
- **Up to 25 pages per search** (about 1,000 results), as Walmart shows.
- **No reviews text**, account, cart or seller-center data; no sign-in is ever used.

### Changelog

- **0.1** (October 2026): searches, browse URLs, product URLs and item ids; Walmart's sort and price, retailer filters plus in-stock and sponsored filters; product details with UPC, variants, offers, fulfilment, clearance, category, specs and highlights; the area each page was priced for; Only changes monitor with price drops and rises, stock, new listings, seller changes and items that left a search.

# Actor input Schema

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

Words to search on Walmart.com, one per line, for example "air fryer" or "65 inch tv". Each search gives one row per result, in Walmart's order.

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

Optional. Walmart search URLs (https://www.walmart.com/search?q=…), browse or category URLs (https://www.walmart.com/browse/…) and product URLs (https://www.walmart.com/ip/…/123456789). A search or browse URL keeps its own sort and filters; a product URL is read from its product page.

## `itemIds` (type: `array`):

Optional. Walmart item ids, the number at the end of a product URL, for example 985675140. Each is read from its product page, with every detail field.

## `maxResultsPerSearch` (type: `integer`):

How many results to keep from each search or URL, for example 40 (one page). Walmart shows about 40 results a page plus a few ads; the actor follows the pages.

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

Optional. Stop after this many rows across the whole run, for example 500.

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

Walmart's own sort order, sent in its URL. A Walmart URL that already has a sort keeps it.

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

Optional. Only results at or above this price, for example 50. Sent to Walmart in its URL, and checked again on each result (in Only changes mode, checked on each result only).

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

Optional. Only results at or below this price, for example 80. Sent to Walmart in its URL, and checked again on each result (in Only changes mode, checked on each result only).

## `soldByWalmartOnly` (type: `boolean`):

Only items Walmart itself sells (not marketplace sellers). Sent to Walmart as its own Retailer filter, and checked again on each result (in Only changes mode, checked on each result only).

## `inStockOnly` (type: `boolean`):

Leave out results Walmart marks out of stock. Applied to the results Walmart returns (its URL has no such filter); left-out results are not charged.

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

Leave out ads. Off: ads are kept and marked sponsored: true. Applied to the results Walmart returns; left-out results are not charged.

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

Also read each result's product page: UPC, model, variants with their prices and stock, other sellers' offers, delivery and pickup options, clearance and rollback flags, category path, specifications and highlights. Adds $4.00 per 1,000 rows.

## `onlyChanges` (type: `boolean`):

Return only what changed since the last run with the same monitor name: price drops and rises, back in stock, out of stock, new listings, seller changes and items that left a search. The first run is the baseline (every row). Results that did not change are free; an item id or product URL that did not change costs $4.00 per 1,000 checks (a full product page read).

## `monitorName` (type: `string`):

Runs with the same name compare against each other, for example "air-fryers-daily". Use one name per list you track.

## `changeTypes` (type: `array`):

Which changes count in Only changes mode, for example only "price-drop" and "back-in-stock".

## `minPriceChangePercent` (type: `number`):

Ignore price moves smaller than this percentage, for example 5. Small moves add up: the price is compared with the last one reported.

## `fields` (type: `array`):

Optional. Keep only these fields in each row, for example \["id", "title", "price", "upc", "pricedFor.postalCode"]. Dotted paths pick nested fields. recordType is always kept.

## Actor input object example

```json
{
  "searchTerms": [
    "air fryer"
  ],
  "maxResultsPerSearch": 40,
  "sort": "best_match",
  "soldByWalmartOnly": false,
  "inStockOnly": false,
  "excludeSponsored": false,
  "includeDetails": false,
  "onlyChanges": false,
  "monitorName": "default",
  "changeTypes": [
    "price-drop",
    "price-rise",
    "back-in-stock",
    "out-of-stock",
    "new-listing",
    "seller-change",
    "removed"
  ],
  "minPriceChangePercent": 0
}
```

# Actor output Schema

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

One row per product, with product details and changes when asked for.

## `products` (type: `string`):

No description

## `details` (type: `string`):

No description

## `changes` (type: `string`):

No description

## `summary` (type: `string`):

Outcome (COMPLETE, PARTIAL, NO_CHANGES, EMPTY, FAILED), counts, charges, the areas Walmart priced for, and what could not be read.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchTerms": [
        "air fryer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("cleanpull/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": ["air fryer"] }

# Run the Actor and wait for it to finish
run = client.actor("cleanpull/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": [
    "air fryer"
  ]
}' |
apify call cleanpull/walmart-scraper --silent --output-dataset

```

## MCP server setup

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