# Wayfair Furniture Price, Stock & Review Extractor (`xyrelith-data/wayfair-furniture-price-stock-and-review-extractor`) Actor

Search, browse by category or brand, or look up by URL or SKU across Wayfair's US, Canada, UK and Ireland storefronts, and get back price, discount, stock status, ratings, reviews, variants and images. No API key needed.

- **URL**: https://apify.com/xyrelith-data/wayfair-furniture-price-stock-and-review-extractor.md
- **Developed by:** [Xyrelith Data](https://apify.com/xyrelith-data) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Wayfair Furniture Price, Stock & Review Extractor

Wayfair doesn't publish a product API, so tracking price moves, stock changes or review counts on its catalog otherwise means refreshing pages by hand. This actor turns Wayfair search results, category and brand pages, and individual product pages across four storefronts into structured records — ready for a spreadsheet, database, or app.

### What this actor does

- **5 ways to find products** — keyword search, a direct Wayfair URL (search, category, brand, or product page), top-level category browse, brand search, or SKU lookup.
- **4 regional storefronts** — wayfair.com (US), wayfair.ca (Canada), wayfair.co.uk (UK), wayfair.ie (Ireland) — with each region's own currency and product data.
- **Price and sale price tracking** — current price, the original "was" price when an item is discounted, and the discount percentage.
- **Stock status on every product** — know at a glance whether an item is in stock, low stock, backordered, or out of stock, plus a simple purchasable yes/no flag.
- **Powerful filtering** — by price range, minimum rating, in-stock only, on-sale only, or a minimum discount %, and sort by price, rating, newest, or best seller.
- **Full product enrichment** — pull complete pricing, description, delivery estimate, colour/size variants, and up to 25 individual customer reviews per product.
- **Fast and reliable** — built to keep working through temporary rate limits so your run completes.
- **No login, no cookies, no API key required.**
- Clean output — empty fields are simply left out of each record, never filled with placeholder or fake values.

### Output per product

- `sku`, `title`, `brand`
- `price` — the current, payable price (the discounted one when a promotion is running)
- `previousPrice` — the struck-through "was" price, included only when the item is actually discounted
- `currency`
- `stockStatus` — Wayfair's own status string for the listing. `IN_STOCK` is what shoppable items return; Wayfair's schema also defines `LOW_STOCK`, `OUT_OF_STOCK`, `BACKORDERED`, `DISCONTINUED` and `UNAVAILABLE`
- `isPurchasable` — `true`/`false` derived from `stockStatus` (`false` for out-of-stock, backordered, discontinued and unavailable listings)
- `estimatedDeliveryMessage` — Wayfair's own "Get it by ..." delivery estimate, when shown
- `ratingValue`, `reviewCount`
- `imageUrl`, `description`
- `breadcrumbs`, `category`, `subCategory`
- `promoFlag` — badge text such as "72-Hour Clearout", when present
- `variants` — the product's own colour / finish / size options, each with `name`, `imageUrl`, `stockStatus` and its own `productUrl` (requires `fetchProductDetails`; omitted for products with no options)
- `reviews` — up to 25 individual customer reviews, each with `reviewId`, `rating`, `body`, `badge`, `date`, `reviewerName` and `reviewerLocation` (requires `fetchProductDetails`; omitted for products with no reviews)
- `productUrl`, `canonicalUrl`, `sourceUrl`
- `country`, `siteName`, `recordType`, `scrapedAt`

```json
{
  "sku": "CXVA1530",
  "title": "Latitude Run Ilkeston 81.6\" Wide Vegan Leather Manual Reclining Sofa",
  "brand": "Latitude Run",
  "productUrl": "https://www.wayfair.com/furniture/pdp/latitude-run-ilkeston-...-cxva1530.html",
  "canonicalUrl": "https://www.wayfair.com/furniture/pdp/latitude-run-ilkeston-...-cxva1530.html",
  "price": 689.99,
  "previousPrice": 1098.99,
  "currency": "USD",
  "stockStatus": "IN_STOCK",
  "isPurchasable": true,
  "estimatedDeliveryMessage": "Get it Fri, May 22 - Thu, May 28",
  "ratingValue": 4.63,
  "reviewCount": 648,
  "imageUrl": "https://assets.wfcdn.com/im/.../Ilkeston+81.6+...+Cup+Holders.jpg",
  "description": "Choose a delivery day that works for you...",
  "breadcrumbs": ["Furniture", "Living Room Furniture", "Sofas"],
  "category": "Furniture",
  "subCategory": "Sofas",
  "promoFlag": "72-Hour Clearout",
  "variants": [
    {
      "name": "Beige Performance Faux Leather",
      "imageUrl": "https://assets.wfcdn.com/im/.../Beige+Performance+Faux+Leather.jpg",
      "stockStatus": "IN_STOCK",
      "productUrl": "https://www.wayfair.com/furniture/pdp/latitude-run-ilkeston-...-cxva1530.html?piid=94939949"
    }
  ],
  "reviews": [
    {
      "reviewId": 165642272,
      "rating": 5,
      "body": "It's such a great price and it looks like it would cost more than it is.",
      "badge": "Verified Buyer",
      "date": "04/29/2026",
      "reviewerName": "Susana"
    }
  ],
  "country": "com",
  "siteName": "Wayfair",
  "recordType": "product",
  "scrapedAt": "2026-05-08T17:24:33.123456+00:00",
  "sourceUrl": "https://www.wayfair.com/keyword.php?keyword=sofa"
}
```

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | enum | `search` | `search`, `byUrl`, `byCategory`, `byBrand`, `byProduct` |
| `country` | enum | `com` | Wayfair regional domain — `com` (US), `ca` (Canada), `co.uk` (UK), `ie` (Ireland) |
| `text` | string | `sofa` | Search keyword (`search` mode) |
| `category` | enum | `furniture` | Top-level Wayfair category (`byCategory` mode) — Furniture, Outdoor, Decor & Pillows, Rugs, Kitchen & Tabletop, Bed & Bath, Lighting, Storage & Organization, Appliances, Home Improvement, Baby & Kids, Holiday Decor, Office, Pet |
| `urls` | array | `[]` | Direct Wayfair URLs (`byUrl` / `byBrand` modes) |
| `brand` | string | – | Brand name for `byBrand` mode, exactly as it appears on Wayfair (e.g. "Latitude Run", "Wade Logan", "Hokku Designs"). Free text rather than a dropdown, since Wayfair carries thousands of brands |
| `skus` | array | `[]` | Wayfair product SKUs (e.g. `W118077895`, `CXVA1530`) for `byProduct` mode |
| `sortBy` | enum | `relevance` | `relevance`, `price_low_to_high`, `price_high_to_low`, `top_rated`, `newest`, `best_seller` |
| `priceMin` | int | – | Drop products priced below this value |
| `priceMax` | int | – | Drop products priced above this value |
| `ratingMin` | float | – | Drop products with rating below this (0.0–5.0) |
| `onSaleOnly` | bool | `false` | Only return products Wayfair shows a struck-through "was" price for |
| `minDiscountPercent` | int | – | Only return products discounted by at least this % off the previous price (1–99); leave empty for no threshold |
| `inStockOnly` | bool | `false` | Only return listings Wayfair explicitly marks as in stock |
| `fetchProductDetails` | bool | `false` | Fetch each product's own detail page for complete pricing, description, delivery data, variants, and reviews |
| `maxItems` | int | `25` | Hard cap on returned products, applied across the whole run (see note below) |
| `maxPagesPerListing` | int | `3` | Maximum result pages to walk per search/category/brand lookup (~48 products per page, 25 pages max) |
| `proxyConfiguration` | proxy | residential proxy | Apify proxy configuration (residential proxy is used by default since Wayfair blocks most non-residential traffic) |

> **How `maxItems` and `maxPagesPerListing` interact.** `maxItems` caps the
> whole run; `maxPagesPerListing` caps how deep each individual seed is
> crawled. A listing page holds about 48 products and the page ceiling is 25,
> so **one** search / category / brand seed can realistically supply at most
> \~1,200 products no matter how high `maxItems` goes. To go beyond that, give
> the run more than one seed — several URLs in `byUrl` or `byBrand` mode, or
> several SKUs in `byProduct` mode — since the cap is shared across all of
> them. Setting `maxItems` to 5,000 with a single keyword is not an error; it
> simply means "no practical limit" and the run ends when the seed is
> exhausted.

#### Example: search with filters

```json
{
  "mode": "search",
  "country": "com",
  "text": "sofa",
  "sortBy": "top_rated",
  "priceMax": 1000,
  "inStockOnly": true,
  "maxItems": 50
}
```

#### Example: on-sale products only

```json
{
  "mode": "search",
  "country": "com",
  "text": "sectional sofa",
  "onSaleOnly": true,
  "minDiscountPercent": 30,
  "fetchProductDetails": true,
  "maxItems": 40
}
```

#### Example: direct URL

```json
{
  "mode": "byUrl",
  "urls": [
    "https://www.wayfair.com/furniture/cat/sofas-c413894.html",
    "https://www.wayfair.com/furniture/pdp/latitude-run-ilkeston-...-cxva1530.html"
  ]
}
```

#### Example: category browse

```json
{
  "mode": "byCategory",
  "country": "co.uk",
  "category": "lighting",
  "sortBy": "newest",
  "fetchProductDetails": true,
  "maxItems": 30
}
```

#### Example: brand search

```json
{
  "mode": "byBrand",
  "country": "com",
  "brand": "Latitude Run"
}
```

#### Example: look up by SKU

```json
{
  "mode": "byProduct",
  "country": "com",
  "skus": ["W118077895", "CXVA1530"]
}
```

### Use cases

- **Price tracking** — monitor price and sale-price changes on specific Wayfair products over time.
- **Stock / availability monitoring** — get alerted the moment a backordered or out-of-stock item becomes purchasable again.
- **Competitive & market research** — compare pricing, ratings, and promotions across brands and categories.
- **Product feeds & catalog enrichment** — pull structured Wayfair listings into your own catalog or comparison site.
- **Deal & clearance hunting** — switch on `onSaleOnly` (or set a `minDiscountPercent` floor) to return only genuinely discounted products, with the struck-through `previousPrice` alongside the payable one.
- **Regional pricing comparison** — compare the same product's price and currency across the US, Canada, UK, and Ireland storefronts.

### FAQ

**Does this require a Wayfair account, login, or API key?** No. It scrapes Wayfair's public storefront directly.

**Does it support Wayfair.de?** No. Wayfair shut down its German storefront in 2020, so `wayfair.de` is not a supported region.

**Why don't all search results have a price?** Wayfair's search and category pages only show pricing for a small number of products up front — most listing cards don't include a visible price at all. Treat listing-page pricing as best-effort, never a guarantee. For complete, reliable pricing (plus rating and review count) on every result, turn on `fetchProductDetails`, which visits each product's own page to collect the full data. Even then, a small number of products — typically ones with multiple size or colour options — may come back with no price, since Wayfair itself doesn't always show one fixed price for those listings.

**What do I get without `fetchProductDetails`?** `title`, `sku`, `productUrl`, `stockStatus` and `isPurchasable` on essentially every result, plus an image on most. Price, previous price, rating and review count are best-effort in this mode and can be absent from an entire run — use `fetchProductDetails` if you need them reliably. Two things worth knowing: your price range filter is still applied by Wayfair itself even when you can't see the price in the output, and the on-sale filters need a previous price to work, so combining them with `fetchProductDetails` turned off can legitimately return nothing.

**How reliable is `stockStatus`?** Very — it's returned on essentially every result, whether or not `fetchProductDetails` is on. `isPurchasable` is only set when Wayfair's own stock status is known; it's never guessed.

**What's `estimatedDeliveryMessage`?** Wayfair's own delivery estimate (e.g. "Get it by Fri, May 22"). Like price, it's most reliably available when `fetchProductDetails` is turned on.

**What exactly does `byCategory` do?** It finds products in one of Wayfair's top-level departments (Furniture, Lighting, Rugs, and so on). It is not literal category-page browsing, so results reflect that department but aren't guaranteed to be 100% within it — the same is true of Wayfair's own category pages, which mix in merchandised and related items. If you need one specific Wayfair category page, copy its URL from the site and use `byUrl` instead.

**How do the sale filters work?** `onSaleOnly` keeps only products Wayfair itself shows a struck-through "was" price for — the same real discount reflected in the `previousPrice` output field, never an estimate. `minDiscountPercent` adds a minimum discount percentage on top of that. Both are opt-in filters for discounted items, so a product with no previous price is dropped rather than kept. Combine them with `fetchProductDetails` for the best coverage, since most listing pages don't show pricing up front.

**If I turn on `inStockOnly`, what happens to results with unknown stock status?** They're excluded. This filter means "only show me listings Wayfair explicitly confirms are in stock" — unlike the price and rating filters, which keep a result when that particular field simply isn't available.

**How does the price filter work?** A product without a price is kept, since a missing field isn't evidence it falls outside your range. A product with a known price outside `priceMin`/`priceMax` is dropped.

**How does `ratingMin` treat products with no rating?** It keeps them, on the same "a missing field isn't evidence" principle as the price filter. That includes brand-new products nobody has reviewed yet: Wayfair shows no stars for those, so the record carries no `ratingValue` at all rather than a fake `0`, and it isn't judged against your threshold. If you only want products with a proven rating, keep `ratingMin` and drop any record without a `ratingValue` in your own post-processing.

**What happens if a request gets temporarily rate-limited?** The actor automatically retries with a fresh connection, so a temporary rate limit doesn't stall or fail your run.

**What happens if I request a SKU that doesn't exist?** That SKU is skipped rather than returning an unrelated product, so you never get mismatched data for a bad SKU.

**Does the scraper extract individual customer reviews?** Yes, when `fetchProductDetails` is on. Each product record then carries a `reviews` array with up to 25 of the product's own reviews — rating, review text, reviewer name and location, date, and Wayfair's own badge ("Verified Buyer", "Incentivized Review"). Products with no reviews simply have no `reviews`, `ratingValue` or `reviewCount` field — an unrated product is reported as unrated, never as "0 stars from 0 reviews". The aggregate `ratingValue` and `reviewCount` are always the full totals, not just the reviews in this array.

**What are `variants`?** The product's own selectable options — colour, finish or size — as Wayfair lists them on the product page, each with its name, thumbnail image and stock status, plus the URL of that specific option. Included only when `fetchProductDetails` is on, and only for products that actually have options.

**What currency will I get?** Each storefront's native currency: USD (US), CAD (Canada), GBP (UK), EUR (Ireland) — matched automatically to the `country` you choose.

**Why does this need a residential proxy?** Wayfair blocks most non-residential traffic, so this actor uses a residential proxy by default, with connections rotated automatically, to reach the site reliably and consistently.

**Is this affiliated with Wayfair?** No — this is an independent, third-party actor that reads Wayfair's public storefront pages. It isn't operated or endorsed by Wayfair.

### Limitations

- `wayfair.de` is not supported, since Wayfair closed its German storefront in 2020. Requesting `de`, or any other unsupported region, falls back to the US storefront rather than failing the run, with a note in the run log so it's never mistaken for a real regional result.
- Individual customer reviews are limited to up to 25 per product (newest first) and require `fetchProductDetails`.
- `byCategory` results reflect the chosen department but aren't guaranteed to be strictly limited to it. Use `byUrl` with a Wayfair category URL when you need one exact category page.
- Sort order is requested from Wayfair directly; if a specific sort isn't honored, results fall back to Wayfair's default ordering rather than erroring.
- Brand pages vary in URL format; the most reliable way to scrape one specific brand page is `byUrl` with the brand's listing URL copied from Wayfair.
- Pricing, rating, review count, and delivery-estimate data on listing pages is limited to a minority of results per page — turn on `fetchProductDetails` to reliably get this data for every result. Stock status is not affected by this limitation.
- The Ireland storefront (`ie`) is fully supported but has not yet been validated against a live production run the way the other three regions have, so treat it as the least battle-tested of the four.
- `fetchProductDetails` takes longer to run since it visits each product's own page; large runs with it enabled will take noticeably longer than a listing-only scrape.
- Sponsored or ad placements on listing pages may return sparser data than organic results.

# Actor input Schema

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

How to find products on Wayfair. search: keyword search. byUrl: paste any Wayfair search, category, brand, or product URL(s). byCategory: browse a top-level category. byBrand: search by brand name or paste a brand's listing URL(s). byProduct: look up specific products by SKU.

## `country` (type: `string`):

Wayfair regional domain. com=US, ca=Canada, co.uk=UK, ie=Ireland. (Wayfair.de shut down in 2020 and is not supported.) Any other value falls back to wayfair.com and the run log records a warning saying so, so you can tell a fallback apart from a real US run.

## `text` (type: `string`):

Free-text keyword (used in search mode). Examples: "sofa", "office chair", "throw pillow", "area rug".

## `category` (type: `string`):

Top-level Wayfair category (resolves to a category browse URL). Used for byCategory mode.

## `urls` (type: `array`):

Direct Wayfair URLs (search results, category page, or product detail page). Domain auto-detected from URL.

## `brand` (type: `string`):

Brand or manufacturer name, exactly as it appears on Wayfair (e.g. "Latitude Run", "Wade Logan", "Hokku Designs"). Results are filtered to that brand. Free text rather than a dropdown, since Wayfair carries thousands of brands.

## `skus` (type: `array`):

Wayfair product SKUs (e.g. "W118077895", "CXVA1530"). The scraper resolves each SKU to its detail page.

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

Sort order for search, category, and brand results, as offered by Wayfair itself.

## `priceMin` (type: `integer`):

Drop products priced below this value (in the destination country's currency). Leave empty to apply no lower bound.

## `priceMax` (type: `integer`):

Drop products priced above this value (in the destination country's currency). Leave empty to apply no upper bound.

## `ratingMin` (type: `number`):

Drop products with rating below this value (0.0-5.0). Products with no rating are kept (the user opted into the filter, not into requiring the field).

## `onSaleOnly` (type: `boolean`):

Only emit products that are actually discounted, i.e. Wayfair shows a struck-through "was" price above the payable one (the record's previousPrice field). Products with no previous price are dropped.

## `minDiscountPercent` (type: `integer`):

Only emit products discounted by at least this percentage off their previous price (1-99). Leave empty to apply no discount threshold. Implies "On sale only": a product with no previous price has no measurable discount and is dropped.

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

Only emit listings Wayfair explicitly marks as IN_STOCK. Listings with no stock-status evidence are dropped (unlike price/rating filters, this is a confirmed-availability guarantee, not a best-effort filter).

## `fetchProductDetails` (type: `boolean`):

Visit each product's own page to enrich results with price, rating, brand, full description, breadcrumbs, a high-resolution image, colour/size variants, and up to 25 individual customer reviews. Recommended for complete, reliable data; takes longer to run than a listing-only scrape.

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

Hard cap on emitted product records. Note how this interacts with "Max listing pages": a single search/category/brand seed yields about 48 products per page, so one seed can realistically return at most ~1,200 products (48 x the 25-page ceiling). Values above that are only reachable when you supply several seeds at once - multiple URLs in byUrl/byBrand mode, or multiple SKUs in byProduct mode - because the cap applies to the whole run, not per seed.

## `maxPagesPerListing` (type: `integer`):

Maximum paginated listing pages (?page=N) to crawl per search/category/brand seed (~48 products per page). This bounds how many products one seed can possibly yield: 25 pages x ~48 = ~1,200. Raise it alongside "Max items" when you want a deep single-seed crawl.

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

Proxy configuration. Wayfair blocks most non-residential traffic, so a Residential proxy is required for reliable results and is used by default. Leaving this blank will cause most or all requests to fail.

## Actor input object example

```json
{
  "mode": "search",
  "country": "com",
  "text": "sofa",
  "category": "furniture",
  "urls": [],
  "brand": "",
  "skus": [],
  "sortBy": "relevance",
  "priceMin": 0,
  "priceMax": 500,
  "ratingMin": 4,
  "onSaleOnly": false,
  "inStockOnly": false,
  "fetchProductDetails": false,
  "maxItems": 5,
  "maxPagesPerListing": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing Wayfair product records.

# 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 = {
    "mode": "search",
    "country": "com",
    "text": "sofa",
    "category": "furniture",
    "urls": [],
    "brand": "",
    "skus": [],
    "sortBy": "relevance",
    "priceMin": 0,
    "priceMax": 500,
    "ratingMin": 4,
    "onSaleOnly": false,
    "inStockOnly": false,
    "fetchProductDetails": false,
    "maxItems": 5,
    "maxPagesPerListing": 2,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("xyrelith-data/wayfair-furniture-price-stock-and-review-extractor").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 = {
    "mode": "search",
    "country": "com",
    "text": "sofa",
    "category": "furniture",
    "urls": [],
    "brand": "",
    "skus": [],
    "sortBy": "relevance",
    "priceMin": 0,
    "priceMax": 500,
    "ratingMin": 4,
    "onSaleOnly": False,
    "inStockOnly": False,
    "fetchProductDetails": False,
    "maxItems": 5,
    "maxPagesPerListing": 2,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("xyrelith-data/wayfair-furniture-price-stock-and-review-extractor").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 '{
  "mode": "search",
  "country": "com",
  "text": "sofa",
  "category": "furniture",
  "urls": [],
  "brand": "",
  "skus": [],
  "sortBy": "relevance",
  "priceMin": 0,
  "priceMax": 500,
  "ratingMin": 4,
  "onSaleOnly": false,
  "inStockOnly": false,
  "fetchProductDetails": false,
  "maxItems": 5,
  "maxPagesPerListing": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call xyrelith-data/wayfair-furniture-price-stock-and-review-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,xyrelith-data/wayfair-furniture-price-stock-and-review-extractor"
        }
    }
}
```

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/XfLp5zlvPjQAQJKas/builds/c8mhE2cJmSIjbZb4y/openapi.json