# Depop Secondhand Fashion Scraper - Search Listings & Products (`parseforge/depop-scraper`) Actor

Scrape Depop secondhand fashion listings by keyword. Extracts title, brand, price, size, condition, seller, likes, category, description and more.

- **URL**: https://apify.com/parseforge/depop-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 👗 Depop Secondhand Fashion Scraper

> 🚀 **Export Depop listings in seconds.** Title, brand, price, size, condition, seller, likes, category, description, and product photo for any keyword search, ready to drop into your spreadsheet, BI tool, or resale pipeline.

> 🕒 **Last updated:** 2026-05-21 · **📊 12 fields** per record · **Millions of listings** indexed globally · **Depop coverage** across all categories · **Real-time secondhand fashion data**

Depop is one of the largest peer-to-peer fashion resale platforms, running millions of active listings across clothing, accessories, and vintage items from sellers worldwide. The structured data behind each listing is richer than the thumbnail grid you scroll: title, brand, size, condition grading, seller handle, like count, category breadcrumb, full description, and the product photo URL. This Actor walks Depop's search results page by infinite scroll, then visits each product detail page to collect the complete record, all with Cloudflare bypass handled automatically.

The Actor accepts a plain search keyword ("jacket", "levi's jeans", "vintage adidas") and an optional sort order, scrolls through search results until your `maxItems` cap is reached, then enriches every listing with its detail page. Output is a clean, flat JSON schema whether you are building a resale price tracker, training a fashion AI, or monitoring competitors.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Resale entrepreneurs, vintage dealers, fashion analysts, brand protection teams, academic researchers, price intelligence platforms, second-hand aggregators | Competitive pricing, inventory sourcing, trend detection, brand monitoring, resale margin analysis, dataset enrichment for fashion apps, market research |

---

### 📋 What the Depop Scraper does

- 🔍 **Searches Depop by keyword.** Pass any search term Depop's search bar accepts and the Actor scrolls through results until your `maxItems` cap is hit.
- 🔃 **Supports four sort orders.** Relevance (default), newly listed, price ascending, and price descending - matching the same filters the Depop UI exposes.
- 🏷️ **Captures full listing detail.** Each result is enriched with a second visit to the product page to pull title, condition, seller handle, likes, category breadcrumb, and full description.
- 📷 **Returns the primary product photo.** The main listing image URL is included in every record, ready for display or download.
- 🛡️ **Bypasses Cloudflare automatically.** Camoufox (real Firefox TLS fingerprint) combined with residential UK proxy handles the bot detection layer without any configuration.
- 📦 **Flat, consistent output.** All 12 fields are present in every record. Missing values return as `null`, never as missing keys, so downstream tooling never has to guard.

Each record stands on its own with identification (url, title, seller), commerce (price, brand, size, condition), engagement (likes), taxonomy (category), and content (description, imageUrl) fields. The output shape is identical whether you searched for streetwear or vintage furniture.

> 💡 **Why it matters:** Depop is the go-to resale destination for Gen Z fashion. The pricing signal sitting behind millions of listings is the closest public proxy for real secondhand market rates - and it includes condition grading, brand attribution, and seller reputation data you cannot get from a generic e-commerce feed.

---

### 🎬 Full Demo

🚧 Coming soon: a 3-minute walkthrough showing keyword search, enrichment, and CSV export end to end.

---

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Required</th><th>Description</th></tr>
<tr><td><code>search</code></td><td>string</td><td>No</td><td>Keyword or phrase to search on Depop. Defaults to "jacket" if omitted.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>No</td><td>Cap on records returned. Free users are limited to 10; paid users may set up to 1,000,000.</td></tr>
<tr><td><code>sort</code></td><td>string (enum)</td><td>No</td><td>Sort order for search results. One of: <code>relevance</code> (default), <code>newlyListed</code>, <code>priceAscending</code>, <code>priceDescending</code>.</td></tr>
</table>

Example: search for vintage Levi's jeans, newest first, up to 50 results.

```json
{
    "search": "levi's jeans vintage",
    "maxItems": 50,
    "sort": "newlyListed"
}
````

Example: find the cheapest Adidas tracksuits available right now.

```json
{
    "search": "adidas tracksuit",
    "maxItems": 100,
    "sort": "priceAscending"
}
```

> ⚠️ **Good to Know:** Depop's search is keyword-based and returns results from all sellers globally. Sort order affects which listings appear first but not the total pool. The detail-page enrichment step adds roughly 2-4 seconds per listing due to Cloudflare challenge handling.

***

### 📊 Output

Each record is a flat JSON object with all 12 fields below. Empty values are returned as `null` so downstream tooling never has to guess.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼 `imageUrl` | string | `https://media-photos.depop.com/r1/367482878/3822833723_8429b361c20e42b3ae0aa6e437133de8/P8.jpg` |
| 📝 `title` | string | `Men's Black Jacket` |
| 🏷️ `brand` | string | `Lululemon` |
| 💰 `price` | string | `£35.18` |
| 📏 `size` | string | `S` |
| ✅ `condition` | string | `Excellent condition` |
| 👤 `seller` | string | `lululemon_reseller` |
| ❤️ `likes` | integer | `47` |
| 🔗 `url` | string | `https://www.depop.com/products/lululemon_reseller-womens-black-navy-jacket/` |
| 🗂️ `category` | string | `Women > Coats & Jackets` |
| 📄 `description` | string | `Lululemon running jacket, size small. Barely worn, excellent condition. No stains or damage.` |
| 🕒 `scrapedAt` | string (ISO 8601) | `2026-05-21T23:32:16.623Z` |
| ❌ `error` | string or null | `null` |

#### 📦 Sample records

<details>
<summary><strong>👗 Typical: popular brand listing with engagement</strong></summary>

```json
{
    "imageUrl": "https://media-photos.depop.com/r1/148073434/3822824999_e3f5fd8b2afd45fcbf01e5e0be1e44a5/P0.jpg",
    "title": "Lululemon Women's Black and Navy Jacket",
    "brand": "Lululemon",
    "price": "£35.18",
    "size": "S",
    "condition": "Excellent condition",
    "seller": "lululemon_reseller",
    "likes": 47,
    "url": "https://www.depop.com/products/lululemon_reseller-womens-black-navy-jacket/",
    "category": "Women > Coats & Jackets",
    "description": "Lululemon running jacket size small. Barely worn, excellent condition. No stains or damage. Happy to answer questions.",
    "scrapedAt": "2026-05-21T23:32:16.623Z",
    "error": null
}
```

</details>

<details>
<summary><strong>🧥 Mid-range: workwear brand, good condition</strong></summary>

```json
{
    "imageUrl": "https://media-photos.depop.com/r1/212345678/3822834001_abc123def456/P0.jpg",
    "title": "Carhartt Men's Grey Jacket",
    "brand": "Carhartt",
    "price": "£27.84",
    "size": "L",
    "condition": "Good condition",
    "seller": "vintage_workwear_uk",
    "likes": 12,
    "url": "https://www.depop.com/products/vintage_workwear_uk-carhartt-mens-grey-jacket/",
    "category": "Men > Coats & Jackets",
    "description": "Carhartt chore coat in grey. Size large. Some light wear on the cuffs consistent with age but no rips or stains. A wardrobe staple.",
    "scrapedAt": "2026-05-21T23:32:20.841Z",
    "error": null
}
```

</details>

<details>
<summary><strong>🖤 Streetwear: high-demand brand, low condition info</strong></summary>

```json
{
    "imageUrl": "https://media-photos.depop.com/r1/300112233/3822835500_def789ghi012/P0.jpg",
    "title": "Trapstar Men's Black Jacket",
    "brand": "Trapstar",
    "price": "£35.19",
    "size": "M",
    "condition": null,
    "seller": "streetwear_archive",
    "likes": 2,
    "url": "https://www.depop.com/products/streetwear_archive-trapstar-mens-black-jacket/",
    "category": null,
    "description": "Trapstar jacket in black. Medium. Worn a few times.",
    "scrapedAt": "2026-05-21T23:32:41.003Z",
    "error": null
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🛡️ | **Cloudflare bypass built in.** Camoufox (real Firefox TLS fingerprint) plus residential UK proxy is handled automatically. You never configure a proxy or worry about bot detection. |
| 📦 | **Detail-page enrichment included.** Every listing is visited individually to pull title, condition, seller, likes, category breadcrumb, and full description - not just what appears on the search grid. |
| ♾️ | **Infinite scroll pagination.** Depop loads 24 items per scroll. The Actor keeps scrolling until your cap is reached or no more items load. |
| 🏷️ | **Condition grading preserved.** Depop concatenates condition with size and brand in a bullet-separated string. This Actor parses it cleanly and returns only the condition segment. |
| 🔃 | **Four sort orders.** Relevance, newly listed, price ascending, and price descending - the same knobs the Depop UI exposes. |
| 🆓 | **Free tier for previewing.** Free Apify accounts get a 10-record preview before committing to a paid plan. |
| 🧾 | **Schema is flat and stable.** Twelve fields, no nested objects, no surprise missing keys - just `null` for empty values. |

> 📊 A single keyword search can return hundreds to thousands of matching listings. The Actor processes roughly 10-15 listings per minute with detail-page enrichment on a residential proxy.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Depop Scraper** *(this Actor)* | Pay per item, free preview | All Depop listings globally | On demand | Keyword, sort order | One JSON input, no API key |
| Depop's own API | Not publicly available | N/A | N/A | N/A | Not available |
| Generic product APIs | Per-call pricing | Mainstream retail, not resale | Indexed weekly | Category, price | Account, project, billing |
| DIY scraper | Engineering time, proxy bill | Whatever you can maintain | Whatever you can maintain | Whatever you build | Build and ship the whole stack |
| Manual copy-paste | Time | What you have patience for | Stale on day two | Manual | None |

Depop has no public API. This Actor is the only production-ready way to programmatically extract listing data at scale.

***

### 🚀 How to use

1. ✅ **Sign up for a free Apify account.** Use [this referral link](https://console.apify.com/sign-up?fpr=vmoqkp) to get started. Free accounts can preview 10 records per run.
2. 👗 **Open the Depop Scraper.** Find it on your dashboard or in the Apify Store.
3. 🛠️ **Enter your search term.** Type any keyword Depop's search bar accepts. Pick a sort order if you want. Set `maxItems`.
4. ▶️ **Click Start.** The Actor scrolls through search results and enriches every listing. Records appear in the dataset tab as they land.
5. 📥 **Download CSV, Excel, JSON, or XML.** Or stream the dataset into Make, Zapier, Airbyte, or your own webhook.

> ⏱️ **Total time:** under 2 minutes to first record, roughly 10-15 enriched records per minute after that. A 100-listing pull typically completes in 8-12 minutes.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%">

#### 🏷️ Resale entrepreneurs and vintage dealers

- Track competitor prices for the same item across multiple sellers
- Monitor how quickly similar listings sell (likes as a proxy)
- Identify underpriced items for arbitrage across platforms
- Build price history snapshots to time your own listings

</td>
<td width="50%">

#### 📈 Brand protection and monitoring

- Detect unauthorized use of brand name or logo in listings
- Track volume and pricing of grey-market products
- Identify top sellers moving your brand's items secondhand
- Monitor condition grades to understand product longevity

</td>
</tr>
<tr>
<td width="50%">

#### 🔍 Fashion analytics and trend intelligence

- Spot emerging keyword trends before they peak in search volume
- Measure demand signals via likes and listing volume
- Benchmark secondhand prices against retail for margin analysis
- Feed recommendation engines with real resale pricing data

</td>
<td width="50%">

#### 🏢 Marketplace builders and aggregators

- Aggregate Depop listings alongside other resale platforms
- Build comparison tools for buyers shopping across marketplaces
- Power deal-alert systems with real-time listing data
- Enrich existing fashion datasets with secondhand price signals

</td>
</tr>
</table>

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers on circular economy and fashion waste
- Longitudinal studies tracking secondhand price trends over time
- Reproducible research with cited, versioned data pulls
- Classroom exercises on marketplace economics and pricing theory

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie resale app launches
- Data visualizations on fashion trends and brand popularity
- Content research for fashion bloggers, YouTubers, and newsletters
- Personal wardrobing tools and style tracking

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Circular economy research and sustainability reporting
- Advocacy datasets on fashion consumption and waste
- Community tools for ethical sourcing and secondhand promotion
- Investigative journalism on brand resale markets

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI recommendation systems with real fashion data
- Validate product-market hypotheses for resale app ideas before engineering spend
- Train small domain-specific models on fashion categorization
- Test pricing algorithm concepts with live market input

</td>
</tr>
</table>

***

### 🔌 Automating Depop Scraper

Schedule runs, chain into pipelines, or trigger from your own code. The Actor exposes the standard Apify run API so any HTTP client works.

- 🟩 **Node.js:** use the [Apify JavaScript client](https://docs.apify.com/api/client/js) to start runs and read the dataset programmatically.
- 🐍 **Python:** use the [Apify Python client](https://docs.apify.com/api/client/python) for the same operations from a notebook or backend service.
- 📚 **Docs:** see the [Apify Actor API reference](https://docs.apify.com/api/v2#/reference/actors) for raw HTTP examples.

Schedules run from Apify Console without writing any glue. Pick a frequency, attach an input template, and the dataset rebuilds itself on the cadence you choose, ready for webhooks or storage exports.

***

### 🤖 Ask an AI assistant about this scraper

Not sure if this Actor covers your use case? Paste the question below into ChatGPT, Claude, or Gemini.

> "I found the ParseForge Depop Scraper on Apify. It scrapes secondhand fashion listings from Depop including title, brand, price, size, condition, seller, likes, category, and description. I want to \[describe your project]. Can this Actor help me? What input would I use?"

The AI will map your requirements against the input schema and sample output documented above.

***

### ❓ Frequently Asked Questions

<details>
<summary>🔍 <strong>Which products can I scrape?</strong></summary>

Any product Depop's search bar returns. Pass any keyword - brand name, item type, style, color, or any combination. The Actor returns whatever Depop surfaces for that query.

</details>

<details>
<summary>📊 <strong>How many listings can I get per run?</strong></summary>

Depop loads 24 items per scroll and most keyword searches have hundreds to thousands of results. The Actor keeps scrolling until your `maxItems` cap is hit. Free accounts are capped at 10 records, paid accounts at 1,000,000.

</details>

<details>
<summary>⚡ <strong>How fast is it?</strong></summary>

Roughly 10-15 listings per minute with full detail-page enrichment. A 100-item run typically completes in 8-12 minutes. Speed depends on Depop's response times and proxy routing.

</details>

<details>
<summary>🔁 <strong>Does it handle infinite scroll?</strong></summary>

Yes. Depop search uses infinite scroll with 24 items per load. The Actor scrolls to the bottom of the page, waits for new content, and repeats until your cap is reached or no more items load.

</details>

<details>
<summary>🛡️ <strong>How does it bypass Cloudflare?</strong></summary>

The Actor uses Camoufox - a real Firefox browser with authentic TLS fingerprinting - combined with a residential UK proxy. This combination passes both Cloudflare's TLS checks and its IP reputation filters automatically.

</details>

<details>
<summary>✅ <strong>What condition values does Depop use?</strong></summary>

Depop uses: "New with tags", "Like new condition", "Excellent condition", "Good condition", "Fair condition", "Poor condition", and "Well worn". The Actor extracts the condition segment cleanly from Depop's bullet-separated description string.

</details>

<details>
<summary>🗂️ <strong>Is the category field always populated?</strong></summary>

Category comes from breadcrumbs on the product detail page and is populated for most listings. Some sellers do not categorize their items, in which case `category` returns as `null`.

</details>

<details>
<summary>💼 <strong>Can I use this Actor for commercial purposes?</strong></summary>

Yes. Output can power commercial dashboards, resale platforms, analytics products, and internal tooling. You are responsible for how the data is used and stored.

</details>

<details>
<summary>💳 <strong>Do I need a paid Apify plan?</strong></summary>

A free Apify account can run the Actor and preview 10 records per run. Paid plans unlock the full `maxItems` range up to 1,000,000. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp).

</details>

<details>
<summary>❗ <strong>What if a detail page fails to load?</strong></summary>

The Actor catches individual page failures and continues processing the remaining listings. A failed detail page returns `null` for enrichment fields but the search-level fields (imageUrl, brand, price, size, url) are always preserved.

</details>

<details>
<summary>⚖️ <strong>Is scraping Depop legal?</strong></summary>

Only publicly accessible, non-personal listing data is collected. The Actor does not log in, bypass authentication, or pull private user information. Compliance with your local laws and Depop's terms is your responsibility.

</details>

<details>
<summary>🔌 <strong>Does the Actor expose an API?</strong></summary>

Yes. Every Apify Actor has a stable run-and-fetch API. Trigger from Make, Zapier, Airbyte, GitHub Actions, a cron job, or your own backend.

</details>

***

### 🔌 Integrate with any app

Trigger runs, read datasets, and chain workflows from wherever your team already works.

- [**Make**](https://apify.com/integrations) - drag-and-drop scenarios that start a Depop run and route the dataset to a sheet or CRM.
- [**Zapier**](https://apify.com/integrations) - zaps that trigger off new dataset items.
- [**Slack**](https://apify.com/integrations) - post run summaries or new listings to a channel.
- [**Airbyte**](https://apify.com/integrations) - sync the dataset to Postgres, BigQuery, Snowflake, or Redshift.
- [**GitHub Actions**](https://docs.apify.com/api/v2) - run the Actor on every push or on a cron schedule.
- [**Google Drive**](https://apify.com/integrations) - drop CSV exports straight into a shared folder.

***

### 🔗 Recommended Actors

- [**🛍️ Bstock Scraper**](https://apify.com/parseforge/bstock-scraper) - wholesale and liquidation lots from B-Stock auctions, ideal for bulk resale sourcing alongside Depop pricing data.
- [**💼 Upwork Scraper**](https://apify.com/parseforge/upwork-scraper) - freelance job listings from Upwork for market research on the creator economy intersecting with fashion resale.
- [**🏠 Airbnb Scraper**](https://apify.com/parseforge/airbnb-scraper) - short-term rental listings for the same cities your fashion sellers are based in.
- [**🍽️ OpenTable Scraper**](https://apify.com/parseforge/opentable-scraper) - restaurant data for full lifestyle and consumer behavior datasets.
- [**🗺️ Google Maps Scraper**](https://apify.com/parseforge/google-maps-scraper) - local business listings to enrich seller location data with neighborhood context.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more e-commerce, marketplace, and resale scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) and we will get back the same day.

***

> **⚠️ Disclaimer:** Independent tool, not affiliated with Depop or its parent company. Only publicly available listing data is collected. Users are responsible for compliance with applicable laws and Depop's terms of use.

# Actor input Schema

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

Keyword to search for on Depop (e.g. 'vintage jacket', 'nike shoes', 'levi jeans')

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

How to sort search results

## Actor input object example

```json
{
  "search": "jacket",
  "maxItems": 10,
  "sort": "relevance"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "search": "jacket",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/depop-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 = {
    "search": "jacket",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/depop-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 '{
  "search": "jacket",
  "maxItems": 10
}' |
apify call parseforge/depop-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Depop Secondhand Fashion Scraper - Search Listings & Products",
        "description": "Scrape Depop secondhand fashion listings by keyword. Extracts title, brand, price, size, condition, seller, likes, category, description and more.",
        "version": "0.1",
        "x-build-id": "fwF7ZVtQR4Kr5MTL7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~depop-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-depop-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/parseforge~depop-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-depop-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/parseforge~depop-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-depop-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",
                "required": [
                    "search"
                ],
                "properties": {
                    "search": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword to search for on Depop (e.g. 'vintage jacket', 'nike shoes', 'levi jeans')"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "sort": {
                        "title": "Sort Order",
                        "enum": [
                            "relevance",
                            "newlyListed",
                            "priceAscending",
                            "priceDescending"
                        ],
                        "type": "string",
                        "description": "How to sort search results",
                        "default": "relevance"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
