# Wayfair Scraper \[$1.5💰] | Prices | Products | Rating Data (`ahmed_jasarevic/wayfair-scraper`) Actor

\[$1.5💰] Scrape Wayfair furniture prices, SKUs, brands, ratings and reviews for price monitoring, competitor analysis and market research. Track price changes on a schedule and download clean JSON, CSV or Excel.

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

## Pricing

from $1.39 / 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

## Wayfair Scraper - Product Prices, SKUs, Ratings and Availability

The **Wayfair Scraper** turns public Wayfair search, category and product pages into structured furniture and home-goods records. Collect product titles, SKUs, brands, current and previous prices, currency, ratings, review counts, availability, descriptions, specs, features, variants, images and product URLs.

Use it for furniture price monitoring, catalog research, competitor assortment analysis or building a clean product feed from a list of search terms and product URLs. The Actor reads data embedded in the served HTML and does not render a browser, so runs stay lightweight even when you need hundreds of products.

### Main Use Cases for Wayfair Product Data

- **Furniture price monitoring** - track current price, `wasPrice` and availability across products and categories.
- **Competitor assortment research** - compare brands, product types, price bands and rating strength.
- **Catalog enrichment** - add images, specs and product URLs to an existing SKU list.
- **Marketplace analytics** - study how products are titled, priced and positioned in the home-goods market.
- **Merchandising alerts** - detect price drops or out-of-stock records between scheduled runs.
- **Product feed building** - create JSON, CSV or Excel feeds for a comparison site or internal dashboard.
- **AI shopping research** - provide an LLM with normalized product rows for filtering and recommendation.

### How It Works

![Wayfair Scraper workflow: search terms, category pages and product URLs become product records with prices, SKUs, ratings and availability](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-wayfair-scraper.webp)

The Actor accepts three discovery paths: search terms, category URLs and direct product URLs. Search terms are converted into Wayfair keyword-search URLs. Category pages are read for product links because their grids are rendered client-side. Direct product URLs are parsed immediately.

Each product page contains structured data in JSON-LD, WEBPACK entry data or an Apollo state block, depending on the page version. The Actor reads those embedded objects and maps them into one flat product record. There is no headless browser and no per-product API key. Product images are kept as URL arrays, and nested options from the source are preserved in `variants` rather than flattened into invented fields.

Wayfair can rate-limit or challenge automated HTTP clients. The Actor supports Apify proxy configuration and retries blocked requests with rotating sessions. Residential proxies are recommended for larger or repeated runs. Some product pages expose fewer fields than others: a null `wasPrice`, an empty `specs` array or an empty `images` array means the source page did not publish that data in the parsed payload. Review text is not populated by the current build; use `rating` and `reviewCount` as the review signals.

### Input

| Field | Type | Required | Default | What it does |
|---|---|---|---|---|
| `searchTerms` | `string[]` | No | `["bar stools"]` | Keywords converted into Wayfair search URLs. Each term is a separate discovery path. |
| `categoryUrls` | `string[]` | No | one bar-stools category | Wayfair category pages used to discover product URLs. |
| `productUrls` | `string[]` | No | `[]` | Direct Wayfair product pages to parse without discovery. |
| `maxItems` | `integer` | No | `50` | Maximum product records to output. Free accounts are capped at 10. |
| `proxy` | `object` | No | disabled | Apify proxy configuration. Residential proxies are recommended for reliability. |
| `debug` | `boolean` | No | `false` | Save failed HTML responses to the key-value store for diagnosis. |

You can combine search terms, category URLs and product URLs in one run. Use direct product URLs when you need exact products; use search or category pages when you need discovery. With no usable input, the Actor exits without collecting products, so provide at least one term or URL.

### Output

The dataset contains **18 fields** per product on the main extraction paths. Optional arrays and values are empty or null when Wayfair does not expose them.

| Field group | Fields | What you get |
|---|---|---|
| Identity | `title`, `sku`, `brand`, `productUrl`, `source` | Product name, SKU, brand, canonical product URL and extraction path. |
| Pricing | `price`, `wasPrice`, `currency` | Current price, previous price when shown and currency code. |
| Reviews | `rating`, `reviewCount`, `reviewText` | Rating and count. `reviewText` is reserved and currently null. |
| Availability | `availability` | Stock or availability label from the page payload. |
| Content | `description`, `specs`, `features` | Description text, key-value specs and feature strings when present. |
| Structure | `dimensions`, `variants`, `images` | Dimension entries, source variant options and product image URLs. |
| Media | `images` | Array of image URLs. |

`source` is normally `pdp-html` for a product page or `category-html` when a product row came from a category payload. The exact completeness varies by page template. `dimensions` and `specs` can be empty on newer React Server Components pages, so do not treat an empty array as proof that a product has no dimensions.

### Pricing

The Actor uses pay-per-event pricing: one small start event per run and one result event per product row.

| Event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
|---|---:|---:|---:|---:|---:|---:|
| Actor start, per run | $0.00005 | $0.00005 | $0.00005 | $0.00005 | $0.00005 | $0.00005 |
| Product result | $0.0015 | $0.00145 | $0.0014 | $0.00139 | $0.00139 | $0.00139 |

That is **$1.50 per 1,000 products** on the FREE tier. Free accounts receive the first **10 products** as a preview. Set `maxItems` to control spend; failed or empty pages do not produce result events.

### Example Input

```json
{
  "searchTerms": ["bar stools", "counter stools"],
  "categoryUrls": ["https://www.wayfair.com/furniture/cat/bar-stools-c46134.html"],
  "maxItems": 50
}
```

### Example Output

```json
{
  "title": "Bayside Upholstered Bar Stool",
  "sku": "W123456789",
  "brand": "Three Posts",
  "price": 129.99,
  "wasPrice": 159.99,
  "currency": "USD",
  "rating": 4.6,
  "reviewCount": 842,
  "reviewText": null,
  "availability": "In Stock",
  "description": "A cushioned counter stool with a solid wood frame.",
  "specs": [{ "label": "Seat Height", "value": "26 in." }],
  "dimensions": [],
  "features": ["Upholstered seat", "Footrest"],
  "variants": [],
  "images": ["https://assets.wayfair.com/images/furniture/example.jpg"],
  "productUrl": "https://www.wayfair.com/furniture/pdp/example",
  "source": "pdp-html"
}
```

### Integrations and Automation

Use Apify schedules for daily or weekly price checks, then send changed rows to Google Sheets, Airtable, a database, Slack or a webhook. Export the dataset as JSON, CSV, Excel, XML or HTML, or query it through the Apify API.

A useful pattern is to keep a fixed `productUrls` list for price tracking and a separate search-term run for discovery. Compare `price`, `wasPrice`, `availability` and `rating` between datasets, and use `sku` as the stable key. Join results with Shopify or marketplace data to compare the same product across channels.

### Related Actors

- [1stDibs Scraper](https://apify.com/ahmed_jasarevic/1stdibs-scraper) - luxury furniture, dealer and provenance data.
- [Chairish Scraper](https://apify.com/ahmed_jasarevic/chairish-scraper) - vintage and consignment furniture listings.
- [Shopify Scraper](https://apify.com/ahmed_jasarevic/shopify-scraper) - store-level tech stack, theme and commerce signals.

### FAQ

#### Does the Wayfair Scraper use a browser?

No. It reads the HTML served by Wayfair and parses embedded JSON-LD, WEBPACK data or React Server Components payloads. That is faster than browser rendering and avoids the challenges that often appear when automating a full browser.

#### Can it collect review text?

The current build exposes `rating` and `reviewCount` but leaves `reviewText` null. Do not build a workflow that depends on review body text from this Actor.

#### Why is `wasPrice` null?

Not every product is discounted or shows a previous price. `wasPrice` is copied only when the page payload contains a comparison price. A missing value does not mean the product was never discounted.

#### How many products can one run collect?

`maxItems` controls the output and accepts up to 10,000 in the schema, but the practical result depends on how many product links the selected search or category pages expose. Free accounts receive a 10-product preview. Starting from direct product URLs is the most predictable way to hit an exact list.

#### Does it paginate search results?

The current discovery model follows product links from the supplied search and category pages rather than walking an unlimited page-number sequence. For broad coverage, supply multiple search terms or category URLs, or use a list of product URLs.

#### Why are specs or dimensions empty?

Wayfair serves different page templates. Newer pages can omit structured specs and dimensions from the embedded payload even though the visual page shows them. The Actor preserves empty arrays rather than guessing values from images or unrelated text.

### For AI Agents and LLM Apps

The Actor is available through the Apify API and Apify MCP server and returns one JSON row per product.

**Minimal input**

```json
{
  "searchTerms": ["bar stools"],
  "maxItems": 10
}
```

**Behavior an agent should know**

- One item represents one Wayfair product.
- `sku` is the best product key; `productUrl` is the link to the source page.
- `price` and `wasPrice` are numeric and use `currency` for the currency code.
- `reviewText` is always null in the current build; use `rating` and `reviewCount`.
- `specs`, `dimensions`, `features` and `images` can be empty arrays.
- Free accounts are capped at 10 products per run.

**Suggested tool description:** "Collect Wayfair product records with prices, SKUs, brands, ratings, availability, specs, images and product URLs from searches or product pages."

### Legal and Compliance

This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by Wayfair. It accesses publicly available product pages for legitimate price research, catalog analysis and market intelligence. Wayfair's terms, robots guidance and applicable law still apply.

Product prices, availability and specifications change frequently. Verify critical values on the source page before making purchasing, pricing or inventory decisions. If you republish product images or descriptions, make sure you have the necessary rights. Do not use the Actor to bypass access controls or to collect non-public customer data.

### SEO Keywords

Wayfair scraper, Wayfair product data, Wayfair prices, Wayfair API alternative, furniture price scraper, home goods data, Wayfair SKU data, Wayfair ratings, Wayfair reviews, product price monitoring, furniture market research, ecommerce catalog data, Wayfair dataset, bar stool prices, sofa price tracker, Wayfair product feed, competitor price analysis, home decor data, furniture images, Wayfair search scraper, Wayfair export

# Actor input Schema

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

One or more keywords to search on Wayfair (e.g. "bar stools", "sofa"). Each term is turned into a keyword.php search URL.

## `categoryUrls` (type: `array`):

Wayfair category page URLs (e.g. https://www.wayfair.com/furniture/cat/bar-stools-c46134.html). Category grids are client-rendered, so the actor walks the subcategory and product links present in the served HTML and extracts any embedded product data it finds. For guaranteed product output, prefer productUrls or searchTerms.

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

Direct Wayfair product page URLs (containing /pdp/). Full product data is extracted from the embedded JSON-LD, WEBPACK_ENTRY_DATA and **APOLLO_STATE** blobs in the page HTML.

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

Maximum number of product records to output. Free (non-paying) users are capped at 10 items.

## `proxy` (type: `object`):

Select proxies to be used by your crawler. Using proxies is highly recommended to avoid rate limiting.

## `debug` (type: `boolean`):

Enable debug mode to save failed HTML pages to key-value store for debugging.

## Actor input object example

```json
{
  "searchTerms": [
    "bar stools"
  ],
  "categoryUrls": [
    "https://www.wayfair.com/furniture/cat/bar-stools-c46134.html"
  ],
  "productUrls": [],
  "maxItems": 50,
  "proxy": {
    "useApifyProxy": false
  },
  "debug": false
}
```

# 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": [
        "bar stools"
    ],
    "categoryUrls": [
        "https://www.wayfair.com/furniture/cat/bar-stools-c46134.html"
    ],
    "productUrls": [],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/wayfair-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": ["bar stools"],
    "categoryUrls": ["https://www.wayfair.com/furniture/cat/bar-stools-c46134.html"],
    "productUrls": [],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/wayfair-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": [
    "bar stools"
  ],
  "categoryUrls": [
    "https://www.wayfair.com/furniture/cat/bar-stools-c46134.html"
  ],
  "productUrls": [],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/wayfair-scraper --silent --output-dataset

```

## MCP server setup

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