eBay scraper API

E-commerce · v1.2.0 · ebay_search

$0.001 / listing

$1.00 / 1K · pay per delivered listing

An eBay scraper API that returns listings for a keyword: item id, title, price and struck-through list price, condition, buying format, shipping and returns lines, seller location, sponsored flag and image — across 15 marketplaces.

By Aldo Morese, founder of QuanticData · Published Aug 21, 2026 · Updated Sep 3, 2026

Run in dashboard See the request

$0.001 per delivered listing · $2 free every month · Failed runs never billed

What it does

What an eBay scraper API does

eBay rebuilt its result cards around generic text spans, which broke every scraper that relied on the old s-item classes. This collector reconstructs a row from the card's text roles instead, so it survives the class churn that takes selector-based scrapers offline.

One detail matters and it is handled: the condition chip is not always first — refurbished listings put a seller blurb ahead of it, so the condition is picked by vocabulary rather than by position.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`query`	string	yes	What to search on eBay, e.g. "running shoes".
`condition`	string	no	Restrict to new or used listings. One of: `any`, `new`, `used`.
`buy_it_now_only`	boolean	no	Exclude auctions.
`country`	string	no	ISO 3166-1 alpha-2 code — picks the local site AND the proxy exit (default us).
`max_results`	integer	no	How many listings to deliver at most (1–250). You pay only for delivered listings.

Outputs — 26 fields, one row per listing

What one listing looks like

Every delivered listing carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`rank`	integer	1-based position across pages.
`page`	integer	Search page the row came from.
`item_id`	string	eBay item id.
`title`	string	Listing title.
`price`	string · nullable	Price as shown.
`price_value`	number · nullable	Numeric price.
`list_price`	string · nullable	Struck-through price when discounted.
`condition`	string · nullable	Condition chip (Brand New, Pre-Owned…).
`attributes`	string[]	Variant/brand chips shown under the title.
`format`	string · nullable	Buying format (Buy It Now, bids…).
`shipping`	string · nullable	Shipping/delivery line.
`location`	string · nullable	Seller location line.
`returns`	string · nullable	Returns line when shown.
`sponsored`	boolean	True for paid placements.
`image`	string · nullable	Thumbnail URL.
`url`	string · nullable	Listing URL.
`best_offer`	boolean	True when the listing accepts offers.
`shipping_cost`	number · nullable	Shipping cost parsed from the shipping line (0 when free).
`bids`	integer · nullable	Bid count on auctions.
`time_left`	string · nullable	Auction time left as shown ("6d 11h").
`rating`	number · nullable	Product star rating when the listing is tied to a catalog product.
`reviews_count`	integer · nullable	Number of product ratings.
`product_id`	string · nullable	eBay catalog product id (ePID) when present.
`watchers`	integer · nullable	Watcher count when the card shows it.
`badge`	string · nullable	Card caption ("NEW LOW PRICE", "NEWLY LISTED").
`urgency`	string · nullable	Urgency line ("Last one").

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/ebay_search/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/ebay_search/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"running shoes","country":"us","max_results":50}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/ebay_search/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "query": "running shoes",
        "country": "us",
        "max_results": 50
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/ebay_search/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"query":"running shoes","country":"us","max_results":50}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the ebay_search collector with query="running shoes" and country="us"

Example response

POST /v1/scraper/collectors/ebay_search/run

$ curl $QD/ebay_search/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"query": "running shoes", "country": "us", "max_results": 50}'
{ "status": "done", "count": 50,
  "results": [
    {
      "item_id": "…",
      "title": "…",
      "price": "…",
      "price_value": … } ],
  "cost": 0.05 }
# 50 listings × $0.001 · nothing delivered, nothing charged

Try it

eBay search, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

eBay scraper API: from query and country, QuanticData reads the eBay results and returns one row per listing with title, price and condition, at $0.001 per delivered listing. — You send query and condition; the run goes out through a residential exit and comes back as listings with rank, page and item_id — 26 fields on every row — and you are billed $0.001 for each listing actually delivered, nothing for a run that delivers none.

$0.001 / listing2,000 listings on the free $2 every month

Semantic inputquery, condition, buy_it_now_only — no URL lists

Up to 250listings per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

Pricing

eBay scraper API pricing

$0.001 per delivered listing. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 2,000 listings before you spend anything.

$0.001per delivered listing$1 per 1,000 delivered listings

2,000 listingson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

What people build with the eBay scraper API

Three shapes of work this endpoint was designed around.

Resale price research

Compare asking prices by condition for the same model across a marketplace.

Auction versus fixed price

Split the market by buying format before deciding how to list.

Grey-market monitoring

Watch which sellers list your product, from which country, at what price.

eBay scraper API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Card markup	Breaks with every class rename	Rebuilt from text roles
Sponsored detection	Missed	Detected
Condition	First chip, often the seller's blurb	Matched against eBay's condition vocabulary

What people search for

Live autocomplete demand around eBay search, pulled with our own Keyword ideas collector.

The index versus the page

eBay's Browse and Finding APIs are real and well documented, and reaching them means registering an application, completing developer onboarding and handling OAuth token refresh. For a team that wants a comparable price series across five marketplaces this quarter, that is a lot of process before the first row.

They also answer from eBay's index with eBay's ranking, while a dataset about the market usually needs the result page as served — including promoted placements and the order buyers actually saw. For comparability the fields that matter are format and shipping: an auction bid mid-flight and a fixed price are not the same measurement, and a cheap item with expensive postage is not cheap.

Limits, filters and the legal bit

Up to 250 listings per run — deep enough that long-tail supply on page four is reachable. The condition and buy_it_now_only filters apply at the source, so narrowing a sweep reduces what you are billed rather than just what you keep. Throughput is your plan's rate limit rather than anything about the collector: 60 requests/minute on pay-as-you-go, up to 1,200 on the top tier.

Collecting publicly visible data is generally lawful in most jurisdictions, and courts have repeatedly declined to treat reading a public page as unauthorised access. eBay's terms restrict automated access, and seller usernames and locations can be personal data depending on context. None of this is legal advice — get some for your actual use case.

eBay scraper API: the POST to the ebay_search collector, 50 listings delivered and the bill, 50 × $0.001 = $0.05 in usage.cost_usd; zero listings would cost $0. — The same call you would paste into a terminal: a Bearer key, query, country and condition in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many listings arrived and usage.cost_usd is $0.05, which is 50 × $0.001. A run that delivers nothing costs nothing. The key is good for 60 req/min on the free tier.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the eBay scraper API.

Something else? Ask us

Can I filter to new or used only?

Yes. condition accepts new or used and maps to eBay's own filter ids, and buy_it_now_only drops auctions.

Which marketplaces are supported?

Fifteen, chosen with country: US, UK, IE, DE, FR, IT, ES, NL, BE, AT, CH, PL, CA, AU.

Do you return the seller name?

The result card publishes location, format, shipping and returns, not a seller handle. Where eBay shows a store name in the card it lands in the attribute chips.

Is there a free eBay scraper API?

Every account gets $2 of credit every month with no card, which is about 2,000 delivered listings on this endpoint at $0.001 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.001. A run capped at 250 listings — the maximum for this collector — costs $0.25 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Why keep the buying format as a column?

Because mixing auctions and fixed-price listings produces a price series that moves for reasons unrelated to the market. Keeping format lets one dataset answer both questions instead of quietly averaging them into a third that means nothing.

Do the filters save money?

Yes — they are applied by eBay before results are collected, so a used-only or Buy-It-Now-only sweep collects and bills fewer rows rather than returning everything for you to discard.

Run the eBay scraper API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Run in dashboard

Illustration: three coloured zones of the page that is read (eBay results) turn into clean JSON with the fields title, price and condition; 26 fields on every row.