# Poshmark Listings Scraper (`automation-lab/poshmark-public-listings-api`) Actor

Search public Poshmark listings and seller closets or fetch listing URLs. Export normalized prices, brands, sizes, conditions, sellers, images, availability, and source URLs.

- **URL**: https://apify.com/automation-lab/poshmark-public-listings-api.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.48 / 1,000 item extracteds

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?

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

## Poshmark Listings Scraper

Export **Poshmark listings** from public marketplace searches, seller closets, and individual listing URLs. The Actor turns each public item into a normalized row containing listing identity, seller, brand, category, size, condition, current and original price, images, inventory status, timestamps, and source URL.

Use the output for repeatable resale inventory snapshots, price analysis, assortment research, or a spreadsheet and data-pipeline export. No Poshmark login or cookies are required.

### What does Poshmark Listings Scraper do?

The Actor accepts three public input routes:

1. a marketplace search phrase such as `nike shoes`;
2. one or more Poshmark search or seller closet URLs;
3. one or more individual public listing URLs.

Searches and closets are paginated until `maxItems` unique records have been saved or Poshmark reports no next page. Individual listing URLs use the public listing detail endpoint. You can request available, sold, or all inventory states.

The default dataset always contains the same normalized listing record shape, so downstream code does not need a separate parser for each input route.

### Who is this Poshmark data for?

- **Resellers** comparing active inventory and asking prices before sourcing or listing products.
- **Pricing analysts** building sold-listing snapshots for comparable-product analysis.
- **Brands and marketplace teams** reviewing public assortment and seller distribution.
- **Data teams** loading normalized resale inventory into a warehouse or dashboard.
- **Researchers** studying public secondhand-market listings responsibly.

### Why use this Actor?

- Search, closet, and listing-detail inputs share one output contract.
- Inventory status can be restricted to available or sold listings.
- Stable listing IDs support deduplication and snapshot comparisons.
- Pagination stops exactly at the requested unique-item limit.
- Rich search responses avoid unnecessary image downloads and detail-page requests.
- JSON, CSV, Excel, API, webhook, and integration exports are available through Apify.

The Actor does not log in, purchase items, message sellers, change listings, or bypass private-account controls.

### What Poshmark listing data is extracted?

| Field | Meaning |
| --- | --- |
| `listingId` | Stable public Poshmark listing identifier |
| `title` | Listing title |
| `description` | Seller-provided description when exposed |
| `sellerUsername` | Public seller closet username |
| `sellerName` | Public seller display name when exposed |
| `sellerUrl` | Public seller closet URL |
| `brand` | Listing brand |
| `department` | Top-level department |
| `category` | Listing category |
| `subcategory` | More specific category feature when exposed |
| `size` | Displayed size |
| `condition` | Normalized condition label |
| `price` | Current listing or sold price |
| `originalPrice` | Seller-provided original price |
| `currency` | ISO currency code |
| `availability` | Public inventory status, such as `available` or `sold_out` |
| `imageUrl` | Primary full-size image URL |
| `imageUrls` | All exposed full-size image URLs |
| `colors` | Seller-selected colors |
| `createdAt` | Poshmark creation timestamp |
| `updatedAt` | Poshmark update timestamp |
| `sourceUrl` | Public listing URL |
| `scrapedAt` | Time this Actor saved the snapshot |

Fields can be `null` when a seller or Poshmark does not expose a value.

### How to scrape Poshmark listings

1. Open the Actor in Apify Console.
2. Enter a search query, add Poshmark URLs, or use both.
3. Choose **Available**, **Sold**, or **All** inventory.
4. Set the maximum number of listings.
5. Click **Start**.
6. Open the **Dataset** tab and export JSON, CSV, Excel, XML, or RSS.

A practical first run is:

```json
{
  "searchQuery": "nike shoes",
  "inventoryStatus": "available",
  "maxItems": 20
}
```

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `searchQuery` | string | — | Marketplace search phrase. |
| `startUrls` | array | `[]` | Public Poshmark search, closet, or listing URLs. |
| `inventoryStatus` | string | `available` | `available`, `sold`, or `all`. |
| `maxItems` | integer | `20` | Maximum unique records across all inputs; 1–1,000. |

Provide at least `searchQuery` or one URL. Supported URL forms include:

```text
https://poshmark.com/search?query=nike%20shoes&type=listings
https://poshmark.com/closet/sneakerdiva
https://poshmark.com/listing/product-title-65abcdef0123456789abcdef
```

URLs outside `poshmark.com`, unsupported Poshmark page types, and malformed limits fail the run with a clear non-zero error rather than silently returning an empty dataset.

### Output example

A current run returns records shaped like this (public identity values below are anonymized):

```json
{
  "listingId": "65abcdef0123456789abcdef",
  "title": "Running shoes in excellent condition",
  "description": "Lightly worn and stored in a smoke-free home.",
  "sellerUsername": "samplecloset",
  "sellerName": "Sample Seller",
  "sellerUrl": "https://poshmark.com/closet/samplecloset",
  "brand": "Sample Brand",
  "department": "Women",
  "category": "Shoes",
  "subcategory": "Athletic Shoes",
  "size": "US 8",
  "condition": "Used - good",
  "price": 45,
  "originalPrice": 90,
  "currency": "USD",
  "availability": "available",
  "imageUrl": "https://di2ponv0v5otw.cloudfront.net/posts/example/image.jpg",
  "imageUrls": [
    "https://di2ponv0v5otw.cloudfront.net/posts/example/image.jpg"
  ],
  "colors": ["Black", "White"],
  "createdAt": "2025-01-15T12:00:00-08:00",
  "updatedAt": "2025-01-20T09:30:00-08:00",
  "sourceUrl": "https://poshmark.com/listing/65abcdef0123456789abcdef",
  "scrapedAt": "2025-01-20T17:30:00.000Z"
}
```

### How much does it cost to scrape Poshmark listings?

Pricing uses one **$0.001 start fee** per run plus a tiered fee for each unique listing saved. Current per-listing prices are:

| Plan | Price per saved listing |
| --- | ---: |
| Free | $0.00092 |
| Bronze | $0.00080 |
| Silver | $0.000624 |
| Gold | $0.00048 |
| Platinum | $0.00048 |
| Diamond | $0.00048 |

At Bronze rates, 100 saved listings cost about **$0.081** including the start event; 1,000 cost about **$0.801**. Empty, rejected, failed, and duplicate records do not receive an item charge. Apify shows the live charge limit before and during a run.

### Recurring inventory and price snapshots

Schedule the same input daily or weekly and keep the stable `listingId` as the comparison key. A downstream workflow can:

1. store each run with its `scrapedAt` timestamp;
2. compare current `price`, `availability`, and `updatedAt` values;
3. detect new IDs, removed IDs, and changed listings;
4. send only the change set to a dashboard or alerting system.

This Actor produces snapshots. It does not maintain history or send alerts by itself.

### Export to a spreadsheet or data pipeline

From the Dataset tab, choose CSV or Excel for analysis in Google Sheets, Excel, or a BI tool. For automated pipelines, use the dataset API, a webhook, Make, Zapier, n8n, or an Apify integration.

Useful warehouse keys are:

- `listingId` as the source primary key;
- `scrapedAt` as the snapshot time;
- `price` and `currency` as separate typed columns;
- `availability` for active-versus-sold segmentation.

### Run with the Apify API

Replace `APIFY_TOKEN` with your Apify token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~poshmark-public-listings-api/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQuery":"nike shoes","inventoryStatus":"available","maxItems":20}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/poshmark-public-listings-api').call({
  searchQuery: 'nike shoes',
  inventoryStatus: 'available',
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token='APIFY_TOKEN')
run = client.actor('automation-lab/poshmark-public-listings-api').call(run_input={
    'searchQuery': 'nike shoes',
    'inventoryStatus': 'available',
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI agents

Add the Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/poshmark-public-listings-api"
```

#### Claude Desktop, Cursor, and VS Code

Claude Desktop, Cursor, and VS Code clients can use this HTTP MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/poshmark-public-listings-api"
    }
  }
}
```

Example prompts:

- “Find 50 available Poshmark listings for vintage denim and summarize the price distribution.”
- “Export 25 sold Lululemon listings and group them by size and condition.”
- “Fetch this public Poshmark closet and return listing IDs, prices, and update times.”

### Reliability, pagination, and retries

The Actor uses Poshmark's public structured web endpoints rather than rendering a browser or downloading product images. Each request has a 45-second timeout. Network failures, HTTP 429 responses, and temporary 5xx responses are retried up to three times with exponential backoff and jitter.

Invalid inputs and stable client errors are not retried blindly. If Poshmark returns an unexpected response or the retry budget is exhausted, the run fails instead of presenting a partial upstream failure as a successful empty result.

Duplicate listing IDs across combined inputs are saved and charged once.

### Limitations

- Only public US Poshmark web data is supported.
- Poshmark can change undocumented public response structures without notice.
- Some fields are absent on some listings and are returned as `null` or an empty array.
- `maxItems` is capped at 1,000 per run.
- Search ranking and result availability are controlled by Poshmark.
- `sold` maps to Poshmark's public `sold_out` inventory state.
- The Actor does not scrape private data, authenticate, buy, offer, like, share, follow, or message.
- Snapshot comparison, storage history, dashboards, and alerts belong in your downstream workflow.

### Responsible use and legality

Scrape only public information for a lawful purpose. Respect applicable privacy, database, intellectual-property, consumer-protection, and contract rules. Avoid collecting unnecessary personal data, apply retention limits, and honor valid deletion or access requests. You are responsible for your inputs, processing purpose, and downstream use.

This Actor is an independent data-extraction tool and is not affiliated with, endorsed by, or sponsored by Poshmark.

### Troubleshooting

#### Why did my run return no listings?

Check that the search or closet currently has records in the selected inventory state. Try `inventoryStatus: "all"` to distinguish a status mismatch from a genuinely empty source. A valid empty source completes successfully with zero item charges.

#### Why was my URL rejected?

The URL must use `poshmark.com` and identify a search page, seller closet, or public listing. Home pages, account pages, feeds, comments, and non-Poshmark URLs are intentionally rejected.

#### Why did the run fail after retries?

Poshmark may be temporarily unavailable or rate-limiting requests. Review the final log message, wait briefly, and rerun. Persistent unexpected-response errors can indicate an upstream schema change.

#### Can I combine searches and URLs?

Yes. Set `searchQuery` and `startUrls` together. The Actor processes them in order, deduplicates by `listingId`, and stops at the shared `maxItems` limit.

### FAQ

#### Does this require a Poshmark account?

No. It reads only public marketplace data and does not use login credentials.

#### Can it scrape seller closets?

Yes. Add one or more public `/closet/<username>` URLs to `startUrls`.

#### Can it collect sold listings?

Yes. Set `inventoryStatus` to `sold`. The normalized output reports Poshmark's source state as `sold_out`.

#### Does it download listing images?

No. It saves exposed image URLs, which reduces runtime, storage use, and network transfer.

#### How are duplicates handled?

The first occurrence of each listing ID is saved. Later occurrences in the same run are ignored and not charged.

### Related automation-lab Actors

- [Poshmark Scraper](https://apify.com/automation-lab/poshmark-scraper) — a simpler category/search-card scraper for existing integrations using that output contract.
- [Mercari US Listings Scraper](https://apify.com/automation-lab/mercari-us-listings-scraper) — public US resale marketplace listings from Mercari.
- [Facebook Marketplace Public Listings Scraper](https://apify.com/automation-lab/facebook-marketplace-public-listings-scraper) — public Marketplace listing discovery for broader local-resale research.

### Support

For reproducible problems, include the public input route, a small sanitized input, run ID, expected result, and observed error. Do not include passwords, cookies, private messages, payment details, or other secrets.

# Actor input Schema

## `searchQuery` (type: `string`):

Words to search in public Poshmark listings, such as a brand, product, or style.

## `startUrls` (type: `array`):

Optional public Poshmark search, seller closet, or individual listing URLs. URLs can be combined with a search query.

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

Return available listings, sold listings, or listings of all inventory states.

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

Maximum number of unique listing records saved across all searches and URLs.

## Actor input object example

```json
{
  "searchQuery": "nike shoes",
  "startUrls": [],
  "inventoryStatus": "available",
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

API endpoint for all listing records saved by this run.

# 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 = {
    "searchQuery": "nike shoes",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/poshmark-public-listings-api").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 = {
    "searchQuery": "nike shoes",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/poshmark-public-listings-api").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 '{
  "searchQuery": "nike shoes",
  "maxItems": 20
}' |
apify call automation-lab/poshmark-public-listings-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/poshmark-public-listings-api"
        }
    }
}
```

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/jQQhrQ3daSVZIlhFW/builds/OovNHnhwSK3I5YR0n/openapi.json