# Poshmark New Listings Alert & Price Watch (US) (`superslowsloth/poshmark-listings`) Actor

Newest Poshmark listings for any search, one flat row each: title, brand, price and original price in USD, size, department, category, condition, seller, timestamps, likes, available or sold status, URL and photo. Filter by department, brand, size, condition and price.

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

## Pricing

from $0.40 / 1,000 listing scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 New Listings Alert & Price Watch (US)

Search [Poshmark](https://poshmark.com) the way a buyer does and get the
**newest listings first**, one flat row each: **title, brand, price and original
price in USD, size, department, category, condition, available or sold status,
seller username, publish time, likes and comments, listing URL and cover
photo.** Filter by department, brand, size, condition and price band. Schedule it
every few minutes with a narrow search and you have a resale feed of new
listings, or a price watch on a brand and size.

No account, no login, nothing downloaded from the listing pages: every field
comes off the search page itself.

### Input

| Field | Notes |
|---|---|
| `queries` | Search terms, one per line (`lululemon align`, `nike air max`). Each is searched separately; a listing two terms both find is returned once, under the first. |
| `maxItems` | Listings returned per search term (default 100, max 5,000). Poshmark serves 48 per page. |
| `department` | Women, Men, Kids, Home, Pets or Electronics. Empty for all. |
| `brands` | One or more brand names (case-insensitive). A brand nobody lists returns no results. |
| `sizes` | One or more sizes as Poshmark prints them (`S`, `M`, `8.5`, `OS`). Multi-size listings (`Various`) can come along. |
| `condition` | `nwt` (New With Tags), `uln` (Like New), `ug` (Good) or `uf` (Fair). One at a time: Poshmark ignores a list. |
| `minPrice`, `maxPrice` | Asking-price band in whole US dollars; either may be left empty. |
| `availability` | `available` (default), `sold_out` or `all` (which also lists "coming soon" listings). |
| `proxyConfiguration` | Apify datacenter proxy by default. |

An unknown `department` is rejected before anything runs and before you are
charged: Poshmark itself silently ignores a department it does not recognise
(`Beauty`, or `men` in lower case) and serves the unfiltered results, so the
actor refuses the input and also checks the department the page says it applied.

### Output

| Field | Notes |
|---|---|
| `listing_id`, `url` | Poshmark's id and `https://poshmark.com/listing/<slug>-<listing_id>`. |
| `title`, `brand` | The seller's title (whitespace and newlines collapsed to single spaces) and brand. `brand` is null for the few listings with none. |
| `price`, `currency` | The asking price as a float, `USD` (Poshmark sends it as a string, `"40.0"`; converted). |
| `original_price`, `discount_percent` | The seller's list price and the whole percent below it. Null when the seller set none: Poshmark stores `0.0` there, and a zero would read as a price cut to nothing. |
| `size`, `department`, `category`, `colors` | As Poshmark lists them. `colors` is a (possibly empty) list. |
| `condition`, `condition_label` | The code and its label (`nwt` / "New With Tags (NWT)", `uln` / "Like New", `ug` / "Good", `uf` / "Fair"). Both null for the roughly one listing in five where the seller set none. A code outside those four (`not_nwt` has been seen on Pets) is passed through with a null label. |
| `inventory_status`, `status_changed_at` | `available`, `sold_out` or `coming_soon`, and when that status last changed - for a sold listing, when it sold. |
| `seller_username` | The public username. The seller's full name and photo are on the page and are **not** exported. |
| `published_at`, `created_at`, `updated_at` | ISO 8601 in UTC. **`published_at` is the one to watch for "new since"**: it is the key the newest-first order is built on (strictly descending over all 48 rows of a page). `created_at` is when the draft was started and is not in order. |
| `cover_image_url`, `like_count`, `comment_count` | Cover photo (medium size, CDN link) and engagement counts. |
| `query` | The search term the row came from. |

#### Honest nulls

A value the page does not carry is `null`, never `0` or `""`. A zero like count
is a real count; a missing one is null.

### How far a search goes

Poshmark serves **at most about 5,000 results per search** however large it says
the result set is (it reports `10000`). A 105-page walk of `lululemon` returned
5,008 unique listings and page 106 was empty. Narrow a very broad term with
the filters or split it by brand, size or price band to see more.

The newest-first list is live: a listing published during your run pushes the
listing before it onto the next page, so consecutive pages overlap by about one
listing. The actor returns and charges each listing id **once per run**.

### Pricing

Pay per event: a small fee per run (`actor-start`, charged only after your input
is validated, so a run that fails on bad input costs nothing) and a fee per
listing row written (`listing-scraped`). Current prices are on the Store page.

### How it fetches

It requests the same HTML search page the website serves
(`poshmark.com/search?query=...&sort_by=added_desc`) with a Chrome TLS
fingerprint, and reads the `window.__INITIAL_STATE__` JSON inlined in it. Pages
are followed with the page's own `max_id` cursor (`page=2` is ignored by
Poshmark). A page is about **5 MB of HTML but ~230 KB over the wire** (Brotli)
for 48 listings, about **4.9 KB of proxy traffic per listing** measured over a
105-page walk. Most of the page is filter facet data the actor does not use but
cannot skip: the proxy cost is per page, so a run for 5 listings costs a whole
page. A search with no matches costs one page (~90 KB).

A 200 response that lacks the search state (an interstitial) is treated as a
refusal and retried from a fresh proxy address; so are 403, 429 and 5xx.
Apify datacenter and residential proxies were both answered with HTTP 200 on
2026-10-09.

Poshmark's other domains (Canada, Australia, India) are not covered; this is the
US site.

# Actor input Schema

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

What you would type into Poshmark's search box, one term per line (for example lululemon align or nike air max). Each term is searched separately, newest listings first. A listing that two terms both find is returned once, under the first.

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

Return at most this many listings for each search term, newest first. Poshmark serves 48 per page and never more than about 5,000 per search, so values above 5000 are not accepted.

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

Only listings in this Poshmark department. Leave empty for all departments.

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

Only listings by these brands, one per line (for example Nike, Lululemon Athletica). Not case-sensitive. A brand with no listings returns no results rather than an error. Leave empty for any brand.

## `sizes` (type: `array`):

Only listings in these sizes, one per line, written the way Poshmark prints them (S, M, XL, 8, 8.5, OS). A listing with several sizes may be included too. Leave empty for any size.

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

Only listings in this condition: New With Tags, Like New, Good or Fair. Poshmark filters on one condition at a time. Leave empty for any condition.

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

Lowest asking price to return, in whole US dollars. Leave empty for no lower bound.

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

Highest asking price to return, in whole US dollars. Leave empty for no upper bound.

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

Available listings (the default, what a buyer sees), sold listings, or everything including 'coming soon' listings. The status of each row is in inventory_status.

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

Apify proxy (automatic datacenter exits) is the default and is what this actor was measured on: poshmark.com answered Apify datacenter and residential exits with HTTP 200 on 2026-10-09. A proxy is what lets a refused request be retried from a fresh address. Each page of 48 listings is about 230 KB over the wire.

## Actor input object example

```json
{
  "queries": [
    "lululemon"
  ],
  "maxItems": 100,
  "department": "",
  "condition": "",
  "availability": "available",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `items` (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": [
        "lululemon"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("superslowsloth/poshmark-listings").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": ["lululemon"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("superslowsloth/poshmark-listings").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 '{
  "queries": [
    "lululemon"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call superslowsloth/poshmark-listings --silent --output-dataset

```

## MCP server setup

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

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/CNOSC98VX6HbrQMiF/builds/QlzeZIdZFN62YbAb5/openapi.json