# eBay Scraper - Listings, Sold Prices & Sellers (8 markets) (`khadinakbar/ebay-all-in-one-scraper`) Actor

Scrape eBay active and sold listings, products, and seller info across 8 marketplaces (US/UK/DE/FR/IT/ES/CA/AU). Search by keyword or paste eBay URLs. Returns flat JSON with 28 fields per item — built for resellers, dropshippers, and AI agents.

- **URL**: https://apify.com/khadinakbar/ebay-all-in-one-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 6 total users, 2 monthly users, 85.4% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event + usage

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 Scraper** is an all-in-one tool to extract eBay **active listings**, **sold listings (price comps)**, **product details**, and **seller info** across **8 global marketplaces** (US, UK, DE, FR, IT, ES, CA, AU). Search by keyword, paste eBay URLs, or pull both active + sold in one run for instant resale intelligence — no eBay developer API needed.

Use it for resale arbitrage, dropshipping research, competitor price tracking, dead-stock pricing, collector comps, dealership inventory monitoring, or feeding an AI agent that needs eBay data. Built for the **Apify platform** with API access, scheduling, integrations (Zapier, Make, n8n, Slack), residential proxy rotation, and full run monitoring.

### What does eBay Scraper do?

This Actor extracts structured data from eBay search results and item pages, in three modes:

- **Active listings** — what's currently for sale (Buy It Now + auctions).
- **Sold listings** — actual completed sales for the last ~90 days (the eBay equivalent of Terapeak / "Sold Comps").
- **Both** — active and sold in one run, perfect for spotting **resale arbitrage** opportunities (low ask vs. high recent sold prices).

You can search by keyword (e.g., `iphone 15 pro`, `vintage rolex submariner`, `pokemon charizard psa 10`), paste any eBay search URL, or paste individual `/itm/` product URLs.

### Why use eBay Scraper?

- **Real sold prices**, not asking prices. Make pricing decisions on data buyers actually paid.
- **Multi-marketplace** — one input, 8 country sites. Compare US vs UK vs DE pricing for the same product.
- **All-in-one** — replaces 3 separate scrapers (search, sold, item detail).
- **AI-agent-ready** — flat JSON, stable keys, MCP-discoverable as `apify--ebay-all-in-one-scraper`.
- **Predictable cost** — flat $0.003 per item, $0.00005 per actor start. No surprise bills.
- **Built for Apify** — schedule it, webhook it, pipe it to Sheets, Airtable, Postgres, or your AI agent.

### How to use eBay Scraper

1. Click **Try for free** at the top of the page.
2. Enter a **Search Query** (e.g., `iphone 15 pro 256gb`) — OR paste eBay URLs into **Start URLs**.
3. Pick a **Marketplace** (default: `ebay.com`).
4. Choose **Mode**: `active`, `sold`, or `both`.
5. Set **Max Results** (50 for a quick test, 1000+ for a full sweep).
6. Optional: filter by **condition**, **min/max price**, **sort order**.
7. Optional: toggle **Visit each item page** for richer data (item specifics, full description, gallery images).
8. Click **Save & Start**. Results stream into the **Output** tab as the run progresses.

### Input

The scraper accepts the following input fields. All are optional — the only requirement is that you provide either `searchQuery` OR `startUrls`.

```json
{
    "searchQuery": "iphone 15 pro 256gb",
    "marketplace": "ebay.com",
    "mode": "sold",
    "maxResults": 100,
    "condition": "used",
    "minPrice": 400,
    "maxPrice": 900,
    "sortBy": "price_asc",
    "detailedItems": false
}
````

Or pass direct URLs:

```json
{
    "startUrls": [
        { "url": "https://www.ebay.com/sch/i.html?_nkw=rolex+submariner&LH_Sold=1&LH_Complete=1" },
        { "url": "https://www.ebay.com/itm/375612345678" }
    ],
    "maxResults": 200
}
```

### Output

Each item in the dataset looks like this (search-card mode):

```json
{
    "itemId": "375612345678",
    "title": "Apple iPhone 15 Pro 256GB Natural Titanium Unlocked - Excellent",
    "price": 749.99,
    "priceText": "US $749.99",
    "currency": "USD",
    "originalPrice": 899.0,
    "discountPercent": 17,
    "condition": "Pre-Owned",
    "listingType": "buy_it_now",
    "bidsCount": null,
    "buyItNowAvailable": true,
    "isSold": false,
    "soldDate": null,
    "shippingCost": 0,
    "shippingType": "free",
    "itemLocation": "Brooklyn, NY",
    "sellerName": "techresellpro",
    "sellerFeedbackPercent": 99.4,
    "sellerFeedbackCount": 18452,
    "imageUrl": "https://i.ebayimg.com/images/g/abc/s-l1600.jpg",
    "itemUrl": "https://www.ebay.com/itm/375612345678",
    "marketplace": "ebay.com",
    "mode": "active",
    "scrapedAt": "2026-05-03T19:42:11.000Z"
}
```

In **detailed mode** (`detailedItems: true`), each item also includes:

```json
{
    "categoryName": "Cell Phones & Smartphones",
    "itemSpecifics": {
        "Brand": "Apple",
        "Model": "iPhone 15 Pro",
        "Storage Capacity": "256 GB",
        "Color": "Natural Titanium",
        "Network": "Unlocked"
    },
    "description": "Excellent condition iPhone 15 Pro...",
    "imageUrls": ["https://i.ebayimg.com/.../s-l1600.jpg", "..."]
}
```

You can download the dataset in **JSON, CSV, Excel, HTML, RSS, or XML** format from the **Output** tab, or pull it via the Apify API.

### Data table

| Field | Type | Description |
|---|---|---|
| `itemId` | string | eBay's unique item identifier |
| `title` | string | Listing title |
| `price` | number | Current price (or final sold price) |
| `currency` | string | USD, GBP, EUR, CAD, AUD |
| `originalPrice` | number | Struck-through price (if discounted) |
| `discountPercent` | number | Computed discount % |
| `condition` | string | Brand New, Pre-Owned, Refurbished, etc. |
| `listingType` | string | buy\_it\_now, auction, auction\_with\_bin, best\_offer |
| `bidsCount` | integer | Bid count (auctions only) |
| `isSold` | boolean | True for sold/completed listings |
| `soldDate` | string | ISO-8601 date of sale (sold mode only) |
| `shippingCost` | number | Shipping cost (0 = free) |
| `shippingType` | string | free, paid, calculated, local\_pickup |
| `itemLocation` | string | Where the item ships from |
| `sellerName` | string | eBay seller username |
| `sellerFeedbackPercent` | number | Seller's positive feedback % |
| `sellerFeedbackCount` | integer | Total seller feedback count |
| `imageUrl` | string | Primary listing image |
| `itemUrl` | string | Direct URL to the item |
| `marketplace` | string | ebay.com, ebay.co.uk, etc. |
| `mode` | string | active or sold |
| `scrapedAt` | string | ISO-8601 timestamp |

Detailed mode adds: `categoryName`, `itemSpecifics`, `description`, `imageUrls`.

### How much does it cost to scrape eBay?

This Actor uses **Pay-Per-Event (PPE)** billing — you only pay for items you actually receive.

| Event | Cost |
|---|---|
| Actor start | $0.00005 (per GB RAM, ~$0.0005 typical) |
| Each eBay item returned | $0.003 |

**Cost examples:**

| Use case | Items | Estimated cost |
|---|---|---|
| Quick price check | 50 | ~$0.15 |
| Reseller sold-comps research | 200 | ~$0.60 |
| Full market sweep | 1000 | ~$3.00 |
| Large keyword sweep | 5000 | ~$15.00 |

Detailed mode (`detailedItems: true`) doesn't change the per-item price but takes longer due to extra page visits. Apify's free $5/month platform credits cover roughly **1,600 items** before any out-of-pocket spend.

### Tips and Advanced options

- **Sold listings only show ~90 days of history** — eBay limits this on the public site. For older comps, you'd need eBay's Terapeak ($20/mo).
- **Use `mode: "both"` for arbitrage hunting** — the dataset interleaves active and sold so you can spot underpriced items.
- **Multi-marketplace tip** — run the same query against `ebay.com`, `ebay.de`, `ebay.co.uk` to find geo-arbitrage (the same camera lens often differs by 30%+ between markets).
- **Pagination is automatic** — you don't need to add `&_pgn=2` to URLs; the actor follows pagination up to your `maxResults`.
- **For 1000+ items**, increase actor memory to 2 GB in the run options for faster throughput.
- **Schedule it** — use Apify's scheduler to re-run daily and pipe diffs to Slack or Sheets for price-change alerts.

### Integrations and use cases

Pair this actor with:

- **`apify/google-shopping-scraper`** — compare eBay vs Google Shopping prices.
- **`khadinakbar/amazon-product-intelligence`** — eBay vs Amazon arbitrage.
- **`khadinakbar/etsy-all-in-one-scraper`** — vintage / collectibles cross-platform.
- **Zapier / Make / n8n** — push results to Sheets, Airtable, Notion, Slack, Postgres, MongoDB.
- **Claude / GPT / Cursor agents** via [Apify MCP](https://mcp.apify.com) — discoverable as `apify--ebay-all-in-one-scraper`.

### FAQ

**Q: Does this work with the eBay Developer API?**
No, this scrapes public eBay HTML. No eBay account, OAuth, or app key required. eBay's official Browse/Finding APIs require app approval and have strict rate limits.

**Q: Can I scrape sold listings older than 90 days?**
Not from the public site — eBay restricts the public sold history to ~90 days. For historical data, you'd need eBay Terapeak (paid) or to run this scraper on a daily schedule and store snapshots yourself.

**Q: Does it work for eBay Motors, eBay Stores, eBay Kleinanzeigen?**
Standard eBay Motors listings work via search. Dedicated eBay Stores (storefront URLs) are not supported — use search with the seller filter instead. eBay Kleinanzeigen (Germany classifieds) is a separate site and not covered.

**Q: What about CAPTCHAs?**
Residential proxies (default) handle eBay's bot protection in 99%+ of cases. If you hit a CAPTCHA loop, retry with a different proxy group or wait 10–20 minutes.

**Q: Can I use this for commercial purposes?**
Yes. eBay listings are public data. As with any scraper, comply with eBay's robots.txt, terms of service, applicable data protection laws (GDPR / CCPA), and use the data lawfully. You are responsible for your use.

### Disclaimer

This scraper is an **independent tool** — not affiliated with, endorsed by, or sponsored by eBay Inc. It accesses publicly available data on eBay's website using HTML scraping. eBay® is a registered trademark of eBay Inc. Use of this Actor is at your own risk; you are responsible for complying with eBay's [Terms of Service](https://www.ebay.com/help/policies/member-behaviour-policies/user-agreement?id=4259), [robots.txt](https://www.ebay.com/robots.txt), and applicable data protection regulations (GDPR, CCPA, etc.).

### Issues and feedback

Found a bug, missing field, or selector that needs updating? Open an issue on the [Issues tab](https://apify.com/khadinakbar/ebay-all-in-one-scraper/issues). Need a custom eBay extraction (storefronts, eBay Motors VIN data, custom analytics)? Send us a message — happy to spin up a tailored version.

# Actor input Schema

## `searchQuery` (type: `string`):

Keyword to search on eBay (e.g., 'iphone 15 pro 256gb', 'vintage rolex submariner'). Supports eBay's standard search syntax including quotes for exact match and minus signs for exclusions. Leave empty if you provide startUrls. NOT a product URL — for direct URL scraping use the startUrls field below.

## `startUrls` (type: `array`):

Direct eBay URLs to scrape. Accepts search result URLs (https://www.ebay.com/sch/i.html?\_nkw=...), category URLs, OR individual item URLs (https://www.ebay.com/itm/...). When provided, searchQuery and other filter fields are ignored. NOT for seller storefront URLs — those return 0 results.

## `mode` (type: `string`):

What to scrape: 'active' returns currently listed items (Buy It Now + auctions), 'sold' returns sold/completed listings for price comps (last ~90 days), 'both' returns active first then sold. Default is 'active'. Sold mode is the eBay equivalent of Terapeak/Sold Comps.

## `marketplace` (type: `string`):

Which eBay regional site to scrape. Affects currency, language, and available inventory. Default is ebay.com (US). NOT all sellers ship internationally — pick the marketplace closest to your buyer location for accurate pricing.

## `maxResults` (type: `integer`):

Maximum number of items to return. eBay paginates 60 results per page; the actor handles pagination automatically. Set to 50 for quick test runs, 1000+ for full market sweeps. Hard cap is 10000 to protect against runaway PPE costs.

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

Filter by item condition. 'any' returns all conditions (default). NOT applied when startUrls already encode a condition filter in the URL.

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

Lower bound on listing price (in marketplace currency). Leave blank for no minimum. Example: 100 returns items priced $100 and above. NOT applied when startUrls already encode price filters.

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

Upper bound on listing price (in marketplace currency). Leave blank for no maximum. Example: 500 returns items priced $500 and below. NOT applied when startUrls already encode price filters.

## `sortBy` (type: `string`):

How eBay should order the results before scraping. 'best\_match' (default) is eBay's relevance ranking. 'ending\_soon' surfaces auctions about to close. 'price\_asc' / 'price\_desc' for cheapest / most expensive first. NOT applied when startUrls already encode sort.

## `detailedItems` (type: `boolean`):

When true, the actor visits each item's detail page to extract item specifics (brand, model, MPN, color, etc.), full description, seller feedback details, and gallery images. Roughly 3x slower and 3x more PPE cost. Default is false (search-page data only).

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

Proxy settings. Leave default — residential proxies are required for eBay reliability and the actor configures them automatically.

## Actor input object example

```json
{
  "searchQuery": "vintage rolex submariner",
  "startUrls": [],
  "mode": "active",
  "marketplace": "ebay.com",
  "maxResults": 50,
  "condition": "any",
  "sortBy": "best_match",
  "detailedItems": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

All scraped eBay items (active and/or sold). Download as JSON, CSV, Excel, HTML, or RSS.

# 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 = {
    "searchQuery": "iphone 15 pro",
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/ebay-all-in-one-scraper").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 = {
    "searchQuery": "iphone 15 pro",
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/ebay-all-in-one-scraper").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 '{
  "searchQuery": "iphone 15 pro",
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/ebay-all-in-one-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=khadinakbar/ebay-all-in-one-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Scraper - Listings, Sold Prices & Sellers (8 markets)",
        "description": "Scrape eBay active and sold listings, products, and seller info across 8 marketplaces (US/UK/DE/FR/IT/ES/CA/AU). Search by keyword or paste eBay URLs. Returns flat JSON with 28 fields per item — built for resellers, dropshippers, and AI agents.",
        "version": "0.5",
        "x-build-id": "h9VA3HySpSNMQNAF3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~ebay-all-in-one-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-ebay-all-in-one-scraper",
                "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/khadinakbar~ebay-all-in-one-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-ebay-all-in-one-scraper",
                "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/khadinakbar~ebay-all-in-one-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-ebay-all-in-one-scraper",
                "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",
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword to search on eBay (e.g., 'iphone 15 pro 256gb', 'vintage rolex submariner'). Supports eBay's standard search syntax including quotes for exact match and minus signs for exclusions. Leave empty if you provide startUrls. NOT a product URL — for direct URL scraping use the startUrls field below."
                    },
                    "startUrls": {
                        "title": "Start URLs (alternative to Search Query)",
                        "type": "array",
                        "description": "Direct eBay URLs to scrape. Accepts search result URLs (https://www.ebay.com/sch/i.html?_nkw=...), category URLs, OR individual item URLs (https://www.ebay.com/itm/...). When provided, searchQuery and other filter fields are ignored. NOT for seller storefront URLs — those return 0 results.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "mode": {
                        "title": "Listing Mode",
                        "enum": [
                            "active",
                            "sold",
                            "both"
                        ],
                        "type": "string",
                        "description": "What to scrape: 'active' returns currently listed items (Buy It Now + auctions), 'sold' returns sold/completed listings for price comps (last ~90 days), 'both' returns active first then sold. Default is 'active'. Sold mode is the eBay equivalent of Terapeak/Sold Comps.",
                        "default": "active"
                    },
                    "marketplace": {
                        "title": "eBay Marketplace",
                        "enum": [
                            "ebay.com",
                            "ebay.co.uk",
                            "ebay.de",
                            "ebay.fr",
                            "ebay.it",
                            "ebay.es",
                            "ebay.ca",
                            "ebay.com.au"
                        ],
                        "type": "string",
                        "description": "Which eBay regional site to scrape. Affects currency, language, and available inventory. Default is ebay.com (US). NOT all sellers ship internationally — pick the marketplace closest to your buyer location for accurate pricing.",
                        "default": "ebay.com"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of items to return. eBay paginates 60 results per page; the actor handles pagination automatically. Set to 50 for quick test runs, 1000+ for full market sweeps. Hard cap is 10000 to protect against runaway PPE costs.",
                        "default": 50
                    },
                    "condition": {
                        "title": "Item Condition",
                        "enum": [
                            "any",
                            "new",
                            "used",
                            "refurbished",
                            "open_box"
                        ],
                        "type": "string",
                        "description": "Filter by item condition. 'any' returns all conditions (default). NOT applied when startUrls already encode a condition filter in the URL.",
                        "default": "any"
                    },
                    "minPrice": {
                        "title": "Minimum Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lower bound on listing price (in marketplace currency). Leave blank for no minimum. Example: 100 returns items priced $100 and above. NOT applied when startUrls already encode price filters."
                    },
                    "maxPrice": {
                        "title": "Maximum Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Upper bound on listing price (in marketplace currency). Leave blank for no maximum. Example: 500 returns items priced $500 and below. NOT applied when startUrls already encode price filters."
                    },
                    "sortBy": {
                        "title": "Sort Order",
                        "enum": [
                            "best_match",
                            "ending_soon",
                            "newest",
                            "price_asc",
                            "price_desc"
                        ],
                        "type": "string",
                        "description": "How eBay should order the results before scraping. 'best_match' (default) is eBay's relevance ranking. 'ending_soon' surfaces auctions about to close. 'price_asc' / 'price_desc' for cheapest / most expensive first. NOT applied when startUrls already encode sort.",
                        "default": "best_match"
                    },
                    "detailedItems": {
                        "title": "Visit each item page (slower, richer data)",
                        "type": "boolean",
                        "description": "When true, the actor visits each item's detail page to extract item specifics (brand, model, MPN, color, etc.), full description, seller feedback details, and gallery images. Roughly 3x slower and 3x more PPE cost. Default is false (search-page data only).",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Leave default — residential proxies are required for eBay reliability and the actor configures them automatically.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
