# Chairish Marketplace Scraper (`automation-lab/chairish-marketplace-scraper`) Actor

Scrape public Chairish furniture, decor, art, and vintage listings with prices, dimensions, seller locations, materials, availability, and images.

- **URL**: https://apify.com/automation-lab/chairish-marketplace-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 80.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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Chairish Marketplace Scraper

Extract public Chairish furniture, decor, art, and vintage marketplace listings into a clean dataset for sourcing, appraisal comps, inventory monitoring, and market intelligence.

The Actor accepts real Chairish category, search, and product URLs. It follows public pagination, deduplicates listings by product ID, and returns prices, availability, seller location, materials, dimensions, images, and descriptions. Optional product-page enrichment adds fields such as the public seller name.

### What does Chairish Marketplace Scraper do?

Chairish Marketplace Scraper turns server-rendered Chairish pages into one normalized record per listing.

It can:

- scrape public `chairish.com/collection/...` category pages;
- scrape public Chairish search URLs that contain a `q` parameter;
- extract a single public Chairish product page;
- follow category and search pagination;
- stop exactly at your requested listing limit;
- deduplicate the same product across multiple inputs;
- optionally open product pages for additional structured fields;
- export results through Apify datasets, API, webhooks, schedules, Make, or Zapier.

The Actor uses structured Product data exposed in the public HTML. It does not require login credentials and does not attempt to collect private contact details.

### Who is it for?

**Vintage furniture dealers** can refresh active inventory and compare asking prices across categories.

**Furniture resellers** can discover comparable pieces, materials, dimensions, and seller locations before sourcing stock.

**Interior-design sourcing teams** can build project shortlists from public Chairish search or category pages.

**Appraisers and researchers** can collect repeatable snapshots of active asking prices and availability.

**Marketplace intelligence teams** can monitor listing mix, pricing, materials, colors, and geographic supply over time.

### Why use this Actor?

- **HTTP-first extraction:** no browser is required for the supported public pages, which keeps runs faster and less expensive. If Chairish explicitly blocks a direct category, search, or supplied product request, the Actor retries that page through a bounded US residential session.
- **Stable IDs:** every row includes the numeric Chairish product ID and canonical URL.
- **Typed dimensions:** width, height, and depth preserve both numeric values and Chairish unit codes.
- **Bounded enrichment:** choose whether the Actor should open each product detail page.
- **Honest failure behavior:** invalid URLs, blocked category/product pages, and unavailable structured data fail clearly instead of reporting a misleading successful empty run.
- **Integration-ready output:** each dataset row has a consistent shape regardless of whether it came from a category, search, or product URL.

### What data can you extract from Chairish?

| Field | Description |
| --- | --- |
| `productId` | Stable numeric Chairish product identifier |
| `url` | Canonical public product URL |
| `title` | Public listing title |
| `description` | Public listing description, or `null` |
| `category` | Chairish category breadcrumb |
| `price` | Numeric asking price, excluding shipping and tax |
| `currency` | Currency code such as `USD` |
| `availability` | Structured availability such as `InStock` |
| `condition` | Structured condition such as `UsedCondition` |
| `priceValidUntil` | Structured price-valid date |
| `sellerName` | Public seller name when exposed; commonly requires detail enrichment |
| `sellerLocality` | Public seller city or locality |
| `sellerRegion` | Region value exposed by Chairish |
| `sellerCountry` | Public seller country |
| `color` | Primary product color |
| `material` | Primary product material |
| `width`, `height`, `depth` | Numeric value and source unit code |
| `images` | Full image URL, thumbnail URL, and caption |
| `sourceUrl` | Page from which the row was extracted |
| `scrapedAt` | ISO 8601 extraction timestamp |

Fields that Chairish does not publish for a listing are returned as `null` or an empty array. The Actor does not infer missing values.

### How to scrape Chairish listings

1. Open the Actor input form.
2. Add at least one public Chairish category, search, or product URL.
3. Set `maxItems` to the maximum number of unique listings you need.
4. Keep `enrichDetails` off for fast catalog extraction, or enable it when seller-name/detail freshness matters.
5. Start the run.
6. Open the **Chairish listings** dataset view.
7. Export the records as JSON, CSV, Excel, XML, or RSS, or consume them through the API.

A low-cost first run can use:

```json
{
  "startUrls": [
    { "url": "https://www.chairish.com/collection/furniture" }
  ],
  "maxItems": 10,
  "maxPages": 2,
  "enrichDetails": false
}
```

### Input parameters

#### `startUrls`

Required array of public `https://www.chairish.com` URLs. Supported routes are:

- category pages such as `https://www.chairish.com/collection/furniture`;
- search pages such as `https://www.chairish.com/search?q=mid-century%20chair`;
- product pages such as `https://www.chairish.com/product/36646520/...`.

Search URLs must include a non-empty `q` parameter. Other domains and Chairish account/private routes are rejected.

#### `maxItems`

Maximum number of unique listing rows saved across all inputs. Default: `100`. Range: `1–10,000`.

The Actor stops adding records as soon as this limit is reached.

#### `maxPages`

Maximum total number of pages fetched. Default: `250`. Range: `1–500`.

A run may finish earlier when `maxItems` is reached or Chairish exposes no next page.

#### `enrichDetails`

When `false` (default), category and search JSON-LD supplies the normalized listing fields with minimal requests.

When `true`, each discovered product page is opened before its row is saved. This commonly adds the public seller name and refreshes product-level structured data, but it increases runtime and upstream requests. Detail enrichment stays direct HTTP; if an individual detail request is blocked, the complete list-page row is still saved instead of spending residential bandwidth per item.

### Chairish scraper output example

A current public Chairish furniture listing produces a row like this:

```json
{
  "productId": "36646520",
  "url": "https://www.chairish.com/product/36646520/antique-scandinavian-hand-painted-folk-art-chest-of-drawers-with-coastal-landscape-decoration",
  "title": "Antique Scandinavian Hand-Painted Folk Art Chest of Drawers With Coastal Landscape Decoration",
  "description": "A wonderfully whimsical antique hand-painted chest of drawers...",
  "category": "Furniture > Cabinets & Storage > Dressers",
  "price": 4900,
  "currency": "USD",
  "availability": "InStock",
  "condition": "UsedCondition",
  "priceValidUntil": "2026-08-03",
  "sellerName": "Coleville Home",
  "sellerLocality": "New York",
  "sellerRegion": "LFP",
  "sellerCountry": "US",
  "color": "Yellow",
  "material": "Oak",
  "width": { "value": 40, "unitCode": "INH" },
  "height": { "value": 34, "unitCode": "INH" },
  "depth": { "value": 24, "unitCode": "INH" },
  "images": [
    {
      "url": "https://chairish-prod.freetls.fastly.net/image/product/master/...",
      "thumbnailUrl": "https://chairish-prod.freetls.fastly.net/image/product/sized/...",
      "caption": "Antique Scandinavian Hand-Painted Folk Art Chest of Drawers..."
    }
  ],
  "sourceUrl": "https://www.chairish.com/collection/furniture",
  "scrapedAt": "2026-07-27T02:17:26.379Z"
}
```

Values change as sellers update listings. Treat the dataset as a snapshot captured at `scrapedAt`.

### How much does it cost to scrape Chairish marketplace listings?

The Actor uses pay-per-event pricing: one **Run started** event per run plus one **Item extracted** event for each saved listing. Failed, rejected, duplicate, and empty records do not generate item events.

| Event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Run started (once per run) | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 |
| Saved listing | $0.000041071 | $0.000035714 | $0.000027857 | $0.000021429 | $0.000014286 | $0.000010000 |

At the FREE item tier, example Actor charges are approximately:

- 10 saved listings: **$0.005411** including the start event;
- 100 saved listings: **$0.009107** including the start event;
- 1,000 saved listings: **$0.046071** including the start event.

Your account tier determines the per-listing price. Platform usage treatment is shown by Apify before you start a run. Detail enrichment and an automatically triggered residential session do not create a second record charge, but they can take longer because the Actor visits more pages or uses a protected route.

### Reliable monitoring and sourcing workflows

#### Daily inventory watch

Schedule a category or search input daily, export each dataset, and compare rows by `productId`. Use `availability`, `price`, and `scrapedAt` to detect changes.

#### Dealer price comps

Run narrow category or search URLs with detail enrichment enabled. Group records by category, material, dimensions, seller locality, or price range in your analysis system.

#### Interior-design shortlist

Use a project-specific Chairish search URL, retain canonical URLs and images, then send new matches to Airtable, Google Sheets, Notion, or a webhook.

#### Appraisal research

Collect active asking-price snapshots for comparable public listings. Asking prices are not sold prices or appraisals, so combine them with qualified professional judgment and other evidence.

### Tips for accurate results

- Prefer a narrow Chairish search or category URL when you need a focused dataset.
- Keep `enrichDetails` off for broad inventory scans when list-page fields are sufficient.
- Enable enrichment when public seller names or freshest product-page values matter.
- Use `productId` rather than title as the deduplication key in downstream systems.
- Keep `scrapedAt` so repeated snapshots can be compared safely.
- Increase `maxPages` when your requested item count spans many result pages.
- Schedule moderate recurring runs instead of sending many overlapping runs at once.

### Limits and failure behavior

- Only public Chairish category, search, and product URLs are supported.
- The Actor does not log in, bypass CAPTCHA, or retrieve private seller contact data.
- Chairish can change its HTML, structured data, pagination, inventory, or access controls without notice.
- A genuinely empty search succeeds with zero rows.
- A category or product page that unexpectedly exposes no Product data fails with a clear message.
- Temporary timeouts, HTTP 429, and selected 5xx responses are retried with bounded backoff.
- An explicit HTTP 403, 418, 429, or challenge on a category, search, or supplied product page triggers a bounded US residential-session retry for that page; the Actor does not use a browser.
- Detail-enrichment requests do not trigger per-item residential fallback. If one is blocked, the complete list-page row is saved and the run log identifies the skipped enrichment.
- Permanent access errors and unsupported inputs are not retried blindly.
- Prices are active asking prices, not transaction history, shipping-inclusive totals, or appraisals.
- Seller region values are preserved from Chairish and may use marketplace-specific codes.

### Use the Chairish scraper with the Apify API

Replace `<APIFY_TOKEN>` with your token. The Actor remains private until its first Store publication.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~chairish-marketplace-scraper/runs?token=<APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://www.chairish.com/search?q=mid-century%20chair"}],
    "maxItems": 50,
    "maxPages": 3,
    "enrichDetails": false
  }'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const actor = client.actor('automation-lab/chairish-marketplace-scraper');
const run = await actor.call({
  startUrls: [{ url: 'https://www.chairish.com/collection/furniture' }],
  maxItems: 100,
  maxPages: 5,
  enrichDetails: false,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/chairish-marketplace-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.chairish.com/collection/furniture'}],
    'maxItems': 100,
    'maxPages': 5,
    'enrichDetails': False,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use Chairish Marketplace Scraper with MCP

Apify MCP lets supported AI clients run this Actor and inspect its datasets.

#### Claude Code

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/chairish-marketplace-scraper"
```

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

Add this MCP JSON block to the client’s MCP configuration:

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

Example prompts:

- “Run Chairish Marketplace Scraper on the furniture collection and return 20 listings with prices and dimensions.”
- “Extract 50 results from this Chairish mid-century chair search and group them by seller locality.”
- “Run detail enrichment for this Chairish product URL and summarize material, size, price, seller, and availability.”

### Integrations

Use Apify schedules for recurring inventory snapshots. Connect successful runs to webhooks, Make, Zapier, Google Sheets, Airtable, cloud storage, or your own data warehouse.

For incremental monitoring, store the last seen `productId`, `price`, `availability`, and `scrapedAt` in your destination. This Actor returns current snapshots; it does not maintain a hidden cross-run history table.

### Is it legal to scrape Chairish?

This Actor extracts data that Chairish exposes on public pages. Public availability does not remove your obligations.

- Review Chairish terms and applicable law for your use case.
- Collect only the data you need.
- Do not use the Actor to harass sellers, circumvent access controls, or build prohibited profiles.
- Respect intellectual-property rights in descriptions and images.
- Apply suitable retention, security, and deletion policies.
- Obtain professional legal advice for regulated or high-risk uses.

You are responsible for the inputs you provide and how you use exported data.

### Troubleshooting

#### Why did my search return zero rows?

Open the exact URL in a normal browser and confirm it currently has public results. A valid Chairish search with no matching products is treated as a successful empty result. Check that the URL contains a non-empty `q` parameter.

#### Why did a category or product run fail?

Inspect the run log for the URL and HTTP status. Chairish may have removed the listing, changed the route, or returned an access challenge. Retry later with a small input rather than repeatedly launching overlapping large runs.

#### Why is `sellerName` null?

Category and search structured data often exposes location but not the seller name. Set `enrichDetails` to `true` so the Actor visits the public product page.

#### Why did I receive fewer rows than `maxItems`?

`maxItems` is a ceiling, not a guaranteed count. The source may have fewer products, deduplication may remove repeats, or `maxPages` may be reached first.

### Related Automation Lab actors

- [1stDibs Listings Scraper](https://apify.com/automation-lab/1stdibs-listings-scraper) for another luxury furniture, art, jewelry, and decor marketplace.
- [eBay Scraper](https://apify.com/automation-lab/ebay-scraper) for broad marketplace listings.
- [eBay Sold Listings Scraper](https://apify.com/automation-lab/ebay-sold-scraper) for completed-sales research.
- [Vinted Scraper](https://apify.com/automation-lab/vinted-scraper) for secondhand marketplace listings.
- [Carousell Listings Scraper](https://apify.com/automation-lab/carousell-listings-scraper) for Carousell inventory and marketplace research.

Choose Chairish Marketplace Scraper when your source must specifically be the public Chairish catalog and product pages.

### FAQ

#### Does this Actor require a Chairish account?

No. The supported v1 routes use public Chairish pages and do not accept login credentials.

#### Does it scrape seller email addresses or phone numbers?

No. It does not promise or attempt to retrieve private seller contact data.

#### Can it scrape one product URL?

Yes. Add the public `/product/<numeric-id>/...` URL to `startUrls`.

#### Can it scrape multiple categories in one run?

Yes. Add multiple category or search URLs. The global `maxItems` and `maxPages` limits apply across the run, and duplicate product IDs are saved only once.

#### Does it download product images?

No. It extracts public image and thumbnail URLs without downloading image binaries into the dataset.

#### Does it include sold prices?

No. Output reflects public current listing data and availability. It does not claim sold-listing history.

#### Can I schedule it?

Yes. Save the input as an Apify task and attach a schedule. Use webhooks or integrations to deliver each completed dataset to your monitoring system.

# Actor input Schema

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

One or more public https://www.chairish.com category, search, or product URLs. Search URLs must include the q parameter.

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

Maximum number of unique Chairish listing records to save across all start URLs.

## `maxPages` (type: `integer`):

Maximum total number of category, search, and product pages to fetch. Pagination stops sooner when maxItems is reached or Chairish has no next page.

## `enrichDetails` (type: `boolean`):

Open each product page over direct HTTP to refresh structured data and add fields such as seller name. If a detail request is blocked, the complete list-page row is still saved.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.chairish.com/collection/furniture"
    }
  ],
  "maxItems": 10,
  "maxPages": 5,
  "enrichDetails": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the normalized Chairish listing records in the overview dataset view.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.chairish.com/collection/furniture"
        }
    ],
    "maxItems": 10,
    "maxPages": 5,
    "enrichDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/chairish-marketplace-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 = {
    "startUrls": [{ "url": "https://www.chairish.com/collection/furniture" }],
    "maxItems": 10,
    "maxPages": 5,
    "enrichDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/chairish-marketplace-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 '{
  "startUrls": [
    {
      "url": "https://www.chairish.com/collection/furniture"
    }
  ],
  "maxItems": 10,
  "maxPages": 5,
  "enrichDetails": false
}' |
apify call automation-lab/chairish-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/xwnyl8kiHEfs2G3BU/builds/zIpViKhGkLqrrgoei/openapi.json