# Thredup Product Search Scraper (`stealth_mode/thredup-product-search-scraper`) Actor

Scrape ThredUp's searchable product catalog with precision. Collect 40+ fields per item including pricing, brand, size, condition, availability — perfect for fashion retailers, resellers, researchers, and price monitoring tools.

- **URL**: https://apify.com/stealth\_mode/thredup-product-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## ThredUp Product Search Scraper: Extract Secondhand Fashion Data at Scale
---

### What Is ThredUp?

ThredUp is the world's largest online consignment and secondhand fashion marketplace, hosting millions of pre-owned clothing, accessories, and home goods. The platform serves fashion-conscious shoppers seeking sustainability and value. For resellers, researchers, and data analysts, scraping ThredUp product search results enables market research, competitor analysis, inventory benchmarking, and price trend tracking — all automatically.

---

### Overview

The **ThredUp Product Search Scraper** extracts detailed product information from ThredUp's searchable catalog pages. It transforms dynamic search results into clean, structured datasets containing pricing, availability, brand details, condition ratings, and more.

The scraper is ideal for:

- **Fashion retailers** tracking secondhand market trends and competitor pricing
- **Resellers** monitoring inventory availability and price fluctuations
- **Data analysts** building historical datasets for fashion market research
- **Price intelligence platforms** aggregating secondhand valuations
- **Sustainability researchers** analyzing the pre-owned fashion ecosystem

Key features include configurable item limits, resilient URL handling, and batch scraping across multiple department and search filters.

---

### Input Format

The scraper accepts a JSON configuration with three core parameters:

```json
{
  "urls": [
    "https://www.thredup.com/women?department_tags=women&page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

#### Input Parameters Explained

| Parameter | Type | Description |
|---|---|---|
| `urls` | Array | Product search page URLs from ThredUp. Include full query strings (filters, page numbers, department tags) for precise targeting. Example: `/women?department_tags=women&page=2` |
| `ignore_url_failures` | Boolean | If `true`, the scraper continues running even if some URLs fail. Useful for bulk operations where occasional failures shouldn't halt the entire job. |
| `max_items_per_url` | Integer | Maximum number of products to extract from each URL (e.g., `200` scrapes up to 200 items per page). Balances thoroughness with performance. |

#### Best Practices

- **Build URL lists** using ThredUp's search filters (department, brand, size, price range) to target specific product segments.
- **Use pagination carefully** — each page parameter adds one URL; avoid excessive pages to prevent rate-limiting.
- **Test URLs first** — verify a single URL returns products before batching hundreds.

***

### Output Format

**Sample output**

```json
{
  "access_levels": [
    "any"
  ],
  "availability": "InStock",
  "brand": "T Party",
  "brand_id": 4758,
  "brand_style_name": null,
  "brand_style_name_raw": null,
  "category": "Formal Skirt",
  "category_tags": [
    "skirts"
  ],
  "clearance": false,
  "cluster_id": null,
  "cluster_item_count": null,
  "color_names": [
    "Burgundy"
  ],
  "department_tags": [
    "women"
  ],
  "es_score": "588025900",
  "favorite_count": 27,
  "id": 226690885,
  "item_number": 228352238,
  "is_favorite": false,
  "is_p2_p": false,
  "materials": [
    "95% VISCOSE",
    "5% SPANDEX"
  ],
  "merchandising_department": "women",
  "mpn_title": null,
  "msrp": 38,
  "new_with_tags": false,
  "original_price": "12.74",
  "original_supplier_id": 60239091,
  "photo_ids": [
    "918196817",
    "918196860",
    "918097901",
    "918097902"
  ],
  "price": "16.99",
  "promotion": {
    "discount_percent": 50,
    "is_dynamic_discount": false,
    "promofied_price": "8.49",
    "promotion_code": "FIRST50",
    "__typename": "ItemPromotion"
  },
  "quality_type": "very_good",
  "search_term": "Burgundy fringed suede wrap skirt with a high waist and asymmetrical hemline",
  "similar_search_filters": {
    "category_tags": [
      "skirts"
    ],
    "department_tags": [
      "women"
    ],
    "sizing_ids": [
      10778
    ],
    "__typename": "ItemSimilarSearchFilters"
  },
  "size_display": "Size S",
  "sku": null,
  "state": "listed",
  "style_tags": [
    "formal"
  ],
  "supplier_id": 60239091,
  "thredup_gender": "women",
  "title": "T Party Formal Skirt",
  "warehouse_id": 16,
  "from_url": "https://www.thredup.com/women?department_tags=women"
}
```

Each product yields a rich record with 40+ structured fields capturing pricing, categorization, condition, and metadata:

#### Product Identification

| Field | Meaning |
|---|---|
| `ID` | Unique ThredUp identifier for the product |
| `Title` | Product name and description as listed |
| `Item Number` | Internal inventory/SKU identifier |
| `SKU` | Stock Keeping Unit for tracking |
| `MPN Title` | Manufacturer Part Number or style reference |

#### Brand & Department Classification

| Field | Meaning |
|---|---|
| `Brand` | Fashion brand name (e.g., "J.Crew," "Nike") |
| `Brand ID` | Unique brand identifier in ThredUp's database |
| `Brand Style Name` | Processed brand style classification |
| `Brand Style Name Raw` | Unprocessed brand style field |
| `Department Tags` | Primary category (e.g., "women," "men," "kids") |
| `Merchandising Department` | Internal merchandising category |
| `Category` | Product type (e.g., "Dresses," "Jeans," "Shoes") |
| `Category Tags` | Subcategory tags for filtering |

#### Condition & Quality Indicators

| Field | Meaning |
|---|---|
| `State` | Condition level (e.g., "Like New," "Good," "Fair," "Poor") |
| `Quality Type` | ThredUp's quality assessment (excellent, good, fair) |
| `New With Tags` | Boolean flag; `true` if item has original tags attached |

#### Physical Attributes

| Field | Meaning |
|---|---|
| `Size Display` | Size shown to customers (e.g., "M," "10," "Large") |
| `Color Names` | Color(s) of the item (comma-separated if multiple) |
| `Materials` | Fabric or material composition |
| `Style Tags` | Style descriptors (e.g., "casual," "formal," "vintage") |

#### Pricing & Value

| Field | Meaning |
|---|---|
| `Price` | Current ThredUp selling price (USD) |
| `Original Price` | Estimated original retail price |
| `MSRP` | Manufacturer's Suggested Retail Price if available |
| `Promotion` | Active promotions or discounts applied |

#### Availability & Demand

| Field | Meaning |
|---|---|
| `Availability` | In-stock status (e.g., "available," "sold out") |
| `Favorite Count` | Number of users who favorited the item |
| `Is Favorite` | Boolean flag; `true` if the current user favorited it |
| `View Count` | Page view statistics |

#### Sourcing & Inventory

| Field | Meaning |
|---|---|
| `Is P2P` | Peer-to-peer listing (individual seller) vs. ThredUp warehouse stock |
| `Supplier ID` | Warehouse or supplier identifier |
| `Original Supplier ID` | Original consignment source ID |
| `Warehouse ID` | Physical warehouse location code |
| `Access Levels` | User access restrictions (public, private, etc.) |

#### Search & Clustering

| Field | Meaning |
|---|---|
| `Search Term` | Query term(s) that surfaced this product |
| `Similar Search Filters` | Related search filters users might try |
| `Cluster ID` | Product cluster ID for similarity grouping |
| `Cluster Item Count` | Number of items in the same cluster |
| `ES Score` | Elasticsearch relevance score (internal ranking) |

#### Images & Media

| Field | Meaning |
|---|---|
| `Photo IDs` | Identifiers for product images in ThredUp's CDN |

#### Marketplace Metadata

| Field | Meaning |
|---|---|
| `ThredUp Gender` | Gender targeting (women, men, kids, unisex) |
| `Clearance` | Boolean flag indicating clearance status |

***

### How to Use

1. **Identify target URLs** — Navigate to ThredUp.com and apply search filters (department, brand, size, price). Copy the filtered search page URL including all query parameters.

2. **Build the configuration** — Create your JSON input with one or more URLs. For example:

```json
   {
     "urls": [
       "https://www.thredup.com/women?department_tags=women&price=0-50&page=1",
       "https://www.thredup.com/women?department_tags=women&price=0-50&page=2"
     ],
     "max_items_per_url": 100,
     "ignore_url_failures": true
   }
```

3. **Run the scraper** — Submit the configuration and monitor progress.

4. **Export results** — Download output in JSON, CSV, or Excel format for analysis.

**Troubleshooting:**

- If results are empty, verify the URL loads products in your browser.
- ThredUp may rate-limit aggressive scraping; reduce `max_items_per_url` or spread requests over time.
- Use `ignore_url_failures: true` when batching 10+ URLs to tolerate occasional connection issues.

***

### Use Cases & Business Value

- **Price trend analysis** — Track how secondhand valuations change over time by condition and brand
- **Competitive intelligence** — Monitor what products competitors are sourcing and pricing
- **Market segmentation** — Identify undervalued brands or categories with high demand
- **Inventory planning** — Inform sourcing decisions based on real-time availability data
- **Sustainability reporting** — Quantify the secondhand fashion market opportunity

The scraper eliminates manual product research, delivering datasets that feed directly into spreadsheets, dashboards, and machine learning models.

***

### Conclusion

The **ThredUp Product Search Scraper** is an essential tool for fashion e-commerce professionals, resellers, and researchers. With 40+ data points per product and flexible filtering, it transforms ThredUp's catalog into actionable intelligence. Start scraping today and unlock insights into the thriving secondhand fashion market.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.thredup.com/women?department_tags=women&page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.thredup.com/women?department_tags=women&page=2"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/thredup-product-search-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 = {
    "urls": ["https://www.thredup.com/women?department_tags=women&page=2"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/thredup-product-search-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "urls": [
    "https://www.thredup.com/women?department_tags=women&page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/thredup-product-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=stealth_mode/thredup-product-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Thredup Product Search Scraper",
        "description": "Scrape ThredUp's searchable product catalog with precision. Collect 40+ fields per item including pricing, brand, size, condition, availability — perfect for fashion retailers, resellers, researchers, and price monitoring tools.",
        "version": "0.0",
        "x-build-id": "sp6c4O90XYztPqzfm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~thredup-product-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-thredup-product-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/stealth_mode~thredup-product-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-thredup-product-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/stealth_mode~thredup-product-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-thredup-product-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "urls": {
                        "title": "URLs of the product search list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
