# eBay Sold Listings Scraper (`automation-lab/ebay-sold-scraper`) Actor

Scrape eBay completed/sold listings for price research 📊 Actual sold prices, not asking prices. Get sold price, date, condition, bids, shipping, and seller. Filter by condition, price range, and listing type.

- **URL**: https://apify.com/automation-lab/ebay-sold-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Listings Scraper

### What does eBay Sold Listings Scraper do?

eBay Sold Listings Scraper extracts completed/sold listing data from [eBay](https://www.ebay.com) — the actual prices that items **sold for**, not just asking prices. It searches eBay's completed listings (using eBay's `LH_Sold=1&LH_Complete=1` filter) and returns structured data including sold price, sold date, item condition, bid count, shipping cost, seller feedback, and direct item URLs.

Unlike the general eBay Scraper (which shows active listings with asking prices), this actor is built specifically for **price research** — finding what something actually sold for. Use it before buying or selling to understand true market value.

Pure HTTP scraping with Cheerio — no browser overhead, fast and cost-efficient.

### Who is eBay Sold Listings Scraper for?

**🛍️ eBay resellers and flippers**
- Research "comp sales" before purchasing inventory
- Validate that your asking price matches what buyers actually paid
- Track seasonal price trends for specific item categories
- Build pricing spreadsheets for hundreds of items at once

**📦 E-commerce sellers**
- Set competitive prices on eBay, Amazon, or Shopify listings
- Analyze competitor sell-through rates by searching their item keywords
- Monitor market prices for restocking decisions
- Research which conditions (new vs. used) command price premiums

**📊 Market researchers and analysts**
- Collect historical price data for vintage or collectible markets
- Build datasets for pricing models and trend analysis
- Track auction vs. Buy It Now price differentials
- Export data to Excel/Google Sheets for reporting

**🤖 Developers and data teams**
- Power price comparison tools and apps
- Build automated alerts for price drops or market shifts
- Integrate sold price data into inventory management systems
- Use with the Apify API or schedule runs for regular data refreshes

### Why use eBay Sold Listings Scraper?

- ✅ **Actual sold prices** — not asking prices. Completed listings show what buyers paid
- ✅ **No API key required** — eBay's official API doesn't expose completed listing data this easily
- ✅ **Fast HTTP-only scraping** — no browser, lightweight, cheap per listing
- ✅ **Filters that matter** — condition, price range, listing type (auction vs. Buy It Now)
- ✅ **Structured output** — JSON/CSV/Excel with consistent field names
- ✅ **Multiple keywords at once** — run 10+ search terms in a single actor run
- ✅ **Residential proxy included** — automatic proxy rotation to avoid blocks
- ✅ **Apify platform benefits** — API access, scheduling, 5,000+ integrations

### What data can you extract?

| Field | Description | Example |
|-------|-------------|---------|
| `title` | Item title | "Canon AE-1 Program 35mm Film Camera" |
| `soldPrice` | Final sold price (USD) | 43.82 |
| `soldPriceString` | Sold price as shown | "$43.82" |
| `soldDate` | Date the item sold | "Apr 2, 2026" |
| `condition` | Item condition label | "Pre-Owned", "Brand New", "Parts Only" |
| `listingType` | Auction or Buy It Now | "Auction" |
| `bidsCount` | Number of bids (auctions) | 7 |
| `shippingCost` | Shipping cost or "Free shipping" | "+$5.99 delivery" |
| `sellerName` | Seller username | "vintage_finds_co" |
| `sellerFeedbackPercent` | Positive feedback % | "99.8%" |
| `sellerFeedbackCount` | Total feedback count | "2.3K" |
| `thumbnail` | Item image URL | "https://i.ebayimg.com/..." |
| `url` | Direct eBay item URL | "https://www.ebay.com/itm/..." |
| `itemId` | eBay item ID | "123456789012" |

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

This actor uses **Pay-Per-Event (PPE) pricing** — you're charged per listing extracted, not per run time. Prices scale down as your usage grows.

| Event | Free plan | Bronze | Silver | Gold | Platinum | Diamond |
|-------|-----------|--------|--------|------|----------|---------|
| Actor start | $0.001 | $0.001 | $0.001 | $0.001 | $0.001 | $0.001 |
| Per sold listing | $0.00345 | $0.003 | $0.00234 | $0.0018 | $0.0012 | $0.00084 |

**Real-world cost examples (Free plan):**

| Use case | Listings | Estimated cost |
|----------|----------|----------------|
| Quick comp check (1 keyword, 10 results) | 10 | ~$0.036 |
| Standard research (1 keyword, 100 results) | 100 | ~$0.346 |
| Deep analysis (5 keywords, 100 each) | 500 | ~$1.726 |
| Bulk research (10 keywords, 200 each) | 2,000 | ~$6.901 |

**Free plan:** Apify gives every account $5 in free credits. That's approximately **1,440 sold listings** you can scrape for free before spending anything.

### How to scrape eBay sold listings

1. Go to [eBay Sold Listings Scraper](https://apify.com/automation-lab/ebay-sold-scraper) on Apify Store
2. Click **Try for free** (or open in Apify Console)
3. Enter one or more search keywords in the **Search keywords** field
4. Set **Max listings per search** (10 for a quick test, 100+ for research)
5. Apply optional filters: condition, price range, listing type
6. Click **Save & Start**
7. Download your results in JSON, CSV, or Excel

**Input example — vintage camera research:**
```json
{
    "searchQueries": ["vintage camera", "film camera 35mm"],
    "maxListingsPerSearch": 100,
    "sort": "newly_listed",
    "condition": ["used"],
    "minPrice": 20,
    "maxPrice": 500
}
````

**Input example — auction-only electronics:**

```json
{
    "searchQueries": ["iphone 14 pro 256gb"],
    "maxListingsPerSearch": 50,
    "sort": "newly_listed",
    "listingType": "auction"
}
```

**Input example — price range analysis:**

```json
{
    "searchQueries": ["lego star wars set", "lego technic", "lego city"],
    "maxListingsPerSearch": 200,
    "maxSearchPages": 10,
    "sort": "price_high"
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | — | **Required.** Keywords to search eBay completed listings. Each runs a separate search. |
| `maxListingsPerSearch` | integer | 100 | Maximum listings to return per keyword. |
| `maxSearchPages` | integer | 5 | Pages to scrape per keyword. Each page has up to 60 listings. |
| `sort` | string | `newly_listed` | Sort order: `best_match`, `newly_listed`, `price_low`, `price_high`. |
| `condition` | string\[] | \[] | Filter by condition: `new`, `open_box`, `refurbished`, `used`, `for_parts`. Leave empty for all. |
| `listingType` | string | `all` | Filter by type: `all`, `auction`, `buy_it_now`. |
| `minPrice` | integer | — | Minimum sold price in USD. |
| `maxPrice` | integer | — | Maximum sold price in USD. |
| `maxRequestRetries` | integer | 5 | Retry attempts for failed requests. |

### Output examples

**Typical sold listing:**

```json
{
    "itemId": "227266797887",
    "title": "Canon AE-1 Program Vintage 35mm Film Camera w/ 50mm Lens Tested Working",
    "soldPrice": 43.82,
    "soldPriceString": "$43.82",
    "soldDate": "Apr 2, 2026",
    "condition": "Pre-Owned",
    "listingType": "Buy It Now",
    "bidsCount": null,
    "shippingCost": "+$12.00 delivery",
    "sellerName": "camera_warehouse_us",
    "sellerFeedbackPercent": "99.5%",
    "sellerFeedbackCount": "3.7K",
    "thumbnail": "https://i.ebayimg.com/images/g/.../s-l500.webp",
    "url": "https://www.ebay.com/itm/227266797887",
    "scrapedAt": "2026-04-02T14:00:00.000Z"
}
```

**Auction listing:**

```json
{
    "itemId": "156789012345",
    "title": "Apple iPhone 15 Pro Max 256GB Natural Titanium Unlocked",
    "soldPrice": 550.00,
    "soldPriceString": "$550.00",
    "soldDate": "Apr 1, 2026",
    "condition": "Pre-Owned · Apple iPhone 15 Pro Max · 256 GB · Unlocked",
    "listingType": "Auction",
    "bidsCount": 20,
    "shippingCost": "Free international shipping",
    "sellerName": "techdeals2024",
    "sellerFeedbackPercent": "100%",
    "sellerFeedbackCount": "892",
    "thumbnail": "https://i.ebayimg.com/images/g/.../s-l500.webp",
    "url": "https://www.ebay.com/itm/156789012345",
    "scrapedAt": "2026-04-02T14:00:00.000Z"
}
```

### Tips for best results

- 🎯 **Use specific keywords** — "canon ae-1 program 35mm" returns more relevant comps than just "camera"
- 📅 **Use "Newly Listed" sort** for the most recent sales data
- 💰 **Narrow price range** filters help when searching high-variance categories (e.g., watches, jewelry)
- 🔄 **Run multiple keywords** — brands, model numbers, and common aliases give fuller market pictures
- 📊 **Export to Excel** and calculate average/median sold prices for robust pricing
- 🗓️ **Schedule weekly runs** to track price trends over time
- 🔢 **Start with 10-20 results** to preview the data quality before running large batches

### Integrations

**eBay Sold Listings Scraper → Google Sheets**
Export 100 comps per keyword directly to a Google Sheet using Apify's Google Sheets integration. Auto-refresh weekly to keep your price research current without manual work.

**eBay Sold Listings Scraper → Make (formerly Integromat)**
Trigger a Make scenario whenever a run finishes: parse the dataset, filter by price range, and push bargains to a Slack channel for your buying team.

**eBay Sold Listings Scraper → Airtable**
Build a live pricing database in Airtable. Run the actor on a schedule, push new sold listings, and use Airtable's rollup formulas to calculate average sold prices per category.

**Scheduled monitoring**
Set up a daily run (via Apify's built-in scheduler) to track sold prices for high-value items. Combine with the Apify API to detect price trend reversals automatically.

**eBay Sold Listings Scraper → Zapier → Email**
Send yourself a daily email digest of recent sales for a specific item, formatted as a price table. Useful for tracking collectibles, electronics, or seasonal inventory.

### Using the Apify API

You can trigger this actor programmatically via the Apify API.

**Node.js (apify-client):**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('automation-lab/ebay-sold-scraper').call({
    searchQueries: ['vintage camera', 'film camera'],
    maxListingsPerSearch: 100,
    sort: 'newly_listed',
    condition: ['used'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("automation-lab/ebay-sold-scraper").call(run_input={
    "searchQueries": ["vintage camera", "film camera"],
    "maxListingsPerSearch": 100,
    "sort": "newly_listed",
    "condition": ["used"],
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

**cURL:**

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~ebay-sold-scraper/runs" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -d '{
    "searchQueries": ["vintage camera"],
    "maxListingsPerSearch": 100,
    "sort": "newly_listed"
  }'
```

### Use with AI agents via MCP

eBay Sold Listings Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/ebay-sold-scraper"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com?tools=automation-lab/ebay-sold-scraper",
            "headers": {
                "Authorization": "Bearer YOUR_APIFY_TOKEN"
            }
        }
    }
}
```

#### Example AI prompts

Once configured, you can ask your AI assistant:

- *"Search eBay sold listings for 'rolex submariner' and show me the last 20 sales with their prices and dates"*
- *"Find what vintage Polaroid cameras actually sold for on eBay in the last month — only used condition, under $200"*
- *"Compare eBay sold prices for 'iphone 15 pro 256gb' vs 'iphone 15 pro max 256gb' — 50 each, auction listings only"*

### Is it legal to scrape eBay sold listings?

eBay's completed/sold listing data is publicly visible to any website visitor without logging in. This actor accesses only publicly available data in the same way a human would browse eBay.

We recommend using this actor responsibly:

- Respect eBay's [Terms of Service](https://www.ebay.com/help/policies/member-behaviour-policies/user-agreement?id=4259)
- Do not use extracted data to spam sellers or buyers
- Comply with applicable data protection laws (GDPR, CCPA) when storing personal data
- Use the data for legitimate price research and market analysis purposes

For more context, see [Apify's guide to ethical web scraping](https://apify.com/blog/is-web-scraping-legal).

### FAQ

**How many results can I get?**
Each search page returns up to 60 sold listings. With `maxSearchPages: 20`, you can get up to 1,200 results per keyword. Run multiple keywords in a single run for broader coverage.

**How fast does it scrape?**
Typically 60 listings per 5-10 seconds. A 100-listing run usually completes in under 30 seconds.

**Why don't some items have a sold date?**
eBay's completed listings page doesn't always show the exact date in the same HTML location — some listings show relative dates (e.g., "2 days ago") that aren't extracted. The field will be empty for those items.

**Why do some condition fields have extra text like "Pre-Owned · Apple iPhone 15"?**
eBay includes item specifics (brand, model, storage) in the condition field for certain categories. This is the raw text from eBay's listing. You can parse or clean this in post-processing.

**Why are my results empty?**
If a search returns no results, the keyword likely has no completed listings in eBay's database. Try:

- Broader keyword (e.g., "canon camera" instead of "canon ae-1 chrome body only")
- Remove price range filters that are too narrow
- Try without condition filters first

**Is this different from the general eBay Scraper?**
Yes — the [eBay Scraper](https://apify.com/automation-lab/ebay-scraper) shows active listings (asking prices). This actor shows **completed/sold listings** (actual transaction prices). Use this actor when you need to know what buyers actually paid, not what sellers are asking.

**Can I scrape eBay sold listings for a specific category?**
Yes — use specific keywords that describe the category (e.g., "vintage denim jacket size L", "pokemon card lot 100"). eBay's search within completed listings is the primary filter mechanism.

### Other e-commerce scrapers

Looking for more market research tools? Try these automation-lab actors:

- [eBay Scraper](https://apify.com/automation-lab/ebay-scraper) — Active listings with asking prices, bids, and filters
- [Amazon Product Scraper](https://apify.com/automation-lab/amazon-scraper) — Product listings, prices, and BSR rankings
- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper) — Customer review data for sentiment analysis

# Actor input Schema

## `searchQueries` (type: `array`):

List of keywords to search eBay completed listings for. Each keyword runs a separate search.

## `maxListingsPerSearch` (type: `integer`):

Maximum number of sold listings to return for each keyword.

## `maxSearchPages` (type: `integer`):

Maximum number of search result pages to scrape per keyword. Each page has up to 60 listings.

## `sort` (type: `string`):

How to sort sold listing results.

## `condition` (type: `array`):

Filter by item condition. Leave empty to include all conditions.

## `listingType` (type: `string`):

Filter by listing type: auction (items that sold via bidding) or Buy It Now.

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

Minimum sold price filter in USD. Leave empty for no minimum.

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

Maximum sold price filter in USD. Leave empty for no maximum.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed requests before skipping.

## Actor input object example

```json
{
  "searchQueries": [
    "vintage camera"
  ],
  "maxListingsPerSearch": 10,
  "maxSearchPages": 1,
  "sort": "newly_listed",
  "listingType": "all",
  "maxRequestRetries": 5
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "searchQueries": [
        "vintage camera"
    ],
    "maxListingsPerSearch": 10,
    "maxSearchPages": 1,
    "sort": "newly_listed",
    "listingType": "all",
    "maxRequestRetries": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ebay-sold-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 = {
    "searchQueries": ["vintage camera"],
    "maxListingsPerSearch": 10,
    "maxSearchPages": 1,
    "sort": "newly_listed",
    "listingType": "all",
    "maxRequestRetries": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ebay-sold-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 '{
  "searchQueries": [
    "vintage camera"
  ],
  "maxListingsPerSearch": 10,
  "maxSearchPages": 1,
  "sort": "newly_listed",
  "listingType": "all",
  "maxRequestRetries": 5
}' |
apify call automation-lab/ebay-sold-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Sold Listings Scraper",
        "description": "Scrape eBay completed/sold listings for price research 📊 Actual sold prices, not asking prices. Get sold price, date, condition, bids, shipping, and seller. Filter by condition, price range, and listing type.",
        "version": "0.1",
        "x-build-id": "LyE8aPbVrhxiumbDd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ebay-sold-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ebay-sold-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/automation-lab~ebay-sold-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ebay-sold-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/automation-lab~ebay-sold-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ebay-sold-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",
                "required": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "List of keywords to search eBay completed listings for. Each keyword runs a separate search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxListingsPerSearch": {
                        "title": "Max listings per search",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of sold listings to return for each keyword.",
                        "default": 100
                    },
                    "maxSearchPages": {
                        "title": "Max search pages",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of search result pages to scrape per keyword. Each page has up to 60 listings.",
                        "default": 5
                    },
                    "sort": {
                        "title": "Sort results by",
                        "enum": [
                            "best_match",
                            "newly_listed",
                            "price_low",
                            "price_high"
                        ],
                        "type": "string",
                        "description": "How to sort sold listing results.",
                        "default": "newly_listed"
                    },
                    "condition": {
                        "title": "Item condition",
                        "type": "array",
                        "description": "Filter by item condition. Leave empty to include all conditions.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "new",
                                "open_box",
                                "refurbished",
                                "used",
                                "for_parts"
                            ],
                            "enumTitles": [
                                "New",
                                "Open Box",
                                "Refurbished",
                                "Used",
                                "For Parts or Not Working"
                            ]
                        }
                    },
                    "listingType": {
                        "title": "Listing type",
                        "enum": [
                            "all",
                            "auction",
                            "buy_it_now"
                        ],
                        "type": "string",
                        "description": "Filter by listing type: auction (items that sold via bidding) or Buy It Now.",
                        "default": "all"
                    },
                    "minPrice": {
                        "title": "Minimum price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum sold price filter in USD. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum sold price filter in USD. Leave empty for no maximum."
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed requests before skipping.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
