# Depop Scraper — search & extract listings (`serene_trombone/depop-scraper`) Actor

Scrape Depop marketplace listings across 9 countries. Extract prices, brands, sizes, condition, seller data, images, and more from the peer-to-peer fashion marketplace.

- **URL**: https://apify.com/serene\_trombone/depop-scraper.md
- **Developed by:** [Steven Bennett](https://apify.com/serene_trombone) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## Depop Scraper

> Extract listings from [Depop](https://www.depop.com/) — the global peer-to-peer marketplace for vintage, streetwear, and second-hand fashion with 30M+ registered users across 9 countries.

**First Depop scraper on Apify Store.** No competition in this niche.

![Depop Scraper demo](screenshot.jpg)

---

### Features

- 🔍 **Search anything** — keyword, category, price range filters
- 🌍 **9 country domains** — US, UK, France, Italy, Spain, Germany, Australia, New Zealand, Canada
- 📊 **Rich data** — price, brand, size, condition, category, photos, seller info, likes count, views
- 🔄 **Smart sorting** — newest, oldest, price low→high, price high→low
- 🛡️ **Anti-bot resistant** — headless browser with stealth plugins handles Depop blocking
- 📦 **Multi-strategy extraction** — API interception, `__NEXT_DATA__` parsing, DOM fallback
- 💰 **Pay-per-event** — you only pay for what you use

### Pricing

| Event | Price |
|-------|-------|
| **Start** | $0.50 per run |
| **Per item** | $0.0020 per listing ($2.00 / 1,000 items) |

A typical search for "vintage dress" (~960 results) would cost **~$2.42**. A small search (50 results) costs **~$0.60**.

### Quick Start

#### Via Apify Console

1. Go to [Depop Scraper](https://console.apify.com/actors/serene_trombone/depop-scraper) in Apify Console
2. Click **Run** and fill in the fields:
   - `search` — what to look for (e.g. "Levi's 501")
   - `country` — Depop domain (e.g. `com`, `co.uk`, `fr`)
   - `maxItems` — how many listings to scrape
3. Wait for the run to complete
4. Download results as JSON, CSV, or Excel

#### Via API

```bash
curl -X POST "https://api.apify.com/v2/acts/serene_trombone~depop-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "search": "vintage dress",
    "country": "com",
    "maxItems": 100,
    "order": "price_low_to_high"
  }'
````

#### Via Apify SDK (Node.js)

```javascript
import { Actor } from 'apify';

const run = await Actor.call('serene_trombone/depop-scraper', {
  search: 'Nike Air Max',
  country: 'co.uk',
  maxItems: 50,
});

const { items } = await Actor.openDataset(run.defaultDatasetId);
console.log(items);
```

#### Via Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("serene_trombone/depop-scraper").call(
    run_input={
        "search": "Levi's jeans",
        "country": "com",
        "maxItems": 100,
    }
)
dataset = client.dataset(run["defaultDatasetId"])
items = dataset.list_items().items
print(items)
```

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `search` | `string` | **required** | Search keyword or phrase |
| `country` | `string` | `com` | Depop domain: `com`, `co.uk`, `fr`, `it`, `es`, `de`, `au`, `nz`, `ca` |
| `maxItems` | `number` | `100` | Max listings to scrape (1–100,000) |
| `category` | `string` | — | Category filter (e.g. `tops`, `dresses`, `shoes`) |
| `minPrice` | `number` | — | Minimum price in local currency |
| `maxPrice` | `number` | — | Maximum price in local currency |
| `order` | `string` | `newest` | Sort: `newest`, `oldest`, `price_low_to_high`, `price_high_to_low` |
| `proxyConfiguration` | `object` | Apify proxy | Proxy configuration (recommended) |

### Output Schema

Each scraped listing returns the following fields:

| # | Field | Type | Description |
|---|-------|------|-------------|
| 1 | `id` | `string \| number` | Unique Depop item ID |
| 2 | `title` | `string \| null` | Listing title |
| 3 | `brand` | `string \| null` | Brand name (e.g. Levi's, Nike, Zara) |
| 4 | `price` | `number \| null` | Item price |
| 5 | `currency` | `string \| null` | Currency code (USD, GBP, EUR, etc.) |
| 6 | `size` | `string \| null` | Size label (e.g. "M", "UK 8", "One Size") |
| 7 | `condition` | `string \| null` | Item condition (e.g. "New", "Used - Good") |
| 8 | `category` | `string \| null` | Product category |
| 9 | `description` | `string \| null` | Full item description (detail mode) |
| 10 | `material` | `string \| null` | Material composition (when available) |
| 11 | `colour` | `string \| null` | Item colour (when available) |
| 12 | `image` | `string \| null` | Main photo URL |
| 13 | `images` | `string[]` | All photo URLs |
| 14 | `url` | `string \| null` | Direct link to the listing on Depop |
| 15 | `likesCount` | `number` | Number of likes |
| 16 | `viewCount` | `number` | Number of views (detail mode) |
| 17 | `sellerId` | `number \| null` | Depop user ID of the seller |
| 18 | `sellerUsername` | `string \| null` | Seller's username |
| 19 | `sellerAvatar` | `string \| null` | Seller's profile picture URL |
| 20 | `sellerBio` | `string \| null` | Seller's bio text (detail mode) |
| 21 | `country` | `string` | Country code (e.g. `com`, `co.uk`) |
| 22 | `domain` | `string` | Domain scraped (e.g. `www.depop.com`) |
| 23 | `scrapedAt` | `string` | ISO 8601 timestamp of when the item was scraped |

### Sample Output

```json
{
  "id": 123456789,
  "title": "Vintage 90s Levi's 501 Jeans",
  "brand": "Levi's",
  "price": 45.00,
  "currency": "USD",
  "size": "W30 L32",
  "condition": "Used - Good",
  "category": "Jeans",
  "image": "https://media.depop.com/products/.../image.jpg",
  "images": [
    "https://media.depop.com/products/.../image1.jpg",
    "https://media.depop.com/products/.../image2.jpg"
  ],
  "url": "https://www.depop.com/products/seller123-vintage-501/",
  "likesCount": 12,
  "viewCount": 234,
  "sellerId": 987654,
  "sellerUsername": "vintage_seller",
  "sellerAvatar": "https://media.depop.com/users/.../avatar.jpg",
  "sellerBio": "curating vintage since 2020",
  "country": "com",
  "domain": "www.depop.com",
  "scrapedAt": "2026-07-04T12:00:00.000Z"
}
```

### Use Cases

- **Reseller research** — find underpriced items, track trending styles
- **Brand monitoring** — track second-hand value of brands over time
- **Market analysis** — fashion economics, pricing trends, vintage market research
- **Competitive intelligence** — monitor competitor listings and pricing
- **Data collection** — AI/ML training datasets for fashion models, size recommender systems
- **Price tracking** — monitor price drops and newly listed items

### Rate Limits & Anti-Bot

Depop uses bot detection and may block aggressive scraping. This Actor handles it with:

- ✅ Headless Playwright browser (full JS rendering)
- ✅ Session rotation with Apify proxy
- ✅ Retry logic with backoff
- ✅ Stealth plugin to avoid detection
- ✅ API interception for efficient data extraction
- ✅ Multi-strategy fallback (API → `__NEXT_DATA__` → DOM)

Using the Actor without Apify proxy may result in blocking.

### Technical Details

The scraper uses a **three-layer extraction strategy**:

1. **API Interception** — Captures JSON responses from Depop's internal API as the page loads
2. **`__NEXT_DATA__` parsing** — Extracts Next.js server-rendered data payload
3. **DOM fallback** — Parses product cards from the rendered HTML as last resort

**Stack:** Crawlee (PlaywrightCrawler) · Node.js 20 · Apify SDK

### Changelog

#### v1.0 — 2026-07-04

- Initial release
- 9 country domain support
- Full search/filter pipeline
- Multi-strategy data extraction
- API response interception
- Deduplication by item ID

***

*Built with 🛠️ by Meester Bot · Not affiliated with Depop*

# Actor input Schema

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

What to search for on Depop (e.g. 'Levi's jeans', 'vintage dress', 'Nike trainers')

## `country` (type: `string`):

Depop domain to scrape. Affects currency and search results.

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

Maximum number of listings to scrape. 0 = unlimited (scrapes all available pages).

## `category` (type: `string`):

Filter by category (e.g. 'tops', 'dresses', 'shoes', 'accessories'). Leave empty for all categories.

## `minPrice` (type: `number`):

Minimum price in local currency. Leave empty for no minimum.

## `maxPrice` (type: `number`):

Maximum price in local currency. Leave empty for no maximum.

## `order` (type: `string`):

How to sort search results on Depop

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

⚠️ Depop may block datacenter IPs. Use residential proxies for reliable scraping (Apify Proxy Residential add-on, or bring your own).

## Actor input object example

```json
{
  "search": "vintage dress",
  "country": "com",
  "maxItems": 100,
  "order": "newest"
}
```

# 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": "vintage dress"
};

// Run the Actor and wait for it to finish
const run = await client.actor("serene_trombone/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": "vintage dress" }

# Run the Actor and wait for it to finish
run = client.actor("serene_trombone/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": "vintage dress"
}' |
apify call serene_trombone/depop-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Depop Scraper — search & extract listings",
        "description": "Scrape Depop marketplace listings across 9 countries. Extract prices, brands, sizes, condition, seller data, images, and more from the peer-to-peer fashion marketplace.",
        "version": "1.0",
        "x-build-id": "reEAhDOs3kza48F0l"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/serene_trombone~depop-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-serene_trombone-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/serene_trombone~depop-scraper/runs": {
            "post": {
                "operationId": "runs-sync-serene_trombone-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/serene_trombone~depop-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-serene_trombone-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 term",
                        "type": "string",
                        "description": "What to search for on Depop (e.g. 'Levi's jeans', 'vintage dress', 'Nike trainers')"
                    },
                    "country": {
                        "title": "Country / domain",
                        "enum": [
                            "com",
                            "co.uk",
                            "fr",
                            "it",
                            "es",
                            "de",
                            "au",
                            "nz",
                            "ca"
                        ],
                        "type": "string",
                        "description": "Depop domain to scrape. Affects currency and search results.",
                        "default": "com"
                    },
                    "maxItems": {
                        "title": "Max items to scrape",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape. 0 = unlimited (scrapes all available pages).",
                        "default": 100
                    },
                    "category": {
                        "title": "Category filter (optional)",
                        "type": "string",
                        "description": "Filter by category (e.g. 'tops', 'dresses', 'shoes', 'accessories'). Leave empty for all categories."
                    },
                    "minPrice": {
                        "title": "Minimum price (optional)",
                        "type": "number",
                        "description": "Minimum price in local currency. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum price (optional)",
                        "type": "number",
                        "description": "Maximum price in local currency. Leave empty for no maximum."
                    },
                    "order": {
                        "title": "Sort order",
                        "enum": [
                            "newest",
                            "oldest",
                            "price_low_to_high",
                            "price_high_to_low"
                        ],
                        "type": "string",
                        "description": "How to sort search results on Depop",
                        "default": "newest"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "⚠️ Depop may block datacenter IPs. Use residential proxies for reliable scraping (Apify Proxy Residential add-on, or bring your own)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```