# Depop Marketplace Monitor (`nerolabs/depop-marketplace-monitor`) Actor

Returns Depop listings for keyword searches or listing URLs (price, sold status), with a monitor mode alerting on new listings for a search, price drops or sales for an item. Inputs: search queries, listing URLs, monitorMode. Agent-ready: pay per event (x402 and MCP), no charge for blocked checks.

- **URL**: https://apify.com/nerolabs/depop-marketplace-monitor.md
- **Developed by:** [Adam Pearce](https://apify.com/nerolabs) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### What does Depop Marketplace Monitor do?

**Depop Marketplace Monitor** watches [Depop](https://www.depop.com), the secondhand-fashion resale marketplace, two ways: give it a **search** (e.g. "vintage carhartt jacket") and it alerts you the moment a new matching listing appears, or give it specific **listing URLs** and it alerts you on a price drop or the item selling out. Every existing Depop scraper on the Apify Store hands you a flat, one-time list of results; this is the only one that keeps watching so you don't have to refresh the search yourself.

Runs on Apify's infrastructure, so it's schedulable (hourly, daily, whatever fits), API-accessible, and works as a tool inside AI agents via Apify's MCP server. No account, no login, no browser extension to install.

### Why use Depop Marketplace Monitor?

Depop moves fast: the best-priced vintage pieces and rare drops get bought within minutes of listing. Checking a saved search by hand, over and over, is exactly the kind of thing worth automating.

- **Resale buyers and thrifters**: get notified the second something matching your search goes up, before anyone else sees it.
- **Resellers and sourcing teams**: watch a whole category or brand for new stock across many sellers, not just one shop.
- **Sellers**: watch your competitors' listings for price changes or track when their stock sells through.
- **Anyone with a wishlist**: watch a specific listing and get told the moment it drops in price or sells to someone else.

### How to use Depop Marketplace Monitor

1. Click **Try for free** and open the Input tab.
2. Add one or more **search queries** (e.g. "vintage carhartt jacket"), specific **listing URLs**, or both.
3. Leave **Monitor mode** off for a one-time snapshot, or turn it on and give your watchlist a stable **Watchlist ID** to only get charged the full rate when something actually changed.
4. Run it. Results land in the dataset, downloadable as JSON, CSV, or Excel, or pulled via the API.
5. Schedule it (Apify's built-in Scheduler) to run every hour or every day and get a running record of what's new or what changed.

### Input

| Field | Description |
|---|---|
| `searchQueries` | Depop search terms to watch, e.g. `vintage carhartt jacket`. In Monitor mode, alerts on new listings matching the search. |
| `productUrls` | Direct Depop listing URLs to watch, e.g. `https://www.depop.com/products/example-item/`. In Monitor mode, alerts on price drops or the item selling/going unavailable. |
| `maxItemsPerSearch` | How many listings to check per search (default 24, one results page). |
| `monitorMode` | Off: a one-time snapshot. On: remembers your last check per search/item and only flags real changes. |
| `watchlistId` | A name for this watchlist, so it doesn't get mixed up with any other list you run. |
| `proxyCountryCode` | Which country the request should look like it's coming from. `US` is the default. |

### Output

```json
{
  "itemUrl": "https://www.depop.com/products/s0c18-brown-leather-jacket-with-a-5555/",
  "itemSlug": "s0c18-brown-leather-jacket-with-a-5555",
  "watchType": "search",
  "sourceQuery": "vintage carhartt jacket",
  "title": "Men's Burgundy and Brown Jacket",
  "brand": "Carhartt",
  "size": "L",
  "price": 9.0,
  "currency": "USD",
  "sellerUsername": null,
  "likesCount": null,
  "description": null,
  "imageUrl": "https://media-photos.depop.com/r1/.../P0.jpg",
  "soldOrUnavailable": false,
  "monitorMode": true,
  "isFirstCheck": false,
  "changeDetected": true,
  "changeSummary": "New listing matching this search since the last check.",
  "changes": ["New listing matching this search."],
  "fetchIssue": null,
  "checkedAt": "2026-08-13T20:53:29.314Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Data table

| Field | Meaning |
|---|---|
| `watchType` | `search` (from a watched search query) or `item` (from a watched listing URL). |
| `price` / `currency` | The listing's current price, when recognized. |
| `sellerUsername` / `likesCount` / `description` | Only populated for `item`-type results (a search results page doesn't show these per-listing). |
| `soldOrUnavailable` | Best-effort. `true`/`false` when confidently detected, `null` when the page loaded but this couldn't be confirmed, never guessed. |
| `changeDetected` | Monitor mode only: a new listing (search watch) or a real price/availability change (item watch) since your last check. |
| `changeSummary` | Plain-English description of what changed, if anything. |
| `fetchIssue` | Set (and nothing charged) if a check genuinely couldn't get a real answer this run. |

### Pricing

Pay-per-event, you only pay for real answers:

- **$0.015** per one-time listing check (from a search or a direct URL).
- **$0.06** per Monitor mode check where something actually changed, a new listing or a real price/availability change.
- **$0.004** per Monitor mode check that confirms nothing changed (cheap, so daily monitoring stays affordable).

Watching 5 searches and 10 specific listings daily in Monitor mode for a month runs somewhere around **$3-8/month**, depending on how much actually changes. A one-time check of a 24-listing search page runs about **$0.36**.

### Tips

- Give a watchlist a stable `watchlistId` and keep reusing it, that's what makes Monitor mode compare against your actual last check instead of starting fresh every time.
- Broad searches ("jacket") return more noise than narrow ones ("carhartt detroit jacket large"), a narrower search means fewer, more relevant new-listing alerts.
- Hourly scheduling suits genuinely fast-moving categories (rare drops, hyped brands); daily is enough for most searches.

### FAQ

**Is this legal?** Reading a public listing or search page is not illegal. This tool doesn't log in, doesn't bypass any paywall, and only reads what's already publicly visible on the page. Automated access sits outside Depop's own Selling API terms, the same real, known tradeoff as most large marketplaces (the Apify Store already hosts several Depop scrapers), worth knowing rather than hidden, use accordingly.

**Why did a check come back with no data and no charge?** Depop sits behind a Cloudflare bot check. This actor solves it with a real browser automatically; if a check still comes back blocked after every retry, it reports that honestly instead of guessing, and you're not charged for it.

**Why is `soldOrUnavailable` sometimes `null`?** Depop's markup isn't documented and can change without notice. When the page loads but a sold/available state can't be confidently read off it, this actor reports `null` rather than guessing `true` or `false`, so you never get told a live listing is dead or vice versa on a hunch.

Found a bug or have a request? Use the **Issues** tab, it's read personally, not a support bot.

# Actor input Schema

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

Keyword searches on Depop (e.g. 'vintage carhartt jacket'). In Monitor mode, alerts when a new listing matching this search appears since the last check.

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

Direct Depop listing URLs (e.g. https://www.depop.com/products/example-item/). In Monitor mode, alerts on a price drop or the item selling/going unavailable.

## `maxItemsPerSearch` (type: `integer`):

How many listings to check per search query (one search results page, roughly 24 listings).

## `monitorMode` (type: `boolean`):

When on, compares against the last check and only reports what's new: new listings matching a watched search, or a price/availability change on a watched item. When off, this is a one-time snapshot.

## `watchlistId` (type: `string`):

Only used in Monitor mode. Give different watchlists different IDs (e.g. by customer or project) to keep their saved state separate. Leave as 'default' for a single watchlist.

## `proxyCountryCode` (type: `string`):

Country to route the residential proxy through. US is the safest default; change only if you need Depop's localized pricing/availability for a specific country.

## Actor input object example

```json
{
  "searchQueries": [
    "vintage carhartt jacket"
  ],
  "maxItemsPerSearch": 24,
  "monitorMode": false,
  "watchlistId": "default",
  "proxyCountryCode": "US"
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQueries": [
        "vintage carhartt jacket"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nerolabs/depop-marketplace-monitor").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 = { "searchQueries": ["vintage carhartt jacket"] }

# Run the Actor and wait for it to finish
run = client.actor("nerolabs/depop-marketplace-monitor").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 '{
  "searchQueries": [
    "vintage carhartt jacket"
  ]
}' |
apify call nerolabs/depop-marketplace-monitor --silent --output-dataset

```

## MCP server setup

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

```

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/mXMnaimN3TwyiCTeg/builds/dlaAw3mVurybVau2O/openapi.json