The RealReal Scraper: Up to 1,000 Free Results a Month (2026)

Product records return 68 fields covering luxury resale listings, designer metadata, pricing, condition grades, and sizing attributes. The free-plan price is $5.00 per 1,000 results, and the scraper operates across 8 departments including women, men, jewelry, watches, and art. The tool extracts live catalog inventory across curated subcategories and designer slugs without requiring login credentials. This Actor is built for luxury resellers, pricing analysts, and market researchers tracking secondary marketplace values. It is not for teams requiring real-time keyword search results, which the scraper does not support.

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

Can you try The RealReal 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 The RealReal Scraper a month, before run-start charges and platform usage.

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

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

What does it cost to run The RealReal 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.

Your bill is determined primarily by maxItems, which directly limits how many dataset records are written per execution. To evaluate data structure before incurring result charges, run a minimal test with maxItems set to 20.

How do you run The RealReal Scraper from the API?

The schema marks 1 of its 18 controls as required: mode. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

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~therealreal-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"byCategory","categoryPath":"clothing/dresses","productUrls":["https://www.therealreal.com/products/women/clothing/suits-and-sets/alexis-skirt-set-w-tags-vtl9p"],"maxItems":20}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "byCategory",
  "categoryPath": "clothing/dresses",
  "productUrls": [
    "https://www.therealreal.com/products/women/clothing/suits-and-sets/alexis-skirt-set-w-tags-vtl9p"
  ],
  "maxItems": 20
}

run = client.actor("crawlerbros~therealreal-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": "byCategory",
  "categoryPath": "clothing/dresses",
  "productUrls": [
    "https://www.therealreal.com/products/women/clothing/suits-and-sets/alexis-skirt-set-w-tags-vtl9p"
  ],
  "maxItems": 20
}

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

That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

Which The RealReal Scraper inputs matter, and which can you skip?

The primary control is mode, which switches between category browsing, designer listings, URL lookups, and taxonomy discovery. For initial runs, specify mode and gender while leaving material, size, and custom category overrides empty.

• mode (string): What to fetch. byCategory/byDesigner/byUrl fetch real product listings/detail. discoverCategories (reliable, one cheap fetch) lists therealreal.com's own complete, real category taxonomy tree (department -> category -> subcategory) straight from the site's own "Refine Results" facet data, each with a live product count -- use it to find real categoryPath/customCategoryPath values beyond the curated dropdown. discoverDesigners (reliable, one cheap fetch) lists up to 200 real designer/brand names (with live product counts) for a department/category, straight from the same facet data -- use it to find real designerSlug values instead of guessing. Default: "byCategory".
• categoryPath (string): A curated common category path. Leave as (department only) to browse the whole department, or pick a subcategory. For a category not listed here, use Custom category path below instead (overrides this field). Default: "".
• productUrls (array): Full therealreal.com/products/... URLs to fetch complete detail for (price, condition, size, measurements, authentication info, images). Default: [].
• maxItems (integer): Hard cap on emitted records. Default: 30.
• gender (string): Top-level department to browse. Default: "women".
• customCategoryPath (string): Advanced: any taxonomy path segment(s) after the department, e.g. clothing/dresses/maxi or shoes/boots/ankle-boots. Copy from a therealreal.com/shop// URL. Overrides the Category dropdown when set. For mode=discoverCategories, filters the taxonomy listing to entries whose category path starts with this value (leave empty to list the entire tree).
• designerSlug (string): The RealReal designer slug, e.g. chanel, gucci, hermes, louis-vuitton, cartier, christian-dior. Find it in a therealreal.com/designers/ URL. Default: "chanel".
• designerGender (string): Restrict the designer's items to a department. Default: "women".
• minPrice (integer): Drop items priced below this (USD).
• maxPrice (integer): Drop items priced above this (USD).
• condition (array): Only include items in these conditions. Leave empty for all conditions. Default: [].
• color (string): Only include items in this color. Default: "".

The other 6 controls, with their defaults, are listed in the input schema on The RealReal Scraper on Apify.

Fixed-choice controls: mode accepts byCategory (Browse by category), byDesigner (Browse by designer/brand), byUrl (Fetch product detail by URL), discoverCategories (Discover category taxonomy (reliable)), discoverDesigners (Discover designers/brands (reliable)); gender accepts women, men, jewelry, watches, art, home, kids, beauty; categoryPath accepts 62 values (default ""), including clothing/dresses (Dresses), "" ((department only)), handbags, handbags/shoulder-bags (Shoulder bags); designerGender accepts women, men, jewelry, watches; color accepts 20 values (default ""), including "" ((any color)), Black, White, Grey.

What does The RealReal Scraper return?

The output provides detailed product records containing SKU, brand, condition, and pricing data suitable for market intelligence. The records conspicuously lack seller contact details and consignor identity, which the marketplace keeps anonymous.

Output per product

• productId, sku
• variantId: The specific listing's internal variant ID
• name, brand, brandId: brandId is the brand's internal numeric designer ID
• department, categoryPath, categoryBreadcrumb[]: breadcrumb only on byUrl
• condition: As Is / Fair / Good / Very Good / Excellent / Pristine
• conditionNotes: byUrl only - the item's real free-text condition description (e.g. "No visible signs of wear", "Minor scratches throughout metal; Minor wear at strap"), distinct from the condition grade above
• size, color, gender, material: size/material resolved across department-specific attribute types (clothing/shoe/ring/art/watch/kids sizes; fabric or metal-type material) so they populate on every department, not just clothing
• artistId: Art department only - the piece's internal artist ID (artist name is already in brand)
• caratWeight, clarityGrade, colorGrade, gemstone, stoneType, stoneShapes[]: Jewelry department only - caratWeight is the total carat weight summed across all stones of that type on the item
• watchModel, referenceNumber, watchCollection, movementType, caseMaterial, bandMaterial, watchStyles[], complications[]: Watches department only
• dressSilhouette: Dresses category only - e.g. "Wrap Dress", "Slip Dress", "Evening Gown" (verified live 2026-07-27: 100% populated on real dresses listings)
• chestSize: Men's clothing only - chest size band (e.g. "42", "48 +"), when the designer reports it alongside size
• priceUsd, priceFormatted: current price
• originalPriceUsd, originalPriceFormatted: only present if discounted from a prior TRR price
• estRetailPriceUsd, estRetailPriceFormatted: brand-new retail estimate, when disclosed
• discountText, discountPercent: only present when the item is on sale - in practice rare/absent, since the browse-listing API this actor reads does not reliably expose a markdown signal (see onSaleOnly note under Input below)
• images[], imageUrl: direct CDN URLs, not hotlink-protected
• productUrl: canonical therealreal.com/products/... URL
• availability, quantity, obsessionCount, waitlisted, editorsPick, badge: badge is the merchandising label text only (e.g. "Good Value", "New")
• buyNowEligible: byUrl only - whether the site offers an instant "Buy It Now" fast-checkout path for this item vs its normal add-to-bag flow
• description, measurements[], authenticationInfo, returnable, returnPolicyText, disclaimerText, categoryLabel, carbonSavedKg, waterSavedLiters: byUrl only
• valuationReportUrl: byUrl only, watches - link to the item's real appraisal/valuation report page
• availablePolicies[]: byUrl only - {name, priceUsd, sku} optional add-on protection/warranty plans, when offered (e.g. watches)
• glossaryTerms[]: byUrl only - {name, description} item-specific terminology (e.g. watch complications), when the site discloses it
• slug: byUrl only - the product's URL slug
• sizeGuide: byUrl only - {guideType: "table", columnHeaders[], rows[][]} (a real size-conversion table, e.g. shoes' US/Italy/UK/France/Japan) or {guideType: "document", description, downloadUrl} (a downloadable PDF chart, e.g. rings), when the department offers one
• measurementGuide: byUrl only - {imageUrl, measurements: [{label, description}]} general how-to-measure diagram/instructions for the department, distinct from the item's own measurements[]
• firstLookProduct: byUrl only - present (true) only when the item is early-access-eligible for registered members
• recordType: "product", scrapedAt

Output - category taxonomy (recordType: "category", mode=discoverCategories)

• name: Human-readable category/subcategory name
• department: Top-level department slug, e.g. women
• categoryPath: Path after the department, e.g. handbags/totes - absent for a top-level department node
• depth: 1 = department, 2 = category, 3 = subcategory
• productCount: Live count of items currently listed under this node
• categoryUrl: https://www.therealreal.com/shop/<department>[/<categoryPath>]
• recordType, scrapedAt

Output - designer facet (recordType: "designer", mode=discoverDesigners)

• designerName: Real designer/brand display name
• designerSlug: Derived slug - verified to resolve to real byDesigner results
• designerId: The RealReal's internal numeric designer ID
• productCount: Live count of items currently listed for this designer within the requested department/category scope
• department: The department this facet was scoped to
• designerUrl: https://www.therealreal.com/designers/<designerSlug>[/<department>]
• recordType, scrapedAt

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 The RealReal 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. Run mode discoverCategories to fetch the live taxonomy tree and verify your target path exists in the product catalog.
2. Execute mode discoverDesigners with gender set to women to retrieve verified designerSlug values alongside live item counts.
3. Switch mode to byCategory or byDesigner, set maxItems to 20, and run a test execution to verify dataset structure.
4. Check that emitted dataset records contain valid values for productId, sku, priceUsd, and brand.
5. Apply narrowing filters such as condition, minPrice, maxPrice, or color to isolate targeted luxury inventory.
6. Increase maxItems up to 500 to collect production batches across your chosen category or designer scope.

How do you apply it? Three worked playbooks

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

Use case 1: Resale price benchmarking

Outcome: Track live prices, discounts, and estimated

Configure: Set mode to "byDesigner", designerSlug to "chanel", designerGender to "women", and maxItems to 50.

Working method: Run the initial designer query to collect baseline pricing. Compare priceUsd against estRetailPriceUsd across returned items to evaluate resale margins. Expand across secondary luxury brands by adjusting designerSlug.

Deliverable: A structured dataset containing current prices, condition grades, and estimated retail valuations for benchmarking.

Stop condition: Stop execution if returned records have missing priceUsd fields across the entire batch.

Use case 2: Sustainability reporting

Outcome: Aggregate carbonSavedKg/waterSavedLiters

Configure: Set mode to "byUrl", productUrls to ["https://www.therealreal.com/products/women/clothing/suits-and-sets/alexis-skirt-set-w-tags-vtl9p"], and maxItems to 20.

Working method: Collect item detail URLs using category browsing. Submit those URLs to mode byUrl in batches. Extract carbonSavedKg and waterSavedLiters from the returned records and aggregate the metrics across listings.

Deliverable: An aggregated environmental metrics summary table calculating total water and carbon saved.

Stop condition: Stop if byUrl consistently returns zero records due to strict anti-bot challenge responses.

Use case 3: Inventory monitoring for resellers

Outcome: Watch a designer's or category's

Configure: Set mode to "byCategory", gender to "women", categoryPath to "clothing/dresses", sortBy to "newest", and maxItems to 100.

Working method: Schedule regular runs to monitor newly added inventory. Inspect obsessionCount, availability, and badge on each record to track demand velocity. Flag items marked with high obsession counts for purchase decisions.

Deliverable: A periodic feed of newly listed resale inventory with demand indicators and pricing.

Stop condition: Stop if the upstream query fails to refresh new listing timestamps between scheduled runs.

What breaks, and how do you design around it?

When high-traffic aggregate endpoints return zero records due to blocking, target specific leaf subcategories instead of broad department roots. For designer lookups, always scope queries with designerGender to avoid hitting blocked root designer URLs.

When should you not use The RealReal Scraper?

Do not use this Actor if your workflow depends on dynamic keyword search across the catalog. The RealReal renders search results entirely client-side after initial page hydration, which prevents server-rendered extraction. If you specifically need luxury handbag inventory and direct keyword search, use Fashionphile Scraper instead. Additionally, if you require vintage designer items with direct keyword filtering, consider WGACA Luxury Vintage Resale Scraper. Avoid this scraper if your pipeline requires high-volume product-detail URL parsing under tight response-time constraints, as single product endpoints face aggressive upstream anti-bot mitigation.

What should you check before trusting the output?

• Verify priceUsd is a positive number and not null on emitted product records.
• Check that brand strictly matches the targeted designerSlug when running mode byDesigner.
• Ensure categoryPath matches your selected department and subcategory structure in mode byCategory.
• Confirm images array contains accessible image URLs hosted on product-images.therealreal.com.
• Halt downstream ingestion if a scheduled run emits zero records due to perimeter blocking on high-traffic aggregate endpoints.

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

Frequently asked questions

What is the cost of running The RealReal Scraper?

Results cost $0.005 per item, which is $5.00 per 1,000 results on the free tier. Apify's free plan includes $5.00 of monthly usage, covering up to 1,000 results before platform usage costs.

Can I search for items using free-text keywords?

No. The RealReal executes keyword search client-side after hydration, so free-text keyword search is not supported. Use mode byCategory or byDesigner to browse structured inventory instead.

Why does mode byCategory occasionally return zero results?

Certain high-traffic top-level categories, like Handbags or aggregate Clothing roots, face strict perimeter blocks. Targeting specific subcategories such as clothing/dresses or shoes/sneakers resolves this issue.

How do I discover valid designer slugs for filtering?

Set mode to discoverDesigners and specify a department. The scraper returns up to 200 real designer slugs with live item counts pulled directly from the site taxonomy.

Does this scraper extract consignor and seller information?

No. The RealReal operates an anonymous consignment model, so consignor identities and store contact details are not disclosed in public product records.

Where to go next

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

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

Other Actors we maintain for related data:

• WGACA Luxury Vintage Resale Scraper: Scrape What Goes Around Comes Around (WGACA) - a luxury vintage/pre-owned designer resale retailer.
• Mytheresa Luxury Fashion Scraper: Scrape luxury fashion product listings from Mytheresa.com - one of the world's leading multi-brand luxury retailers.
• Worn Wear Resale Scraper: Scrape Patagonia Worn Wear - Patagonia's official secondhand resale marketplace.
• Fashionphile Scraper: Scrape Fashionphile - the premier pre-owned luxury handbag and accessories marketplace.
• ThredUp Scraper: Scrape ThredUp - the largest online resale marketplace for women's and kids' secondhand fashion.
• GoodBuy Gear Scraper - Baby & Kids Gear Resale: Scrape GoodBuy Gear, the largest certified-resale marketplace for baby and kids gear.
• ASOS Scraper: Scrape ASOS (Europe's largest online fashion marketplace) with search by keyword, browse by category, fetch by product ID or URL, or check live stock and pricing.
• DBA.dk Scraper: Scrape DBA.dk - Denmark's largest online marketplace for used and new items.

Related guides:

• Gymshark Scraper: 3 Practical Use Cases & Operational Playbooks
• Shein Product Scraper: 14 Data Fields, Up to 2,500 Free Results/Month
• Shopee Scraper Playbook: Extracting Southeast Asian E-Commerce Data
• Ozon Scraper - Products, Categories & Search: 3 Practical Use Cases

Resources

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

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

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

• The RealReal Scraper on Apify