# Chairish Scraper \[$1/1K💰] | Vintage Furniture | Antique Prices (`ahmed_jasarevic/chairish-scraper`) Actor

Extract product data from Chairish vintage marketplace collections — prices, markdowns, discounts, categories, dimensions, materials, style, brand, condition, images and dealer info via JSON-LD. Built for resale comps, antique price research and furniture market analysis. $1 per 1,000 listings.

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

## Pricing

from $0.90 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Chairish Scraper

Extract product data from **Chairish** — the US marketplace for vintage, antique and used design — across any collections: price, original price, discount %, category taxonomy, dimensions, materials, style, brand, condition, images and dealer info, read from the JSON-LD structured data Chairish embeds in its collection pages.

Built for resale comps, antique price research, furniture market analysis and vintage-inventory databases.

### Build Vintage Furniture Price Databases and Resale Comps

- **Resale & consignment comps** — current asking prices and markdown percentages per category (chairs, sofas, lighting, rugs, art …).
- **Antique & vintage price research** — structured price records with condition, brand and dimensions for valuation work.
- **Dealer / seller intelligence** — seller names and locations per listing for sourcing and competitor monitoring.
- **Trend and assortment analysis** — category taxonomy paths, materials and styles across the marketplace.
- **Catalog enrichment** — JSON-LD `Product` records (plus optional detail-page data) ready for a warehouse or price index.
- **Multi-collection scrapes** — any set of Chairish collection paths in one run.

### How It Works

![How the Chairish Scraper works: collection pages become product rows with resale prices, dimensions, materials, condition and dealer locations.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-chairish-scraper)

Every Chairish collection page embeds a complete schema.org Product object in its initial HTML, so the Actor reads it with plain HTTP and Cheerio. Product detail pages are optional and add the two fields collections omit: original price and design style.

Each row covers one product with current price, discount, category path, dimensions, materials, condition, images, dealer name and location. Caps are enforced per collection before rows are saved.

Chairish embeds a complete `schema.org/Product` JSON-LD object in every collection page, served in the initial plain HTTP response — no browser rendering and no interactive challenge on these pages. A CheerioCrawler:

1. Fetches each collection page (48 products per page, up to 99 pages per collection — Chairish's own pagination ceiling) and parses the embedded JSON-LD.
2. Optionally visits individual product pages (`includeProductPages: true`) for the two fields collection pages do not carry: `originalPrice` and `style`.
3. Enforces `maxItemsPerCollection` before pushing, so a collection never overflows its cap even with concurrent pages.

The `proxy` input is standard Apify configuration. Chairish blocks direct requests from the Apify platform, so the Actor automatically switches to Apify Proxy there; locally, direct HTTP works.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `collections` | array | No | 12 popular collections (chairs, sofas, lighting, tables, beds, dining-chairs, dining-tables, rugs, art, mirrors, decor, vintage-furniture) | Collection paths (`^[a-z0-9\-/]+$` — lowercase, dashes and slashes allowed, e.g. `rugs/persian`). |
| `maxItemsPerCollection` | integer | No | `0` | Products per collection. `0` = unlimited up to Chairish's 99-page cap (~4,700 items). |
| `includeProductPages` | boolean | No | `false` | Fetch product detail pages for `originalPrice`, `discountPercent`, `style` and extra images (slower). Adds a separate **$0.001 per product** charge (`product-detail-page` event). |
| `proxy` | object | **Yes** | `{ "useApifyProxy": true }` | Standard Apify proxy picker. Apify Proxy is recommended and used automatically on the Apify platform. |

### Output Fields

One object per product (20 fields):

| Field | Description |
| --- | --- |
| `productId`, `productUrl` | Chairish product identity and canonical URL |
| `productName` | Full product title |
| `price` | Current price (USD) |
| `originalPrice` | Pre-markdown price (requires `includeProductPages: true`) |
| `discountPercent` | Calculated from current vs original price |
| `currency` | Price currency (usually USD) |
| `category` | Chairish taxonomy path (e.g. `Furniture > Chairs > Arm Chairs`) |
| `dimensions` | `depth` / `height` / `width` in inches (INH) |
| `materials` | e.g. `Oak/Velour` |
| `style` | Design style (requires `includeProductPages: true`) |
| `brand` | Brand / maker when available |
| `condition` | New / Used / Refurbished / Vintage |
| `images` | Array of image objects (`contentUrl`, `thumbnailUrl`, `caption`, `representativeOfPage`) |
| `sellerInfo` | Dealer name and address object |
| `dealerLocation` | Formatted dealer location string |
| `jsonLd` | The complete raw `schema.org Product` object |
| `collection` | Which input collection the row came from |
| `scrapedAt` | Extraction timestamp |

### Example Input

```json
{
  "collections": ["chairs", "sofas", "lighting", "rugs/persian"],
  "maxItemsPerCollection": 100,
  "includeProductPages": false,
  "proxy": { "useApifyProxy": true }
}
```

### Example Output

```json
{
  "productId": "37474231",
  "productName": "Vintage Danish Wingback Lounge Chair in Furniture Velour and Oak, 1960s",
  "price": 932,
  "originalPrice": null,
  "discountPercent": null,
  "currency": "USD",
  "category": "Furniture > Chairs > Arm Chairs, Recliners & Sleeper Chairs",
  "dimensions": { "depth": "29.92 INH", "height": "42.52 INH", "width": "29.53 INH" },
  "materials": "Oak/Velour",
  "style": null,
  "brand": null,
  "condition": "Used/Vintage",
  "images": [
    {
      "contentUrl": "https://chairish-prod.freetls.fastly.net/image/product/master/…",
      "thumbnailUrl": "https://chairish-prod.freetls.fastly.net/image/product/sized/…?width=600&height=600",
      "caption": "Vintage Danish Wingback Lounge Chair…",
      "representativeOfPage": true
    }
  ],
  "sellerInfo": { "name": "Chairish Dealer", "address": { "locality": "", "region": "LFP", "country": "Denmark" } },
  "dealerLocation": "Denmark",
  "productUrl": "https://www.chairish.com/product/37474231/…",
  "jsonLd": { "...": "complete schema.org Product object" },
  "collection": "chairs",
  "scrapedAt": "2026-10-18T10:00:00.000Z"
}
```

### Automate Price Tracking With Schedules & Webhooks

- **Schedule** weekly runs per collection to track markdowns, new arrivals and price history.
- **Webhooks** push completed runs into Google Sheets, Slack, Zapier or Make for alerting workflows (new listing under €X, price drop ≥ Y%).
- **API / MCP** — start runs and pull datasets from any pipeline or AI agent.
- **Cost control** — `$1 per 1,000 listings` stored; turning on `includeProductPages` adds `$1 per 1,000` product detail pages (and is slower), so enable it only when you need `originalPrice` / `style`.

### Related Actors

Verified related actors on Apify that pair well with this one. All links point to real, publicly available actors.

- [Etsy Scraper](https://apify.com/epctex/etsy-scraper)
- [🔥 Etsy Listings Scraper – Live Carts & Ads](https://apify.com/yumitori/etsy-listings-scraper)
- [Advanced 1stdibs Scraper](https://apify.com/saswave/advanced-1stdibs-scraper)
- [1stDibs Scraper - Luxury Furniture & Art Prices](https://apify.com/lulzasaur/1stdibs-scraper)
- [Chairish Scraper](https://apify.com/saswave/chairish-scraper)

### Frequently Asked Questions

#### Does Chairish have an official API?

No official public API is published. Chairish exposes its catalog through the website only — but every collection page embeds complete `schema.org/Product` JSON-LD, which is what this Actor parses. Paid third-party "Chairish APIs" exist (maintained REST wrappers over the same public data, priced in credits); this Actor keeps the pipeline inside Apify with pay-per-event billing and no separate API subscription.

#### How is Chairish different from 1stDibs for vintage price data?

Chairish and 1stDibs are the two largest US online marketplaces for vintage and antique design — Chairish centers on consignment from independent dealers across furniture, art, lighting and decor; 1stDibs focuses on vetted luxury dealers. For cross-market comps, pair this Actor with the 1stDibs scrapers linked in Related Actors and build one combined price index.

#### Why are `originalPrice` and `style` empty?

Collection-page JSON-LD does not carry those two fields. Set `includeProductPages: true` and the Actor fetches each product's detail page, which adds `originalPrice`, `style` and extra images — at the cost of one extra request per product.

#### Can I use this for resale comps and valuation?

Yes — `price`, `discountPercent`, `category`, `dimensions`, `materials`, `condition` and `brand` per listing are the standard fields comp tools ingest. `collection` tells you which category a row came from, and `jsonLd` preserves the full source object for audits.

#### How much does a run cost?

`$1 per 1,000 listings` stored, pay per event — 2,000 products from two collections costs about $2. With `includeProductPages: true`, each product detail page adds another $0.001, so a full 2,000-product details run costs about $4. `maxItemsPerCollection` caps spend per collection; quiet collections (no matches) store nothing and cost nothing beyond the crawl itself.

#### Can an AI agent call this Actor?

Yes — JSON input through the Apify API and MCP server. Note that `proxy` is the one schema-required field; `{ "proxy": { "useApifyProxy": true } }` is a valid minimal call. See [For AI Agents & LLM Apps](#for-ai-agents--llm-apps).

#### Is there a pagination limit?

Yes — Chairish serves at most 99 pages per collection (48 products per page). `maxItemsPerCollection: 0` therefore tops out around ~4,700 products per collection; raise specificity (more collection paths) rather than expecting infinite depth.

### For AI Agents & LLM Apps

Returns Chairish vintage/antique product records (price, discount, taxonomy, dimensions, materials, condition, images, dealer) parsed from collection-page JSON-LD.

Minimal input (required `proxy` field, default collections):

```json
{ "proxy": { "useApifyProxy": true } }
```

Typical input (bounded multi-collection scrape):

```json
{
  "collections": ["chairs", "lighting"],
  "maxItemsPerCollection": 200,
  "includeProductPages": false,
  "proxy": { "useApifyProxy": true }
}
```

Output fields: `productId`, `productName`, `price`, `originalPrice`, `discountPercent`, `currency`, `category`, `dimensions`, `materials`, `style`, `brand`, `condition`, `images`, `sellerInfo`, `dealerLocation`, `productUrl`, `jsonLd`, `collection`, `scrapedAt`.

Behaviors an agent should know:

- `proxy` is required by the input schema; `{ "useApifyProxy": true }` is the working default — the Actor also forces Apify Proxy on the Apify platform because Chairish blocks datacenter direct requests.
- `collections` items must match `^[a-z0-9\-/]+$` (lowercase; nested paths like `rugs/persian` are valid).
- `maxItemsPerCollection: 0` = unlimited up to Chairish's 99-page cap (~4,700 items per collection); the cap is enforced before rows are pushed.
- `includeProductPages: true` is the only way to populate `originalPrice` and `style`; it adds one request per product, slows runs, and charges an extra `$0.001` per product (`product-detail-page` event).
- Some products have incomplete JSON-LD (missing `brand`, `dimensions`) — expect nulls; rows are pushed as-is.
- Billing is per stored row, so empty collections cost nothing in result charges.

Billing: pay per event — `$0.001` per product row stored (`apify-default-dataset-item`).

### Legal & Compliance Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by Chairish, Inc. or chairish.com. It accesses only publicly available collection and product pages — no login, no authenticated areas; the data it returns (product listings, prices, dealer names and locations) is what Chairish already publishes to every visitor. Dealer records are business-facing; where natural persons' data appears (e.g. in descriptions or contact fields), handle it under GDPR/CCPA rules. You are responsible for your own compliance with Chairish's Terms of Service and robots.txt and with applicable data-protection law; do not use personal contact data from the output for unsolicited commercial outreach in violation of applicable law such as CAN-SPAM, GDPR or TCPA.

### SEO Keywords

chairish scraper, chairish api, chairish alternative, vintage furniture data, antique price data, vintage furniture prices, antique furniture prices, furniture price database, chairish listings, chairish price tracker, vintage market data, vintage furniture marketplace, furniture market research, resale comps furniture, 1stdibs data, antique dealer database, vintage decor data, furniture comp pricing

# Actor input Schema

## `collections` (type: `array`):

List of collection paths to scrape (e.g., 'chairs', 'sofas', 'lighting'). Leave empty to scrape default popular collections.

## `maxItemsPerCollection` (type: `integer`):

How many products to scrape from each collection. The crawler automatically calculates how many pages to fetch. When the limit is reached, that collection stops while the remaining collections continue. 0 = unlimited (up to Chairish's maximum of 99 pages per collection).

## `includeProductPages` (type: `boolean`):

Also fetch individual product pages to get originalPrice, discountPercent, style, richer materials and the full image gallery. Slower; each detailed product is charged an extra $0.001 (product-detail-page event) on top of the result price.

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

Select proxies to be used by your crawler. Apify Proxy is recommended - Chairish blocks direct requests from the Apify platform, so the Actor automatically switches to Apify Proxy there.

## Actor input object example

```json
{
  "collections": [
    "chairs",
    "sofas",
    "lighting",
    "tables",
    "beds",
    "dining-chairs",
    "dining-tables",
    "rugs",
    "art",
    "mirrors",
    "decor",
    "vintage-furniture"
  ],
  "maxItemsPerCollection": 10,
  "includeProductPages": false,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset of scraped Chairish products, one row per listing.

# 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 = {
    "collections": [
        "chairs",
        "sofas",
        "lighting",
        "tables",
        "beds",
        "dining-chairs",
        "dining-tables",
        "rugs",
        "art",
        "mirrors",
        "decor",
        "vintage-furniture"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/chairish-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 = {
    "collections": [
        "chairs",
        "sofas",
        "lighting",
        "tables",
        "beds",
        "dining-chairs",
        "dining-tables",
        "rugs",
        "art",
        "mirrors",
        "decor",
        "vintage-furniture",
    ],
    "proxy": { "useApifyProxy": True },
}

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

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

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

```

## CLI example

```bash
echo '{
  "collections": [
    "chairs",
    "sofas",
    "lighting",
    "tables",
    "beds",
    "dining-chairs",
    "dining-tables",
    "rugs",
    "art",
    "mirrors",
    "decor",
    "vintage-furniture"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call ahmed_jasarevic/chairish-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/chairish-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/7EBjraa0diB8wvYNp/builds/x12te0CWtiwdTgTNf/openapi.json