DEV Community: Marc Andrew

eBay Sold Listings API in 2026: What Replaced findCompletedItems (Tested)

Marc Andrew — Wed, 21 Oct 2026 00:26:56 +0000

If you built anything on eBay sold prices before 2025, you probably had a findCompletedItems call somewhere. It stopped working, and the obvious replacements do not return sold data. This post covers what still works in 2026, how to call it from Python, and how much the results differ in quality between providers, measured on the same searches.

Short version: eBay has no open sold listings API anymore. findCompletedItems was retired on February 5, 2025, the Browse API only returns active listings, and Marketplace Insights is limited to approved partners. Third-party eBay sold listings APIs fill the gap, and they are not equally accurate: in a blind 40-search test, wrong-item rates ranged from 5.4% to 31.6%.

What happened to eBay's sold data APIs

eBay API	Sold listings?	Status in 2026
Finding API `findCompletedItems`	Yes, before 2025	Decommissioned February 5, 2025
Browse API `item_summary/search`	No, active listings only	Available
Marketplace Insights API	Yes, about 90 days	Limited release, approved partners only
Terapeak / Product Research	Yes, up to 3 years	Seller Hub tool, no public API

So if you searched for an "eBay completed items API" or a "findCompletedItems replacement" and ended up on the Browse API docs: it will not give you sold prices. There is no sold filter.

Your options for eBay sold listings data

Marketplace Insights. The official route, if eBay approves you. Most new developers are not approved, and it covers about 90 days.
Scrape eBay's sold search yourself. Possible, but you own the parsing, the breakage when eBay changes its markup, and the cleanup of wrong items. Scrapers that read the sold page also show the asking price on Best Offer sales, not what the buyer paid.
A third-party eBay sold listings API. One HTTP call, JSON back. This is what most people use now. The rest of this post is about picking one and calling it.

Get eBay sold listings in Python

Here is a working example with CompSniper. The free plan gives you 100 requests a month. Create a key and set it as COMPSNIPER_API_KEY.

import os
import requests

API = "https://api.compsniper.com/v1/scrape"
headers = {"Authorization": f"Bearer {os.environ['COMPSNIPER_API_KEY']}"}

response = requests.get(
    API,
    headers=headers,
    params={"keyword": "nintendo switch oled", "count": 240, "ebaySite": "ebay.com"},
    timeout=75,
)
response.raise_for_status()
data = response.json()

summary = data["summary"]
print(f"{summary['count']} sales, median ${summary['median']}, middle range ${summary['p25']} to ${summary['p75']}")

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

Each sold item comes back with the sold price and currency, the date it ended, condition, shipping, seller, the listing URL and image. The summary block gives you the median, the 25th and 75th percentile, min, max and average shipping, computed after wrong items are removed, so you do not need to write the statistics yourself.

The same call works in Node.js:

const res = await fetch(
  "https://api.compsniper.com/v1/scrape?keyword=nintendo+switch+oled&count=240",
  { headers: { Authorization: `Bearer ${process.env.COMPSNIPER_API_KEY}` } },
);
if (!res.ok) throw new Error(await res.text());
const data = await res.json();
console.log(data.summary.median, data.items.length);

Other eBay sites work the same way: pass ebaySite as ebay.co.uk, ebay.de, ebay.fr, ebay.it, ebay.es, ebay.ca or ebay.com.au, and prices come back in that site's currency.

Going past 90 days: eBay sold price history

eBay's sold search only reaches back about 90 days. For slow-moving items, seasonal trends or "what did this sell for last year", use the history endpoint, which goes back up to 3 years:

response = requests.get(
    "https://api.compsniper.com/v1/research/sold",
    headers=headers,
    params={
        "keyword": "nintendo switch oled",
        "startDate": "2023-10-21",
        "endDate": "2026-10-21",
        "sort": "lastSoldDescending",
        "limit": 50,
    },
    timeout=60,
)
response.raise_for_status()
for row in response.json()["results"]:
    print(row["lastSoldDate"], row["soldUnits"], row["averageSoldPrice"]["amount"], row["title"])

It is included on every plan, free too. Docs: 3-year eBay sold history API.

The part most comparisons skip: accuracy

Every sold listings API returns rows. The question is how many of those rows are the item you searched for. eBay's keyword search drags in other models, other grades and sets, cases, chargers, parts-only units and look-alikes, and each one pulls your median away from the real price.

We ran the same 40 searches (trading cards, electronics, fashion and collectibles), each with a written definition of the correct item, through five sold listings APIs, then labeled all 7,285 unique rows right or wrong without knowing which API returned them:

API	Wrong items returned
CompSniper	5.4%
Trawl	25.7%
SoldComps	26.0%
Soldgraph	27.6%
CompsAPI	31.6%

Full method and data: Sold listings API accuracy benchmark 2026.

Whatever you pick, test it yourself the same way. Take 20 searches from your real use case, write down what a correct match is before you look, and count wrong rows per API. A cheap API that returns one wrong item in four costs you more in bad prices than it saves.

Best Offer: the price eBay does not show

When a listing sells through an accepted offer, eBay's sold page shows the original asking price crossed out, not what the buyer paid. If you price from those rows you overstate the market, most of all on items where many sales close on offers.

CompSniper returns the accepted Best Offer price where it is available, at no extra cost. Docs: accepted Best Offer prices API.

Quick checklist for choosing an eBay sold data API

Accuracy: what share of returned rows are the wrong item? Ask for numbers or measure it.
Best Offer: does it return the accepted price or the crossed-out asking price?
History: do you need more than eBay's 90 days?
Coverage: which eBay sites, and do you need Poshmark, Mercari, Grailed, Depop or TCGplayer too?
Price summary: do you get a median and range back, or do you compute them?
Failures: are failed requests charged?

FAQ

Does eBay still have a sold listings API?
Not one you can sign up for. Marketplace Insights is a limited release for approved partners. findCompletedItems was decommissioned on February 5, 2025.

What replaced findCompletedItems?
For most developers, a third-party eBay sold listings API that returns sold prices, dates and listing details as JSON.

Can the eBay Browse API return sold items?
No. It searches active listings only.

How far back does eBay sold data go?
eBay's sold search shows about 90 days. History endpoints such as CompSniper's /v1/research/sold reach back up to 3 years.

Is there a free eBay sold listings API?
Yes. CompSniper's free plan includes 100 requests a month, and 3-year history is included on it.

If you are migrating off findCompletedItems, the CompSniper quickstart has cURL, Python and Node examples, and the free key takes about a minute. Questions about a specific use case? Drop them in the comments.

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.