# SoldRadar — eBay Sold Prices & Market Intel (8 Markets) (`yumitori/soldradar`) Actor
Real eBay sold prices across 8 marketplaces — not asking prices. Get median/avg price stats, sold & watch counts, promoted-listing bid data, sponsored & best-offer flags, and auto-discovered category IDs. Thousands of sold comps per keyword in seconds. No login, no captcha.
- **URL**: https://apify.com/yumitori/soldradar.md
- **Developed by:** [Yakugusa Yumitori](https://apify.com/yumitori) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet
## Pricing
from $2.99 / 1,000 results
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/platform/actors/running/actors-in-store#pay-per-event
## What's an Apify Actor?
Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):
```bash
pip install apify-client
```
In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):
````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash
In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).
If your project is in a different language, use 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
## eBay Sold Items Scraper — Sold Prices, Market Intel & Bid Data (8 Marketplaces)
Get **confirmed eBay sold prices** — what items *actually sold for*, not asking prices. Search any keyword across **8 marketplaces**, filter by price, condition, category, and buying format, and export clean structured rows for comps, resale pricing, and market research.
Most eBay scrapers parse fragile HTML one search at a time. This actor hits a fast structured endpoint instead — batching **up to 50 keywords in parallel** and pulling **thousands of sold listings per keyword** (200 per request, deduped) in seconds. It can also expand each keyword into the related terms shoppers actually use — plus a **sponsored-listing flag** on every row and a **promoted-listing bid feed**. No login, no captcha, no API key.
---
### What makes this scraper different
Other eBay sold-price scrapers HTML-scrape one search at a time, hit eBay's 10k wall, and hand you the basics. This scraper surfaces data **no other eBay actor exposes**:
| | Typical eBay sold scraper | **This scraper** |
|---|---|---|
| Depth per keyword | ~10,000 (eBay's web cap) | **12,000+** — bypasses the cap |
| Promoted-listing **bid data** | ❌ | ✅ advertiser bid **+ actual clearing CPC** per keyword |
| Sponsored flag per row | ❌ | ✅ `isSponsored` |
| Best-Offer-accepted flag | rarely | ✅ `isBestOfferAccepted` — so accepted-offer rows don't poison your comps |
| Keyword expansion | ❌ | ✅ one seed → the terms buyers actually type |
| Category-ID discovery | manual / external lookup site | ✅ **auto-listed for your keyword in every run** |
| Engine | headless browser + proxies | **direct JSON, sub-second, no proxy for US** |
| Authenticity Guarantee / product ratings | ❌ | ✅ |
**The bits you won't find anywhere else:**
- 💰 **Promoted Listings bid intelligence** — for any keyword, see what advertisers are bidding and the *actual cost-per-click that cleared*. Sellers pay for this kind of competitive ad data; no other eBay scraper exposes it.
- 🧹 **Clean comps, not noise** — `isBestOfferAccepted` and `isSponsored` flag the rows where the displayed price isn't the true market price, so your averages aren't silently skewed (in cards/sneakers ~30% of "sold" prices are accepted-offer asking prices).
- 🔁 **Keyword expansion** — turn `mechanical keyboard` into the 8 related terms shoppers really search, all scraped in one run — a whole niche from one seed.
- 📊 **True market size** — every keyword reports `totalEntries`, the full count of matching sold listings, not just what you pulled.
- 🗂️ **Category IDs, auto-discovered** — no hunting for `categoryId` values or visiting a separate lookup site. Every run lists the category IDs relevant to *your* keyword in the run summary, so you can re-run scoped to a category in seconds.
- 📈 **Built-in price stats** — every keyword gets a ready-made summary: **count, min, max, average, median, 25th/75th percentile** — with Best-Offer-accepted rows excluded so the numbers reflect *actual* sale prices. The median + percentiles give you a real comp instantly, no spreadsheet.
---
### Quick start
```json
{
"queries": ["iphone 14 pro", "iphone 15 pro"],
"listingStatus": "sold",
"marketplace": "EBAY-US",
"maxItemsPerQuery": 500,
"sortOrder": "endedRecently"
}
````
Two keywords, the 500 most recently sold of each, deduped — runs in a few seconds.
***
### What you get on every listing
**Price data** — `price` (the final sold price for sold listings; the asking price for active), `currency`, `totalPrice` (price + shipping). Plus `soldDate` and `ended`.
**Discounts & offers** — `originalPrice` (was-price), `discountPercent`, `hasPriceDrop`, `couponText`, `bestOfferEnabled`, `freeReturns`.
**Demand signals** — `quantitySold` ("27 sold"), `watchCount` ("68 watchers"), `scarcity` (`last_one` / `almost_gone`), `hasVariations`.
**Shipping** — `shippingPrice`, `shippingType` (`free` / `paid` / `pickup`), `deliveryEstimate`.
**Listing format & lifecycle** — `listingType` (`auction` / `fixed_price`), `bidCount` + `endTime` (active auctions), `quantityAvailable`.
**Placement & trust** — `isSponsored` (eBay Promoted Listing — appears on Best Match searches), `isBestOfferAccepted` (see caveat below), `hasAuthenticityGuarantee`, `isAuthorizedSeller`, `benefitsCharity`, `isRefurbished`.
**Condition & attributes** — `condition` (e.g. "Pre-Owned", "Open Box", "Very Good - Refurbished"), `brand`, `itemSpecifics` (on-card specs, e.g. `["ASUS", "16 GB"]`), `fitment` (vehicle compatibility for Motors).
**Seller intel** — `sellerName`, `sellerFeedbackScore`, `sellerPositivePct`, `itemLocation`.
**Product** — `title`, `itemId`, `epid` (eBay product id), `image` (full-res), `itemUrl`, `productRating`, `productReviewCount`.
Plus `sourceQuery` and `marketplace` so you know which keyword and site surfaced each row.
***
### Proxies & international coverage
The **US marketplace works with no proxy at all.** For non-US marketplaces, enable a proxy in the input — the actor automatically routes through an IP in the **marketplace's own country**, which surfaces materially more local inventory (eBay ranks results by detected location). You bring your own Apify Proxy; nothing is shared.
*Same "laptop" sold search — a country-matched residential IP returned up to **24% more listings** on European markets. US/CA/IT/ES are roughly equal; the gain is largest where local inventory is otherwise under-surfaced.*
**Which proxy to pick:**
| Run | Recommended proxy | Why |
|---|---|---|
| **US marketplace** | None, or **Datacenter** | Works direct; datacenter is cheap and eBay tolerates the volume |
| **Non-US marketplace** | **Residential** (country auto-matched) | Only residential reliably provides in-country IPs for the coverage gain — datacenter country pools are too small |
| Testing / low volume | None | US is full-coverage direct; non-US just returns less |
You select the proxy group in the **Proxy** input; the actor sets the country to match your chosen marketplace automatically.
***
### What you control
| Knob | Default | What it does |
|---|---|---|
| `queries` | — | 1–50 keywords, batched in one run |
| `listingStatus` | `sold` | `sold` (confirmed sales) · `active` (live) · `completed` (sold + unsold) |
| `marketplace` | `EBAY-US` | US · UK · DE · FR · IT · ES · CA · AU (prices in local currency) |
| `maxItemsPerQuery` | `200` | 1–20,000 per keyword (fetched 200 at a time) |
| `sortOrder` | `endedRecently` | `endedRecently` · `newlyListed` · `priceLowToHigh` · `priceHighToLow` · `bestMatch` |
| `condition` | `any` | `any` · `new` · `used` · `certified_refurbished` · `open_box` |
| `buyingFormat` | `all` | `all` · `auction` · `buy_it_now` |
| `concurrentQueries` | `2` | 1–5 keywords running in parallel |
| `dedupeAcrossQueries` | `true` | Same item matching two keywords is counted once |
**Filters:** `minPrice` / `maxPrice`, `categoryId` (e.g. `58058`), `freeShippingOnly`, `soldWithinDays` (recent-comps window — e.g. `30` for the last month; stops paging once past the window).
**Power options:** `expandKeywords` (fan each seed into related searches and scrape those too, `expansionLimit` controls how many), `includeAdIntelligence` (capture Promoted Listings bid data into a separate `promoted-ads` dataset).
***
### Use it for
**Resale comps & pricing.** Pull the recent sold prices for a model, slice by condition, and you have a defensible comp table.
```json
{
"queries": ["rtx 4090"],
"listingStatus": "sold",
"condition": "used",
"minPrice": 800,
"maxPrice": 2000,
"maxItemsPerQuery": 1000,
"sortOrder": "endedRecently"
}
```
**Market research at scale.** Turn one seed into a whole niche with keyword expansion, then read the spread.
```json
{
"queries": ["mechanical keyboard"],
"expandKeywords": true,
"expansionLimit": 8,
"listingStatus": "sold",
"maxItemsPerQuery": 300
}
```
**Cross-market arbitrage.** Same keyword, different marketplace — prices and demand often diverge sharply. Run `EBAY-GB`, `EBAY-DE`, `EBAY-AU` with a country-matched residential proxy.
**Promoted Listings intel.** Turn on `includeAdIntelligence` to capture, per keyword, the advertiser bid, the actual clearing CPC, and which items are being promoted — landed in a separate `promoted-ads` dataset.
***
### Output
Lands in the default dataset — export as JSON, CSV, Excel, or JSONL. Three pre-built views ship with the dataset:
- **Overview** — image, title, price, condition, sold date, seller
- **Pricing** — price, shipping, total, format, condition (the comp table)
- **Seller intel** — seller feedback, location, product ratings
A run summary lands in the key-value store under `SUMMARY` with everything per keyword:
- **`priceStats`** — `count`, `min`, `max`, `avg`, `median`, `p25`, `p75` over the sold prices pulled (Best-Offer-accepted rows excluded), e.g. `{ "median": 295.5, "p25": 145, "p75": 849.26, "count": 174 }` — an instant comp.
- **`categories`** — the eBay category IDs relevant to the keyword (e.g. `15032 Cell Phones & Accessories`, `9394 Cell Phone Accessories`) so you can scope a follow-up run with `categoryId`, no manual lookup.
- Plus `totalEntries` (true market size), per-keyword counts, and the run config.
When `includeAdIntelligence` is on, promoted-listing records land in the `promoted-ads` dataset.
#### Sample row
A real row from an `iphone 14 pro` sold run on EBAY-US:
```json
{
"itemId": "188461874527",
"title": "NEW Apple iPhone 16E (2025) Factory \ud83d\udd13 Unlocked - 100% \ud83d\udd0b Battery 128",
"itemUrl": "https://www.ebay.com/itm/188461874527",
"epid": "10075287556",
"image": "https://i.ebayimg.com/images/g/XCgAAeSw1DRqIEXw/s-l1600.jpg",
"price": 439,
"currency": "USD",
"shippingPrice": 10,
"shippingType": "paid",
"totalPrice": 449,
"originalPrice": null,
"discountPercent": null,
"hasPriceDrop": false,
"couponText": null,
"condition": "Open Box",
"brand": null,
"itemSpecifics": [],
"isRefurbished": false,
"listingType": "fixed_price",
"ended": true,
"soldDate": "2026-06-05",
"bidCount": null,
"endTime": null,
"quantityAvailable": 9,
"quantitySold": null,
"hasVariations": false,
"bestOfferEnabled": true,
"scarcity": null,
"watchCount": null,
"freeReturns": true,
"deliveryEstimate": null,
"fitment": null,
"benefitsCharity": false,
"isSponsored": false,
"isAuthorizedSeller": false,
"hasAuthenticityGuarantee": false,
"isBestOfferAccepted": false,
"sellerName": "gorillacellular",
"sellerFeedbackScore": 1868,
"sellerPositivePct": 99.4,
"itemLocation": "United States",
"productRating": null,
"productReviewCount": null,
"sourceQuery": "iphone 14 pro",
"marketplace": "EBAY-US"
}
```
#### Promoted-ads record (optional)
```json
{
"keyword": "black handbag",
"sourceQuery": "handbag",
"marketplace": "EBAY-US",
"adType": "FIRST_PARTY",
"adSubType": "PROMOTED_STORE",
"bid": 1.59,
"clearingPrice": 1.35,
"promotedItemIds": ["397732549485", "277655788860", "277655694673"]
}
```
***
### Speed & limits
| Run shape | Time |
|---|---|
| 1 keyword, 200 sold (1 request) | < 1s |
| 1 keyword, 1,000 sold (5 requests) | 3–5s |
| 5 keywords parallel, 500 each | ~10s |
| 50 keywords, expansion on, deep | minutes |
**Notes**
- Unlike the eBay website (capped at ~10,000 per search), the endpoint behind this actor keeps paginating — **12,000+ unique listings per query confirmed**, often most of the available pool. For very large niches, narrow with price / category / condition to target the slice you want.
- **Best Offer caveat:** when a listing sold via an accepted Best Offer, eBay does not disclose the actual accepted amount — it shows the listed asking price (struck through). On those rows `price` is therefore an *upper bound*, not the true sold price. We flag every such row with `isBestOfferAccepted: true` so you can exclude them for precise comps. (In offer-heavy categories like trading cards or sneakers this can be ~30% of sold listings.)
- **Promoted bid data** is a point-in-time snapshot, populated for roughly 80% of commercial keywords — treat it as directional ad-intelligence, not a guaranteed field.
***
> ⚠️ **Unofficial.** This actor is not affiliated with, endorsed by, or sponsored by eBay Inc. "eBay" is a trademark of eBay Inc., used here for descriptive purposes only. Collects only publicly available listing data.
# Actor input Schema
## `queries` (type: `array`):
One or more eBay search terms. Add a single term for a focused run, or paste many for bulk research — each keyword runs independently and its rows are tagged with `sourceQuery`.
## `listingStatus` (type: `string`):
"sold" = confirmed completed sales with final prices (the default — for comps & pricing). "active" = current live listings. "completed" = all ended listings incl. unsold.
## `marketplace` (type: `string`):
Which eBay site to search. Prices return in that market's local currency.
## `maxItemsPerQuery` (type: `integer`):
Hard cap on listings returned per keyword. Fetched 200 at a time, so 1000 = 5 requests, 5000 = 25 requests. eBay's mobile API serves 12,000+ per query (far past the website's 10k cap).
## `sortOrder` (type: `string`):
How to rank results. For sold comps, "Ended recently" is most useful.
## `minPrice` (type: `integer`):
Only listings at or above this price (local currency).
## `maxPrice` (type: `integer`):
Only listings at or below this price.
## `condition` (type: `string`):
Filter by item condition.
## `buyingFormat` (type: `string`):
Restrict to a buying format.
## `categoryId` (type: `string`):
Optional eBay category id to scope the search (e.g. 58058 = Computers/Tablets & Networking). Leave blank for all categories. Don't know the ID? Just run once — every run lists the category IDs relevant to your keyword in the run summary (key-value store → SUMMARY → perQuery\[].categories). No external lookup needed.
## `freeShippingOnly` (type: `boolean`):
Only return listings that ship free.
## `soldWithinDays` (type: `integer`):
For sold/completed runs: only keep listings that sold within the last N days. With the default 'Ended recently' sort, the actor stops paging as soon as it's past the window — fast, precise recent comps. Leave blank for no date limit.
## `expandKeywords` (type: `boolean`):
Before searching, expand each seed keyword into related terms eBay shoppers actually search, and scrape those too. Great for broad market research.
## `expansionLimit` (type: `integer`):
When keyword expansion is on, how many related terms to add per seed.
## `includeAdIntelligence` (type: `boolean`):
Capture eBay Promoted Listings auction data per keyword (advertiser bid + actual clearing CPC + promoted items) into a separate `promoted-ads` dataset. Populated for ~80% of commercial keywords; a point-in-time snapshot. (Per-listing `isSponsored` flags are always included regardless.)
## `dedupeAcrossQueries` (type: `boolean`):
When running multiple keywords, drop a listing on later keywords if its `itemId` was already seen. The first row keeps its `sourceQuery`.
## `concurrentQueries` (type: `integer`):
How many keywords to scrape in parallel. 1 = sequential. Higher = faster but risks rate-limiting.
## `proxyConfiguration` (type: `object`):
Optional — leave OFF for US (works great with no proxy). Turn ON Apify Residential only for non-US marketplaces, where it auto-routes through an in-country IP and surfaces more local inventory (see the README chart). For US bulk runs, Datacenter is a cheap alternative.
## Actor input object example
```json
{
"queries": [
"rtx 4090"
],
"listingStatus": "sold",
"marketplace": "EBAY-US",
"maxItemsPerQuery": 200,
"sortOrder": "endedRecently",
"condition": "any",
"buyingFormat": "all",
"freeShippingOnly": false,
"expandKeywords": false,
"expansionLimit": 5,
"includeAdIntelligence": true,
"dedupeAcrossQueries": true,
"concurrentQueries": 2,
"proxyConfiguration": {
"useApifyProxy": false
}
}
```
# Actor output Schema
## `listings` (type: `string`):
All scraped listings (overview / pricing / seller intel views available).
## `summary` (type: `string`):
Totals + per-keyword counts + run config.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"queries": [
"rtx 4090"
],
"proxyConfiguration": {
"useApifyProxy": false
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("yumitori/soldradar").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"queries": ["rtx 4090"],
"proxyConfiguration": { "useApifyProxy": False },
}
# Run the Actor and wait for it to finish
run = client.actor("yumitori/soldradar").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
"rtx 4090"
],
"proxyConfiguration": {
"useApifyProxy": false
}
}' |
apify call yumitori/soldradar --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=yumitori/soldradar",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "SoldRadar — eBay Sold Prices & Market Intel (8 Markets)",
"description": "Real eBay sold prices across 8 marketplaces — not asking prices. Get median/avg price stats, sold & watch counts, promoted-listing bid data, sponsored & best-offer flags, and auto-discovered category IDs. Thousands of sold comps per keyword in seconds. No login, no captcha.",
"version": "1.0",
"x-build-id": "sl6GcCABDjU7z3HtW"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/yumitori~soldradar/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-yumitori-soldradar",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
},
"/acts/yumitori~soldradar/runs": {
"post": {
"operationId": "runs-sync-yumitori-soldradar",
"x-openai-isConsequential": false,
"summary": "Executes an Actor and returns information about the initiated run in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/runsResponseSchema"
}
}
}
}
}
}
},
"/acts/yumitori~soldradar/run-sync": {
"post": {
"operationId": "run-sync-yumitori-soldradar",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
}
},
"components": {
"schemas": {
"inputSchema": {
"type": "object",
"required": [
"queries"
],
"properties": {
"queries": {
"title": "Search keywords",
"minItems": 1,
"maxItems": 50,
"uniqueItems": true,
"type": "array",
"description": "One or more eBay search terms. Add a single term for a focused run, or paste many for bulk research — each keyword runs independently and its rows are tagged with `sourceQuery`.",
"items": {
"type": "string"
}
},
"listingStatus": {
"title": "Listing status",
"enum": [
"sold",
"active",
"completed"
],
"type": "string",
"description": "\"sold\" = confirmed completed sales with final prices (the default — for comps & pricing). \"active\" = current live listings. \"completed\" = all ended listings incl. unsold.",
"default": "sold"
},
"marketplace": {
"title": "Marketplace",
"enum": [
"EBAY-US",
"EBAY-GB",
"EBAY-DE",
"EBAY-FR",
"EBAY-IT",
"EBAY-ES",
"EBAY-CA",
"EBAY-AU"
],
"type": "string",
"description": "Which eBay site to search. Prices return in that market's local currency.",
"default": "EBAY-US"
},
"maxItemsPerQuery": {
"title": "Max results per keyword",
"minimum": 1,
"maximum": 20000,
"type": "integer",
"description": "Hard cap on listings returned per keyword. Fetched 200 at a time, so 1000 = 5 requests, 5000 = 25 requests. eBay's mobile API serves 12,000+ per query (far past the website's 10k cap).",
"default": 200
},
"sortOrder": {
"title": "Sort",
"enum": [
"endedRecently",
"newlyListed",
"priceLowToHigh",
"priceHighToLow",
"bestMatch"
],
"type": "string",
"description": "How to rank results. For sold comps, \"Ended recently\" is most useful.",
"default": "endedRecently"
},
"minPrice": {
"title": "Minimum price",
"minimum": 0,
"type": "integer",
"description": "Only listings at or above this price (local currency)."
},
"maxPrice": {
"title": "Maximum price",
"minimum": 0,
"type": "integer",
"description": "Only listings at or below this price."
},
"condition": {
"title": "Condition",
"enum": [
"any",
"new",
"used",
"certified_refurbished",
"open_box"
],
"type": "string",
"description": "Filter by item condition.",
"default": "any"
},
"buyingFormat": {
"title": "Buying format",
"enum": [
"all",
"auction",
"buy_it_now"
],
"type": "string",
"description": "Restrict to a buying format.",
"default": "all"
},
"categoryId": {
"title": "Category ID",
"type": "string",
"description": "Optional eBay category id to scope the search (e.g. 58058 = Computers/Tablets & Networking). Leave blank for all categories. Don't know the ID? Just run once — every run lists the category IDs relevant to your keyword in the run summary (key-value store → SUMMARY → perQuery[].categories). No external lookup needed."
},
"freeShippingOnly": {
"title": "Free shipping only",
"type": "boolean",
"description": "Only return listings that ship free.",
"default": false
},
"soldWithinDays": {
"title": "Sold within (days)",
"minimum": 1,
"maximum": 365,
"type": "integer",
"description": "For sold/completed runs: only keep listings that sold within the last N days. With the default 'Ended recently' sort, the actor stops paging as soon as it's past the window — fast, precise recent comps. Leave blank for no date limit."
},
"expandKeywords": {
"title": "Expand keywords (auto-suggest)",
"type": "boolean",
"description": "Before searching, expand each seed keyword into related terms eBay shoppers actually search, and scrape those too. Great for broad market research.",
"default": false
},
"expansionLimit": {
"title": "Expansions per keyword",
"minimum": 1,
"maximum": 10,
"type": "integer",
"description": "When keyword expansion is on, how many related terms to add per seed.",
"default": 5
},
"includeAdIntelligence": {
"title": "Include promoted-listing bid intel",
"type": "boolean",
"description": "Capture eBay Promoted Listings auction data per keyword (advertiser bid + actual clearing CPC + promoted items) into a separate `promoted-ads` dataset. Populated for ~80% of commercial keywords; a point-in-time snapshot. (Per-listing `isSponsored` flags are always included regardless.)",
"default": true
},
"dedupeAcrossQueries": {
"title": "Dedupe across keywords",
"type": "boolean",
"description": "When running multiple keywords, drop a listing on later keywords if its `itemId` was already seen. The first row keeps its `sourceQuery`.",
"default": true
},
"concurrentQueries": {
"title": "Concurrent keywords",
"minimum": 1,
"maximum": 5,
"type": "integer",
"description": "How many keywords to scrape in parallel. 1 = sequential. Higher = faster but risks rate-limiting.",
"default": 2
},
"proxyConfiguration": {
"title": "Proxy",
"type": "object",
"description": "Optional — leave OFF for US (works great with no proxy). Turn ON Apify Residential only for non-US marketplaces, where it auto-routes through an in-country IP and surfaces more local inventory (see the README chart). For US bulk runs, Datacenter is a cheap alternative.",
"default": {
"useApifyProxy": false
}
}
}
},
"runsResponseSchema": {
"type": "object",
"properties": {
"data": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"actId": {
"type": "string"
},
"userId": {
"type": "string"
},
"startedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"finishedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"status": {
"type": "string",
"example": "READY"
},
"meta": {
"type": "object",
"properties": {
"origin": {
"type": "string",
"example": "API"
},
"userAgent": {
"type": "string"
}
}
},
"stats": {
"type": "object",
"properties": {
"inputBodyLen": {
"type": "integer",
"example": 2000
},
"rebootCount": {
"type": "integer",
"example": 0
},
"restartCount": {
"type": "integer",
"example": 0
},
"resurrectCount": {
"type": "integer",
"example": 0
},
"computeUnits": {
"type": "integer",
"example": 0
}
}
},
"options": {
"type": "object",
"properties": {
"build": {
"type": "string",
"example": "latest"
},
"timeoutSecs": {
"type": "integer",
"example": 300
},
"memoryMbytes": {
"type": "integer",
"example": 1024
},
"diskMbytes": {
"type": "integer",
"example": 2048
}
}
},
"buildId": {
"type": "string"
},
"defaultKeyValueStoreId": {
"type": "string"
},
"defaultDatasetId": {
"type": "string"
},
"defaultRequestQueueId": {
"type": "string"
},
"buildNumber": {
"type": "string",
"example": "1.0.0"
},
"containerUrl": {
"type": "string"
},
"usage": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "integer",
"example": 1
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
},
"usageTotalUsd": {
"type": "number",
"example": 0.00005
},
"usageUsd": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "number",
"example": 0.00005
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
}
}
}
}
}
}
}
}
```