# Poshmark Scraper — Listings, Prices, Sold Comps & Seller Leads (`haketa/poshmark-scraper`) Actor

Scrape Poshmark listings across the US & Canada. Search any keyword or department and pull price, size, brand, condition, colors, photos, likes and seller username/name for lead-gen — plus sold-item price history (sold comps). Fast, structured, no login.

- **URL**: https://apify.com/haketa/poshmark-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Poshmark Scraper — Listings, Prices, Sold Comps & Seller Leads (US & Canada)

> **Extract Poshmark listings at scale — with prices, sizes, brands, conditions, photos, likes, seller profiles, and sold-item price history.** Search any keyword or browse a whole department across the **US and Canada** marketplaces and get clean, structured JSON, CSV or Excel in seconds. Built for resellers, brands, sourcing teams, market researchers, and lead-gen — no login, no cookies, no fuss.

[![Poshmark Data](https://img.shields.io/badge/Poshmark-Listings%20%2B%20Sold%20Comps-e91e63)]()
[![Markets](https://img.shields.io/badge/Markets-US%20%2B%20Canada-blue)]()
[![Seller Leads](https://img.shields.io/badge/Includes-Seller%20Leads-success)]()
[![No Login](https://img.shields.io/badge/Auth-None%20Required-brightgreen)]()
[![Speed](https://img.shields.io/badge/Speed-100%20listings%20in%20~4s-orange)]()

***

### What This Actor Does

The **Poshmark Scraper** turns any Poshmark search into a structured dataset. Give it a keyword (`nike air max`, `lululemon leggings`, `vintage levis`), pick a department, choose **available** or **sold** listings, and it returns every listing as a clean row with:

- **Pricing** — current price, original/listing price, and currency (USD or CAD)
- **Product** — title, brand, size, condition, department, category, colors
- **Media** — cover photo plus all listing photos
- **Engagement** — like count and comment count (a proxy for demand)
- **Availability** — available vs. sold-out status
- **Seller (lead-gen)** — seller username, full name, and a direct link to their closet
- **Description** — the full listing description text

It works across the two active Poshmark marketplaces — **United States** (`poshmark.com`) and **Canada** (`poshmark.ca`) — and paginates deep past the first page so you can pull hundreds or thousands of listings per query.

#### Two things most Poshmark tools skip — and this one nails

1. **Sold comps (price history).** Flip the status to **Sold** and you get recently sold listings with their final prices — the single most valuable input for pricing a resale item correctly. Stop guessing what a piece will sell for; see what it *actually* sold for.
2. **Seller leads.** Every listing carries the seller's username, display name and closet URL, so you can build lists of active sellers by niche, brand, or category for outreach, recruiting, or partnership.

***

### Why Use This Instead of Copy-Pasting or Building Your Own

Scraping Poshmark by hand or with a naive script gets painful fast:

- The site is a **JavaScript app** — a plain `curl` of the page returns an almost-empty shell with no listing data.
- Listings load through **infinite scroll**, and the pagination cursor is easy to get wrong — most DIY scripts pull the first ~40 results and then silently re-fetch the same page forever.
- Prices, sizes and brands come back in **nested, inconsistent shapes** that need normalizing before they're usable in a spreadsheet or database.
- Photos, seller info and sold-status live in **different parts of the payload** and are easy to miss.
- Running at any real volume means handling **retries, backoff and rate** politely so you don't get throttled.

This Actor handles all of it: correct deep pagination, clean camelCase fields, full photo arrays, seller lead extraction, sold-comp support, retries with backoff, and dedup — so you get a tidy dataset instead of a debugging project.

***

### Quick Start

#### Run it in the console (no code)

1. Open the Actor and click **Try for free**.
2. Type a **Search keyword** (e.g. `lululemon leggings`) — or leave it empty and pick a **Department** to browse.
3. Choose **Listing status**: *Available* (currently for sale), *Sold* (for sold comps / price history), or *Both*.
4. Set **Max listings** and click **Start**.
5. Download your data as **JSON, CSV, Excel, or HTML**, or push it to Google Sheets, a database, or a webhook.

#### Run it via API (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "query": "lululemon leggings",
    "marketplace": "us",
    "inventoryStatus": "available",
    "sortBy": "newest",
    "maxItems": 300,
}

run = client.actor("YOUR_USERNAME/poshmark-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["price"], item["sellerUsername"])
```

#### Pull sold comps for pricing (Python)

```python
run_input = {
    "query": "nike dunk low panda",
    "inventoryStatus": "sold",     # <-- recently SOLD listings
    "sortBy": "newest",
    "maxItems": 100,
}
run = client.actor("YOUR_USERNAME/poshmark-scraper").call(run_input=run_input)

prices = [i["price"] for i in client.dataset(run["defaultDatasetId"]).iterate_items() if i["price"]]
prices.sort()
print("sold count:", len(prices))
print("median sold price:", prices[len(prices)//2] if prices else None)
```

#### Run it via API (Node.js)

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('YOUR_USERNAME/poshmark-scraper').call({
    query: 'coach bag',
    marketplace: 'ca',
    inventoryStatus: 'available',
    maxItems: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'listings');
```

***

### Input Parameters

| Field | Type | Description |
|---|---|---|
| `query` | string | Keyword to search across title, brand, category and description (e.g. `nike air max`). Leave empty to browse a whole department. |
| `marketplace` | select | `us` (poshmark.com) or `ca` (poshmark.ca). Default `us`. |
| `department` | select | `All`, `Women`, `Men`, `Kids`, `Home`, `Electronics`, or `Pets`. Default `All`. |
| `inventoryStatus` | select | `available` (for sale), `sold` (sold comps / price history), or `all` (both). Default `available`. |
| `sortBy` | select | `relevance`, `newest`, `price_high_low`, `price_low_high`, or `most_liked`. Default `relevance`. |
| `maxItems` | integer | Maximum listings to return. Default `100`. A single query tops out around 5,000 results. |
| `proxyConfiguration` | object | Optional. Works fine without a proxy; use one for very large volumes or a specific country. |

**Tip:** To pull a large slice of a brand or category, combine a specific `query` with `sortBy: newest` and a higher `maxItems`. To research pricing, run the same query twice — once with `inventoryStatus: available` and once with `sold` — and compare.

***

### Output

Each listing is one dataset record. Example:

```json
{
  "id": "6aa89243ab650b40c9f900c9",
  "title": "Nike Dallas Cowboys Salute to Service Therma Fit Hoodie Black Camo Size Small",
  "listingUrl": "https://poshmark.com/listing/6aa89243ab650b40c9f900c9",
  "price": 25,
  "originalPrice": null,
  "currency": "USD",
  "brand": "Nike",
  "size": "S",
  "condition": "ug",
  "newWithTags": false,
  "department": "Men",
  "category": "Sweatshirts & Hoodies",
  "colors": ["Black", "Green"],
  "status": "available",
  "likeCount": 3,
  "commentCount": 0,
  "description": "Brand new without tags. Ships same day...",
  "coverImage": "https://.../m_6aabd9d9....jpg",
  "images": ["https://.../a.jpg", "https://.../b.jpg"],
  "sellerUsername": "fabricreimagine",
  "sellerName": "Fabric Reimagined",
  "sellerId": "5df81b0d0b26fa7299d16814",
  "sellerProfileUrl": "https://poshmark.com/closet/fabricreimagine",
  "createdAt": "2026-09-17T05:13:40-07:00",
  "scrapedAt": "2026-09-23T18:20:00.000Z"
}
```

#### Field reference

| Field | Meaning |
|---|---|
| `id`, `title`, `listingUrl` | Listing identity and direct link |
| `price`, `originalPrice`, `currency` | Current price, original price (when set), and currency |
| `brand`, `size`, `condition`, `newWithTags` | Product attributes; `newWithTags` is `true` for NWT listings |
| `department`, `category`, `colors` | Classification and colors |
| `status` | `available` or `sold_out` |
| `likeCount`, `commentCount` | Engagement signals (demand proxy) |
| `description` | Full listing description |
| `coverImage`, `images` | Main photo and all photos |
| `sellerUsername`, `sellerName`, `sellerId`, `sellerProfileUrl` | Seller lead data + closet link |
| `createdAt`, `scrapedAt` | Listing creation time and scrape timestamp |

***

### Use Cases

#### 1. Reseller pricing & sold comps

Before you list, pull `inventoryStatus: sold` for the exact item and see the real distribution of final sale prices. Price to sell, not to sit. Track median sold price by brand, size, and condition over time.

#### 2. Brand & category market research

How many active Nike listings are there this week? What's the average asking price for Lululemon leggings by size? Pull a brand across a department and build a live pricing and inventory snapshot.

#### 3. Sourcing & arbitrage

Sort by `price_low_high` and scan for underpriced listings in a category you know well. Combine available prices with sold comps to spot margin opportunities.

#### 4. Seller lead generation

Every record includes the seller's username, name and closet URL. Build targeted lists of active sellers in a niche — for wholesale outreach, consignment recruiting, cross-listing services, or partnership offers.

#### 5. Trend & demand tracking

`likeCount` and `commentCount` are lightweight demand signals. Track which brands, styles or keywords are accumulating likes fastest and spot momentum early.

#### 6. Inventory & competitor monitoring

Running a closet or a resale business? Monitor competing listings in your categories, watch price drops, and keep an eye on what's selling and what's sitting.

#### 7. Dataset building for analytics & AI

Assemble clean, structured secondhand-fashion datasets for pricing models, recommendation engines, or resale-market dashboards.

***

### Sold Comps: The Pricing Superpower

Most listing scrapers only show you what sellers *hope* to get. This Actor also pulls what items **actually sold for**. Set `inventoryStatus` to `sold`, search the item, and you get a list of recently sold listings with final prices — the closest thing to a "market price" on Poshmark.

A simple recipe for any item:

1. Run the query with `inventoryStatus: sold`, `sortBy: newest`.
2. Take the median of `price` across results — that's your realistic sale price.
3. Run the same query with `inventoryStatus: available` to see current competition and how your price stacks up.

***

### Frequently Asked Questions

**Which Poshmark marketplaces are supported?**
The two active ones: the United States (`poshmark.com`) and Canada (`poshmark.ca`). Prices come back in USD and CAD respectively.

**Do I need a Poshmark login or cookies?**
No. The Actor reads publicly visible listing data — no account, login, or cookies required.

**How many listings can I get per run?**
A single query returns up to roughly 5,000 listings. For broader coverage, split your search into narrower queries (by brand, department, or keyword) and run them in parallel.

**Can I get the full price history of a single item?**
Poshmark doesn't expose a per-listing price-change log, but `sold` mode gives you the sold-price distribution for a search — which is what you actually need to price accurately.

**Is the seller's email or phone included?**
No. The Actor returns the seller's public username, display name and closet URL only. It does not extract private contact details.

**How fast is it?**
Roughly 100 listings in about 4 seconds for a typical query, scaling near-linearly with `maxItems`.

**What formats can I export?**
JSON, CSV, Excel, HTML, or via API. You can also connect it to Google Sheets, webhooks, Make, Zapier, or your own pipeline.

**Can I schedule it?**
Yes — use Apify Schedules to run daily/weekly and build a time series of prices, inventory, and sold comps.

***

### Tips for Best Results

- **Be specific with `query`.** `nike dunk low panda` returns a tighter, more useful set than just `nike`.
- **Use `newest` for deep pulls.** It paginates reliably when you want a large, fresh slice of a category.
- **Pair available + sold.** Two quick runs give you both the competitive landscape and the real sale prices.
- **Split big jobs.** Several narrow queries beat one huge one for both speed and coverage.
- **Schedule for trends.** Daily runs turn snapshots into a price-and-demand time series.

***

### Legal & Responsible Use

This Actor collects only publicly available listing information and is intended for legitimate research, pricing, analytics and business use. You are responsible for how you use the data. Please:

- Respect Poshmark's Terms of Service and robots directives.
- Comply with applicable data-protection laws (GDPR, CCPA, etc.) when handling any personal data such as seller usernames.
- Do not use the data for spam, harassment, or any unlawful purpose.
- Use reasonable request volumes and scheduling.

This project is an independent tool and is not affiliated with, endorsed by, or sponsored by Poshmark.

# Actor input Schema

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

Keyword to search across title, brand, category and description. Examples: nike air max, lululemon leggings, vintage levis. Leave empty to browse a whole department.

## `marketplace` (type: `string`):

Which Poshmark marketplace to scrape.

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

Limit to a department, or All.

## `inventoryStatus` (type: `string`):

Available (currently for sale), Sold (great for sold-comps / price history), or Both.

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

Result ordering.

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

Maximum number of listings to return. Poshmark caps a single query around 5,000 results.

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

Optional. This Actor works fine without a proxy; use one for large volumes or a specific country.

## Actor input object example

```json
{
  "query": "lululemon leggings",
  "marketplace": "us",
  "department": "All",
  "inventoryStatus": "available",
  "sortBy": "relevance",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `id` (type: `string`):

Poshmark listing ID

## `title` (type: `string`):

Listing title

## `listingUrl` (type: `string`):

Link to the listing

## `price` (type: `string`):

Current price

## `originalPrice` (type: `string`):

Original/retail price

## `currency` (type: `string`):

Currency code

## `brand` (type: `string`):

Brand

## `size` (type: `string`):

Size

## `condition` (type: `string`):

Item condition code

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

Department (Women/Men/Kids...)

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

Category

## `status` (type: `string`):

available or sold\_out

## `likeCount` (type: `string`):

Like count

## `sellerUsername` (type: `string`):

Seller username

## `sellerName` (type: `string`):

Seller full name

## `sellerProfileUrl` (type: `string`):

Seller closet URL

## `coverImage` (type: `string`):

Main photo URL

## `scrapedAt` (type: `string`):

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 = {
    "query": "lululemon leggings",
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/poshmark-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 = {
    "query": "lululemon leggings",
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/poshmark-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 '{
  "query": "lululemon leggings",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call haketa/poshmark-scraper --silent --output-dataset

```

## MCP server setup

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