# TheRealReal Data | Luxury Resale & Thrift Comps (`b2b_leads/therealreal-real-time-data-scraper`) Actor

Find underpriced luxury fast. TheRealReal Real-Time Data gives you designer listing search, price and markdown history, condition grades, full product details, designer inventory and real sold comps — streamed live to your dataset with Slack webhooks. Free trial: 2 results.

- **URL**: https://apify.com/b2b\_leads/therealreal-real-time-data-scraper.md
- **Developed by:** [Emmanuel](https://apify.com/b2b_leads) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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.

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

## TheRealReal Real-Time Data

**Live luxury resale market intelligence, authenticated designer comps, and vintage deal finder.**
Every row is one item on TheRealReal — what it is listed at today, what it retailed for, its condition grade, its cost in a markdown, and the full image gallery — streamed to your dataset as it is collected.

> **Free trial:** runs on a free Apify plan export the first **2 records**. Upgrade to a paid Apify plan for unlimited exports. Details in [Pricing, free tier & limits](#pricing-free-tier--limits).

### Who it is for

- **Resale & consignment sellers** sourcing designer inventory and setting prices against real marketplace data.
- **Vintage and thrift flippers** cross-listing to Poshmark, eBay, Depop, Mercari, Grailed and Vinted who need trustworthy luxury comps.
- **Consignment owners and buying teams** sizing how much of a designer is on the market and at what price.
- **Fashion researchers, brand pricing teams and appraisers** building sell-through and condition-mix tables.
- **AI agents and pricing bots** that need a clean, machine-readable feed of authenticated luxury listings.

### What you can collect

| Checkbox | What it returns | `featureType` |
| --- | --- | --- |
| **Listing Search** *(on by default)* | Live keyword search across authenticated designer inventory, with prices, markdowns, estimated retail, condition grade, size, category and gallery. | `listing_search` |
| **Listing Details** | The complete record for specific listings you name (URL, product id or SKU), including the description, condition report and measurements. | `listing_details` |
| **Designer Inventory** | A designer's full live inventory, so you can track stock depth and price positioning brand by brand. | `closet_listings` |
| **Designer Profile** | Designer-level supply table: how many items are live today, and how many have sold in the archive. | `seller_profile` |
| **Sold Comps** | Completed sales for comps, margins and sell-through — scoped by keyword, by designer, or both. | `sold_history` |
| **Scrape By URL** | Any TheRealReal URL — search results, a category or shop page, a designer page, or one listing. The page type is detected for you. | `scrape_by_url` |

Every row also carries `scrapedAt`, a stable `item_id`, the `sku`, and the item URL, so nothing is ambiguous later.

### Why it is fast and stays cheap

- **Streaming output.** Each record is written the moment it is collected, so a 10-record demo run feels instant and a 10,000-record run stays light on memory (512 MB default).
- **Fast search cards first.** Search results land with the fields you actually filter on — price, markdown, estimated retail, condition, designer, size, category, gallery. Enrichment is opt-in and never delays the card.
- **Enrichment never duplicates.** Turn on *Enrich with full listing details* and the **same** `listing_search` row gains description, condition report, measurements and the complete gallery with `detailsFetched: true`. One discovered listing is always exactly one row.

### Quick start

1. Click **Start** — Listing Search is enabled and prefilled with high-intent luxury demo queries (`gucci marmont`, `chanel flap bag`, `hermes scarf`), 10 records each.
2. Get results in seconds, streamed straight into your dataset.
3. Add keywords, a designer filter or a category filter, raise *Records per keyword*, and enable the other features you need.

Recommended for real work: keep **Residential proxy** on (default) and the proxy country on **United States** — TheRealReal is a US storefront.

### Use cases that pay for themselves

- **Find undervalued inventory** — pull new arrivals per designer, filter on condition and markdown, and compare listed price against estimated retail.
- **Price a piece before you buy or consign** — sold comps per designer or per keyword give you a real sale price, not a guess.
- **Build sell-through and demand tables** — Designer Profile stacks live inventory against sold-archive depth, per designer.
- **Watch a designer's price moves** — rerun Designer Inventory or Listing Search on a schedule and diff `current_price` per `item_id`.
- **Feed deal alerts** — send every row to Slack, Discord or your own pricing bot the second it is collected.
- **Keep multi-platform pricing in sync** — the output field names match the rest of the thrift/resale actor family, so TheRealReal rows union cleanly with Poshmark, Depop, Grailed, Mercari and ShopGoodwill datasets.

### Input reference

| Field | Type | Default | Notes |
| --- | --- | --- | --- |
| **Listing Search** | | | |
| `enableListingSearch` | boolean | `true` | Live keyword search. |
| `searchKeywords` | string\[] | `["gucci marmont", "chanel flap bag", "hermes scarf"]` | Each keyword contributes its own rows. |
| `searchMaxResults` | number | `10` | Records per keyword (1–200). Multiplied by keyword count, bounded by the run limit. |
| `searchFetchFullDetails` | boolean | `false` | Merges full product details into the same search row (`detailsFetched: true`). |
| `searchSort` | select | `relevance` | `relevance`, `newest`, `price_low_to_high`, `price_high_to_low`. |
| `searchBrand` | string | – | Designer filter by name or slug (`Gucci`, `gucci`, `louis-vuitton`). Optional; narrows the pool. |
| `searchCategory` | string | – | Category filter as the marketplace names it (`women/handbags`, `men/shoes`, `jewelry/rings`, `watches/bracelet`). Optional; narrows the pool. |
| **Listing Details** | | | |
| `enableListingDetails` | boolean | `false` | Full records for specific listings. |
| `listingIds` | string\[] | `[]` | Product ids (`54592052`) or SKUs (`GUC2147434`). |
| `listingUrls` | string\[] | `[]` | Full product URLs. |
| **Designer Inventory** | | | |
| `enableClosetListings` | boolean | `false` | Live inventory per designer. |
| `sellerUsernames` | string\[] | `[]` | Designer names or slugs (`gucci`, `chanel`, `hermes`). Shared with Designer Profile and Sold Comps. |
| `sellerMaxListings` | number | `30` | Live listings per designer (1–200). |
| **Designer Profile** | | | |
| `enableSellerProfile` | boolean | `false` | Live inventory depth + sold-archive depth per designer. Uses `sellerUsernames`. |
| **Sold Comps** | | | |
| `enableSoldHistory` | boolean | `false` | Completed sales for comps. Scope with `searchKeywords`, `sellerUsernames`, or both. |
| `soldMaxItems` | number | `30` | Sold items per scope (1–500). |
| **Scrape By URL** | | | |
| `enableScrapeByUrl` | boolean | `false` | Direct URL processing with page-type detection. |
| `scrapeUrls` | string\[] | `[]` | Any TheRealReal URL. Other sites are rejected. Uses *Records per keyword* as the per-URL cap. |
| **Run limits & delivery** | | | |
| `maxItems` | number | `0` | Total rows for the whole run. `0` = no run limit. |
| `webhookUrl` | string | – | Optional extra real-time push of every record. |
| `webhookFormat` | select | `json` | `json` or `slack`. |
| **Connection** | | | |
| `proxyConfiguration` | object | Residential, US | Residential proxy delivers the most reliable results at scale. |

#### Practical search examples

| Goal | Input |
| --- | --- |
| Price a designer's handbags by keyword | `searchKeywords: ["chanel classic flap"]`, `searchCategory: "women/handbags"` |
| Only one designer's inventory, cheapest first | `searchBrand: "hermes"`, `searchSort: "price_low_to_high"` |
| Fresh arrivals to hunt underpriced pieces | `searchSort: "newest"`, `searchMaxResults: 50` |
| One specific listing, fully detailed | `enableListingDetails`, `listingIds: ["GUC2147434"]` |
| Comps for a model, not a seller | `enableSoldHistory`, `searchKeywords: ["gucci marmont"]` |

### Output reference

One row per item (or per designer for `seller_profile`). Full datasets are also available as pre-built views in the run's **Output** tab: *Overview*, *Listing Search results*, *Listing Details*, *Designer Inventory*, *Designer Profiles*, *Sold Comps*, *Scrape By URL*.

#### Core fields on listing-like rows

| Field | Meaning |
| --- | --- |
| `featureType` | Which feature produced the row. |
| `scrapedAt` / `scraped_at` | ISO-8601 timestamp. |
| `url` / `item_url` | Source page and direct item page. |
| `item_id` | Stable product id — use it to diff prices between runs. |
| `sku` | Consignor item number, unique per physical item. |
| `title`, `description` | Name and (on details/enriched rows) the full condition-and-features description. |
| `main_image_url`, `additional_image_urls` | Full gallery, enlarged variants. |
| `status`, `is_sold` | `available`, `sold`, `reserved`, `not_for_sale`. |
| `current_price` | Listed today, after any markdown. |
| `original_price` | Price before the current markdown (`null` when not discounted). |
| `msrp_price` | The marketplace's estimated original retail price. |
| `currency` | e.g. `USD`. |
| `discount_percentage`, `price_drop_amount` | Markdown size, as % and as an amount. |
| `brand`, `brand_id` | Designer name and id. |
| `size` | Displayed size(s), e.g. `9.5 / IT 39.5`. |
| `condition` | The marketplace's own condition grade, e.g. `Excellent`. |
| `category`, `department`, `subcategory` | Category path, e.g. `handbags` / `women` / `clutches`. |
| `color`, `colors`, `style_tags` | Color and secondary style/pattern descriptors. |
| `item_specifics` | Label → detail pairs, including the condition report. |
| `seller_username` | Designer slug on designer-scoped rows (`closet_listings`, `sold_history`), otherwise `null`. |
| `detailsFetched` | `true` when full product details were merged into this search row. |

#### Per-feature notes

- **`listing_search`** — the fast card plus, when enrichment is on, the full detail set on the same row.
- **`listing_details`** — includes `brand_id`, `colors`, `item_specifics`, `quantity_available`.
- **`closet_listings`** — `seller_username` carries the designer slug; `position` is the rank within that designer's inventory.
- **`seller_profile`** — `total_listings` is live inventory depth, `total_sales` is sold-archive depth.
- **`sold_history`** — `current_price` is the price the item sold at; `seller_username` is set only for designer-scoped comps.
- **`scrape_by_url`** — `pageType` is `listing`, `search`, `designer` or `category`.

Fields the marketplace does not publish — engagement counts, listing and sale timestamps, shipping quotes, seller bios — are returned as `null` rather than guessed.

| A whole category, no keyword | `enableScrapeByUrl`, `scrapeUrls: ["https://www.therealreal.com/shop/women/handbags"]` |

### Webhook alerts

Every record is **always** saved to the dataset. A webhook is an additional push, fired per record as it is collected, and it never blocks collection: a failing webhook cannot stop or slow a run.

**Slack** (`webhookFormat: "slack"`) — post to an incoming webhook URL and every new row renders as a ready-to-read message:

```
:shopping_bags: *GG Marmont Small*
*Type:* listing_search  •  *Price:* USD 1395  •  *Brand:* Gucci  •  *Condition:* Excellent  •  *Seller:* n/a
<https://www.therealreal.com/products/women/handbags/…|Open on TheRealReal>
```

**JSON** (`webhookFormat: "json"`) — the complete row is posted as-is, so Zapier, Make, n8n, Airtable or your own pricing service can act on it directly.

### Use it from AI agents (MCP)

Connect the Apify MCP server and ask in plain language:

- *"What is the average sold price for a Gucci Marmont bag on TheRealReal?"*
- *"List Chanel handbags in Excellent condition and rank them by discount."*
- *"How many Gucci items are live today versus sold in the archive?"*
- *"Watch the Hermès scarf market and alert me on Slack when a new listing appears under $400."*

The agent calls this Actor, reads the dataset, and answers from real listing rows — then keeps the same shape for Poshmark, Depop, Grailed or eBay when you add them.

### Pricing, free tier & limits

- **Free Apify plan:** the first **2 records** are exported, then the run stops cleanly with a note in the log. No errors, no partial rows.
- **Paid plans:** full output, bounded only by your inputs and by any spending limit you set on the Actor.
- **Pay-per-event:** each exported record is charged as one `result` event. The run stops gracefully when your spending limit is reached, and the run summary is still written.
- **Run limit (`maxItems`):** cap total rows for the whole run — handy for a bounded price sweep.
- **Cost control:** records per keyword × keywords is the row count. Search-only runs are the cheapest; enrichment adds a little time per listing.

### FAQ

**Do I need a residential proxy?** Yes — keep the default Residential proxy on, country United States. Datacenter routing is more likely to be turned away, which shows up as missing rows rather than wrong data.

**Why did I get fewer rows than I asked for?** Usually because a designer or category filter narrowed the pool, or the designer genuinely has fewer items than your cap. The log reports the real available count per keyword before collecting, and the run summary shows what was saved.

**Are prices and availability current?** Every row is collected during the run. Availability reflects the moment of collection, so a piece can sell between your run and your purchase — rerun before you commit.

**How fresh is the data if I schedule it?** As fresh as your schedule: a run every 15 minutes is a live deal feed; a daily run is a price-tracking table.

**Are timestamps available?** The marketplace does not publish listing or sale timestamps, so those fields are `null`. Use `scrapedAt` for your own change tracking — diff `item_id` + `current_price` between runs to build price history.

**Can I get sold prices for a specific model?** Yes — Sold Comps accepts keywords, so `"gucci marmont"` returns completed sales for that model, not just that seller.

**Will it be rate limited?** Collection is deliberately paced, with retries that start a fresh connection when the marketplace pushes back, so long runs complete without you tuning anything. If you see gaps, raise the run limit and rerun — nothing collected is lost.

**Does it work without keywords?** Yes: use Scrape By URL with a category, shop or designer URL, or enable Designer Inventory with a designer list.

**Where do I report a problem?** Open an issue on the Actor's **Issues** tab with the run id and the input you used — never paste proxy credentials.

# Actor input Schema

## `enableListingSearch` (type: `boolean`):

Search TheRealReal by keyword. On by default — prefilled so you can click Start and get results in seconds. Output size = your keyword count x the per-keyword cap below.

## `searchKeywords` (type: `array`):

One or more search terms (e.g. gucci marmont, chanel flap bag, hermes scarf). Each keyword contributes its own rows, so output grows with the number of keywords.

## `searchMaxResults` (type: `integer`):

How many listings to collect for each keyword. Total output = keywords x this number, bounded by the run limit. Leave the optional filters empty and this number is what you actually get.

## `searchFetchFullDetails` (type: `boolean`):

When on, each search result is the SAME row enriched with full product fields (description, material and care notes, measurements, condition report, complete image gallery). Still featureType listing\_search with detailsFetched=true — never a second row, and nothing is filtered out for being incomplete. Adds a little extra time per listing. Enrichment never changes how many records you get.

## `searchSort` (type: `string`):

How to order search results. Does not change how many rows you get.

## `searchBrand` (type: `string`):

Optional designer filter by name or slug, e.g. Gucci or gucci. Narrows which listings exist, so your output can be smaller than the record count you asked for. Unknown designer names are reported and the filter is skipped — nothing is faked.

## `searchCategory` (type: `string`):

Optional category scope as this marketplace names it, e.g. women/handbags, men/shoes, jewelry/rings, watches/bracelet. Unknown categories are reported and the filter is skipped.

## `enableListingDetails` (type: `boolean`):

Fetch the full record for specific TheRealReal listings by product URL, product id, or SKU.

## `listingIds` (type: `array`):

TheRealReal product ids (e.g. 54592052) or SKUs (e.g. GUC2147434). Required when Listing Details is on and no URLs are given.

## `listingUrls` (type: `array`):

Full TheRealReal product URLs (https://www.therealreal.com/products/...).

## `enableClosetListings` (type: `boolean`):

Collect a designer's full live inventory to track stock depth and price positioning. TheRealReal is a designer-operated consignment house rather than a peer closet marketplace, so the designer is the inventory identity here.

## `sellerUsernames` (type: `array`):

Designer names or slugs, e.g. gucci, chanel, hermes, louis-vuitton. Shared by Designer Inventory, Designer Profile, and Sold Comps.

## `sellerMaxListings` (type: `integer`):

How many live listings to collect for each designer.

## `enableSellerProfile` (type: `boolean`):

Designer-level profile: live inventory depth plus published sold-archive depth, so you can size supply and resale velocity per designer. Uses the designer list above.

## `enableSoldHistory` (type: `boolean`):

Collect completed (sold) listings for comps, margins and sell-through. TheRealReal publishes a site-wide sold archive, so comps can be scoped by keyword, by designer, or both.

## `soldMaxItems` (type: `integer`):

How many completed listings to collect for each keyword and each designer.

## `enableScrapeByUrl` (type: `boolean`):

Paste any TheRealReal URL — search results, category or shop page, designer page, or a single listing. The page type is detected automatically.

## `scrapeUrls` (type: `array`):

Any TheRealReal search, category, designer, shop or listing URL. URLs from other sites are rejected.

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

Maximum rows to export for the whole run, across every enabled feature. 0 = no run limit (collect everything the enabled features match). Use it to bound cost on large bulk runs, e.g. 1000 for a price-research sweep. The free-tier trial and any Apify spending limit still apply.

## `webhookUrl` (type: `string`):

Optional. Every record is always saved to the run dataset — this webhook is an ADDITIONAL real-time push. Each new row is also POSTed to this URL (Slack, Discord, Zapier, Make, n8n, custom pricing bot).

## `webhookFormat` (type: `string`):

JSON sends the full record. Slack sends a ready-to-read message.

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

Residential proxy required for reliable results. TheRealReal is a US storefront, so keep the country on United States.

## Actor input object example

```json
{
  "enableListingSearch": true,
  "searchKeywords": [
    "gucci marmont",
    "chanel flap bag",
    "hermes scarf"
  ],
  "searchMaxResults": 10,
  "searchFetchFullDetails": false,
  "searchSort": "relevance",
  "searchBrand": "",
  "searchCategory": "",
  "enableListingDetails": false,
  "listingIds": [],
  "listingUrls": [],
  "enableClosetListings": false,
  "sellerUsernames": [],
  "sellerMaxListings": 30,
  "enableSellerProfile": false,
  "enableSoldHistory": false,
  "soldMaxItems": 30,
  "enableScrapeByUrl": false,
  "scrapeUrls": [],
  "maxItems": 0,
  "webhookUrl": "",
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Full dataset for this run (every featureType).

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

Core resale fields across features, including detailsFetched for search rows.

## `search` (type: `string`):

featureType=listing\_search only. One listing = one row; full details are merged when "Enrich with full listing details" is enabled.

## `details` (type: `string`):

featureType=listing\_details — only from the Listing Details feature (specific ids/SKUs/URLs), not from search enrichment.

## `closet_listings` (type: `string`):

featureType=closet\_listings — live designer inventory.

## `seller_profile` (type: `string`):

featureType=seller\_profile — live inventory depth and sold-archive depth per designer.

## `sold_history` (type: `string`):

featureType=sold\_history — completed listings for comps, margins, and sell-through.

## `scrape_by_url` (type: `string`):

featureType=scrape\_by\_url — rows produced from direct URLs.

# 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 = {
    "enableListingSearch": true,
    "searchKeywords": [
        "gucci marmont",
        "chanel flap bag",
        "hermes scarf"
    ],
    "searchMaxResults": 10,
    "searchFetchFullDetails": false,
    "searchSort": "relevance",
    "enableListingDetails": false,
    "listingIds": [],
    "listingUrls": [],
    "enableClosetListings": false,
    "sellerUsernames": [],
    "sellerMaxListings": 30,
    "enableSellerProfile": false,
    "enableSoldHistory": false,
    "soldMaxItems": 30,
    "enableScrapeByUrl": false,
    "scrapeUrls": [],
    "maxItems": 0,
    "webhookFormat": "json",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/therealreal-real-time-data-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 = {
    "enableListingSearch": True,
    "searchKeywords": [
        "gucci marmont",
        "chanel flap bag",
        "hermes scarf",
    ],
    "searchMaxResults": 10,
    "searchFetchFullDetails": False,
    "searchSort": "relevance",
    "enableListingDetails": False,
    "listingIds": [],
    "listingUrls": [],
    "enableClosetListings": False,
    "sellerUsernames": [],
    "sellerMaxListings": 30,
    "enableSellerProfile": False,
    "enableSoldHistory": False,
    "soldMaxItems": 30,
    "enableScrapeByUrl": False,
    "scrapeUrls": [],
    "maxItems": 0,
    "webhookFormat": "json",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/therealreal-real-time-data-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 '{
  "enableListingSearch": true,
  "searchKeywords": [
    "gucci marmont",
    "chanel flap bag",
    "hermes scarf"
  ],
  "searchMaxResults": 10,
  "searchFetchFullDetails": false,
  "searchSort": "relevance",
  "enableListingDetails": false,
  "listingIds": [],
  "listingUrls": [],
  "enableClosetListings": false,
  "sellerUsernames": [],
  "sellerMaxListings": 30,
  "enableSellerProfile": false,
  "enableSoldHistory": false,
  "soldMaxItems": 30,
  "enableScrapeByUrl": false,
  "scrapeUrls": [],
  "maxItems": 0,
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call b2b_leads/therealreal-real-time-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,b2b_leads/therealreal-real-time-data-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/VxUKOBaDtYTFth5kD/builds/g4xSALZwb2SAVsZbR/openapi.json