# Wayfair Scraper (`kawsar/wayfair-scraper`) Actor

Wayfair product scraper that collects prices, ratings, brands, and images by keyword or category URL, so you can track deals and monitor competitors without writing a line of code.

- **URL**: https://apify.com/kawsar/wayfair-scraper.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Wayfair Scraper

Wayfair Scraper collects product listings from Wayfair by keyword or category URL. Give it search terms like "bed" or "sofa", set a product limit, and it pages through results automatically, pulling structured data for every product it finds.

Good for price tracking, competitor research, market analysis, and building product databases. No code needed.

---

### What you get

Each product record contains these fields:

| Field | Description | Example |
|---|---|---|
| `productName` | Full product listing name | `Reigen Boucle Platform Bed` |
| `brand` | Manufacturer or brand name | `Joss & Main` |
| `sku` | Wayfair product SKU | `W110085069` |
| `price` | Current sale price | `$579.00` |
| `originalPrice` | Was-price before discount | `$899.00` |
| `discount` | Percentage off original price | `36%` |
| `currency` | Currency code | `USD` |
| `rating` | Average star rating out of 5 | `4.72` |
| `reviewCount` | Total customer reviews | `813` |
| `options` | Available colors and sizes | `3 Colors, 3 Sizes` |
| `imageUrl` | Main product image (500×500 px) | `https://assets.wfcdn.com/...` |
| `url` | Full product page URL | `https://www.wayfair.com/furniture/pdp/...` |
| `category` | Breadcrumb category path from the listing page | `Furniture > Bedroom Furniture > Beds` |
| `productDescription` | Short description from the product page | `You'll love the...` |
| `keyword` | Search term or URL that returned this product | `bed` |
| `scrapedAt` | ISO 8601 timestamp of when the product was collected | `2026-05-03T10:00:00+00:00` |

`productDescription` is only populated when **Scrape product detail pages** is enabled. All other fields are collected from the listing page itself.

---

### How to use

1. Open the actor and click **Input**.
2. Enter one or more search terms in **Keywords** (e.g. `bed`, `dining table`, `office chair`).
3. Optionally paste Wayfair category or search result URLs into **Start URLs**.
4. Set **Max items** — this is the limit per keyword or URL, not a global cap.
5. Enable **Scrape product detail pages** only if you need descriptions. It adds one extra request per product and slows things down.
6. Click **Start**.

All keywords and start URLs run in parallel, so adding more keywords does not increase total run time proportionally.

---

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `keywords` | list of strings | — | Search terms. Each runs as a separate Wayfair keyword search. |
| `startUrls` | list of URLs | — | Direct Wayfair category or search result URLs to scrape. |
| `scrapeProductDetails` | boolean | `false` | Visit each product page for description. Slower. |
| `maxItems` | integer | `50` | Max products per keyword or start URL (max 1000). |
| `requestTimeoutSecs` | integer | `60` | Per-request timeout in seconds (max 120). |

---

### Example input

Scrape up to 100 beds and up to 100 sofas at the same time:

```json
{
  "keywords": ["bed", "sofa"],
  "maxItems": 100,
  "scrapeProductDetails": false
}
````

Scrape a specific category page:

```json
{
  "startUrls": [
    "https://www.wayfair.com/furniture/sb0/beds-c1880099.html"
  ],
  "maxItems": 200
}
```

***

### Example output

```json
{
  "productName": "Reigen Boucle Platform Bed",
  "brand": "Joss & Main",
  "sku": "W110085069",
  "price": "$579.00",
  "originalPrice": "$899.00",
  "discount": "36%",
  "currency": "USD",
  "rating": 4.72,
  "reviewCount": 813,
  "options": "3 Colors, 3 Sizes",
  "imageUrl": "https://assets.wfcdn.com/im/97255953/resize-h500-w500%5Ecompr-r85/3382/338242703/Reigen+Boucle+Platform+Bed.jpg",
  "url": "https://www.wayfair.com/furniture/pdp/joss-main-reigen-boucle-platform-bed-w110085069.html",
  "category": "Furniture > Bedroom Furniture > Beds",
  "productDescription": null,
  "keyword": "bed",
  "scrapedAt": "2026-05-03T10:00:00.000000+00:00"
}
```

***

### Use cases

**Price monitoring** — Collect prices for a category today, run again next week, compare. Track sale cycles and spot when items go on discount.

**Competitor research** — See which brands dominate a category, how they position on price, and what rating distribution looks like across a product line.

**SEO and content research** — Pull product names and descriptions at scale to understand keyword patterns, naming conventions, and how brands write listings.

**Building product databases** — Aggregate product data across multiple categories for a comparison site, price alert tool, or internal catalogue.

**Market analysis** — Understand average price points, review counts, and discount depth for any furniture or home goods category.

***

### Performance

- Wayfair shows roughly 24-48 products per listing page. Pagination is handled automatically.
- All keywords and start URLs run in parallel. Two keywords do not take twice as long.
- Each page request takes 30-60 seconds because the actor uses full browser rendering to bypass Wayfair's bot detection. This is expected.
- Enabling **Scrape product detail pages** adds one request per product. For 50 products, expect roughly 5 additional minutes. Use it only when you need descriptions.
- For large runs (500+ products), set **Request timeout** to 90-120 seconds to handle occasional slow responses.

***

### Supported URL types

The actor works with any Wayfair listing page:

- Keyword search: `https://www.wayfair.com/keyword.php?keyword=desk`
- Category browse: `https://www.wayfair.com/furniture/sb0/beds-c1880099.html`
- Sale pages: `https://www.wayfair.com/daily-sales/...`
- Brand pages: `https://www.wayfair.com/brand/bnd/...`

It does not scrape individual product pages as a starting point. Use keywords or category URLs.

***

### Output and export

Results appear in the **Dataset** tab as the run progresses. Export as:

- **JSON** — one object per line, good for pipelines and APIs
- **CSV** — opens directly in Excel or Google Sheets
- **Excel** — formatted spreadsheet, ready to share
- **JSONL** — streaming-friendly line-delimited JSON

***

### FAQ

**Why does a run return fewer products than my maxItems limit?**
Wayfair may show fewer results than expected for some keywords, especially niche ones. The actor stops when there are no more pages, not when a timeout is reached.

**Why is each page slow?**
Wayfair uses bot detection that blocks plain HTTP requests. The actor renders each page in a full browser environment to get real results, which takes 30-60 seconds per page. This is the same time a browser takes.

**Can I scrape multiple keywords at once?**
Yes. All keywords in the list run in parallel. Add as many as you need.

**Does `maxItems` apply to the total run or per keyword?**
Per keyword and per start URL. If you set `maxItems: 50` with two keywords, you get up to 100 products total.

**Is `category` always filled in?**
For category browse URLs, yes. For keyword searches, it depends on whether Wayfair shows breadcrumbs on that page. Enable **Scrape product detail pages** for guaranteed category data on every product.

**What does `options` mean?**
The available color and size variants for a product, as shown on the listing card. Example: `3 Colors, 2 Sizes`. Individual variant details require visiting the product page.

# Actor input Schema

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

List of search terms to scrape from Wayfair (e.g. "bed", "sofa", "dining table").

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

Optional list of Wayfair category or search result URLs to scrape directly.

## `scrapeProductDetails` (type: `boolean`):

If enabled, the actor visits each product page to collect the description and breadcrumb category. Slower but more complete.

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

Maximum number of products to collect per keyword or start URL.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "keywords": [
    "bed",
    "sofa",
    "desk chair"
  ],
  "startUrls": [
    "https://www.wayfair.com/furniture/sb0/beds-c1880099.html",
    "https://www.wayfair.com/keyword.php?keyword=desk"
  ],
  "scrapeProductDetails": false,
  "maxItems": 50,
  "requestTimeoutSecs": 60
}
```

# 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 = {
    "keywords": [
        "bed",
        "sofa"
    ],
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/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 = {
    "keywords": [
        "bed",
        "sofa",
    ],
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("kawsar/wayfair-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "bed",
    "sofa"
  ],
  "startUrls": []
}' |
apify call kawsar/wayfair-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=kawsar/wayfair-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wayfair Scraper",
        "description": "Wayfair product scraper that collects prices, ratings, brands, and images by keyword or category URL, so you can track deals and monitor competitors without writing a line of code.",
        "version": "0.0",
        "x-build-id": "IOWPE6a4wn8dVNrSc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~wayfair-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-wayfair-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/kawsar~wayfair-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-wayfair-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/kawsar~wayfair-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-wayfair-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "List of search terms to scrape from Wayfair (e.g. \"bed\", \"sofa\", \"dining table\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional list of Wayfair category or search result URLs to scrape directly.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeProductDetails": {
                        "title": "Scrape product detail pages",
                        "type": "boolean",
                        "description": "If enabled, the actor visits each product page to collect the description and breadcrumb category. Slower but more complete.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of products to collect per keyword or start URL.",
                        "default": 50
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 60
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
