# Mercari + Poshmark + Depop Scraper (`crawlerbros/mercari-poshmark-depop-scraper`) Actor

Tri-platform fashion-resale scraper. Pull listings, sellers, brand pages, categories, and individual items from Mercari (US), Poshmark, and Depop with one actor, search by keyword, browse a category, fetch a single item, or list everything in a seller's closet/profile.

- **URL**: https://apify.com/crawlerbros/mercari-poshmark-depop-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 11 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 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

## Mercari + Poshmark + Depop Scraper

Tri-platform fashion-resale scraper. Pull listings, sellers, brand pages, categories, and individual items from **Mercari (US)**, **Poshmark**, and **Depop** with a single actor — no login required.

Use it to track competitor pricing, monitor a brand's secondhand availability, audit a seller's catalog, or build a multi-marketplace dataset of secondhand fashion in one place.

### What you can scrape

| Platform | Search by query | By item URL | By seller / closet | By brand | By category | Auto-detect URL |
|---|:---:|:---:|:---:|:---:|:---:|:---:|
| **Depop**     | yes | yes | yes | yes | — | yes |
| **Poshmark**  | yes | yes | yes | yes | yes | yes |
| **Mercari**   | yes | yes | yes | — | yes | yes |

Every mode pushes flat, omit-empty records to the dataset — no nested null/empty fields.

### Output fields

Listing records (the most common shape — fields populated when available):

- **Identity**: `platform`, `id`, `title`, `slug`, `url`, `recordType` (`listing`)
- **Pricing**: `price`, `currency`, `originalPrice`, `discountedPrice`
- **Photos**: `coverImageUrl`, `imageUrls[]`
- **Attributes**: `brand`, `category`, `categoryPath[]`, `categoryFeatures[]`, `condition`, `sizes[]`, `colors[]`
- **State**: `status` (e.g. `on_sale`, `published`, `sold`), `available`, `multiItem`
- **Engagement**: `likesCount`, `commentsCount`
- **Timestamps**: `createdAt`, `updatedAt`, `createdAtUnix`, `updatedAtUnix`
- **Seller** (nested): `id`, `username`, `displayName`, `url`, `avatarUrl`, `country`, `ratingScore`, `reviewCount`, `numItemsOnSale`, `isAmbassador`, `isBoutique`
- **Mercari extras**: `shippingPayer`, `shippingFromArea`
- **Depop extras**: `fullDescription`

Seller records (`recordType: "seller"`):

- `platform`, `id`, `username`, `displayName`, `url`, `avatarUrl`
- `bio`, `city`, `state`, `country`
- `followersCount`, `followingCount`, `listingCount`, `soldCount`
- `ratingScore`, `reviewCount`, `verified`, `isAmbassador`, `isBoutique`

Error records (`recordType: "error"`):

- `platform`, `url`, `httpStatus`, `reason`, `scrapedAt`

### Modes — quick reference

#### `searchListings`
Search by free-text query. All three platforms support this.

```jsonc
{
  "platform": "depop",
  "mode": "searchListings",
  "query": "vintage levis",
  "sortBy": "relevance",
  "maxItems": 50
}
````

Filters available:

- All — `query`, `minPrice`, `maxPrice`, `sortBy`, `maxItems`
- Poshmark — `department`, `nwtOnly`, `availableOnly`
- Mercari — `categoryId`, `itemStatus`
- Depop — `category`, `discountedOnly`

#### `byItem`

Fetch a fixed list of items by URL or ID. The most reliable mode — no listing page parsing.

```jsonc
{
  "platform": "mercari",
  "mode": "byItem",
  "urls": ["https://www.mercari.com/us/item/m86443601198/"],
  "maxItems": 50
}
```

Mercari accepts either `urls` or `itemIds` (e.g. `m86443601198`).

#### `bySeller`

Fetch a seller's profile + their listings.

```jsonc
{
  "platform": "poshmark",
  "mode": "bySeller",
  "usernames": ["dr_dolittle"],
  "includeSellerProfile": true,
  "maxItems": 50
}
```

Mercari uses numeric seller IDs — pass them in `sellerIds` instead of `usernames`.

#### `byBrand` (Poshmark, Depop)

Listings under a specific brand.

```jsonc
{
  "platform": "poshmark",
  "mode": "byBrand",
  "brands": ["Nike", "Levi's"],
  "maxItems": 50
}
```

#### `byCategory` (Mercari, Poshmark)

Listings in a top-level category.

```jsonc
{
  "platform": "poshmark",
  "mode": "byCategory",
  "category": "Women-Shoes",
  "maxItems": 50
}
```

For Mercari, pass `categoryId` (e.g. `1` for Women, `2` for Men).

#### `byUrl` (auto-detect)

Drop in any URL — listing page, closet/profile, brand page, category page — and the actor figures out what to fetch.

```jsonc
{
  "platform": "depop",
  "mode": "byUrl",
  "urls": ["https://www.depop.com/products/awesome-vintage-jacket-12345/"],
  "maxItems": 50
}
```

### Anti-bot strategy

| Platform | Default tier | Auto-escalate |
|---|---|---|
| **Depop**     | Apify residential proxy (Depop's Cloudflare hard-blocks datacenter IPs on the public web API) | No further escalation needed |
| **Poshmark**  | curl\_cffi Chrome-131 (no proxy)                                                              | On 403/429: datacenter → residential |
| **Mercari**   | curl\_cffi for `byItem` / `byUrl`-of-item; **headless Chromium** routed through Apify residential for `searchListings` / `byCategory` / `bySeller` listings | Yes |

You can disable auto-escalation by setting `autoEscalateOnBlock: false` (the run will fail fast on first block). Pass custom proxy groups via `proxyGroups`.

### FAQ

**Why does Mercari `searchListings` use a browser?**
Mercari's search results are 100% client-rendered. The XHR is a Bearer-JWT-signed Apollo persisted query, and the JWT issuer (`/v1/initialize`) is gated by Cloudflare — so we drive a real Chromium that Mercari's React app can sign requests through. Item-detail pages are server-rendered, so `byItem` is HTTP-only and fast.

**Why is Depop on residential proxy by default?**
Depop's `webapi.depop.com` returns HTTP 403 to every datacenter IP we've tested (curl\_cffi chrome131/120/116/safari17, all the same). Apify's residential proxy bypasses this reliably.

**Daily test runs?**
The actor's prefill is set to `platform=depop`, `mode=searchListings`, `query="vintage levis"`, `maxItems=10` — Depop reliably returns ≥10 records on residential proxy.

**Do I need to provide cookies?**
No. None of the three platforms require login for the modes shipped here.

**What's the max items per run?**
1000 (`maxItems` upper bound). Each platform paginates differently — Depop and Poshmark return up to ~48 per page, Mercari ~20 per page.

**What currencies are returned?**
Mercari is always USD. Poshmark is USD by default. Depop returns the seller's local currency (USD/GBP/EUR/AUD/etc.) via the `currency` field.

**Image URLs — are they accessible?**
Yes. CDN images from `mercdn.net` (Mercari), `di2ponv0v5otw.cloudfront.net` (Poshmark), and Depop's CDN are all hotlinkable. No KV-rehosting required.

### Tips

- **Search-listing mode is paginated**. Mercari's browser-driven path scrolls to load more items; Depop paginates via `offset_id`; Poshmark returns 48 in `__INITIAL_STATE__`.
- **`byItem` is the fastest and most stable mode** — use it whenever you already have a list of item URLs/IDs.
- **`byUrl` is the most ergonomic** — drop in 10 mixed URLs (some listings, some closets, some brand pages) and the actor dispatches each correctly.
- **Boundary checks**: minPrice/maxPrice filters apply to `price` after parsing; if `currency` differs across listings (Depop with global sellers), the comparison is done in the listing's native units.

### Limitations

- **Mercari API is gated** — the official internal `/v1/api` requires a Bearer JWT issued from `/v1/initialize`, which we can only obtain by driving a real browser. We've documented the headers if you want to extend this actor with a captured-token mode in the future.
- **Poshmark seller profile bio + recent reviews** require additional XHR calls we don't currently make — only the basic profile fields are emitted.
- **Depop product pages from datacenter IP** are 403 — even with the SSR HTML fallback, you'll need residential proxy. The actor handles this for you.

# Actor input Schema

## `platform` (type: `string`):

Which marketplace to scrape.

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

What to scrape on the chosen platform. Available modes per platform:

- `searchListings` (all 3) — search by keyword + filters
- `byItem` (all 3) — fetch one or more items by URL or ID
- `bySeller` (all 3) — fetch a seller's closet/profile + their listings
- `byBrand` (Poshmark, Depop) — listings under a brand
- `byCategory` (Mercari, Poshmark) — listings in a top-level category
- `byUrl` (all 3) — auto-detect URL kind (item / seller / brand / category)

## `query` (type: `string`):

Free-text search query for `searchListings` mode (and Poshmark `byBrand` if `brands` is empty). UTF-8 supported.

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

Item / seller / brand / category URLs. Examples:

- Mercari item: `https://www.mercari.com/us/item/m12345/`
- Poshmark listing: `https://poshmark.com/listing/Title-69f...`
- Poshmark closet: `https://poshmark.com/closet/username`
- Depop product: `https://www.depop.com/products/slug-id/`
- Depop user: `https://www.depop.com/username/`

## `itemIds` (type: `array`):

Mercari item IDs starting with `m` (e.g. `m86443601198`). You may also use full URLs in the `urls` field instead.

## `usernames` (type: `array`):

Poshmark or Depop usernames (no `@` prefix needed). Mercari uses numeric seller IDs — see `sellerIds`.

## `sellerIds` (type: `array`):

Mercari seller numeric IDs (e.g. `314172943`).

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

Brand names (e.g. `Nike`, `Levi's`, `Lululemon`). Spaces are auto-converted to `-` for Poshmark URLs.

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

Poshmark category slug (e.g. `Women-Shoes`, `Men-Pants`, `Kids-Tops`). For Depop `searchListings` this field is also used as a category filter (Depop accepts slugs like `womenswear`, `menswear`, `vintage`, `streetwear` — pass via `urls`/manual override, the enum below is Poshmark-specific).

## `categoryId` (type: `string`):

Mercari numeric top-level category ID. Pick one — sub-category browsing is supported by passing a deep `categoryPath` via `urls` instead.

## `department` (type: `string`):

Restrict search results to a single Poshmark department.

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

Sort order for `searchListings`. Each platform supports a different set; only the values listed below are accepted.

## `itemStatus` (type: `string`):

Filter Mercari results by listing status.

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

Lower bound for listing price. Currency follows the platform's region (USD for Mercari/Poshmark, GBP/USD/EUR for Depop based on seller).

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

Upper bound for listing price.

## `nwtOnly` (type: `boolean`):

Restrict Poshmark search results to listings tagged "New With Tags".

## `availableOnly` (type: `boolean`):

Restrict Poshmark search results to listings that are still available (drop sold-out).

## `discountedOnly` (type: `boolean`):

Restrict Depop search results to listings that are currently discounted.

## `includeSellerProfile` (type: `boolean`):

Push the seller's profile (display name, avatar, follower count, etc.) as a record alongside their listings.

## `includeSellerListings` (type: `boolean`):

When true (default), Mercari `bySeller` also drives a headless browser to capture the seller's listings. Set false to push only the seller profile (much faster).

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

Hard cap on emitted records (listings + sellers + errors combined).

## `autoEscalateOnBlock` (type: `boolean`):

If true (default), the actor automatically engages Apify Proxy when it hits HTTP 403 / 429 anti-bot blocks. Depop is initialized on RESIDENTIAL by default because datacenter IPs are hard-blocked. Set false to disable (request fails fast).

## `proxyGroups` (type: `array`):

Apify proxy groups to use when auto-escalating after a block. Empty = datacenter (default), then RESIDENTIAL fallback.

## Actor input object example

```json
{
  "platform": "depop",
  "mode": "searchListings",
  "query": "vintage levis",
  "urls": [],
  "itemIds": [],
  "usernames": [],
  "sellerIds": [],
  "brands": [],
  "nwtOnly": false,
  "availableOnly": true,
  "discountedOnly": false,
  "includeSellerProfile": true,
  "includeSellerListings": true,
  "maxItems": 10,
  "autoEscalateOnBlock": true,
  "proxyGroups": []
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset of all scraped listings, sellers, and error records. Each record begins with `recordType` and `platform`, followed by entity fields (id, title, price, currency, brand, category, condition, photos, seller info, url) and a `scrapedAt` ISO timestamp.

# 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 = {
    "platform": "depop",
    "mode": "searchListings",
    "query": "vintage levis",
    "nwtOnly": false,
    "availableOnly": true,
    "discountedOnly": false,
    "includeSellerProfile": true,
    "includeSellerListings": true,
    "maxItems": 10,
    "autoEscalateOnBlock": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/mercari-poshmark-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 = {
    "platform": "depop",
    "mode": "searchListings",
    "query": "vintage levis",
    "nwtOnly": False,
    "availableOnly": True,
    "discountedOnly": False,
    "includeSellerProfile": True,
    "includeSellerListings": True,
    "maxItems": 10,
    "autoEscalateOnBlock": True,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/mercari-poshmark-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 '{
  "platform": "depop",
  "mode": "searchListings",
  "query": "vintage levis",
  "nwtOnly": false,
  "availableOnly": true,
  "discountedOnly": false,
  "includeSellerProfile": true,
  "includeSellerListings": true,
  "maxItems": 10,
  "autoEscalateOnBlock": true
}' |
apify call crawlerbros/mercari-poshmark-depop-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mercari + Poshmark + Depop Scraper",
        "description": "Tri-platform fashion-resale scraper. Pull listings, sellers, brand pages, categories, and individual items from Mercari (US), Poshmark, and Depop with one actor, search by keyword, browse a category, fetch a single item, or list everything in a seller's closet/profile.",
        "version": "1.0",
        "x-build-id": "0IcOHR9oXuhsW8k9E"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~mercari-poshmark-depop-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-mercari-poshmark-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/crawlerbros~mercari-poshmark-depop-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-mercari-poshmark-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/crawlerbros~mercari-poshmark-depop-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-mercari-poshmark-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": [
                    "platform",
                    "mode"
                ],
                "properties": {
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "depop",
                            "poshmark",
                            "mercari"
                        ],
                        "type": "string",
                        "description": "Which marketplace to scrape.",
                        "default": "depop"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchListings",
                            "byItem",
                            "bySeller",
                            "byBrand",
                            "byCategory",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to scrape on the chosen platform. Available modes per platform:\n\n- `searchListings` (all 3) — search by keyword + filters\n- `byItem` (all 3) — fetch one or more items by URL or ID\n- `bySeller` (all 3) — fetch a seller's closet/profile + their listings\n- `byBrand` (Poshmark, Depop) — listings under a brand\n- `byCategory` (Mercari, Poshmark) — listings in a top-level category\n- `byUrl` (all 3) — auto-detect URL kind (item / seller / brand / category)",
                        "default": "searchListings"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text search query for `searchListings` mode (and Poshmark `byBrand` if `brands` is empty). UTF-8 supported.",
                        "default": "vintage levis"
                    },
                    "urls": {
                        "title": "URLs (mode=byItem / byUrl)",
                        "type": "array",
                        "description": "Item / seller / brand / category URLs. Examples:\n- Mercari item: `https://www.mercari.com/us/item/m12345/`\n- Poshmark listing: `https://poshmark.com/listing/Title-69f...`\n- Poshmark closet: `https://poshmark.com/closet/username`\n- Depop product: `https://www.depop.com/products/slug-id/`\n- Depop user: `https://www.depop.com/username/`",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "itemIds": {
                        "title": "Mercari item IDs (mode=byItem on Mercari)",
                        "type": "array",
                        "description": "Mercari item IDs starting with `m` (e.g. `m86443601198`). You may also use full URLs in the `urls` field instead.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "usernames": {
                        "title": "Seller usernames (mode=bySeller on Poshmark / Depop)",
                        "type": "array",
                        "description": "Poshmark or Depop usernames (no `@` prefix needed). Mercari uses numeric seller IDs — see `sellerIds`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sellerIds": {
                        "title": "Mercari seller IDs (mode=bySeller on Mercari)",
                        "type": "array",
                        "description": "Mercari seller numeric IDs (e.g. `314172943`).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "brands": {
                        "title": "Brand names (mode=byBrand on Poshmark / Depop)",
                        "type": "array",
                        "description": "Brand names (e.g. `Nike`, `Levi's`, `Lululemon`). Spaces are auto-converted to `-` for Poshmark URLs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category (mode=byCategory on Poshmark — also Depop search filter)",
                        "enum": [
                            "Women-Tops",
                            "Women-Dresses",
                            "Women-Shoes",
                            "Women-Jeans",
                            "Women-Pants",
                            "Women-Bags",
                            "Women-Jewelry",
                            "Women-Coats_and_Jackets",
                            "Men-Shoes",
                            "Men-Tops",
                            "Men-Jeans",
                            "Men-Pants",
                            "Men-Sweaters",
                            "Men-Suits_and_Sport_Coats",
                            "Men-Coats_and_Jackets",
                            "Men-Watches",
                            "Kids-Tops",
                            "Kids-Bottoms",
                            "Kids-Shoes",
                            "Kids-Dresses",
                            "Home-Bedding",
                            "Home-Decor",
                            "Home-Kitchen",
                            "Pets",
                            "Electronics-Cell_Phones_and_Accessories",
                            "Beauty"
                        ],
                        "type": "string",
                        "description": "Poshmark category slug (e.g. `Women-Shoes`, `Men-Pants`, `Kids-Tops`). For Depop `searchListings` this field is also used as a category filter (Depop accepts slugs like `womenswear`, `menswear`, `vintage`, `streetwear` — pass via `urls`/manual override, the enum below is Poshmark-specific)."
                    },
                    "categoryId": {
                        "title": "Mercari category ID (mode=byCategory on Mercari)",
                        "enum": [
                            "1",
                            "2",
                            "3",
                            "4",
                            "5",
                            "6",
                            "8",
                            "10",
                            "1305",
                            "1313",
                            "1318",
                            "1320",
                            "1322"
                        ],
                        "type": "string",
                        "description": "Mercari numeric top-level category ID. Pick one — sub-category browsing is supported by passing a deep `categoryPath` via `urls` instead."
                    },
                    "department": {
                        "title": "Poshmark department (mode=searchListings on Poshmark)",
                        "enum": [
                            "Women",
                            "Men",
                            "Kids",
                            "Home",
                            "Pets",
                            "Electronics"
                        ],
                        "type": "string",
                        "description": "Restrict search results to a single Poshmark department."
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "newest",
                            "priceLow",
                            "priceHigh",
                            "endingSoon",
                            "added_desc",
                            "price_asc",
                            "price_desc",
                            "best_match",
                            "like_count_desc",
                            "newlyListed",
                            "priceAscending",
                            "priceDescending",
                            "popular"
                        ],
                        "type": "string",
                        "description": "Sort order for `searchListings`. Each platform supports a different set; only the values listed below are accepted."
                    },
                    "itemStatus": {
                        "title": "Item status (Mercari)",
                        "enum": [
                            "on_sale",
                            "sold",
                            "all"
                        ],
                        "type": "string",
                        "description": "Filter Mercari results by listing status."
                    },
                    "minPrice": {
                        "title": "Min price",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Lower bound for listing price. Currency follows the platform's region (USD for Mercari/Poshmark, GBP/USD/EUR for Depop based on seller)."
                    },
                    "maxPrice": {
                        "title": "Max price",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Upper bound for listing price."
                    },
                    "nwtOnly": {
                        "title": "NWT only (Poshmark)",
                        "type": "boolean",
                        "description": "Restrict Poshmark search results to listings tagged \"New With Tags\".",
                        "default": false
                    },
                    "availableOnly": {
                        "title": "Available only (Poshmark)",
                        "type": "boolean",
                        "description": "Restrict Poshmark search results to listings that are still available (drop sold-out).",
                        "default": true
                    },
                    "discountedOnly": {
                        "title": "Discounted only (Depop)",
                        "type": "boolean",
                        "description": "Restrict Depop search results to listings that are currently discounted.",
                        "default": false
                    },
                    "includeSellerProfile": {
                        "title": "Include seller profile record (mode=bySeller)",
                        "type": "boolean",
                        "description": "Push the seller's profile (display name, avatar, follower count, etc.) as a record alongside their listings.",
                        "default": true
                    },
                    "includeSellerListings": {
                        "title": "Include seller listings (Mercari, mode=bySeller)",
                        "type": "boolean",
                        "description": "When true (default), Mercari `bySeller` also drives a headless browser to capture the seller's listings. Set false to push only the seller profile (much faster).",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records (listings + sellers + errors combined).",
                        "default": 50
                    },
                    "autoEscalateOnBlock": {
                        "title": "Auto-escalate to Apify proxy on block",
                        "type": "boolean",
                        "description": "If true (default), the actor automatically engages Apify Proxy when it hits HTTP 403 / 429 anti-bot blocks. Depop is initialized on RESIDENTIAL by default because datacenter IPs are hard-blocked. Set false to disable (request fails fast).",
                        "default": true
                    },
                    "proxyGroups": {
                        "title": "Apify proxy groups (used on auto-escalation)",
                        "type": "array",
                        "description": "Apify proxy groups to use when auto-escalating after a block. Empty = datacenter (default), then RESIDENTIAL fallback.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
