DEV Community: Marc Andrew

How to Get Poshmark Sold Listings with Python Without Maintaining a Scraper

Marc Andrew — Fri, 04 Sep 2026 19:59:19 +0000

If you are building a resale tool, the useful question is rarely what sellers are asking. You need to
know what comparable items have already sold for.

Poshmark does not provide a broadly documented developer API for general sold-listing research. You can
either maintain the marketplace request flow yourself or use an API that returns the public listing
evidence in a stable response.

I own CompSniper, and we recently added dedicated Poshmark and Mercari
endpoints alongside our eBay sold-listing API. This walkthrough uses the production Poshmark endpoint.

Make one Poshmark sold-listing request

Create a free CompSniper account, copy the API key, and keep it in an environment variable:

export COMPSNIPER_API_KEY="cs_live_REPLACEWITHYOURKEY"

Install Requests:

python -m pip install requests

Then search one page of Poshmark US sold listings:

import os
import requests

response = requests.get(
    "https://api.compsniper.com/v1/poshmark/sold",
    headers={
        "Authorization": f"Bearer {os.environ['COMPSNIPER_API_KEY']}"
    },
    params={
        "keyword": "louis vuitton neverfull",
        "department": "women",
        "page": 1,
    },
    timeout=45,
)
response.raise_for_status()

data = response.json()
print("Listings:", data["totalItems"])
print("Median displayed price:", data["summary"]["median"])

for item in data["items"][:5]:
    print(item["title"], item["soldPrice"], item["soldAt"])

One page returns up to 48 sold listings. A successful page uses one CompSniper request.

What comes back

The Poshmark response keeps marketplace-specific fields instead of forcing them into an eBay schema:

{
  "keyword": "louis vuitton neverfull",
  "page": 1,
  "totalItems": 48,
  "hasNextPage": true,
  "items": [
    {
      "listingId": "6478a1b2c3d4e5f6a7b8c9d0",
      "title": "Louis Vuitton Neverfull MM Damier Ebene",
      "soldPrice": 1250,
      "originalPrice": 1960,
      "brand": "Louis Vuitton",
      "size": "OS",
      "category": "Women > Bags",
      "condition": "Pre-owned",
      "soldAt": "2026-07-15T18:30:00-07:00",
      "listedAt": "2026-06-01T12:00:00-07:00",
      "daysToSell": 44.27,
      "sellerUsername": "luxurycloset"
    }
  ],
  "summary": {
    "count": 48,
    "currency": "USD",
    "median": 1175,
    "p25": 925,
    "p75": 1395
  }
}

The summary is calculated deterministically from the returned displayed prices. Keep the sample size
beside the median so a three-item niche query is not treated like a forty-eight-item market.

Add useful filters

The endpoint supports:

page
minPrice and maxPrice
department: all, women, men, kids, home, pets, or electronics
condition: all or nwt
brand
sortBy: sold_recently, price_asc, price_desc, or likes
enrich=true for optional public seller evidence

For example:

params = {
    "keyword": "nike air max 90",
    "department": "women",
    "condition": "nwt",
    "minPrice": 25,
    "maxPrice": 200,
    "sortBy": "price_desc",
}

Handle the important price limitation

A public sold listing does not necessarily reveal the private transaction amount. An item may have sold
through an offer or as part of a bundle. Treat soldPrice as the public displayed sold-listing price,
not proof of an undisclosed accepted amount.

The same principle applies when data is missing. Seller enrichment fields and item-level shipping remain
null when the marketplace does not expose that evidence.

Mercari uses the same API key

The Mercari endpoint returns up to 100 public US listings per page:

response = requests.get(
    "https://api.compsniper.com/v1/mercari",
    headers={
        "Authorization": f"Bearer {os.environ['COMPSNIPER_API_KEY']}"
    },
    params={
        "keyword": "sony wh-1000xm5",
        "count": 25,
        "sold": "true",
    },
    timeout=45,
)
response.raise_for_status()

Set sold=false for active listings. Mercari public search does not provide a reliable exact sold
timestamp, so the API returns status and price without inventing a sale date.

Do not retry every 429

Two different conditions use HTTP 429:

rate_limited is temporary. Respect Retry-After and retry a bounded number of times.
quota_exceeded is not temporary. Stop and show the returned upgrade URL or wait for the reset.

Blindly retrying quota_exceeded only creates a loop.

Complete examples

The free plan includes 100 requests each month and does not require a credit card.

eBay's Browse API Doesn't Return Sold Listings. Here Is a Node.js Alternative

Marc Andrew — Thu, 03 Sep 2026 21:21:04 +0000

If you are building a pricing, resale, or inventory tool, active listings answer the wrong question. The price a seller asks for an item is not necessarily the price a buyer paid.

eBay's public Browse API returns active inventory. Marketplace Insights covers sold history, but access is restricted. That leaves many developers maintaining search-page parsers or using a sold-data provider.

This example uses CompSniper because it returns completed listings and a price summary through one GET request.

Disclosure: I am Marc, the owner of CompSniper.

Make one sold-listings request

Node.js 20 and newer already include fetch, URLSearchParams, and request timeouts, so this example does not need an HTTP package.

const params = new URLSearchParams({
  keyword: "sony wh-1000xm5",
  count: "10",
  ebaySite: "ebay.com",
  itemCondition: "used",
});

const response = await fetch(
  `https://api.compsniper.com/v1/scrape?${params}`,
  {
    headers: {
      Authorization: `Bearer ${process.env.COMPSNIPER_API_KEY}`,
    },
    signal: AbortSignal.timeout(75_000),
  },
);

const data = await response.json();
if (!response.ok) {
  throw new Error(data.error ?? `HTTP ${response.status}`);
}

console.log("Listings:", data.totalItems);
console.log("Median:", data.summary.median, data.summary.currency);
console.log("Range:", data.summary.p25, "to", data.summary.p75);

for (const item of data.items.slice(0, 5)) {
  console.log(item.title, item.soldPrice, item.endedAt);
}

Keep the API key in a server, worker, or serverless function. Do not place it in browser JavaScript.

Select the buyer's marketplace

The marketplace matters. A UK reseller normally wants UK sold listings and prices in pounds, not US listings in dollars.

const params = new URLSearchParams({
  keyword: "iphone 15 pro -case -charger",
  ebaySite: "ebay.co.uk",
  count: "100",
  itemCondition: "used",
  minPrice: "250",
  maxPrice: "1200",
});

The same response shape works for the US, UK, Germany, France, Italy, Spain, Canada, and Australia.

Treat the two 429 responses differently

This is the integration mistake that creates the most unnecessary failures.

rate_limited is temporary. Wait for the Retry-After value, add a little jitter, and retry a bounded number of times.

quota_exceeded is not temporary. Stop immediately and show the response's reset time or upgrade URL. Retrying it cannot succeed and only produces more 429 responses.

if (response.status === 429 && data.code === "quota_exceeded") {
  throw new Error(`Quota exhausted. Upgrade: ${data.upgrade_url}`);
}

if (response.status === 429 && data.code === "rate_limited") {
  const seconds = Number(response.headers.get("Retry-After") ?? 1);
  await new Promise((resolve) =>
    setTimeout(resolve, seconds * 1000 + Math.random() * 400),
  );
}

Temporary 500, 502, and 503 responses can use the same bounded backoff approach. Never build an infinite retry loop.

Type the response instead of guessing

The response includes listing rows plus calculated statistics. Listing prices are decimal strings, while the summary values are numbers. Fields can be null when eBay did not display the information on the result card.

A complete TypeScript quick start is available in the public examples repository:

View the TypeScript example on GitHub

The full tutorial also includes response types, bounded pagination, eight-marketplace handling, Best Offer notes, and the limitations of sold-price samples:

Read the complete JavaScript and TypeScript guide

You can create a free key with 100 monthly requests if you want to run the example against current sold listings.

We Tested 100 eBay Sold-Comp Searches. 37.9% of Rows Were Filtered Out

Marc Andrew — Tue, 01 Sep 2026 00:13:02 +0000

A raw sold-listings search is not automatically a usable comp set.

Search for a phone and you may also get cases, chargers, broken screens, empty boxes, and nearby models. Search for a camera lens and you may get caps, adapters, or a different focal length. If those rows go directly into a median, the result can describe the search noise instead of the product.

I wanted a larger measurement than a single convenient example, so I ran a fixed 100-product study through CompSniper, the sold-price API I own.

The goal was not to prove that an automated classifier is always correct. The goal was narrower:

Measure what the production relevance cleaner removed and how the product-level median changed on one predeclared sample.

The protocol

I selected the products before making the first request:

20 smartphones and tablets
20 gaming and computing products
20 cameras and lenses
20 audio and music products
20 collectibles and luxury products

Every search used the same settings:

Marketplace: ebay.com
Sold window: 2026-06-02 through 2026-08-31
Page: 1
Requested rows: 240
Sort: ended recently
Condition: any
Relevance cleaning: enabled

Each relevance-enabled response contained the raw sample count and raw median captured before classification, followed by the cleaned rows and deterministic price summary from the same fetched page. That meant one production request per product, not separate raw and cleaned fetches.

All 100 requests succeeded with unique request IDs.

The headline results

Across the study:

19,220 priced raw rows were parsed
11,942 priced rows remained after cleaning
7,278 rows were classified out
The weighted removal rate was 37.87%
34 of 100 product medians changed by at least 10%
15 of 100 changed by at least 25%
11 of 100 changed by at least 50%

The direction was not always upward:

73 medians increased
21 medians decreased
6 medians stayed unchanged

That is important. The cleaner is not instructed to raise prices. It tries to retain listings for the requested product. Removing bad matches can move the median in either direction.

The largest movements

Here were five of the largest increases in this sample:

Product	Raw rows	Cleaned rows	Raw median	Cleaned median	Change
GoPro Hero 12 Black	219	61	$59.99	$230.00	+283.40%
Lenovo ThinkPad X1 Carbon Gen 11	222	14	$293.50	$602.49	+105.28%
Canon RF 70-200mm f/2.8 L IS USM	224	46	$1,104.50	$2,097.00	+89.86%
NVIDIA GeForce RTX 4090	233	51	$1,399.00	$2,599.99	+85.85%
Sony Walkman TPS-L2	114	45	$328.55	$573.00	+74.40%

The largest decrease was the Google Pixel 7 Pro 128GB search, where the raw median was $424.09 and the cleaned median was $199.99, a 52.84% decrease.

These outliers are reasons to inspect the row-level evidence. They are not proof that every removed listing was wrong.

Removal rate and median movement are different metrics

The median product-level removal rate was 28.85%, but the median absolute median-price change was only 4.2%.

That is a useful distinction. A search can contain many cheap accessories spread across the results without moving the center very much. Another search can contain fewer mismatches concentrated far away from the actual product price and move the median substantially.

At the category level, the weighted removal rates were:

Category	Weighted removal rate	Median absolute price change
Collectibles and luxury	47.05%	8.84%
Smartphones and tablets	45.99%	4.74%
Audio and music	40.60%	7.03%
Cameras and lenses	30.31%	0.52%
Gaming and computing	26.28%	3.21%

Best Offer remains a real limitation

The cleaned sample contained 2,184 rows marked as accepted Best Offer, or 18.29% of cleaned priced rows.

eBay indicates that an offer was accepted but does not disclose the accepted amount. The visible listing price may therefore differ from the actual transaction price. If your workflow requires exact transaction-level prices, exclude rows where bestOfferAccepted is true.

What this study does not prove

This was not a human-labeled precision and recall evaluation.

It used:

one marketplace
one collection run
one query per product
page one only
title-based classification
a bounded recent sold window

Different wording, dates, pages, marketplaces, and condition filters can produce different samples. A cleaned median is still historical sample evidence, not a formal appraisal or a guarantee of the next sale price.

Reproduce or inspect it

The complete report includes category charts, the 15 largest absolute changes, all 100 predeclared products, integrity checks, FAQ, and the full methodology.

The public CSV contains product-level counts and statistics. It excludes listing titles, seller data, API keys, and internal request IDs.

Disclosure

I am Marc Andrew, owner of CompSniper, and this is first-party research produced with the CompSniper API. CompSniper is an independent product and is not affiliated with or endorsed by eBay Inc.

Get eBay Sold Listings with Python (Without Building a Scraper)

Marc Andrew — Sun, 30 Aug 2026 21:35:55 +0000

If your Python application needs resale prices, active eBay listings are the wrong input. You need
completed sales: what buyers actually paid, when the item sold, its condition, and enough evidence to
calculate a useful range.

Here is the smallest working request with CompSniper:

import os
import requests

response = requests.get(
    "https://api.compsniper.com/v1/scrape",
    headers={"Authorization": f"Bearer {os.environ['COMPSNIPER_API_KEY']}"},
    params={"keyword": "shure sm7b", "count": 240, "itemCondition": "used"},
    timeout=75,
)
response.raise_for_status()
data = response.json()

print(data["summary"]["median"], data["summary"]["currency"])
print(data["summary"]["p25"], data["summary"]["p75"])

The response includes up to 240 sold rows and a summary with median, mean, minimum, maximum, p25, p75,
average shipping, currency, and sample size.

Do not retry every 429

There are two distinct cases:

rate_limited is temporary. Wait for Retry-After, add a little jitter, and cap the number of attempts.
quota_exceeded lasts until reset or upgrade. Stop immediately. Retrying it only creates more errors.

The full guide includes filters, pagination, a real raw-versus-cleaned sample, and bounded Python retry
code:

https://compsniper.com/guides/ebay-sold-listings-api-python

The complete Python, Node.js, cURL, pagination, retry, and Card Batch examples are public here:

https://github.com/CompSniper/compsniper-api-examples

CompSniper includes 100 requests per month without a credit card. It is an independent product and is
not affiliated with eBay.