# Poshmark Sold Listings Scraper (`automation-lab/poshmark-sold-listings-scraper`) Actor

🛍️ Scrape public Poshmark sold listings for resale comps, prices, item metadata, sellers, engagement counts, and images.

- **URL**: https://apify.com/automation-lab/poshmark-sold-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 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.
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

## Poshmark Sold Listings Scraper

Scrape public Poshmark sold listings for resale comps, sold prices, seller details, item metadata, and listing images.

Use it when you need structured Poshmark sales evidence before pricing inventory, sourcing similar items, or building a resale analytics workflow.

### What does Poshmark Sold Listings Scraper do?

Poshmark Sold Listings Scraper turns public Poshmark sold search results into a clean dataset.

It searches Poshmark for sold-out listings, extracts the listing cards embedded in the page HTML, and saves each sold listing as a structured row.

You can start from simple keywords such as `nike sneakers`, or provide full Poshmark search URLs.

The actor is designed for sold-comps research rather than active listing monitoring.

### Who is it for?

#### Resellers

Use sold prices to decide whether an item is worth sourcing.

#### Poshmark sellers

Compare your listing price against recent sold comps.

#### Thrift and arbitrage operators

Check categories, sizes, brands, and actual resale prices before buying inventory.

#### Ecommerce analysts

Build repeatable datasets of sold Poshmark listings for market research.

#### Pricing tool builders

Feed sold comp records into spreadsheets, dashboards, or repricing models.

### Why use this actor?

- 🛍️ Focused on sold listings, not active listings
- 💵 Extracts sold price and original price when available
- 🧾 Captures item details like brand, size, category, condition, and colors
- 👤 Includes seller identifiers shown in public results
- 🖼️ Saves image URLs for visual review
- ⚡ HTTP-first implementation for lower run cost
- 📦 Outputs JSON, CSV, Excel, and API-friendly datasets on Apify

### What data can you extract?

| Field | Description |
| --- | --- |
| `id` | Poshmark listing ID |
| `title` | Listing title |
| `listingUrl` | Direct Poshmark listing URL |
| `query` | Search query that produced the row |
| `sourceUrl` | Search URL fetched by the actor |
| `isSold` | Whether the listing is marked sold out |
| `status` | Public inventory status |
| `soldAt` | Sold/status-change timestamp when present |
| `firstPublishedAt` | First published timestamp when present |
| `createdAt` | Listing creation timestamp |
| `updatedAt` | Listing update timestamp |
| `daysToSell` | Approximate days between listing and sold timestamp |
| `price` | Sold/listing price shown in search data |
| `originalPrice` | Original asking price when present |
| `currency` | Currency code, usually USD |
| `brand` | Brand name |
| `size` | Item size |
| `department` | Poshmark department |
| `category` | Main category |
| `subcategory` | Subcategory/category feature labels |
| `condition` | Condition code shown by Poshmark |
| `colors` | Public color labels |
| `sellerUsername` | Seller username |
| `sellerName` | Seller display/full name |
| `sellerId` | Seller ID |
| `sellerImageUrl` | Seller avatar URL |
| `likes` | Like count |
| `comments` | Comment count |
| `shares` | Share count |
| `description` | Listing description snippet/data |
| `imageUrl` | Primary image URL |
| `imageUrls` | Listing image URLs |
| `scrapedAt` | Actor scrape timestamp |

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

This actor uses pay-per-event pricing.

You pay a small run-start event plus one result event for each sold listing saved.

Current pricing is a $0.005 run-start event plus a BRONZE result price of $0.0001 per sold listing, with standard Apify tier discounts for higher plans.

The formula calculator produced a lower theoretical price, but platform pricing validation rejected sub-$0.0001 tier values, so the live price uses the accepted minimum floor. A 120-item cloud validation run measured an 87.6% net margin at the lower formula price; the platform-floor price is safely profitable.

### How to use it

1. Open the actor on Apify.
2. Add one or more search queries.
3. Optionally add full Poshmark search URLs.
4. Set the maximum sold listings to save.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, XML, or RSS.

### Input

#### Search queries

Add keywords that match how you would search Poshmark.

Examples:

- `nike sneakers`
- `lululemon leggings`
- `coach bag`
- `patagonia fleece`

#### Poshmark search URLs

You can also paste a public Poshmark search URL.

If the URL does not include sold listing filters, the actor adds `type=listings` and `availability=sold_out`.

#### Maximum sold listings

Use `maxItems` to control cost and dataset size.

A small first run such as 20 items is recommended.

### Example input

```json
{
  "queries": ["nike sneakers", "lululemon leggings"],
  "maxItems": 50
}
````

### Example output

```json
{
  "id": "6a09e3a24a072bceec44d88b",
  "title": "Nike V2K Runner",
  "listingUrl": "https://poshmark.com/listing/6a09e3a24a072bceec44d88b",
  "query": "nike sneakers",
  "isSold": true,
  "soldAt": "2026-05-30T00:50:46.000Z",
  "price": 70,
  "originalPrice": 120,
  "brand": "Nike",
  "size": "US 6.5",
  "category": "Shoes",
  "sellerUsername": "example_seller",
  "likes": 21,
  "imageUrl": "https://di2ponv0v5otw.cloudfront.net/...jpg",
  "scrapedAt": "2026-06-05T00:00:00.000Z"
}
```

### Tips for better results

- 🔎 Use specific brand + item keywords.
- 👟 Include item type, model, or style when possible.
- 📉 Start with small `maxItems` values while testing.
- 🧮 Export CSV for spreadsheet comp analysis.
- 🧵 Run multiple related queries to compare brands or sizes.

### Integrations

Use the dataset with:

- Google Sheets or Excel price comp models
- Airtable resale inventory workflows
- BI dashboards for category analysis
- Internal sourcing tools
- Automated repricing systems
- Apify webhooks for post-run processing

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/poshmark-sold-listings-scraper').call({
  queries: ['nike sneakers'],
  maxItems: 25,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/poshmark-sold-listings-scraper').call(
    run_input={'queries': ['nike sneakers'], 'maxItems': 25}
)
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~poshmark-sold-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"queries":["nike sneakers"],"maxItems":25}'
```

### MCP usage

Use this actor from Apify MCP with:

`https://mcp.apify.com/?tools=automation-lab/poshmark-sold-listings-scraper`

Claude Code setup:

```bash
claude mcp add apify-poshmark-sold-listings "https://mcp.apify.com/?tools=automation-lab/poshmark-sold-listings-scraper"
```

Claude Desktop MCP server config:

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

Example prompts showing MCP usage:

- "Use MCP to run automation-lab/poshmark-sold-listings-scraper and find recent sold comps for Nike sneakers on Poshmark."
- "Use the Apify MCP server to run the Poshmark sold listings scraper for Lululemon leggings and summarize the price range."
- "With MCP, scrape sold Coach bag listings and return a table of price, size, seller, and URL."

### Data quality notes

The actor extracts data available in public Poshmark search HTML.

Some timestamps or fields may be absent when Poshmark does not expose them in the result state.

Sold dates are based on public status-change timestamps when present.

### Limitations

The MVP reads the first public server-rendered result page for each query or URL.

For larger datasets, provide multiple targeted queries.

Future versions may add detail-page enrichment or validated pagination if public endpoints remain stable.

### Troubleshooting

#### Why did I get fewer results than `maxItems`?

The public search page may expose fewer sold listings for that query. Try additional related keywords.

#### Why are some fields blank?

Poshmark does not expose every field for every listing in search results. The actor only returns public data that is present.

#### Can it scrape my private closet analytics?

No. This actor only targets public sold search results and does not log in to Poshmark.

### Legality

This actor extracts publicly available information from Poshmark pages.

You are responsible for using the data in accordance with applicable laws, Poshmark terms, and privacy rules.

Avoid collecting personal data you do not need.

### Related scrapers

Other automation-lab actors that can support resale or ecommerce research:

- https://apify.com/automation-lab/poshmark-scraper
- https://apify.com/automation-lab/ebay-scraper
- https://apify.com/automation-lab/shopify-scraper
- https://apify.com/automation-lab/etsy-scraper

### Changelog

#### 0.1

Initial build with keyword/search URL input, sold listing extraction, seller metadata, price fields, engagement counts, and images.

### Support

If a run does not return expected public listings, include your input and run URL when opening an issue.

### FAQ

#### Does it require a Poshmark account?

No. The actor uses public pages only.

#### Does it use a browser?

No. The current implementation is HTTP-first for speed and cost control.

#### Can I search multiple brands?

Yes. Add multiple entries to `queries`.

#### Can I export to CSV?

Yes. Apify datasets support CSV, JSON, Excel, XML, and RSS exports.

# Actor input Schema

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

Keywords to search on Poshmark sold listings, such as brand + product type.

## `searchUrls` (type: `array`):

Optional full Poshmark search URLs. The actor adds sold-out listing filters when they are missing.

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

Maximum number of sold listing records to save across all queries and URLs.

## Actor input object example

```json
{
  "queries": [
    "nike sneakers",
    "lululemon leggings"
  ],
  "searchUrls": [
    {
      "url": "https://poshmark.com/search?query=nike%20sneakers&type=listings&availability=sold_out"
    }
  ],
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "queries": [
        "nike sneakers",
        "lululemon leggings"
    ],
    "searchUrls": [
        {
            "url": "https://poshmark.com/search?query=nike%20sneakers&type=listings&availability=sold_out"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/poshmark-sold-listings-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 = {
    "queries": [
        "nike sneakers",
        "lululemon leggings",
    ],
    "searchUrls": [{ "url": "https://poshmark.com/search?query=nike%20sneakers&type=listings&availability=sold_out" }],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/poshmark-sold-listings-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 '{
  "queries": [
    "nike sneakers",
    "lululemon leggings"
  ],
  "searchUrls": [
    {
      "url": "https://poshmark.com/search?query=nike%20sneakers&type=listings&availability=sold_out"
    }
  ]
}' |
apify call automation-lab/poshmark-sold-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Poshmark Sold Listings Scraper",
        "description": "🛍️ Scrape public Poshmark sold listings for resale comps, prices, item metadata, sellers, engagement counts, and images.",
        "version": "0.1",
        "x-build-id": "us4CImkfBymPrpk0e"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~poshmark-sold-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-poshmark-sold-listings-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/automation-lab~poshmark-sold-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-poshmark-sold-listings-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/automation-lab~poshmark-sold-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-poshmark-sold-listings-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",
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords to search on Poshmark sold listings, such as brand + product type.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "Poshmark search URLs",
                        "type": "array",
                        "description": "Optional full Poshmark search URLs. The actor adds sold-out listing filters when they are missing.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum sold listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of sold listing records to save across all queries and URLs.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```