# Depop Scraper (`khadinakbar/depop-scraper`) Actor

Scrape public Depop listings by keyword or product URL with prices, brands, sizes, images, seller stats, and detail enrichment. MCP-ready.

- **URL**: https://apify.com/khadinakbar/depop-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Automation, MCP servers
- **Stats:** 9 total users, 2 monthly users, 93.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 listing scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

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

Depop Scraper is an Apify Actor for public Depop listings. It accepts keyword searches or direct public product URLs, then returns one dataset record per listing. Each record can include product URL, title, price, brand, size, condition, images, seller stats, and detail enrichment fields. The Actor is usable through Apify MCP and is built for workflows that need structured public marketplace records instead of screenshots or copied page text.

### Best fit and connected workflows

Use this Actor when your workflow starts from public Depop discovery and needs normalized listing data.

It fits well when you want to:

- Search public Depop results by keyword such as `vintage levis` or `carhartt jacket`.
- Enrich a known Depop product URL with listing metadata and seller signals.
- Read a compact dataset row per listing for analysis, filtering, or downstream automation.
- Feed an AI agent a predictable public marketplace record through Apify MCP.
- Compare public product details across multiple keywords or URLs in a single run.

This Actor is designed as a focused workflow.

### Opening contract

This Actor accepts public Depop search terms or public Depop product URLs. One output record represents one listing. The most valuable fields are `productUrl`, `title`, `price`, `brandName`, `size`, `condition`, `likeCount`, `sellerUsername`, `sellerItemsSold`, `imageUrl`, and, when detail enrichment is enabled, `description`, `sizes`, `colors`, `sellerReviewCount`, and `sellerRating`. The outcome is a flat dataset of public listing records plus machine-readable run summary data in the default key-value store.

### Practical scenario

Maya works on resale pricing for a vintage store. She starts with the search term `carhartt jacket` and sets a small `maxItems` cap to review a short sample of public listings. The returned records show `title`, `price`, `size`, `condition`, `sellerUsername`, and `sellerItemsSold`. Maya uses those fields to compare listing style, then opens the `productUrl` for the items that look closest to her inventory.

### Input fields

| Field | Type | Purpose |
| --- | --- | --- |
| `mode` | string | Choose `search` for keywords or `productUrls` for specific listings. |
| `searchQueries` | array of strings | Depop search terms to scrape in search mode. |
| `productUrls` | array of strings | Direct public Depop product URLs to enrich in product URL mode. |
| `country` | string | Marketplace context for search results and pricing, such as `us` or `gb`. |
| `maxItems` | integer | Hard cap on listings returned and billed across the run. |
| `maxPages` | integer | Maximum search API pages to request per keyword when available. |
| `fetchDetails` | boolean | Enrich listings with product page fields such as description, sizes, colors, and seller stats. |
| `proxyConfiguration` | object | Optional Apify or custom proxy settings. |

### Focused input example

```json
{
  "mode": "search",
  "searchQueries": ["vintage levis", "carhartt jacket"],
  "country": "us",
  "maxItems": 10,
  "maxPages": 1,
  "fetchDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

### Output fields

| Field | Type | Meaning |
| --- | --- | --- |
| `productId` | string | Depop numeric product identifier when available. |
| `slug` | string | Product slug parsed from the URL. |
| `productUrl` | string | Canonical public Depop product URL. |
| `title` | string | Product title from search or detail data. |
| `description` | string | Public product description when enrichment is enabled. |
| `brandName` | string | Brand shown on the listing or product detail. |
| `price` | number | Current item price. |
| `originalPrice` | number | Original price before discount when exposed. |
| `shippingPrice` | number | Shipping price when exposed. |
| `currency` | string | Currency code attached to the price. |
| `size` | string | Primary visible size label. |
| `sizes` | array of strings | All size labels returned by product detail. |
| `condition` | string | Depop condition label when available. |
| `colors` | array of strings | Color labels attached to the listing. |
| `category` | string | Most specific category shown for the listing. |
| `categoryPath` | array of strings | Category path from broadest to most specific. |
| `gender` | string | Department or gender value returned by Depop. |
| `likeCount` | integer | Public like count when available. |
| `isSold` | boolean | Whether Depop marks the listing as sold or unavailable. |
| `isReduced` | boolean | Whether Depop marks the current price as reduced. |
| `availability` | string | Schema.org availability or Depop status value. |
| `sellerUsername` | string | Seller handle inferred from the product slug or detail page. |
| `sellerRating` | number | Seller average review rating from product detail. |
| `sellerReviewCount` | integer | Number of seller reviews shown on product detail. |
| `sellerItemsSold` | integer | Seller items-sold count shown on product detail. |
| `sellerLastSeen` | string | Seller activity string returned by Depop. |
| `sellerAverageShippingDays` | integer | Seller average shipping days when exposed. |
| `imageUrl` | string | Primary product image URL. |
| `imageUrls` | array of strings | Product image gallery URLs when detail enrichment is enabled. |
| `searchQuery` | string | Search term that produced the record in search mode. |
| `sourceType` | string | Discovery source such as `search-api`, `browser-search`, `product-url`, or `search-index`. |
| `scrapedAt` | string | Timestamp when the listing was captured. |

### Output example

```json
{
  "productId": "812243847",
  "slug": "redheadthreadf-vintage-y2k-levis-501-jeans-1a85",
  "productUrl": "https://www.depop.com/products/redheadthreadf-vintage-y2k-levis-501-jeans-1a85/",
  "title": "Levi's Men's Blue Jeans",
  "description": "Vintage Y2K Levi's 501 jeans. Tagged 32. Great condition.",
  "brandName": "Levi's",
  "price": 15,
  "originalPrice": 34.99,
  "shippingPrice": 1.99,
  "currency": "USD",
  "size": "32\"",
  "sizes": ["32\""],
  "condition": "Excellent condition",
  "colors": ["Blue"],
  "category": "Jeans",
  "categoryPath": ["Menswear", "Bottoms", "Jeans"],
  "gender": "male",
  "likeCount": 12,
  "isSold": false,
  "isReduced": true,
  "availability": "https://schema.org/InStock",
  "sellerUsername": "redheadthreadf",
  "sellerRating": 5,
  "sellerReviewCount": 323,
  "sellerItemsSold": 2120,
  "sellerLastSeen": "active_today",
  "sellerAverageShippingDays": 3,
  "imageUrl": "https://media-photos.depop.com/b1/example/P0.jpg",
  "imageUrls": ["https://media-photos.depop.com/b1/example/P0.jpg"],
  "searchQuery": "vintage levis",
  "sourceType": "search-api",
  "scrapedAt": "2026-07-08T14:55:00.000Z"
}
```

### How it works

The Actor first tries Depop's public search API route for keyword runs. When that route is challenged, it uses a browser-loaded search page and records the listings it can verify. In product URL mode, it opens each public product URL and enriches the record from the page data and visible product metadata. The output dataset uses a stable flat shape, and the run summary is written to the default key-value store in `OUTPUT` and `RUN_SUMMARY`.

The implementation also includes HTTP search with browser fallback, product URL mode, optional detail enrichment, and all five Apify schemas described in the live contract.

### Pricing

This Actor uses Pay per event pricing plus Apify platform usage.

- Actor start: charged once per run, scaled by allocated RAM.
- Listing scraped: charged once per Depop listing returned with product URL, price or product details, and marketplace metadata.

The live price is shown in the Pricing tab of the Actor page. For example, a run capped at ten listings charges for up to ten `Listing scraped` events, plus the run start event, and any Apify platform usage such as proxy or storage is billed separately according to your Apify account settings.

### Use with AI agents (MCP)

This Actor is usable through Apify MCP as a tool for fetching public Depop listing records.

**Tool description:** Scrape public Depop listings by keyword or product URL, then return one dataset row per listing with public marketplace fields such as price, brand, size, images, seller stats, and a machine-readable run summary.

**Actor identity:** `khadinakbar/depop-scraper`

> Find public Depop listings for the keyword "vintage levis" in the US marketplace. Return up to 10 items, include detail enrichment, and give me the dataset records plus the run summary.

The dataset records are flat and easy to interpret in agents or downstream automations. Use `title`, `price`, `brandName`, `size`, `condition`, `sellerUsername`, and `imageUrl` for quick ranking or summarization. `sourceType` shows whether a record came from the search API, browser search, or a direct product URL. `productUrl` provides provenance back to the public listing. `maxPages` controls how many keyword search pages are requested when the lightweight route is available, while `maxItems` caps the number of listings returned and billed across the whole run. When Depop challenges the API route, the Actor falls back to verified browser-loaded results and records the route in the output summary.

### JavaScript example

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

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const run = await client.actor('khadinakbar/depop-scraper').call({
  mode: 'search',
  searchQueries: ['vintage levis'],
  country: 'us',
  maxItems: 5,
  maxPages: 1,
  fetchDetails: true,
  proxyConfiguration: {
    useApifyProxy: false,
  },
});

const dataset = await client.dataset(run.defaultDatasetId).listItems();
console.log(dataset.items);

const output = await client.keyValueStore(run.defaultKeyValueStoreId).getRecord('OUTPUT');
console.log(output);
```

### Best results and outcome guidance

Use one clear discovery path per run: keyword search for market sampling, or product URLs for known items. Set `maxItems` to the number of listings you want to review, and raise `maxPages` only when you want more keyword coverage. Turn `fetchDetails` on when you need seller stats, images, and product-page enrichment. Turn it off when you only need a quick public listing inventory sample.

### Continue the workflow

- Then use [eBay Scraper - Sold Prices, Listings & Sellers (8 Markets)](https://apify.com/khadinakbar/ebay-all-in-one-scraper) to extend Depop Scraper with a neighboring commerce research source when the brief calls for Ebay data.
- Then use [Craigslist Scraper - Jobs, Housing, Cars, Services API](https://apify.com/khadinakbar/craigslist-all-in-one-scraper) to extend Depop Scraper with a neighboring commerce research source when the brief calls for Craigslist data.

### Design note

I found that every dataset record is required to include `productUrl`, `sourceType`, and `scrapedAt`, which makes those fields the safest anchor for downstream automation.

### FAQ

#### Is this Actor for public Depop search results or private account data?

It is for public Depop listings and public product pages.

#### Can I start from a list of product URLs?

Yes. Use `mode: "productUrls"` and pass direct public Depop product URLs.

#### Does one output row represent one listing?

Yes. Each dataset row represents one Depop listing.

#### What should I use when I want seller stats and images?

Set `fetchDetails: true` so the Actor opens each product page and enriches the record.

#### Can I use this Actor through Apify MCP?

Yes. It is MCP-ready and can be called as the Apify Actor `khadinakbar/depop-scraper`.

#### How do I control run size and cost?

Use `maxItems` to cap the number of listings and review the live Pricing tab for the current event charges.

### Responsible use

Use this Actor only for public marketplace data and lawful workflows. Respect Depop's terms, platform access rules, and privacy expectations. Keep usage focused on public listings, product pages, and the fields exposed by the Actor's input and output schemas.

# Actor input Schema

## `mode` (type: `string`):

Choose how the actor finds Depop listings. Use 'search' to scrape public search results for one or more keywords, or 'productUrls' to enrich specific Depop product URLs. Defaults to 'search'. This is not a seller review scraper or a login-based shop manager.

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

Depop search terms to scrape in search mode, for example 'vintage levis' or 'y2k baby tee'. Each keyword is run separately and results are deduped by product URL. Defaults to 'vintage levis'. This is not a full-site crawl or authenticated saved search.

## `productUrls` (type: `array`):

Direct Depop product URLs to enrich in productUrls mode, for example 'https://www.depop.com/products/shopname-item-slug/'. Multiple URLs are supported and are deduped before scraping. Leave empty in search mode. This does not accept generic website URLs.

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

Country context for Depop search results and pricing, using lowercase ISO-like market codes such as 'us' or 'gb'. Defaults to 'us'. The country also informs the currency used by search requests. This is not a shipping destination filter.

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

Hard cap on the number of Depop listings returned and billed across the whole run. Defaults to 10 and can be set as low as 1 for a cheap test. The actor stops charging once this cap is reached. This is not a page count.

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

Maximum Depop search API pages to request per keyword when the lightweight API route is available. Each page is about 24 listings. Defaults to 1 so default runs finish quickly. If Depop challenges the API route, the actor falls back to the browser-loaded listings it can verify instead of pretending pagination worked.

## `fetchDetails` (type: `boolean`):

Open each product page to enrich listings with full title, description, image gallery, condition, colors, seller review count, items sold, and shipping signals. Defaults to true for richer records. Turn it off for faster keyword inventory checks. This does not log in or scrape private buyer data.

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

Optional custom or Apify proxy settings. When left blank, the actor uses its managed mobile proxy for better resistance to Depop's edge protection. Supply your own proxy only when you need to control egress or billing.

## Actor input object example

```json
{
  "mode": "search",
  "searchQueries": [
    "vintage levis"
  ],
  "productUrls": [],
  "country": "us",
  "maxItems": 1,
  "maxPages": 1,
  "fetchDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Dataset items containing Depop product URLs, titles, prices, brands, sizes, conditions, image URLs, seller stats, source query, and scrape timestamp.

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

Machine-readable run summary with mode, query counts, fallback route, item count, charge count, warnings, and status message.

## `runSummary` (type: `string`):

Machine-readable terminal outcome, counters, warnings, and billing details.

# 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 = {
    "mode": "search",
    "searchQueries": [
        "vintage levis"
    ],
    "productUrls": [],
    "country": "us",
    "maxItems": 1,
    "maxPages": 1,
    "fetchDetails": false,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "mode": "search",
    "searchQueries": ["vintage levis"],
    "productUrls": [],
    "country": "us",
    "maxItems": 1,
    "maxPages": 1,
    "fetchDetails": False,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "mode": "search",
  "searchQueries": [
    "vintage levis"
  ],
  "productUrls": [],
  "country": "us",
  "maxItems": 1,
  "maxPages": 1,
  "fetchDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call khadinakbar/depop-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/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/HDXYspABiBT15QUBl/builds/NylXDRr7lmwpZgZww/openapi.json