# 1stDibs Scraper: New Listing & Price Drop Alerts (`accountable_eel/1stdibs-listing-lookup`) Actor

1stDibs furniture and design scraper by category: price, designer, era and dealer, with new-listing and price-drop alerts for a list of categories. No login required. Pay per listing; misses and quiet runs are free.

- **URL**: https://apify.com/accountable\_eel/1stdibs-listing-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 listing returneds

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

## 1stDibs Scraper: New Listing & Price Drop Alerts

**Watch a category, get only what's new.** New listings and price drops since your last run,
charged per new row, free on quiet days. Schedule it hourly and send it to Discord, Slack, Google
Sheets or n8n.

This actor reads 1stDibs the way you'd browse it: pick one or more furniture/design categories (or
paste a category link straight from your browser), and get one row per listing with the title,
price, a euro conversion 1stDibs itself computes, the designer or maker when credited, the era, the
main photo and the link. Turn on monitoring and each run returns only the listings that appeared, or
got cheaper, since the previous run.

### Who it's for

- **Dealers and sourcing agents** who lose good pieces to whoever refreshes the page fastest. A
  watchlist on "armchairs" or a pasted category link with your price cap, run every hour, puts new
  listings in your Discord or Telegram without keeping a tab open.
- **Interior designers** researching what a style or period genuinely costs on the market right now,
  across categories, in one currency.
- **Resellers** who want a price-check before they flip a piece, or a running log of a category's
  price movement.
- **Bot and workflow builders** who are tired of maintaining their own scraper each time 1stDibs
  changes its site. You get a stable JSON row per listing and keep your own logic.

### Why this one

- **Every furniture/design category in one run.** One line runs on the category you name or paste;
  the actor never guesses a category slug — every keyword in its known list maps to a real 1stDibs
  navigation path, read live off 1stDibs' own site menu.
- **Monitoring built in, not bolted on.** `deltaMode` remembers what each watchlist has seen. New
  listings and price drops (with your own minimum drop %) come back; everything else is removed
  before billing. A quiet run returns one summary row and costs only the start fee.
- **Global pricing, one currency.** `price` is 1stDibs' own base USD price; `priceEur` is 1stDibs' own
  EUR conversion (not a third-party rate), so no extra request is needed to compare across listings.
- **Dealer transparency.** 1stDibs is a vetted-dealer marketplace, not a peer-to-peer one — every
  listing is `sellerType: "dealer"`. You get an anonymous seller hash to group listings by dealer
  without a name, and the raw dealer company name only if you ask for it.

### Categories

Keywords match this actor's known category list (read live off 1stDibs' own furniture navigation
menu — never guessed). A pasted 1stDibs category URL always works too, and keeps any filters already
in its query string.

| Keyword | Category | Keyword | Category |
|---|---|---|---|
| `armchairs`, `arm chairs` | Armchairs | `night stands`, `nightstands` | Night Stands |
| `chairs` | Chairs | `floor lamps` | Floor Lamps |
| `dining chairs` | Dining Room Chairs | `table lamps` | Table Lamps |
| `lounge chairs` | Lounge Chairs | `chandeliers`, `chandeliers & pendants` | Chandeliers & Pendants |
| `sofas`, `couches` | Sofas | `wall lights`, `sconces` | Wall Lights & Sconces |
| `dining tables` | Dining Tables | `mirrors` | Mirrors |
| `coffee tables` | Coffee Tables | `rugs`, `carpets`, `rugs & carpets` | Rugs & Carpets |
| `side tables` | Side Tables | `wall decor` | Wall Decor |
| `desks`, `writing desks` | Desks | `sculptures` | Sculptures |
| `cabinets` | Cabinets | `vases`, `vases & vessels` | Vases & Vessels |
| `dressers` | Dressers | `bowls`, `bowls & baskets` | Bowls & Baskets |
| `bookcases` | Bookcases | `boxes` | Boxes |
| `credenzas` | Credenzas | `clocks` | Clocks |
| `wardrobes` | Wardrobes | `pillows`, `pillows and throws` | Pillows and Throws |
| `mid-century modern` | Mid-Century Modern (lighting) | `art deco` | Art Deco (lighting) |
| `scandinavian modern` | Scandinavian Modern (lighting) | `home accents` | Home Accents |

A keyword outside this list is rejected with a `BAD_FORMAT` row explaining why, rather than guessed
into a broken URL — paste the category link from your browser instead; it will always work.

### What you get

By default each listing is its own row. Every row also repeats the search it came from.

| Field | What it is |
|---|---|
| `listingId`, `url`, `title` | 1stDibs' item ID, the listing link and its title |
| `price`, `currency` | 1stDibs' own base price, always in USD |
| `priceEur` | 1stDibs' own EUR conversion of `price` (not a third-party rate) |
| `designer` | Credited designer or maker, when 1stDibs shows one — often empty, not every piece is attributed |
| `era` | e.g. "1940s". 1stDibs has no exact listing date, so this and `isNewListing`/monitoring are the only "how old/new" signals |
| `category` | 1stDibs' internal category code |
| `imageUrl` | Link to the main photo (links only, nothing is downloaded) |
| `country` | The dealer's country |
| `sellerType`, `sellerHash` | Always `dealer` (see "Why this one"), and an anonymous 16-character dealer hash |
| `isNewListing`, `isSold` | 1stDibs' own flags |
| `isNew`, `changeType`, `firstSeenAt` | Monitoring: `new`, `price-drop` or `seen`, and when this watchlist first saw it |
| `previousPrice`, `priceDropPct` | Monitoring: the price last seen and the drop in %, on price-drop rows |
| `searchQuery`, `listingCount`, `totalAvailable`, `truncated` | The search summary |
| `newCount`, `priceDropCount`, `monitorStatus` | Monitoring summary |

Not available anywhere on 1stDibs' category pages, so not in this actor: a structured condition grade
(1stDibs vintage/antique listings don't carry one — only free-text framing like "Vintage 1940s
European Mid-Century Modern"), and an exact listing date (only the `era`, e.g. "1940s").

### Monitoring: new listings and price drops

The recipe most buyers use:

1. Put your categories in `searches` (keywords from the table above, or paste a category link with
   your own price filter already applied), and turn on **Only return listings that are new, or
   cheaper, since the last run** (`deltaMode`).
2. Optionally turn on **Seed silently** so the first run remembers today's listings without sending
   them all to your webhook.
3. Save it as a Task and add an hourly **Schedule** in Apify.
4. Add a webhook or integration on the Task for **Run succeeded**: Discord or Slack webhook,
   Telegram bot via n8n or Make, a Google Sheets append, or an HTTP call to your own bot.

```json
{
  "searches": ["armchairs"],
  "maxPrice": 3000,
  "deltaMode": true,
  "skipFirstRun": true,
  "alertOnNew": true,
  "alertOnPriceDrop": true,
  "minPriceDropPct": 10
}
```

How it decides:

- **New** means this watchlist has never returned that item ID before.
- **Price drop** means the USD price is at least `minPriceDropPct` below the price last seen. The
  remembered price updates every run, so a second cut is measured from the latest price.
- Unchanged listings are removed before you are billed. A run with nothing new returns one summary
  row with `monitorStatus: NO_NEW_ROWS`, `listingCount: 0`, and costs only the start fee.
- Each watchlist remembers up to 5,000 listings, oldest forgotten first.

**The window limitation.** A run only sees the newest `maxListingsPerSearch` listings sorted by
1stDibs' own "Newest" order (60 by default, up to 300). A listing that drops in price after it has
slid out of that window is not seen again. For price-drop alerts keep categories narrow or raise
`maxListingsPerSearch`.

**A slow origin.** 1stDibs' own pages take 5-20 seconds to respond. This actor pages up to 5 times
(300 listings) per search per run and defaults "Max concurrency" to 2 rather than the usual 5 — don't
raise it much on this actor, it will just queue behind the same slow origin.

### Price

- **Listings:** $3 per 1,000 listings returned, plus a $0.00005 start fee per run.
- A monitoring run with nothing new costs the start fee only. A category that returns nothing is
  never billed.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `searches` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~1stdibs-listing-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"searches":["armchairs"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

Tips:

- Paste a category link from 1stDibs when you need a sub-category not in the keyword table, or a
  category already filtered your way.
- `includeKeywords`/`excludeKeywords` match the title, designer and category before billing, so
  "reproduction" in `excludeKeywords` never costs you a row.
- 1stDibs' own robots.txt blocks free-text search (`/search/`, `/soa/`) — that's why this actor works
  by category, not open keyword search.

### Input

```json
{
  "searches": [
    "armchairs"
  ]
}
```

One per line: a pasted 1stDibs furniture/design category URL, or a category keyword from this actor's known list (e.g. "armchairs", "coffee tables", "chandeliers"). 1stDibs' own robots.txt blocks free-text search, so unmapped keywords are rejected with a clear reason instead of guessed. Accepted formats: armchairs, coffee tables, https://www.1stdibs.com/furniture/seating/lounge-chairs/.

### Sample output

| query | found | status | searchQuery | listingCount | totalAvailable | truncated | newCount | priceDropCount | monitorStatus | listings | listingId | title | price | currency | priceEur | designer | era | category | imageUrl | country | sellerType | sellerHash | sellerId | sellerName | isNewListing | isSold | changeType | isNew | previousPrice | priceDropPct | firstSeenAt | url | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| armchairs | true | OK | <search> | <listings returned> | \<total matching on 1stdibs> | <more results were available> | <new listings this run> | <price drops this run> | \<monitoring status (quiet / seeded runs)> | \<all listings found (full list)> | <1stdibs item id> | <title> | \<price (usd)> | <currency> | \<price in eur (1stdibs' own conversion)> | \<designer / maker (when 1stdibs credits one)> | \<era (e.g. "1940s") — 1stdibs has no exact date> | <1stdibs category code> | <image> | \<seller's country> | \<seller type (always "dealer" — 1stdibs is a vetted-dealer marketplace)> | <anonymous seller hash> | \<seller id (raw seller info only)> | \<seller company name (raw seller info only)> | <1stdibs' own "new listing" flag> | <sold> | \<new / price-drop / seen> | \<is this listing new?> | \<previous price seen by this monitor (usd)> | \<price drop % (this monitor)> | <first seen on a run> | <listing link> | 1970-01-01T00:00:00.000Z |

A real row from an `armchairs` run (2026-09-22), trimmed:

```json
{
  "searchQuery": "armchairs",
  "listingCount": 60,
  "totalAvailable": 18987,
  "truncated": true,
  "listingId": "f_51834272",
  "url": "https://www.1stdibs.com/furniture/seating/lounge-chairs/mid-century-lounge-chair-cane-walnut/id-f_51834272/",
  "title": "Mid-Century Lounge Chair in Cane and Walnut",
  "price": 4400,
  "currency": "USD",
  "priceEur": 3911.71,
  "designer": null,
  "era": "1940s",
  "category": "F_SEA_LOU",
  "imageUrl": "https://a.1stdibscdn.com/mid-century-lounge-chair-in-cane-and-walnut-for-sale/f_9331/f_518342721789555095360/tmp_image_master.JPEG",
  "country": "Netherlands",
  "sellerType": "dealer",
  "sellerHash": "3a91f2c8e4b6d017",
  "isNewListing": false,
  "isSold": false
}
```

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~1stdibs-listing-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"searches":["armchairs"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~1stdibs-listing-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"searches":["armchairs"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~1stdibs-listing-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"searches":["{{search}}"]}`, mapping the row's search into the `searches` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "1stDibs Scraper: Furniture Price & New Listing Alerts" — the agent will find and run this actor.

**Discord or Slack alerts without code.** Schedule the monitoring Task hourly, then add an
integration on the Task: in n8n or Make, trigger on "Apify: run succeeded", read the run's dataset,
skip rows where `listingCount` is 0, and post `title`, `price`, `designer` and `url` to a Discord or
Slack webhook. Google Sheets users can append the same rows for a running price log.

### vs. alternatives

| | What it costs | What you get | Trade-off |
|---|---|---|---|
| **This actor** | $3 per 1,000 listings, quiet monitoring runs free | Category search across 1stDibs' furniture/design catalog, dealer transparency, built-in new-listing and price-drop monitoring | Category search only (1stDibs' robots.txt blocks free text); no structured condition grade, because 1stDibs doesn't publish one |
| Generic scrape-on-demand actors | Varies, usually per-run | A dump of one page's results | No monitoring; you rebuild "what's new" and price-drop detection yourself |
| Checking 1stDibs by hand | Free, plus your time | Full control | Doesn't scale past a handful of categories and misses whatever appears between visits |

### Data & privacy

**Data & privacy.** This actor reads public category results that anyone can see without logging in. It
doesn't log in, solve CAPTCHAs or reveal hidden contact details. Dealer identity is off by default: you
get a `dealer` flag and an anonymous seller hash so you can group listings by dealer without
names. Turning on seller info makes you responsible for having a lawful reason to process it. Not
affiliated with 1stDibs.

### FAQ

**Is this allowed?**
It collects the same public listing data your browser shows, for the categories you
choose. It's built for monitoring a category, not for copying the marketplace. Check that your use fits
1stDibs' terms and your local law.

**Why did my monitoring run return nothing?**
Nothing new or cheaper appeared since the last run. You get one row with `monitorStatus:
NO_NEW_ROWS` and are charged only the start fee. On the very first run with "Seed silently" on, the
status is `SEEDED`.

**Why is `truncated` true?**
Either the run stopped at its `maxListingsPerSearch` cap before reaching the end of the category, or
1stDibs refused a page partway through (the listings collected up to then are delivered and billed;
nothing else is).

**Can I search by keyword instead of category?**
No — 1stDibs' own robots.txt disallows its search pages, so this actor only reads category pages.
Use the category table above, or paste a category link.

**Why is `designer` often empty?**
1stDibs only credits a designer/maker on listings where the dealer entered one — most vintage
pieces are attributed by style and era instead. This isn't a parsing gap; it's genuinely absent on
those listings.

**What do I need to set up?**
Nothing. No 1stDibs account, no cookies, no proxy settings.

**Can an AI agent call this?**
Yes, through the Apify MCP server or the API call shown above. Ask for "1stDibs Scraper: Furniture
Price & New Listing Alerts".

### Related actors

- [Selency Listing Lookup](https://apify.com/accountable_eel/selency-listing-lookup): the same one
  row per listing shape for Selency's French vintage furniture and decor marketplace.
- [Grailed Listing Lookup](https://apify.com/accountable_eel/grailed-listing-lookup): sold-price
  comps and new-listing alerts for resale menswear and streetwear.
- [Vinted Listing Lookup](https://apify.com/accountable_eel/vinted-listing-lookup): new-listing and
  price-drop alerts across 22 Vinted second-hand fashion sites.

# Actor input Schema

## `searches` (type: `array`):

One per line: a pasted 1stDibs furniture/design category URL, or a category keyword from this actor's known list (e.g. "armchairs", "coffee tables", "chandeliers"). 1stDibs' own robots.txt blocks free-text search, so unmapped keywords are rejected with a clear reason instead of guessed. Accepted formats: armchairs, coffee tables, https://www.1stdibs.com/furniture/seating/lounge-chairs/. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Matched against the title, designer and category.

## `excludeKeywords` (type: `array`):

Optional. Matched against the title, designer and category.

## `maxResults` (type: `integer`):

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `sort` (type: `string`):

Forced to "Newest" whenever monitoring is on, so two runs can be compared listing-by-listing.

## `maxListingsPerSearch` (type: `integer`):

1stDibs pages 60 items at a time; this actor pages up to 5 times (300 listings) per search per run, capped by the slow origin's own request budget. You pay per listing returned, so this is also your budget control.

## `locale` (type: `string`):

Only English was live-verified this build; the other locale mirrors are documented by 1stDibs' own site structure but not independently re-tested — see the README.

## `minPrice` (type: `integer`):

Optional. Applied after fetching (1stDibs' category pages don't take a price-filter URL parameter this actor could confirm), so it narrows results rather than the request itself.

## `maxPrice` (type: `integer`):

Optional. See "Minimum price".

## `deltaMode` (type: `boolean`):

Turns this actor into a monitor. A listing counts as new when its 1stDibs item ID has not been returned by a previous run of the same watchlist, and as a price drop when its USD price falls since it was last seen. Already-seen, unchanged listings are dropped before you are billed, so a quiet run costs only the run fee. The first run has nothing to compare against, so (unless "Seed silently" is on) it returns everything and remembers it.

## `deltaName` (type: `string`):

Leave empty and we derive one from this run's search settings, so two schedules with different settings keep separate memories. Type your own name to keep one memory across a settings change, or to have two schedules share one.

## `alertOnNew` (type: `boolean`):

Include newly-seen listings when monitoring is on. Turn off to get price-drop alerts only.

## `alertOnPriceDrop` (type: `boolean`):

Include listings whose price dropped since this watchlist last saw them. Turn off to get new-listing alerts only.

## `minPriceDropPct` (type: `integer`):

A listing must drop by at least this percentage since it was last seen by THIS monitor to be reported as a price-drop.

## `skipFirstRun` (type: `boolean`):

Instead of returning every current listing as "new" the first time a watchlist runs, this banks them silently and starts alerting from the second run on.

## `includeSellerInfo` (type: `boolean`):

Off by default. When on, adds the seller's 1stDibs ID and dealer company name. An anonymous seller hash is always included either way.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `expandRows` (type: `boolean`):

When on, each listing found gets its own row instead of being grouped under its search. You're still only charged once per search, no matter how many rows it produces.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

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

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "searches": [
    "armchairs"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "sort": "newest",
  "maxListingsPerSearch": 60,
  "locale": "en",
  "deltaMode": false,
  "deltaName": "",
  "alertOnNew": true,
  "alertOnPriceDrop": true,
  "minPriceDropPct": 5,
  "skipFirstRun": false,
  "includeSellerInfo": false,
  "columns": [
    "searchQuery",
    "listingCount",
    "totalAvailable",
    "truncated",
    "newCount",
    "priceDropCount",
    "monitorStatus",
    "listings",
    "listingId",
    "title",
    "price",
    "currency",
    "priceEur",
    "designer",
    "era",
    "category",
    "imageUrl",
    "country",
    "sellerType",
    "sellerHash",
    "sellerId",
    "sellerName",
    "isNewListing",
    "isSold",
    "changeType",
    "isNew",
    "previousPrice",
    "priceDropPct",
    "firstSeenAt",
    "url"
  ],
  "expandRows": true,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searches": [
        "armchairs"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/1stdibs-listing-lookup").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 = {
    "searches": ["armchairs"],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/1stdibs-listing-lookup").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 '{
  "searches": [
    "armchairs"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/1stdibs-listing-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/1stdibs-listing-lookup"
        }
    }
}
```

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/SI5b9Q3EKSoOLHnf4/builds/HVPLtZpqSqqoMbG9Q/openapi.json