# Wayfair Product and Price Scraper (`automation-lab/wayfair-product-price-scraper`) Actor

Track Wayfair assortment and pricing with product and variant IDs, sale prices, discounts, promotions, ratings, images, and regional listing context.

- **URL**: https://apify.com/automation-lab/wayfair-product-price-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 and Price Scraper

Turn Wayfair search and category pages into structured product and price data.

The Actor extracts visible Wayfair product variants without requiring a Wayfair account.
Use a keyword such as `office chair`, submit an exact category URL, or combine several inputs.
Each dataset row contains stable IDs, prices, discounts, ratings, images, promotions, and source context.

It is designed for scheduled assortment snapshots, competitor price tracking, catalog research, and retail analytics.
The crawler uses lightweight HTTP first and starts a browser only when Wayfair serves a partial listing shell.

### What does the Wayfair Product and Price Scraper do?

The Actor visits anonymous pages on `wayfair.com` and returns one row per selected listing variant.
It supports Wayfair keyword pages, category pages, and browse pages.
It follows server-rendered pagination within the limit you choose.
It deduplicates products across overlapping inputs by product ID and variant ID.

You can use it to:

- 🔎 search Wayfair by one or many product keywords;
- 💵 capture current price, previous price, savings, and discount percentage;
- 🏷️ collect sale and promotion labels;
- ⭐ export ratings and aggregate review counts;
- 🖼️ save product image URLs and Wayfair image IDs;
- 🧩 identify selected variants and choice IDs;
- 📍 preserve the requested ship-to ZIP context;
- 🕒 timestamp every recurring snapshot.

### Who is it for?

**Retailers and furniture brands** can compare their catalog against Wayfair assortment and prices.

**Marketplace resellers** can discover promoted products and monitor price movement before sourcing decisions.

**Competitive-intelligence teams** can schedule daily or weekly category snapshots and compare datasets over time.

**Catalog and data teams** can normalize Wayfair IDs, URLs, images, ratings, and pricing into a warehouse.

**Developers and automation builders** can call the Actor through the API, MCP, webhooks, or integrations.

### Why use this Wayfair scraper?

Manual browsing is useful for one product but inefficient for a category or recurring monitor.
This Actor provides repeatable inputs and export-ready output.

- No Wayfair login is required.
- Keyword and URL workflows use the same output contract.
- Result caps keep smoke tests and scheduled runs bounded.
- HTTP-first extraction reduces browser and proxy usage when possible.
- Partial anti-bot pages fail closed instead of returning misleading empty data.
- Dataset results work with JSON, CSV, Excel, XML, RSS, and API clients.

### What Wayfair data can I extract?

| Field | Type | Description |
| --- | --- | --- |
| `productId` | string | Wayfair display listing ID |
| `variantId` | string | Selected listing variant ID |
| `selectedChoiceIds` | number[] | Variant choice IDs from the listing URL |
| `name` | string | Display product name |
| `url` | string | Canonical visible product URL |
| `imageUrl` | string or null | Lead product image |
| `imageId` | number or null | Wayfair image identifier |
| `currentPrice` | number | Current displayed price |
| `previousPrice` | number or null | Previous or strike-through price |
| `currency` | string | Display currency, normally USD |
| `savingsAmount` | number or null | Previous price minus current price |
| `discountPercent` | number or null | Calculated percentage discount |
| `promotion` | string or null | Sale or promotion label |
| `rating` | number or null | Average product rating |
| `reviewCount` | number or null | Aggregate rating count |
| `marketingCopy` | string or null | Listing marketing description when embedded |
| `inStock` | boolean or null | Positive add-to-cart stock signal when visible |
| `isSponsored` | boolean | Whether Wayfair marks the listing as sponsored |
| `shipToPostalCode` | string or null | ZIP context submitted with the run |
| `sourceUrl` | string | Search/category page that produced the item |
| `searchTerm` | string or null | Keyword input, when applicable |
| `pageNumber` | number | Source pagination number |
| `position` | number | Listing position reported by Wayfair |
| `scrapedAt` | string | ISO extraction timestamp |

### How to scrape Wayfair products

1. Open the Actor input page.
2. Enter one or more values in **Wayfair search terms**.
3. Optionally add exact Wayfair category or browse URLs.
4. Keep `maxItems` small for the first run.
5. Choose how many pages to follow per input.
6. Optionally enter a US ZIP code for regional context.
7. Run the Actor and open the default dataset.
8. Export the records or connect a downstream integration.

### Input

A small keyword run:

```json
{
  "searchTerms": ["office chair"],
  "maxItems": 20,
  "maxPagesPerUrl": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
````

An exact category snapshot:

```json
{
  "startUrls": [
    { "url": "https://www.wayfair.com/furniture/sb0/office-chairs-c478390.html" }
  ],
  "maxItems": 50,
  "maxPagesPerUrl": 2,
  "postalCode": "10001"
}
```

At least one non-empty `searchTerms` or `startUrls` value is required.
Non-Wayfair hosts and product-detail URLs fail validation because this Actor is listing-focused.

### Output example

```json
{
  "productId": "W112194307",
  "variantId": "W112194307_290186980",
  "selectedChoiceIds": [290186980],
  "name": "Murva Ergonomic Office Chair with Footrest",
  "url": "https://www.wayfair.com/furniture/pdp/example-w112194307.html?piid=290186980",
  "imageUrl": "https://assets.wfcdn.com/im/example.jpg",
  "imageId": 447643739,
  "currentPrice": 209.99,
  "previousPrice": 289.99,
  "currency": "USD",
  "savingsAmount": 80,
  "discountPercent": 27.59,
  "promotion": "Pay Over Time Sale",
  "rating": 4.86,
  "reviewCount": 43,
  "shipToPostalCode": "10001",
  "sourceUrl": "https://www.wayfair.com/keyword.php?keyword=office%20chair",
  "searchTerm": "office chair",
  "pageNumber": 1,
  "position": 1,
  "scrapedAt": "2026-07-16T05:49:33.341Z"
}
```

Values reflect what Wayfair displayed at scrape time and may vary by location or session.

### How much does it cost to scrape Wayfair products?

This Actor uses pay-per-event pricing.
A small start event covers run initialization, and an item event is charged for each saved product record.
Plan tiers receive decreasing per-item prices. The one-time start is **$0.005**. Per saved product, current tier prices are **$0.00056189 FREE**, **$0.00048860 BRONZE**, **$0.00038111 SILVER**, **$0.00029316 GOLD**, **$0.00019544 PLATINUM**, and **$0.00013681 DIAMOND**.
The current prices are also shown on the Actor pricing tab before you start a run.

Actual spend depends on the number of saved rows, pages, browser fallback, and residential proxy transfer.
Use `maxItems: 20` and one page for a low-cost first test.
Filtered duplicates are not pushed or charged as result items.

### Pagination and duplicate handling

Wayfair category pages expose numbered page links.
The Actor follows those links until `maxPagesPerUrl`, `maxItems`, or the available pages are exhausted.

Overlapping keywords can surface the same product.
The Actor deduplicates by product ID plus selected variant ID across the entire run.
Different selected variants can remain separate records when their variant IDs differ.

### Regional prices and availability

Wayfair can personalize price, delivery, and availability by location.
Set `postalCode` to pass a US ZIP context and preserve it in every row.
The field is evidence of the requested context, not a guarantee that every upstream promotion is ZIP-specific.

`inStock: true` means an add-to-cart signal was visible.
`inStock: null` means no reliable positive or negative stock signal was available on the listing card.
The Actor does not turn an unknown state into `false`.

### Price monitoring workflow

Create a scheduled Actor task with stable inputs.
Store each run's timestamped dataset or send it to your database.
Join snapshots on `productId` and `variantId`.
Compare `currentPrice`, `previousPrice`, `promotion`, and `inStock` between runs.
Alert only after confirming a material change across the desired ZIP context.

This workflow supports repricing research, sale detection, and assortment change monitoring.

### Assortment and catalog analysis

Use category URLs when you need a repeatable shelf definition.
Use keywords when you need discovery across Wayfair's current search interpretation.

Useful analyses include:

- new and removed listing IDs;
- promoted share of a category;
- average current price by keyword;
- discount distribution;
- rating and review-count coverage;
- repeated product variants across categories;
- image and marketing-copy changes.

### Integrations

Send results to tools available through the Apify platform.

- **Google Sheets:** append a scheduled price snapshot for analysts.
- **Slack:** post a webhook alert when downstream code detects a price drop.
- **Zapier or Make:** trigger catalog enrichment and approval flows.
- **Google Drive or S3:** archive dated exports for historical analysis.
- **Webhooks:** start a comparison job after each successful run.
- **Apify API:** load records directly into a warehouse or application.

Use the stable product and variant IDs as downstream keys.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/wayfair-product-price-scraper').call({
  searchTerms: ['standing desk'],
  maxItems: 25,
  maxPagesPerUrl: 1,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/wayfair-product-price-scraper').call(run_input={
    'searchTerms': ['outdoor dining set'],
    'maxItems': 25,
    'maxPagesPerUrl': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Keep tokens in environment variables or a secrets manager in production.

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~wayfair-product-price-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms":["sectional sofa"],"maxItems":20,"maxPagesPerUrl":1}'
```

Poll the returned run ID, then download its default dataset.

### Use with Apify MCP

Connect AI clients through Apify MCP:

```text
https://mcp.apify.com/?tools=automation-lab/wayfair-product-price-scraper
```

#### Claude Code setup

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/wayfair-product-price-scraper"
```

#### Claude Desktop, Cursor, and VS Code setup

For **Claude Desktop**, **Cursor**, or **VS Code**, add this server to the client's MCP configuration and authenticate with your Apify token:

```json
{
  "mcpServers": {
    "apify-wayfair": {
      "url": "https://mcp.apify.com/?tools=automation-lab/wayfair-product-price-scraper"
    }
  }
}
```

Try specific example prompts:

- “Scrape 20 Wayfair office chairs and rank them by current discount percentage.”
- “Create a Wayfair sectional sofa price snapshot for ZIP 10001, including variant IDs and ratings.”
- “Extract the first Wayfair office-chair category page and return product ID, current price, previous price, and promotion.”
- “Compare these Wayfair variant IDs with yesterday's dataset and flag price changes above 10%.”

Keep result caps small while testing prompts.

### Scheduling recurring snapshots

Save a successful input as an Apify task.
Open **Schedules**, choose the task, and select a daily or weekly cadence.
Use a webhook to notify your pipeline after success.

Do not overwrite historical data if price trends matter.
Archive datasets with the run ID and `scrapedAt` timestamp.
Monitor failure alerts because Wayfair delivery can change.

### Reliability and anti-bot handling

Wayfair sometimes returns HTTP 429 or a shell containing only the first few products.
The Actor detects that partial response rather than silently treating it as a complete page.
It first tries inexpensive anonymous HTTP and then uses a US residential browser fallback.
Blocked exits rotate conservatively with bounded retries.

If every route remains blocked, the run fails non-zero and logs the affected source URL.
A failed run does not overwrite the extraction error during cleanup.

### Limitations

- The Actor currently targets public `wayfair.com` US listing pages.
- It does not scrape product-detail specifications or individual review bodies.
- Product-detail URLs are rejected by design.
- Marketing copy can be null when Wayfair omits it from embedded state.
- Availability can be null when the listing card has no reliable signal.
- Prices, promotions, ranking, and stock can differ by location and time.
- Wayfair can change its HTML, embedded state, rate limits, and pagination.
- Very large runs consume more proxy bandwidth and should be tested gradually.

### Tips for accurate results

- Start with one keyword and one page.
- Use category URLs for repeatable assortment boundaries.
- Keep the same ZIP context across snapshots.
- Compare by product and variant IDs, not name alone.
- Store `sourceUrl`, `pageNumber`, and `position` for ranking analysis.
- Treat null availability as unknown.
- Review a sample of records before automating business decisions.
- Increase limits only after a small run succeeds.

### Legality: is scraping Wayfair legal?

Public web data can generally be collected for legitimate purposes, but rules vary by jurisdiction and use case.
You are responsible for complying with Wayfair's terms, applicable laws, privacy requirements, and contractual obligations.

Avoid collecting personal data that you do not need.
Respect intellectual-property rights and do not republish protected images or copy without permission.
Use reasonable request volumes and secure all exported data.
This documentation is not legal advice.

### Troubleshooting

**The run says a partial listing shell was returned.**
Wayfair served fewer unique products than a normal listing page.
Keep the residential proxy enabled and retry later rather than accepting incomplete output.

**The run fails with HTTP 429.**
Wayfair rate-limited the current route.
Use the default US residential proxy configuration and a small one-page input.

**My URL is rejected.**
Use a Wayfair keyword, category, or browse listing URL.
Product-detail URLs and other hosts are outside this Actor's contract.

**Why is `inStock` null?**
The listing card did not expose a trustworthy stock signal.
Null is intentionally different from out of stock.

### FAQ

**Does the Actor require a Wayfair account?**
No. It targets anonymous public listing pages.

**Can I provide multiple keywords?**
Yes. Results deduplicate across all keywords and URLs in the run.

**Can it monitor previous prices?**
It captures Wayfair's displayed previous price and calculated discount.
For historical trends, schedule runs and compare stored datasets.

**Does it scrape reviews?**
It returns aggregate rating and review count, not individual review text.

**Can I scrape Wayfair Canada or the UK?**
Not in this release. The validated scope is `wayfair.com` US.

**Why use a browser fallback?**
Wayfair sometimes sends a partial server response to HTTP clients.
The browser allows the listing grid to hydrate before extraction.

### Related scrapers

Combine this Actor with related Automation Lab catalog tools:

- [Amazon Scraper](https://apify.com/automation-lab/amazon-scraper) for Amazon search-result comparisons.
- [eBay Scraper](https://apify.com/automation-lab/ebay-scraper) for marketplace listing and price research.
- [Etsy Scraper](https://apify.com/automation-lab/etsy-scraper) for handmade and specialty catalog monitoring.

Use source-specific IDs separately, then normalize titles, prices, currency, and snapshot timestamps in your warehouse.

### Support

If a run fails, open the run log and note the input, failing URL, build number, and timestamp.
Share a run with the developer through Apify's support flow when possible.
Do not post API tokens, proxy credentials, or private downstream data.

For reproducible reports, include a small input that demonstrates the issue.
The Actor deliberately logs route failures without logging proxy credentials.

### Start scraping Wayfair

Run a small `office chair` search, inspect the dataset, and save the input as a task.
Once the fields match your workflow, schedule recurring snapshots or connect the Actor through API, MCP, or webhooks.

# Actor input Schema

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

Keywords to search on Wayfair, such as office chair or sectional sofa.

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

Wayfair keyword, category, or browse URLs. Product detail URLs are intentionally rejected.

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

Stop after saving this many unique Wayfair product variants across all inputs.

## `maxPagesPerUrl` (type: `integer`):

Follow Wayfair pagination up to this many pages for each keyword or URL.

## `postalCode` (type: `string`):

Optional US ZIP code sent as Wayfair postal-code context and preserved in every output record.

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

US residential proxy rotation is enabled because Wayfair consistently rate-limits datacenter exits; customize or disable it if your connection already works.

## Actor input object example

```json
{
  "searchTerms": [
    "office chair"
  ],
  "maxItems": 20,
  "maxPagesPerUrl": 1,
  "postalCode": "10001",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `overview` (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": [
        "office chair"
    ],
    "maxItems": 20,
    "maxPagesPerUrl": 1,
    "postalCode": "10001",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/wayfair-product-price-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": ["office chair"],
    "maxItems": 20,
    "maxPagesPerUrl": 1,
    "postalCode": "10001",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/wayfair-product-price-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 '{
  "searchTerms": [
    "office chair"
  ],
  "maxItems": 20,
  "maxPagesPerUrl": 1,
  "postalCode": "10001",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call automation-lab/wayfair-product-price-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wayfair Product and Price Scraper",
        "description": "Track Wayfair assortment and pricing with product and variant IDs, sale prices, discounts, promotions, ratings, images, and regional listing context.",
        "version": "0.1",
        "x-build-id": "FaJPc1SXC3BSQpZJI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~wayfair-product-price-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-wayfair-product-price-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/automation-lab~wayfair-product-price-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-wayfair-product-price-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/automation-lab~wayfair-product-price-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-wayfair-product-price-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": {
                    "searchTerms": {
                        "title": "Wayfair search terms",
                        "type": "array",
                        "description": "Keywords to search on Wayfair, such as office chair or sectional sofa.",
                        "default": [
                            "office chair"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Wayfair category or listing URLs",
                        "type": "array",
                        "description": "Wayfair keyword, category, or browse URLs. Product detail URLs are intentionally rejected.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum product variants",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique Wayfair product variants across all inputs.",
                        "default": 20
                    },
                    "maxPagesPerUrl": {
                        "title": "Maximum pages per input",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Follow Wayfair pagination up to this many pages for each keyword or URL.",
                        "default": 1
                    },
                    "postalCode": {
                        "title": "Ship-to US ZIP code",
                        "pattern": "^\\d{5}(?:-\\d{4})?$",
                        "type": "string",
                        "description": "Optional US ZIP code sent as Wayfair postal-code context and preserved in every output record."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "US residential proxy rotation is enabled because Wayfair consistently rate-limits datacenter exits; customize or disable it if your connection already works.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
