# Depop Scraper — Fashion Resale & Sold Items | from $1.50/1K (`s7_studio/depop-scraper`) Actor

Scrape Depop seller shops and product listings via the internal Depop web API. Returns title, brand, category, price, condition, size, seller stats, likes, sold status. No proxy needed. Pay per result.

- **URL**: https://apify.com/s7\_studio/depop-scraper.md
- **Developed by:** [S7 Studio](https://apify.com/s7_studio) (community)
- **Categories:** E-commerce, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.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/actors/running/actors-in-store.md#pay-per-usage

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 — Fashion Resale + Sold Items | from $1.50/1K | First on Store

Built for Depop resellers tracking competitor shop inventory, vintage clothing arbitrageurs comparing Depop to eBay/Vinted prices, and brand researchers monitoring streetwear re-sale values.

**Pricing:** Pay per listing — $1.50/1K (active listings), $2.50/1K (sold items for price research). First 5 results free.

**No proxy. No CAPTCHA. Internal JSON API — not HTML scraping.**

Scrape **Depop seller shops** and product listings at scale via the Depop internal web API. Get brand, category, price, size, condition, likes, sold status, seller stats — all in a clean flat JSON output. No proxy needed. Pay per result.

> **First-mover advantage**: as of May 2026 there are zero dedicated Depop scrapers on the Apify Store. If you need Depop resale data, this is your only automated option.

### What data do you get?

| Field | Description |
|---|---|
| `product_id` | Numeric Depop product ID |
| `title` | Listing title (derived from description first line) |
| `description` | Full listing text |
| `brand` | Brand name (e.g. Nike, Levi's, Adidas) |
| `category` | Category name (e.g. T-shirts, Jeans, Trainers) |
| `size` | Listing size (e.g. S, M, L, 32, UK9) |
| `condition` | Item condition (when available) |
| `price` | Numeric price in listing currency |
| `currency` | ISO currency code (GBP, USD, EUR, AUD…) |
| `seller_username` | Seller's Depop handle |
| `seller_id` | Numeric seller ID |
| `sold` | `true` if item is sold, `false` if active |
| `likes` | Number of likes (from detail fetch) |
| `country` | Seller country code (GB, US, etc.) |
| `image_url` | Highest-resolution listing photo URL |
| `url` | Direct link to the Depop listing |
| `parse_confidence` | Data quality score 0–1 (1.0 = all fields present) |
| `warnings` | Machine-readable quality flags |

### How to use

#### Scrape a seller's shop

Provide one or more Depop usernames to fetch all their active listings:

```json
{
  "sellerUsernames": ["vintagethreads", "depopfashion"],
  "maxResults": 200,
  "includeSold": false
}
```

#### Include sold items (price research)

```json
{
  "sellerUsernames": ["vintagethreads"],
  "includeSold": true,
  "maxResults": 100
}
```

#### Fetch specific product IDs

```json
{
  "productIds": ["660869422", "661695995"]
}
```

#### Filter by brand and price

```json
{
  "sellerUsernames": ["bigvintagestore"],
  "brandFilter": "Nike",
  "minPrice": 20,
  "maxPrice": 100,
  "maxResults": 500
}
```

### Why use this?

#### Zero access friction

Depop's internal web API (`webapi.depop.com`) is reachable from Apify cloud IPs with standard browser impersonation — no residential proxy, no CAPTCHA solving, no Playwright overhead. Cost per run = Apify compute only.

#### Reliable JSON — not HTML scraping

This actor queries the same internal JSON API that the Depop website uses. Unlike HTML scrapers that break every time a CSS class changes, our API-based approach survives Depop frontend redesigns.

#### Dropshipping & resale research

- Find underpriced items before they sell: sort by recently listed
- Track competitor pricing for specific brands/categories
- Identify trending items by likes count
- Build price history by comparing active vs sold listings

#### `parse_confidence` quality signal

Every record ships a `parse_confidence` score (0.0–1.0). A score below 0.8 means key fields are missing and the API response drifted — you'll know immediately if something breaks, without digging through empty datasets.

### Limitations

- **No keyword search**: Depop's public search API (`/api/v2/search/products/`) was deprecated (HTTP 410). This actor works on seller shops and direct product IDs. To find items, scrape known sellers or discover seller usernames from Depop manually.
- **No condition field**: Depop does not expose the item condition (new/like new/good/fair/poor) in the public listing API. The `condition` field will be `null`.
- **No created\_at**: Listing date is not available in the public listing API. The `created_at` field will be `null`.
- **Sold items order**: Sold items are returned newest-sold-first.

### vs. competitors

| Feature | This actor | Any alternative |
|---|---|---|
| Dedicated Depop scraper | Yes (first on Store) | None as of May 2026 |
| Internal API (not HTML) | Yes | N/A |
| Sold items + price | Yes | N/A |
| parse\_confidence | Yes | N/A |

### Use with AI agents (MCP)

This actor is tagged `MCP_SERVERS` — compatible with Claude, GPT-4o, and other MCP-aware agents:

```
https://mcp.apify.com/?tools=bovi/depop-scraper
```

### Pricing example

| Volume | Mode | Cost |
|---|---|---|
| 100 listings | Active | $0.15 |
| 1,000 listings | Active | $1.50 |
| 100 listings | Sold items | $0.25 |
| 1,000 listings | Sold items | $2.50 |

First 5 results are free. Sold items (with `sold: true`) use the $2.50/1K rate — active listings use $1.50/1K.

### FAQ

**Do I need a proxy or Depop account?**
No. The actor uses Depop's internal web API (`webapi.depop.com`) which is accessible from Apify cloud IPs with standard browser headers — no proxy, no login needed.

**Can I search Depop by keyword?**
Not currently — Depop deprecated their public search API (returns HTTP 410). You must scrape by seller username or direct product IDs. To find sellers, browse Depop manually and note usernames.

**What output formats are available?**
JSON (default), CSV, and Excel — via the Apify dataset export or API.

**What if a seller username returns empty?**
Confirm the username exists on Depop (case-insensitive). Private shops return no listings. The actor logs a warning and moves to the next username — it does not crash.

### Pricing

Pay per listing — $1.50/1K (active), $2.50/1K (sold items for price research). First 5 results free.

### Integrations

Built for fashion resellers and vintage arbitrageurs tracking competitor inventory and sold-item prices across Depop shops — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

### Legal

This actor fetches publicly visible listing data from Depop's own web API — the same data shown to any unlogged visitor browsing the site. Use of this data is subject to Depop's Terms of Service. The actor developer is not affiliated with Depop.

# Actor input Schema

## `sellerUsernames` (type: `array`):

Depop seller usernames to scrape (e.g. 'vintagethreads', 'depopfashion'). Each username fetches that seller's active listings.

## `productIds` (type: `array`):

Specific Depop product IDs to fetch details for (numeric IDs from product URLs). Used in productIds mode.

## `maxResults` (type: `integer`):

Maximum number of listings to return per seller (0 = no limit, fetches all pages). Default 100.

## `includeSold` (type: `boolean`):

Also scrape sold listings for each seller (in addition to active listings). Useful for dropshipping research and price history. Default false.

## `includeSellerInfo` (type: `boolean`):

Fetch and embed seller profile data (followers, reviews\_rating, items\_sold) in each listing record. Adds 1 API call per seller. Default true.

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

Skip listings with price below this value (in the seller's currency). 0 = no minimum.

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

Skip listings with price above this value. 0 = no maximum.

## `brandFilter` (type: `string`):

Only return listings where brand\_name contains this string (case-insensitive). Leave blank for all brands.

## `conditionFilter` (type: `string`):

Only return listings with this condition. One of: new, like\_new, good, fair, poor. Leave blank for all.

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

Optional Apify proxy configuration. The Depop internal API works without a proxy from Apify cloud IPs. Only needed if you observe 403 errors.

## Actor input object example

```json
{
  "sellerUsernames": [
    "vintagethreads"
  ],
  "productIds": [],
  "maxResults": 100,
  "includeSellerInfo": true,
  "proxyConfiguration": {}
}
```

# Actor output Schema

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

Dataset containing Depop Scraper records (title, brand, category, size, price, sold, likes, seller\_username, country, url, parse\_confidence).

# 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 = {
    "sellerUsernames": [
        "vintagethreads"
    ],
    "productIds": [],
    "maxResults": 100,
    "includeSold": false,
    "includeSellerInfo": true,
    "minPrice": 0,
    "maxPrice": 0,
    "brandFilter": "",
    "conditionFilter": "",
    "proxyConfiguration": {}
};

// Run the Actor and wait for it to finish
const run = await client.actor("s7_studio/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 = {
    "sellerUsernames": ["vintagethreads"],
    "productIds": [],
    "maxResults": 100,
    "includeSold": False,
    "includeSellerInfo": True,
    "minPrice": 0,
    "maxPrice": 0,
    "brandFilter": "",
    "conditionFilter": "",
    "proxyConfiguration": {},
}

# Run the Actor and wait for it to finish
run = client.actor("s7_studio/depop-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "sellerUsernames": [
    "vintagethreads"
  ],
  "productIds": [],
  "maxResults": 100,
  "includeSold": false,
  "includeSellerInfo": true,
  "minPrice": 0,
  "maxPrice": 0,
  "brandFilter": "",
  "conditionFilter": "",
  "proxyConfiguration": {}
}' |
apify call s7_studio/depop-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s7_studio/depop-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/pVzAvF98mzvFjas9e/builds/mKJxdjr7vf4Jxf4Ey/openapi.json