# Wayfair Scraper (Cheap) (`data_api/wayfair-scraper-cheap`) 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/data\_api/wayfair-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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 Product Scraper

![Wayfair Product Scraper](cover.jpg)

Wayfair carries a huge catalog of furniture and home goods, and the prices keep moving. Checking them by hand does not scale. Give this scraper a search term like "bookshelf" or a category URL, and it walks the results page by page and hands back a clean row for every product: name, current price, list price, discount, brand, star rating, review count, image link, and the product URL. Run one keyword or a dozen at once, cap how many results you want, and pull the data into a sheet or your own pipeline. No browser, no copy-paste.

### What you get

Each product comes back as one tidy row with the same columns every time. Anything Wayfair does not show lands as `null`, so your output stays rectangular when it hits a spreadsheet or database. The fields split into a few groups:

- **Identity** — `itemName`, `brandName`, `sku`, `searchTerm`
- **Pricing** — `currentPrice`, `listPrice`, `discountRate`, `currencyCode`
- **Reputation** — `starRating`, `reviewsTotal`
- **Details** — `variantOptions`, `imageLink`, `productUrl`, `categoryPath`, `descriptionText`
- **Run metadata** — `collectedAt`

`categoryPath` and `descriptionText` fill in only when you switch on **Open each product page**. Everything else comes straight off the listing cards.

### Quick start

1. Open the actor and go to the **Input** tab.
2. Add one or more terms under **Search terms**, such as `bookshelf`, `floor lamp`, or `patio set`.
3. Or drop Wayfair category and search pages into **Source URLs** to scrape them directly.
4. Set **Results limit** — this is the cap per term or URL, not a total for the run.
5. Flip on **Open each product page** only when you need descriptions and breadcrumb categories; it adds a request per product.
6. Hit **Start**, then export as JSON, CSV, Excel, or XML once it finishes.

![How it works](how-it-works.jpg)

Search terms and source URLs all run together, so a longer list does not stretch the run time as much as you would expect.

### Use cases

- **Price tracking** — pull a category today, run it again next week, and watch where prices and discounts move.
- **Competitor research** — see which brands fill a category, where they sit on price, and how their ratings stack up.
- **Catalog building** — gather products across many categories for a comparison site, a price-alert tool, or an internal catalog.
- **Deal hunting** — sort by `discountRate` to surface the steepest markdowns across a whole search.
- **Market analysis** — read average prices, review volumes, and discount depth for any home-goods niche.
- **Content and SEO work** — collect product names and descriptions at scale to study naming patterns and keyword use.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchTerms` | array of strings | One of `searchTerms` or `sourceUrls` | Words or phrases to look up; each runs as its own Wayfair search. |
| `sourceUrls` | array of strings | One of `searchTerms` or `sourceUrls` | Wayfair category or search-result pages to scrape directly. |
| `fetchDetailPages` | boolean | No | Open each product page for its description and breadcrumb category. Slower. Default `false`. |
| `resultsLimit` | integer | No | Products to keep per search term or source URL. Default `40` (max 1000). |
| `timeoutSeconds` | integer | No | Seconds to wait on one request before giving up. Default `75` (max 120). |

#### Example input

```json
{
    "searchTerms": ["bookshelf", "floor lamp"],
    "sourceUrls": [],
    "fetchDetailPages": false,
    "resultsLimit": 40,
    "timeoutSeconds": 75
}
````

### Output

Every product becomes one row, and the columns are the same across the whole dataset. Missing values come back as `null` rather than disappearing, so the shape stays predictable.

#### Example output

```json
{
    "itemName": "Reigen Boucle Platform Bed",
    "brandName": "Joss & Main",
    "sku": "W110085069",
    "currentPrice": "$579.00",
    "listPrice": "$899.00",
    "discountRate": "36%",
    "currencyCode": "USD",
    "starRating": 4.72,
    "reviewsTotal": 813,
    "variantOptions": "3 Colors, 3 Sizes",
    "imageLink": "https://assets.wfcdn.com/im/97255953/resize-h500-w500/3382/338242703/Reigen+Boucle+Platform+Bed.jpg",
    "productUrl": "https://www.wayfair.com/furniture/pdp/joss-main-reigen-boucle-platform-bed-w110085069.html",
    "categoryPath": "Furniture > Bedroom Furniture > Beds",
    "descriptionText": null,
    "searchTerm": "bed",
    "collectedAt": "2026-06-30T10:00:00.000000+00:00"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `itemName` | string | Product title as it reads on the listing card. |
| `brandName` | string | Maker or brand behind the product. |
| `sku` | string | Wayfair stock-keeping code, for example W110085069. |
| `currentPrice` | string | Price you pay now, with its currency symbol. |
| `listPrice` | string | Pre-discount or was-price, when shown. |
| `discountRate` | string | Percentage off the list price, such as 62%. |
| `currencyCode` | string | Three-letter currency code, for example USD. |
| `starRating` | number | Mean customer score on a five-star scale. |
| `reviewsTotal` | integer | How many shoppers reviewed the product. |
| `variantOptions` | string | Color and size choices on offer. |
| `imageLink` | string | URL to the main product photo at 500x500. |
| `productUrl` | string | Link to the product page. |
| `categoryPath` | string | Breadcrumb category trail; filled when detail pages are on. |
| `descriptionText` | string | Short blurb from the product page; filled when detail pages are on. |
| `searchTerm` | string | The search word or URL that surfaced this product. |
| `collectedAt` | string | ISO 8601 timestamp of when the product was captured. |

### Tips for best results

- **Test small first.** Run a single term with `resultsLimit` at 10 to confirm the columns suit your pipeline before scaling up.
- **`resultsLimit` is per source.** Two search terms at a limit of 40 returns up to 80 products, not 40.
- **Leave detail pages off unless you need them.** `categoryPath` and `descriptionText` cost one extra request each, so a run of 50 products can add a few minutes.
- **Raise `timeoutSeconds` for big runs.** Wayfair renders each page fully to clear bot checks, so the odd page is slow; 90 to 120 seconds smooths over those.
- **Category URLs give cleaner breadcrumbs.** Keyword pages sometimes skip the category trail; a category or search URL fills `categoryPath` more reliably.

### How can I use Wayfair product data?

**How can I use the Wayfair Product Scraper to track prices over time?**
Run the same search terms or category URLs on a schedule and keep each export. Compare `currentPrice`, `listPrice`, and `discountRate` between runs to see when items drop, how deep the markdowns go, and which brands discount the most often.

**How can I scrape a whole Wayfair category without writing code?**
Paste the category page into **Source URLs**, set a `resultsLimit`, and start the run. The scraper pages through the listing on its own and returns every product as a row, so you get a full category export in JSON, CSV, or Excel with no scripting.

**How can I compare Wayfair brands and prices for competitor research?**
Feed in several search terms that map to a category and look at `brandName`, `currentPrice`, `starRating`, and `reviewsTotal` side by side. Grouping the rows by brand shows who owns the shelf space, where they price, and how shoppers rate them.

**How can I find the biggest Wayfair discounts in a search?**
Pull a search or category, then sort the export by `discountRate`. Because every row carries both `currentPrice` and `listPrice`, you can rank items by how much is knocked off and surface the deepest deals across the whole result set.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# 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": 20,
  "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"
    ],
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/wayfair-scraper-cheap").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"],
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("data_api/wayfair-scraper-cheap").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"
  ],
  "startUrls": []
}' |
apify call data_api/wayfair-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wayfair Scraper (Cheap)",
        "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": "vzWEv2CAmAD6aPLKJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~wayfair-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-wayfair-scraper-cheap",
                "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/data_api~wayfair-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-wayfair-scraper-cheap",
                "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/data_api~wayfair-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-wayfair-scraper-cheap",
                "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": 20
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
