# Thredup.com Scraper (`devcake/thredup-com-scraper`) Actor

Extract ThredUp product data with this unofficial API. Get pricing, photos, brands & sustainability metrics for Poshmark reselling and dropshipping.

- **URL**: https://apify.com/devcake/thredup-com-scraper.md
- **Developed by:** [devcake](https://apify.com/devcake) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 0 monthly users, 80.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Scraper - Secondhand Fashion Product Data Extractor & API Alternative

Extract ThredUp product data with this powerful secondhand fashion scraper. Get complete product details, pricing, photos, brands, sizes, sustainability metrics, and inventory data from the largest online thrift store. The unofficial ThredUp API for resellers, dropshippers, and fashion market researchers.

### 🛒 What Is ThredUp Scraper

This ThredUp data extractor captures complete product listings from ThredUp's secondhand fashion marketplace. Extract thousands of items concurrently including clothing, shoes, and accessories with full pricing history, condition details, multiple product photos, and environmental impact data showing water and energy savings for each item.

Perfect for ThredUp inventory sourcing, price monitoring, competitive analysis, and building product databases for resale businesses.

### 👥 Who Uses This ThredUp Scraper

- 🛍️ **Poshmark Resellers** - Source ThredUp inventory to flip on Poshmark, eBay, Mercari, Depop, and Vinted
- 📦 **Dropshippers** - Find trending secondhand fashion items to list across multiple resale platforms
- 💰 **Fashion Arbitrage Sellers** - Compare ThredUp prices against Amazon, Poshmark, and eBay to find profitable flips
- 🏪 **Boutique Owners** - Stock your store with curated secondhand pieces from ThredUp's catalog
- 🤖 **Reselling Automation Tools** - Feed ThredUp data into your crosslisting and repricing software
- 📊 **Market Researchers** - Track sustainability data, pricing trends, and brand availability in circular fashion
- 🔔 **Price Monitoring Services** - Watch ThredUp pricing across categories and brands for deal alerts


### 🎯 Key Features

- 📋 Extract complete ThredUp product catalogs by category or search
- 📸 Get high-resolution product photos in multiple sizes
- 💵 Track pricing changes and promotional discounts
- 📊 Monitor inventory availability and sell-through rates
- 🌿 Access unique sustainability metrics for eco-conscious businesses
- 📁 Export data in multiple formats (JSON, CSV, Excel, HTML)


### 🚀 How to Use This ThredUp Scraper

1. 🔗 **Enter ThredUp URLs** - Provide category pages or search results (e.g., `thredup.com/shop/women/dresses`)
2. ⚙️ **Set your limits** - Control scope with max items and page settings
3. ▶️ **Run the extraction** - Scrape ThredUp products to your dataset
4. 💾 **Export your data** - Download as JSON, CSV, Excel, or connect via API


### 💡 ThredUp Scraper Use Cases

#### Cross-Platform Reselling (Poshmark, eBay, Mercari, Depop)
Find underpriced branded items on ThredUp to resell at markup on Poshmark, eBay, Mercari, Depop, and other resale marketplaces. Search specific brands like Nike, Lululemon, Free People, Madewell, and Anthropologie to build profitable inventory. Track items from listing to sale to identify high-demand products.

#### ThredUp to Poshmark Arbitrage
Scan ThredUp for designer deals and automatically cross-reference prices on Poshmark. Identify items with 50%+ profit margins after fees. Monitor ThredUp's new arrivals to catch undervalued inventory before other resellers.

#### Fashion Price Intelligence
Monitor ThredUp pricing trends across categories and seasons. Track how prices change during sales events, holiday promotions, and clearance cycles. Compare ThredUp's secondhand pricing to retail to understand market positioning.

#### Sustainable Fashion Research
ThredUp provides unique sustainability data for every item - gallons of water saved, pounds of carbon offset, hours of electricity conserved. Extract this data to research circular fashion impact, create sustainability reports, or build eco-conscious shopping tools.

#### Brand Inventory Tracking
Monitor brand availability across ThredUp's catalog. Track which designers appear most frequently, price ranges by brand, and sell-through rates. Perfect for brands researching the resale value of their products.

#### Thrift Store Inventory Automation
Build automated sourcing pipelines that scan ThredUp for items matching your buying criteria. Filter by brand, size, price range, condition, and category to surface only profitable opportunities.


### ⚙️ Input Options

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| startUrls | array | No | ThredUp category or search URLs to scrape |
| searchQueries | array | No | Department/category paths (e.g., `women/dresses`) |
| maxItems | integer | No | Maximum items per query (default: 100) |
| maxPages | integer | No | Maximum pages per query (default: 10) |

> **Note:** US Residential proxy is automatically configured - no setup required.

### 📝 Example Input

```json
{
  "searchQueries": ["women/dresses", "women/jeans", "men/shirts"],
  "maxItems": 100,
  "maxPages": 10
}
````

### 📊 Sample Output

```json
{
  "title": "Nike Dri-FIT Running Top",
  "brand": "Nike",
  "category": "Athletic Shirts",
  "description": "Black moisture-wicking running shirt. Excellent condition. Size Medium.",
  "size": "Size M",
  "gender": "women",
  "price": 24.99,
  "original_price": 35.00,
  "msrp": 55.00,
  "savings_percent": 54.5,
  "clearance": false,
  "promotion": null,
  "availability": "InStock",
  "new_with_tags": false,
  "state": "listed",
  "photo_urls": {
    "large": ["https://thredup-assets-cdn..."]
  },
  "sustainability": {
    "glasses_of_water": 437.95,
    "hours_of_lighting": 156.18,
    "miles_by_car": 0.87
  },
  "category_tags": ["Athletic", "Tops"],
  "style_tags": ["Running", "Activewear"],
  "favorite_count": 42
}
```

### 🌟 Why Use This ThredUp Data Extractor

**Built for Resellers:** Unlike generic e-commerce scrapers, this tool understands the secondhand market. It captures the unique data points resellers need: condition grades, sustainability metrics, original vs. resale pricing, and cross-platform arbitrage signals.

**Fast Concurrent Extraction:** Scrape thousands of ThredUp products simultaneously. No more waiting for sequential page loads - get your inventory data in minutes, not hours.

**Complete Product Intelligence:** Get every data point ThredUp displays including hidden fields like favorite counts, promotion details, and detailed sustainability calculations.

**Apify Platform Integration:** Run on Apify's cloud infrastructure with automatic scaling, proxy rotation, dataset storage, and API access. Schedule regular scrapes to keep your inventory data fresh.

Build a complete reselling stack by combining ThredUp sourcing with crosslisting automation and repricing tools.

### 📈 Perfect For These Business Models

- 👗 **Clothing Resellers** - Source inventory for Poshmark, eBay, Mercari, Depop storefronts
- 🏪 **Dropshipping Businesses** - List ThredUp items on your Shopify or WooCommerce store
- 📈 **Resale Analytics Platforms** - Build pricing intelligence and market trend reports
- 🌱 **Sustainable Fashion Apps** - Showcase environmental impact of secondhand shopping
- 🛍️ **Personal Shoppers** - Find specific items for clients across ThredUp's catalog
- 💸 **Thrift Flippers** - Buy low on ThredUp, sell high on premium resale platforms

Start extracting ThredUp data today and supercharge your resale business with complete product intelligence from the world's largest online thrift store.

# Actor input Schema

## `startUrls` (type: `array`):

List of ThredUp category or search URLs to scrape (e.g., https://www.thredup.com/women/dresses)

## `searchQueries` (type: `array`):

Alternative to URLs: Search by department/category (e.g., women/dresses, women/tops). Leave empty if using Start URLs.

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

Maximum number of items to scrape per search query or URL.

## `maxPages` (type: `integer`):

Maximum pages to scrape per query. Each page contains up to 119 items.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.thredup.com/women/dresses"
  ],
  "searchQueries": [],
  "maxItems": 30,
  "maxPages": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

All scraped products with full details

## `summary` (type: `string`):

Statistics about the scrape run

# 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 = {
    "startUrls": [
        "https://www.thredup.com/women/dresses"
    ],
    "searchQueries": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("devcake/thredup-com-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 = {
    "startUrls": ["https://www.thredup.com/women/dresses"],
    "searchQueries": [],
}

# Run the Actor and wait for it to finish
run = client.actor("devcake/thredup-com-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 '{
  "startUrls": [
    "https://www.thredup.com/women/dresses"
  ],
  "searchQueries": []
}' |
apify call devcake/thredup-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Thredup.com Scraper",
        "description": "Extract ThredUp product data with this unofficial API. Get pricing, photos, brands & sustainability metrics for Poshmark reselling and dropshipping.",
        "version": "1.0",
        "x-build-id": "dTf19AGNqL0QeUmsN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devcake~thredup-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devcake-thredup-com-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/devcake~thredup-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-devcake-thredup-com-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/devcake~thredup-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-devcake-thredup-com-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "List of ThredUp category or search URLs to scrape (e.g., https://www.thredup.com/women/dresses)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Alternative to URLs: Search by department/category (e.g., women/dresses, women/tops). Leave empty if using Start URLs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Items per Query",
                        "minimum": 30,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of items to scrape per search query or URL.",
                        "default": 30
                    },
                    "maxPages": {
                        "title": "Max Pages per Query",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum pages to scrape per query. Each page contains up to 119 items.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
