Chairish Scraper: 21 Data Fields, Up to 1,000 Free Results/Month

Each record carries 21 output fields, including title, brand, price, seller info, photos, dimensions, materials, and design style. Scrape vintage home decor, furniture, art, rugs, and lighting from Chairish by keyword, category, style, condition, or product slug. On Apify's free plan, results cost $5.00 per 1,000 results, with $5.00 of monthly usage included to cover up to 1,000 items before run-start and platform charges. Residential proxies are required for cloud runs. Built for interior designers, antique resellers, and market analysts; not for anyone who needs seller phone numbers or email addresses, which Chairish product pages do not contain.

Try it: open Chairish Scraper on Apify, sign in on the free plan and run the prefilled example.

Can you try Chairish Scraper before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of Chairish Scraper a month, before run-start charges and platform usage.

The example request further down caps maxItems at 10, so a first run returns at most 10 results and costs at most $0.05 in result charges. That is enough to see the real shape of the data before deciding anything.

Chairish Scraper was last updated on 2026-07-13. It is one of 1,725 Actors CrawlerBros publishes on Apify, which together have 692,561 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run Chairish Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

The maxItems control has the largest impact on your result charges because billing scales per item written to the dataset. Capping maxItems at 10 on initial tests keeps result charges to $0.05 while you verify output fields. Filtering by category, style, or price narrows your output without changing the unit cost per item.

How do you run Chairish Scraper from the API?

The schema marks 1 of its 10 controls as required: mode. The payload below uses the schema's own prefilled values, so it runs as written once you substitute your API token.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~chairish-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"searchProducts","query":"mid century chair","category":"","style":"","condition":"","maxItems":10,"proxyConfiguration":{"useApifyProxy":true,"apifyProxyGroups":["RESIDENTIAL"]}}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "searchProducts",
  "query": "mid century chair",
  "category": "",
  "style": "",
  "condition": "",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": True,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}

run = client.actor("crawlerbros~chairish-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "searchProducts",
  "query": "mid century chair",
  "category": "",
  "style": "",
  "condition": "",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}

const run = await client.actor('crawlerbros~chairish-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

The synchronous endpoint holds the connection open until the run finishes, which is convenient for small batches and wrong for large ones. For anything long running, start the run asynchronously and poll, or attach a webhook, so a dropped connection does not cost you the results.

Which Chairish Scraper inputs matter, and which can you skip?

The required mode field toggles between searching catalog listings with searchProducts and fetching specific items with getBySlug. When using searchProducts, set query, category, or style to define your product set. Keep minPrice, maxPrice, and condition empty on early passes to avoid over-filtering.

• mode (string): Operation mode: search for products or fetch specific products by slug. Default: "searchProducts".
• query (string): Keyword search query (mode=searchProducts). E.g. 'mid century chair', 'art deco lamp'.
• category (string): Browse by Chairish category (mode=searchProducts). Default: "".
• style (string): Filter by design style. Default: "".
• condition (string): Filter by item condition. Default: "".
• minPrice (integer): Only include items priced at or above this value.
• maxPrice (integer): Only include items priced at or below this value.
• slugs (array): List of Chairish product slugs or full URLs. E.g. '191661/antique-colonial-williamsburg-style-candle-chandelier' or 'https://www.chairish.com/product/191661/...'.
• maxItems (integer): Maximum number of items to return. Default: 10.
• proxyConfiguration (object): Proxy settings. Chairish blocks Apify datacenter IP ranges - a residential proxy is required for cloud runs. The default uses Apify's residential proxy group. Default: {"useApifyProxy":true,"apifyProxyGroups":["RESIDENTIAL"]}.

Fixed-choice controls: mode accepts searchProducts (keyword, category, style, price), getBySlug (Get products by slug/URL); category accepts 12 values (default ""), including "" (All categories), furniture, lighting, rugs; style accepts 16 values (default ""), including "" (Any style), mid-century-modern (Mid-Century Modern), art-deco (Art Deco), industrial; condition accepts "" (Any condition), New/Never Used, Like New, Excellent, Very Good, Good, Fair.

What does Chairish Scraper return?

Returned records provide structured product attributes suited for inventory tracking, competitive price monitoring, and vintage catalog ingestion. Items include pricing, seller names, seller URLs, dimensions, and materials, but omit direct dealer email addresses and phone numbers.

• id (e.g. 484040)
• slug (e.g. 484040/1980s-jean-negulusco-abstract-work-on-...)
• title (e.g. 1980s Jean Negulusco Abstract Work on Paper, ...)
• description (e.g. Striking graphic original work by Jean Negule...)
• brand (e.g. Jean Negulesco)
• condition (e.g. Good)
• price (e.g. 1450)
• currency (e.g. USD)
• isAvailable (e.g. true)
• sellerName (e.g. SURPLUS)
• sellerUrl
• color (e.g. Black)
• materials
• styles
• era (e.g. 1980s)
• dimensions
• photos
• productUrl
• sourceUrl
• recordType (e.g. vintageItem)
• scrapedAt (e.g. 2026-05-30T12:00:00+00:00)

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open Chairish Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Set the mode field to searchProducts and enter a keyword into query, such as mid century chair.
2. Confirm proxyConfiguration is set to use Apify proxy with the RESIDENTIAL proxy group enabled.
3. Set maxItems to 10 for a first run to keep result charges capped at $0.05.
4. Run the Actor and open the dataset preview to verify that price, sellerName, and brand are present.
5. Add category, style, or condition filters to narrow your output set.
6. Switch mode to getBySlug and populate the slugs array with full Chairish listing URLs or product identifiers to fetch specific items.
7. Verify that the dimensions object contains valid numeric values for widthInches, heightInches, and depthInches.

How do you apply it? Three worked playbooks

These are Chairish Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Interior design research

Outcome: Find vintage pieces matching specific styles, eras, and materials

Configure: Set mode to searchProducts, style to mid-century-modern, category to furniture, and maxItems to 50.

Working method: Execute a broad discovery run across mid-century furniture listings, then parse materials and era fields in your exported dataset to match design project requirements.

Deliverable: A dataset containing furniture listings with dimensions, material lists, seller names, and photo URLs.

Stop condition: The output dataset contains zero records due to conflicting style and category filter combinations.

Use case 2: Market research

Outcome: Analyze pricing trends for antique and vintage categories

Configure: Set mode to searchProducts, category to art, minPrice to 500, maxPrice to 5000, and maxItems to 200.

Working method: Collect records across defined price ranges, then compute average and median price values grouped by era and brand attributes.

Deliverable: A tabular export mapping pricing, brand, condition, and availability across target categories.

Stop condition: The price field returns null or non-numeric values across consecutive dataset items.

Use case 3: Seller monitoring

Outcome: Track inventory from specific Chairish dealers

Configure: Set mode to getBySlug, input target listing paths into the slugs array, and set maxItems to 100.

Working method: Supply product slugs from specific dealer inventories to the slugs parameter and track changes in price and isAvailable over scheduled runs.

Deliverable: An inventory dataset recording changes in item availability, current listing prices, and seller details.

Stop condition: The mode is set to getBySlug while the slugs input array is empty.

What breaks, and how do you design around it?

Chairish blocks datacenter IP ranges, so cloud runs fail if proxyConfiguration is changed to turn off residential proxies. Keep Apify's residential proxy group enabled in proxyConfiguration for cloud execution. When you need to extract more than 10,000 records, split your task into separate runs using narrower search filters.

When should you not use Chairish Scraper?

Do not use this Actor if your project requires direct email addresses or phone numbers for Chairish dealers, as those fields are not part of the public product records. For general mass-market retail home decor datasets rather than vintage items, use At Home Scraper - Furniture, Decor & Rugs. If you require high-end luxury antiques from global marketplaces, consider 1stDibs Scraper or Pamono Vintage & Antique Design Scraper. If your scraping is focused strictly on Chairish furniture categories, Chairish Furniture Scraper offers a narrower category focus.

What should you check before trusting the output?

• Confirm that the price field contains valid numeric values and currency equals USD.
• Verify that materials and styles contain populated arrays of string data.
• Ensure sellerName and productUrl are non-empty strings on every record.
• Check that dimensions contains widthInches, heightInches, and depthInches rather than null values.
• Stop a scheduled run if maxItems is set above 10 but zero dataset records are returned, indicating a proxy blocking issue.

None of this proves a record is correct. It gives a scheduled Chairish Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

Why are residential proxies required for cloud runs?

Chairish blocks request traffic originating from datacenter IP addresses. Apify residential proxies are enabled by default in proxyConfiguration to allow cloud runs to complete without blocking.

How much does running this Actor cost on Apify?

Results cost $0.005 each on the free plan, which equals $5.00 per 1,000 results. Apify also bills platform usage on top of event charges. A test run capped at 10 items costs up to $0.05 in result charges.

Can I retrieve specific listings instead of searching?

Yes. Set the mode parameter to getBySlug and pass a list of Chairish product slugs or full product URLs into the slugs array to retrieve specific listings.

What product details are returned in each dataset record?

Each record carries 21 fields, including title, brand, price, currency, availability, seller name, seller URL, dimensions in inches, materials, design styles, era, photos, and product URL.

Where to go next

When you are ready to run it, open Chairish Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the Chairish Scraper Actor page for the current input schema, pricing tier, and run history.

Other Actors we maintain for related data:

• Chairish Furniture Scraper: Scrape vintage, antique and designer furniture and decor listings from chairish.com.
• At Home Scraper - Furniture, Decor & Rugs: Scrape At Home (athome.com), the US home-decor superstore.
• Pamono Vintage & Antique Design Scraper: Scrape pamono.com - the leading marketplace for vintage, antique, and contemporary design.
• 1stDibs Scraper: Scrape 1stDibs - the leading online marketplace for antique, vintage, and contemporary furniture, jewelry & watches, art, and fashion.

Related guides:

• Home Depot Product Scraper: Three Practical Use Cases
• Blick Art Materials Scraper: Pull Data from 237 Categories (2026)

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-29.

• Actor last updated by its maintainers on 2026-07-13.

• Run outcome figures cover the 30 day public window ending 2026-09-29.

• Chairish Scraper on Apify