# Poshmark Listings Scraper (`khadinakbar/poshmark-listings-scraper`) Actor

Scrape public Poshmark browse and listing pages for resale sourcing, price research, and market analysis. Returns prices, brands, sizes, images, availability, engagement, timestamps, and public seller handles. Not for private accounts or contact harvesting. $0.018/listing plus platform usage.

- **URL**: https://apify.com/khadinakbar/poshmark-listings-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $18.00 / 1,000 poshmark listing saveds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 for Resale Data

Use this Apify Actor to turn a keyword, a public Poshmark browse page, or a direct listing URL into one record per saved listing. It is built for resale sourcing, price research, assortment monitoring, and market analysis, and it returns public fields such as title, brand, size, price, availability, images, engagement counts, timestamps, and public seller handles. The actor works as an Apify Actor usable through Apify MCP, with a stable dataset-backed output for downstream analysis.

### Best fit and connected workflows

This Actor fits workflows that begin with a public Poshmark search phrase or saved browse page and end with structured listing data.

Common routing patterns include:

- Keyword research for a brand or product phrase, then comparison across price, size, and availability.
- A curated public browse URL with Poshmark filters preserved, then extraction into a dataset for analysis.
- A direct listing URL when you need one exact item record, its public photos, and seller context.
- Sold-comparable research using the sold availability filter and publication timestamps.
- Agent workflows that need a consistent JSON record per listing and a clean dataset readback through Apify MCP or the Actor API.

### Practical scenario

Maya is checking a public Poshmark browse page for running shoes. She starts with the keyword `nike shoes`, keeps availability set to available, and lets the Actor enrich each listing page. The returned record includes title, brand, size, price, like count, published time, listing URL, and seller username. Maya uses those fields to shortlist items for sourcing and opens the listing URLs to review the public photos before choosing the next watchlist action.

### Inputs

| Field | Type | Default | Purpose |
| --- | --- | --- | --- |
| `searchQuery` | string | `nike shoes` | Product or brand phrase converted to a public Poshmark browse URL. |
| `startUrls` | array | `[]` | Public Poshmark `/browse/`, `/brand/`, `/category/`, or `/listing/` URLs. |
| `maxResults` | integer | `25` | Maximum number of validated listings saved and billed in the run. |
| `includeDetails` | boolean | `true` | Opens each public listing page to refresh price, inventory, images, engagement, and timestamps. |
| `availability` | string | `available` | Returns available listings, sold listings, or both. |
| `department` | string | `Women` | Department used for keyword-generated browse pages and server-rendered availability filters. |
| `sortBy` | string | `relevance_v2` | Browse order for keyword-generated results. |
| `maxConcurrency` | integer | `3` | Parallel request cap for public Poshmark requests. |
| `proxyConfiguration` | object | Apify Residential proxy in the US | Network route for public Poshmark pages. |

#### Focused input example

```json
{
  "searchQuery": "lululemon define jacket",
  "availability": "sold",
  "department": "Women",
  "sortBy": "added_desc",
  "maxResults": 20,
  "includeDetails": true,
  "maxConcurrency": 3
}
```

### Output fields

Each dataset row represents one complete validated public Poshmark listing.

| Field | Type | Meaning |
| --- | --- | --- |
| `listingId` | string | Stable Poshmark listing identifier. |
| `listingUrl` | string | Public canonical-style Poshmark listing URL. |
| `title` | string | Public listing title. |
| `description` | string or null | Public seller-written description, capped at 5,000 characters. |
| `brand` | string or null | Brand assigned to the listing. |
| `department` | string or null | Top-level catalog department such as Women or Men. |
| `category` | string or null | Catalog category. |
| `subcategory` | string or null | First catalog feature or subcategory when present. |
| `size` | string or null | Seller-selected display size. |
| `price` | number or null | Current listing price. |
| `originalPrice` | number or null | Original or compare-at price. |
| `currency` | string or null | Currency code supplied by Poshmark, normally USD. |
| `discountPercent` | number or null | Calculated percentage below original price. |
| `availability` | string | Normalized item inventory status. |
| `status` | string or null | Raw public status returned by Poshmark. |
| `isSold` | boolean | Whether the listing inventory is sold out. |
| `isMultiItem` | boolean | Whether inventory contains multiple item units or sizes. |
| `quantityAvailable` | integer or null | Sum of publicly exposed available size quantities. |
| `imageUrl` | string or null | Largest available cover image URL. |
| `imageUrls` | array | Deduplicated public listing image URLs, capped at 12. |
| `colors` | array | Public color labels assigned to the listing. |
| `styleTags` | array | Public style tags assigned to the listing. |
| `sellerUsername` | string or null | Public Poshmark seller handle. |
| `sellerDisplayName` | string or null | Public display name shown with the listing. |
| `sellerProfileUrl` | string or null | Public closet URL constructed from the seller handle. |
| `likeCount` | integer | Public listing like count. |
| `commentCount` | integer | Public listing comment count. |
| `shareCount` | integer | Public listing share count. |
| `publishedAt` | string or null | First public publication time when available. |
| `updatedAt` | string or null | Last public update time when available. |
| `statusChangedAt` | string or null | Most recent public listing or inventory status-change time. |
| `sourceUrl` | string | Source page from which the listing was collected. |
| `scrapedAt` | string | UTC timestamp when the record was normalized. |

#### Illustrative output record

```json
{
  "listingId": "6a50a7029f19e233e4b2264d",
  "listingUrl": "https://poshmark.com/listing/Nike-Flex-Shoes-Running-Athletic-Sneakers-Sz-11-6a50a7029f19e233e4b2264d",
  "title": "Nike Flex Shoes Running Athletic Sneakers Sz. 11",
  "description": "Nike Flex Running Shoes size 11. Great shape!",
  "brand": "Nike",
  "department": "Women",
  "category": "Shoes",
  "subcategory": "Athletic Shoes",
  "size": "11",
  "price": 13,
  "originalPrice": null,
  "currency": "USD",
  "discountPercent": null,
  "availability": "available",
  "status": "published",
  "isSold": false,
  "isMultiItem": false,
  "quantityAvailable": 1,
  "imageUrl": "https://di2ponv0v5otw.cloudfront.net/posts/example.jpg",
  "imageUrls": [
    "https://di2ponv0v5otw.cloudfront.net/posts/example.jpg"
  ],
  "colors": [
    "Pink",
    "White"
  ],
  "styleTags": [
    "Athleisure",
    "Activewear"
  ],
  "sellerUsername": "public_seller",
  "sellerDisplayName": "Public Seller",
  "sellerProfileUrl": "https://poshmark.com/closet/public_seller",
  "likeCount": 3,
  "commentCount": 0,
  "shareCount": 2,
  "publishedAt": "2026-07-10T08:02:25.000Z",
  "updatedAt": "2026-07-13T16:05:32.000Z",
  "statusChangedAt": "2026-07-10T08:02:25.000Z",
  "sourceUrl": "https://poshmark.com/browse/nike-shoes",
  "scrapedAt": "2026-07-15T10:00:00.000Z"
}
```

### How it works

The Actor accepts either a search keyword or a list of public Poshmark URLs. When you provide a keyword, it converts it into a public browse URL. When you provide `startUrls`, those URLs take precedence.

It reads public `/browse/`, `/brand/`, `/category/`, and `/listing/` pages only. When `includeDetails` is enabled, it opens each public listing page before saving the record so the dataset can include refreshed price, inventory, images, engagement, and timestamps. Saved rows are normalized into the default dataset with a consistent field contract.

### Pricing

This Actor uses pay per event plus Apify platform usage.

- Actor start: charged once per run, scaled by allocated memory
- Poshmark listing saved: charged for each complete validated public listing saved to the default dataset
- Apify compute and proxy usage: billed separately through the platform

For current pricing, open the live Pricing tab on the Actor page.

As an example, a run that saves ten listings records ten listing saves, and the event-based charge follows the live Pricing tab, plus platform usage.

### Use with AI agents (MCP)

This Actor is available as an Apify Actor usable through Apify MCP. The tool exposes structured inputs and a dataset-backed output that agents can read after the run.

**Tool description:** Extract public Poshmark listings from a keyword, browse URL, or direct listing URL, then read normalized listing records from the default dataset.

**Actor identity:** `khadinakbar/poshmark-listings-scraper`

> Use `khadinakbar/poshmark-listings-scraper` for public Poshmark resale research. Start from a keyword or browse URL, then return the dataset rows with title, brand, size, price, availability, images, seller handle, and timestamps.

**Output interpretation:** Each dataset row is one public listing saved as a complete validated record. `availability` provides the normalized inventory state, while `status`, `isSold`, `quantityAvailable`, and `statusChangedAt` add public context. `sourceUrl` shows the browse page or listing URL that produced the record.

**Provenance and scope:** The Actor works from public Poshmark pages only. It surfaces public seller handles and public closet URLs, while keeping the collection centered on listing data.

**Pagination and cost guidance:** `maxResults` sets the hard cap for validated listings saved and billed across the run. Higher `maxConcurrency` can speed up larger detail runs, while lower values create a gentler request pattern. `includeDetails` adds a public listing-page refresh before each row is saved.

### Apify API example

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

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const run = await client.actor('khadinakbar/poshmark-listings-scraper').call({
  searchQuery: 'nike shoes',
  availability: 'available',
  department: 'Women',
  sortBy: 'relevance_v2',
  maxResults: 10,
  includeDetails: true,
});

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

### Best results and outcome guidance

Use a specific brand or product phrase for keyword runs when you want broad public browse coverage. Use `startUrls` when you already have a filtered browse page or a direct listing URL. Set `availability` to match the research task, such as available listings for sourcing or sold listings for comparable-sales review. Keep `includeDetails` enabled when freshness, images, and engagement matter, and use a lower `maxConcurrency` when you want a gentler request pattern. For larger research jobs, increase `maxResults` only as far as the analysis needs.

### Continue the workflow

- Then use [Sephora Product Scraper for US Catalog Research](https://apify.com/khadinakbar/sephora-product-scraper) to extend Poshmark Listings Scraper for Resale Data with a neighboring commerce research source when the brief calls for Sephora data.
- Then use [Ozon Scraper — Russia Marketplace Products, Prices & Reviews](https://apify.com/khadinakbar/ozon-scraper) to extend Poshmark Listings Scraper for Resale Data with a neighboring commerce research source when the brief calls for Ozon data.

### Design note

I found that the dataset contract includes both `sellerUsername` and `sellerProfileUrl`, which makes public seller context easy to reuse without relying on account-internal fields.

### FAQ

#### Can I use this Actor for a saved browse URL with Poshmark filters?

Yes. `startUrls` accepts public `/browse/` URLs, so you can keep the Poshmark filters already present in the page.

#### Can I request one exact listing page?

Yes. A public `/listing/` URL can be passed in `startUrls` to collect a single exact item record.

#### How do I switch between live sourcing and sold-comparable research?

Use the `availability` input. `available` is suited to live sourcing, `sold` to sold-comparable analysis, and `all` to collect both.

#### Which department should I pick for keyword-generated searches?

Choose the public Poshmark department that matches the item family, such as Women, Men, Kids, Home, Electronics, or Pets.

#### What happens if I need richer listing details?

Keep `includeDetails` enabled. The Actor opens each public listing page before saving it so the record can include refreshed price, inventory, images, engagement, and timestamps.

### Responsible use

Use this Actor on public Poshmark pages only and in ways that align with applicable law, Poshmark's terms, privacy rules, and your own contractual obligations. The output is designed for listing analysis, resale sourcing, and market research, with a scope centered on public listing data rather than contact harvesting, private account access, or account automation.

# Actor input Schema

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

Enter a product or brand phrase such as 'nike running shoes' or 'lululemon jacket'. The actor converts it to a public Poshmark browse URL and never calls the disallowed /search or /api paths. Defaults to 'nike shoes' for a working sample. This field is ignored when startUrls contains one or more URLs.

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

Add public URLs whose path starts with /browse/, /brand/, /category/, or /listing/. For example, use a browse URL to retain Poshmark filters or a listing URL to extract one exact item. When provided, these URLs take precedence over searchQuery. Closet, profile, search, API, message, and non-Poshmark URLs are rejected.

## `maxResults` (type: `integer`):

Hard cap for complete validated listings saved and billed across the run. For example, set 10 for a low-cost proof run or 100 for broader assortment research. Defaults to 25 and cannot exceed 500. This is not a page-count or concurrency setting.

## `includeDetails` (type: `boolean`):

Open each public listing page before saving it to refresh price, inventory, images, engagement, and timestamps. Enable this for the richest and most current record or disable it for faster browse-page snapshots. Defaults to true. This never opens seller closets, private pages, or account endpoints.

## `availability` (type: `string`):

Choose whether to return available listings, sold listings, or both. 'Available' is useful for live sourcing, while 'Sold' supports comparable-sales research. Defaults to available. The actor also verifies the item-level inventory status before saving each record.

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

Select the public Poshmark department for keyword-generated browse pages. An explicit department is required for Poshmark's server-rendered availability filter, including sold-comparable runs. Defaults to Women; choose Men, Kids, Home, Electronics, or Pets when relevant. Existing startUrls retain their own department parameters.

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

Select how keyword-generated browse results should be ordered on Poshmark. Use newest for monitoring, low or high price for range research, or most liked for demand signals. Defaults to relevance. Existing startUrls retain their own URL parameters unless pagination updates the page token.

## `maxConcurrency` (type: `integer`):

Control how many public Poshmark requests can run in parallel. Lower values are gentler and can reduce intermittent blocks; higher values are faster for larger detail runs. Defaults to 3 and maxes at 5, while a separate global rate limit still applies. This does not change maxResults or billing.

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

Configure the network route used for public Poshmark pages. The default uses Apify Residential proxy in the United States for steadier access. Supply a custom proxy only when you need to control egress or proxy billing. Disabling the proxy can increase blocking on cloud runs.

## Actor input object example

```json
{
  "searchQuery": "nike shoes",
  "startUrls": [],
  "maxResults": 10,
  "includeDetails": true,
  "availability": "available",
  "department": "Women",
  "sortBy": "relevance_v2",
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

Validated listing rows in the default dataset.

## `output` (type: `string`):

Outcome, returned count, charge counts, dataset pointer, and warnings.

## `runSummary` (type: `string`):

Full terminal outcome, lifecycle counters, cost evidence, and warnings.

# 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",
    "startUrls": [],
    "maxResults": 10,
    "includeDetails": true,
    "availability": "available",
    "department": "Women",
    "sortBy": "relevance_v2",
    "maxConcurrency": 3,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/poshmark-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 = {
    "searchQuery": "nike shoes",
    "startUrls": [],
    "maxResults": 10,
    "includeDetails": True,
    "availability": "available",
    "department": "Women",
    "sortBy": "relevance_v2",
    "maxConcurrency": 3,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/poshmark-listings-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 '{
  "searchQuery": "nike shoes",
  "startUrls": [],
  "maxResults": 10,
  "includeDetails": true,
  "availability": "available",
  "department": "Women",
  "sortBy": "relevance_v2",
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call khadinakbar/poshmark-listings-scraper --silent --output-dataset

```

## MCP server setup

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