# Depop $1💰 URL Keyword and Review Scraper (`abotapi/depop-scraper`) Actor

From $1/1k. Scrape depop.com search results, listings, shops, and reviews into JSON, CSV, or Excel, including titles, descriptions, prices, shipping, brands, conditions, colours, sizes, photos, and seller profiles.

- **URL**: https://apify.com/abotapi/depop-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 10 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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 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: Items, Shops & Reviews

Pull structured data from Depop without writing a line of code. This actor turns Depop search results, product pages, seller shops, and seller reviews into clean JSON, CSV, or Excel rows. It reads the same JSON the Depop website uses, so every record is complete and consistent: title, full description, price and shipping, brand, condition, colours, sizes, all photos, and the seller's public profile.

Three ways to start: search by keyword with filters, paste any mix of product / search / shop URLs, or list sellers to pull every review they have received.

### Why this scraper

- Three modes in one actor: keyword search, URL input (product, search, or shop), and seller reviews.
- Rich product records: title, description, price breakdown, brand, condition, colours, sizes, every photo, like count, and seller profile.
- Seller reviews on demand: one row per review, with rating, text, date, reviewer, and the product the review is about.
- Source-side filters: brand, category, colour, condition, department, gender, price range, and sort.
- Shop sweep: paste a seller URL and the actor walks every item they have listed.
- Fast and lightweight: reads JSON directly, no heavy page rendering, optional detail enrichment only when you want it.
- 12 marketplaces supported (US, UK, AU, EU, NZ, CA) with the correct currency per market.
- Walks the whole catalogue by default. `maxPages` defaults to 0 (unlimited): the walk keeps going until the source reports its total, a page comes back empty, or a page repeats content already served this walk. There is no artificial page-number ceiling; `maxListings` is the cap you actually want.
- `maxListings` is the sole cap on volume (default 20, so a first run is small and fast; set 0 for unlimited).
- Resumable runs: set `resumeFromRunId` to a previous run or dataset id to collect only the items that run doesn't already have (a delta). Long unlimited runs also checkpoint their progress to the key-value store, so an Apify platform migration or a Resurrect of a failed run picks up where it left off instead of starting over.
- **Resume & recurring updates** — turn on Incremental mode to get only NEW, UPDATED, and REAPPEARED items on a scheduled run of the same search, or use Resume to continue one specific interrupted crawl with `resumeFromRunId`. See "Resume & recurring updates" below.

### Data you get

> Sample shape, values are illustrative placeholders, not from a live listing.

| Field | Example |
| --- | --- |
| id | "000000001" |
| slug | "seller-name-sample-item-0000" |
| url | "https://www.depop.com/products/seller-name-sample-item-0000/" |
| title | "Sample Vintage Jacket" |
| description | "Full item description appears here when fetchDetails is on." |
| price | 30 |
| totalPrice | 30 |
| buyerFee | 0 |
| tax | 0 |
| taxType | "n/a" |
| shippingCost | 5 |
| shippingBoundary | "NATIONAL" |
| shippingId | "USPS" |
| nationalShippingCost | 0 |
| currency | "USD" |
| isReduced | true |
| discountPercentage | 28 |
| originalPriceBeforeDiscount | 70 |
| discountType | "VALUE\_FLASH\_SALE" |
| status | "ONSALE" |
| brandName | "Sample Brand" |
| brandIsKnown | true |
| conditionName | "Like new condition" |
| colours | \["black", "white"] |
| colourIds | \["black", "white"] |
| material | \["Polyester", "Rubber"] |
| age | \["Modern"] |
| style | \["Sportswear", "Streetwear"] |
| source | \["Preloved"] |
| attributeTags | { "occasion": \["Casual"], "trainersType": \["Running"] } |
| categoryName | "Shoes" |
| group | "tops" |
| productTypeName | "Sweatshirts" |
| gender | "unisex" |
| quantity | 1 |
| sizes | \[{ "id": 0, "name": "M", "quantity": 1, "status": "STATUS\_ONSALE" }] |
| variants | \[{ "variantId": 0, "quantity": 1 }] |
| hasFreeShipping | true |
| likeCount | 0 |
| pictures | \["https://media-photos.depop.com/b1/00000000/0000000000\_0000/P0.jpg"] |
| mainPicture | "https://media-photos.depop.com/b1/00000000/0000000000\_0000/P0.jpg" |
| pictureCount | 1 |
| sellerUsername | "sampleseller" |
| sellerId | "00000000" |
| sellerVerified | false |
| sellerItemsSold | 0 |
| sellerReviewsRating | 5 |
| sellerReviewsTotal | 0 |
| sellerLastSeen | "2026-01-01T00:00:00.000Z" |
| sellerOnVacation | false |
| raw | { complete product object with every original field } |

Review rows (Reviews mode) carry these fields instead:

> Sample shape, values are illustrative placeholders.

| Field | Example |
| --- | --- |
| id | "00000000:000000000" |
| kind | "review" |
| role | "seller" |
| rating | 5 |
| text | "Sample review text appears here." |
| date | "2026-01-01T00:00:00.000Z" |
| authorUsername | "samplereviewer" |
| productId | "000000000" |
| productPicture | "https://media-photos.depop.com/b1/00000000/0000000000\_0000/P0.jpg" |
| sellerId | "00000000" |
| sellerUsername | "sampleseller" |
| sellerUrl | "https://www.depop.com/sampleseller/" |
| sellerReviewsTotal | 0 |
| sellerItemsSold | 0 |

**Incremental mode only.** When `incrementalMode` is on, every returned row (product or review) also carries:

| Field | Description |
|---|---|
| `changeType` | `NEW` | `UPDATED` | `REAPPEARED` | `EXPIRED` |
| `changedFields` | Top-level fields that changed since last seen; non-empty only for `UPDATED` |
| `firstSeenAt` | When this item was first observed by this monitoring campaign |
| `lastSeenAt` | When this item was last observed |

### How to use

Search by keyword with filters:

```json
{
  "mode": "search",
  "queries": ["nike vintage", "carhartt jacket"],
  "country": "us",
  "sortBy": "newest",
  "minPrice": 20,
  "maxPrice": 100,
  "maxPages": 5,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US" }
}
```

Search with brand and condition filters plus full detail enrichment:

```json
{
  "mode": "search",
  "queries": ["shoes"],
  "country": "gb",
  "brands": ["270"],
  "conditions": ["used_like_new", "used_excellent"],
  "fetchDetails": true,
  "maxListings": 50,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "GB" }
}
```

Mixed URLs (product page, search page, and a whole shop):

```json
{
  "mode": "url",
  "urls": [
    "https://www.depop.com/products/sampleseller-sample-item-0000/",
    "https://www.depop.com/search/?q=carhartt",
    "https://www.depop.com/sampleseller/"
  ],
  "maxPages": 3,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US" }
}
```

Pull every review for one or more sellers:

```json
{
  "mode": "reviews",
  "sellers": ["sampleseller", "https://www.depop.com/anotherseller/"],
  "reviewRole": "seller",
  "maxPages": 10,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US" }
}
```

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| mode | string | search | search, url, or reviews. |
| queries | array | \["nike vintage"] | Keywords (Search mode). Each runs its own paginated search. |
| country | string | us | Marketplace and currency. Also the default proxy country. |
| sortBy | string | relevance | relevance, newest, price-asc, or price-desc (Search mode). |
| minPrice | integer | (none) | Minimum price in the marketplace currency. |
| maxPrice | integer | (none) | Maximum price in the marketplace currency. |
| gender | string | any | any, female, male, or unisex (Search mode). |
| brands | array | \[] | Numeric brand IDs (Search mode). |
| categories | array | \[] | Numeric category IDs (Search mode). |
| colours | array | \[] | Colour slugs such as black, white, pink (Search mode). |
| conditions | array | \[] | brand\_new, used\_like\_new, used\_excellent, used\_good, used\_fair. |
| groups | array | \[] | Department group slugs such as tops, footwear (Search mode). |
| sizes | array | \[] | Numeric size IDs (Search mode, advanced). |
| urls | array | (example) | Product, search, or shop URLs (URL mode). |
| sellers | array | (example) | Usernames, shop URLs, or numeric IDs (Reviews mode). |
| reviewRole | string | seller | seller or buyer reviews (Reviews mode). |
| maxPages | integer | 0 | Max pages per keyword / URL / shop / seller. 0 means unlimited: the walk stops on its own at the source's reported total, an empty page, or a page that repeats content already served this walk. |
| maxListings | integer | 20 | Total item cap across all keywords / URLs / shops / sellers. The sole volume cap once maxPages is unlimited. 0 means unlimited. |
| fetchDetails | boolean | true | Enrich each item with full description, photos, material/style, and seller stats. Turn off for lighter SERP-only runs. |
| proxy | object | Residential | Proxy configuration. Residential is recommended. |
| resumeFromRunId | string | (none) | Continue one specific previous run/dataset: items already collected there are skipped, so this run only appends new items. For recurring daily monitoring of the same search, use Incremental mode instead — see "Resume & recurring updates" below. |
| incrementalMode | boolean | false | Daily/recurring monitoring of this same search, URLs, or sellers. First run returns everything as `NEW`; later runs return only `NEW`/`UPDATED`/`REAPPEARED` — unchanged items are suppressed (not returned, not billed). See "Resume & recurring updates" below. |
| stateKey | string | (none) | Incremental mode only. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently-configured runs. Leave empty to derive a key automatically from the search/URL/seller and filter settings. |
| emitExpired | boolean | false | Incremental mode only. Also return items from a previous run no longer found, marked `EXPIRED`, once a run has fully scanned the tracked search (Max Pages Per Search and Max Items both unlimited, and Resume not used). Adds and bills extra synthetic rows. |

### Resume & recurring updates

There are two different things here — pick the one that matches what you're doing:

| Need | Use |
| --- | --- |
| A crawl stopped and should continue | `resumeFromRunId` / automatic checkpoint recovery |
| Run the same search/URLs/sellers every day and receive only changes | `incrementalMode` |
| Keep separate daily campaigns for similar searches | distinct `stateKey` values |
| Run a normal full snapshot | leave both off |

**Resume** (`resumeFromRunId`) continues one specific interrupted or previous large crawl: paste a run ID or dataset ID and this run skips items already collected there, returning only the remaining new items. An automatic same-run checkpoint also protects against platform migrations/Resurrects without any input needed.

**Incremental mode** (`incrementalMode`) is for a schedule (for example, daily): the actor remembers the previous run of the *same* search/URLs/sellers by itself, so you never paste a run ID. The first run returns everything as `NEW`. Later runs return only `NEW`, `UPDATED`, and `REAPPEARED` items — items unchanged since the last run are always suppressed (not returned, not charged). Turn on `emitExpired` only when you also want previously-seen items that vanished returned (and billed) as `EXPIRED`. State is isolated per search/URL/seller and filter setup automatically; set `stateKey` to name or deliberately share a monitoring campaign.

Scheduled-run example — same search, run daily:

Day 1 (first run ever for this search):

```json
{ "mode": "search", "queries": ["nike vintage"], "incrementalMode": true }
```

→ every item comes back with `"changeType": "NEW"`.

Day 2 (the schedule fires again, identical input):

```json
{ "mode": "search", "queries": ["nike vintage"], "incrementalMode": true }
```

→ items whose price/status/etc. changed come back as `"changeType": "UPDATED"` with `changedFields` listing what changed, brand-new items come back as `"changeType": "NEW"`, items that vanished and came back come back as `"changeType": "REAPPEARED"` — and items that are still there, unchanged, are **not** returned at all (suppressed, not charged).

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape — the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable **summary** of each record — not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip.

### Output example

> Sample shape, values are illustrative placeholders, not from a live listing.

```json
{
  "id": "000000001",
  "slug": "sampleseller-sample-vintage-jacket-0000",
  "url": "https://www.depop.com/products/sampleseller-sample-vintage-jacket-0000/",
  "title": "Sample Vintage Jacket",
  "description": "Full item description appears here when fetchDetails is on.",
  "price": 30,
  "totalPrice": 30,
  "shippingCost": 5,
  "currency": "USD",
  "isReduced": false,
  "status": "ONSALE",
  "brandName": "Sample Brand",
  "brandId": "0000",
  "conditionName": "Like new condition",
  "colours": ["black"],
  "categoryName": "Coats & Jackets",
  "gender": "unisex",
  "sizes": [{ "id": 0, "name": "M", "quantity": 1 }],
  "likeCount": 0,
  "pictures": ["https://media-photos.depop.com/b1/00000000/0000000000_0000/P0.jpg"],
  "mainPicture": "https://media-photos.depop.com/b1/00000000/0000000000_0000/P0.jpg",
  "sellerId": "00000000",
  "sellerUsername": "sampleseller",
  "sellerVerified": false,
  "sellerItemsSold": 0,
  "sellerReviewsRating": 5,
  "sellerReviewsTotal": 0,
  "countryCode": "US"
}
```

### Plan requirement

This site accepts traffic only from residential connections, so a Residential proxy is required for reliable results. Residential proxy is included on Apify paid plans (Starter and above). On the free plan, runs may return zero items because datacenter connections are rejected by the site.

Pick the marketplace country that matches your target audience; the actor pins the residential proxy to that country by default and quotes prices in the matching currency. You can override the proxy country in the Proxy field.

# Actor input Schema

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

How to find data to scrape. 'search' and 'url' return items; 'reviews' returns one row per review left for the listed sellers.

## `queries` (type: `array`):

Keywords to search for (Search mode only). Multi-keyword supported. Each keyword runs its own paginated search; results are combined.

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

Which regional inventory and currency to use (Search mode). Also used as the default residential proxy country.

## `sortBy` (type: `string`):

Result ordering (Search mode only). Default = relevance.

## `minPrice` (type: `integer`):

Minimum price in the marketplace currency. Leave empty for no minimum.

## `maxPrice` (type: `integer`):

Maximum price in the marketplace currency. Leave empty for no maximum.

## `gender` (type: `string`):

Filter by department (Search mode only).

## `brands` (type: `array`):

Numeric brand IDs (Search mode only). E.g. 270 = Nike. Multiple selectable. Leave empty for all brands.

## `categories` (type: `array`):

Numeric category IDs (Search mode only). E.g. 231 = Shoes. Multiple selectable.

## `colours` (type: `array`):

Colour slugs (Search mode only). E.g. black, white, pink, blue, red, green, multi. Multiple selectable.

## `conditions` (type: `array`):

Condition slugs (Search mode only). One or more of: brand\_new, used\_like\_new, used\_excellent, used\_good, used\_fair.

## `groups` (type: `array`):

Department group slugs (Search mode only). E.g. tops, bottoms, footwear, accessories, coats-jackets. Multiple selectable.

## `sizes` (type: `array`):

Numeric size IDs (Search mode only, advanced). Size IDs are category-specific; leave empty unless you know them.

## `urls` (type: `array`):

Direct Depop URLs (URL mode only). Multi-URL supported. Accepts product URLs (/products/<slug>/), search URLs (/search/?q=...), and shop URLs (/<username>/, which walk every item the seller has listed). Filter fields above are ignored in URL mode.

## `sellers` (type: `array`):

Seller usernames, shop URLs, or numeric user IDs (Reviews mode only). Multi-seller supported; each seller's reviews are surfaced as separate rows.

## `reviewRole` (type: `string`):

Whether to fetch reviews the user received as a seller or as a buyer (Reviews mode only).

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

Maximum pages to walk per keyword / URL / shop / seller. ~24 items per page; up to 20 reviews per page. Set 0 for unlimited (the walk still stops naturally at the end of results; bounded by Max Items).

## `maxListings` (type: `integer`):

Cap across all keywords / URLs / shops / sellers combined. Default 20. Set 0 for unlimited (capped only by Max Pages and the natural end of results).

## `resumeFromRunId` (type: `string`):

Optional. ID of a previous run of this actor (or a dataset ID). Items already in that dataset are skipped, so this run returns only NEW items (a delta). Combine both runs' datasets for the full set. For recurring/scheduled monitoring of the same search, use Incremental mode below instead.

## `incrementalMode` (type: `boolean`):

Turn this on for daily/recurring monitoring of the same search, URLs, or sellers. The first run returns everything as NEW. Later runs return only NEW, UPDATED, and REAPPEARED items — items unchanged since the last run are suppressed (not returned, not billed). State is kept separately per search/URL/seller and filter setup; use State key below to name or deliberately share a monitoring campaign. To continue one specific interrupted run instead, use Resume from a previous run above.

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently-configured runs. Leave empty to let the actor derive a key automatically from the search/URL/seller and filter settings — different setups then never mix state with each other.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return items that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search (Max Pages Per Search and Max Items both set to 0/unlimited, and Resume not used) — this returns and bills extra synthetic rows, so leave it off unless you need expiry tracking.

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

If true (Search/URL mode), the actor fetches each item's detail page to enrich the record with full description, all photos, colours, material, style, condition, category, and seller rating / items-sold stats. Adds one or two requests per item. On by default; turn off for faster, lighter runs that return search-card fields only.

## `proxy` (type: `object`):

Residential proxy is strongly recommended; this site rejects datacenter connections. The default country follows the marketplace country above.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON — the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "nike vintage"
  ],
  "country": "us",
  "sortBy": "relevance",
  "gender": "any",
  "brands": [],
  "categories": [],
  "colours": [],
  "conditions": [],
  "groups": [],
  "sizes": [],
  "urls": [
    "https://www.depop.com/search/?q=carhartt"
  ],
  "sellers": [
    "mishmoshmart"
  ],
  "reviewRole": "seller",
  "maxPages": 0,
  "maxListings": 20,
  "incrementalMode": false,
  "emitExpired": false,
  "fetchDetails": true,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (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 = {
    "mode": "search",
    "queries": [
        "nike vintage"
    ],
    "brands": [],
    "categories": [],
    "colours": [],
    "conditions": [],
    "groups": [],
    "sizes": [],
    "urls": [
        "https://www.depop.com/search/?q=carhartt"
    ],
    "sellers": [
        "mishmoshmart"
    ],
    "incrementalMode": false,
    "emitExpired": false,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/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",
    "queries": ["nike vintage"],
    "brands": [],
    "categories": [],
    "colours": [],
    "conditions": [],
    "groups": [],
    "sizes": [],
    "urls": ["https://www.depop.com/search/?q=carhartt"],
    "sellers": ["mishmoshmart"],
    "incrementalMode": False,
    "emitExpired": False,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/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 '{
  "mode": "search",
  "queries": [
    "nike vintage"
  ],
  "brands": [],
  "categories": [],
  "colours": [],
  "conditions": [],
  "groups": [],
  "sizes": [],
  "urls": [
    "https://www.depop.com/search/?q=carhartt"
  ],
  "sellers": [
    "mishmoshmart"
  ],
  "incrementalMode": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call abotapi/depop-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/PUe0ccR6QW3BQ9OAI/builds/4k1AyhR8KfkEUsFls/openapi.json