# 🛒 eBay Sold Comps Scraper (`skootle/ebay-sold-comps`) Actor

Scrape eBay sold listings (90-day window) for any query. Sold price, condition, shipping, sold date, seller info. Plus computed comps: median, P10/P90, byVariant grouped by storage/color/condition, sell-through rate, velocity. Export, run via API, schedule, or integrate with other tools.

- **URL**: https://apify.com/skootle/ebay-sold-comps.md
- **Developed by:** [Skootle](https://apify.com/skootle) (community)
- **Categories:** E-commerce, AI, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 sold listing or comps summary records

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 Comps hero](https://raw.githubusercontent.com/kesjam/skootle-actors-assets/main/heroes/ebay-sold-comps.png)

### TL;DR

Scrape eBay's last 90 days of sold listings for any search query. Returns clean rows with sold price (numeric USD + raw), condition enum, shipping cost, sold date in ISO 8601, seller info, and computed comps: median, P10, P90, sample-size confidence, broken down by condition tier and by variant tuple (storage, color, model). Includes sell-through rate and velocity (sold/day). For resellers, collectibles valuation, AI shopping agents, insurance appraisers.

---

<!-- skootle:review-cta -->
> Try it on a small dataset, then let us know what you think in a [review](https://apify.com/skootle/ebay-sold-comps/reviews).

---

### What does eBay Sold Comps Scraper do?

eBay Sold Comps Scraper extracts every sold listing from eBay's last-90-days window for any search query. You give it queries (e.g., `["iphone 15 pro 256gb", "vintage rolex submariner"]`); it returns two record types:

1. **`sold_listing`** — one record per individual sold item with sold price, condition enum (`NEW | LIKE_NEW | PRE_OWNED | GOOD | FOR_PARTS | UNKNOWN`), shipping cost, sold date, seller name + feedback %, photos, and item specifics tuple (`brand`, `model`, `storage`, `color`).

2. **`comps_summary`** — one record per query with `medianUsd`, `p10Usd`, `p90Usd`, `sampleSize`, `confidence` enum (`high` / `medium` / `low`), `byCondition[]` block, `byVariant[]` block, `sellThroughRate`, and `velocityScorePerDay`.

So a "256GB Natural Titanium Pre-Owned" gets its own price band separate from "128GB Black For Parts". Every record carries `agentMarkdown` for direct LLM consumption.

### Why scrape eBay sold comps?

eBay sold listings are the deepest comp source for almost any product on Earth — collectibles, used electronics, vintage tools, watches, sneakers, retro tech, anything that resells. eBay only keeps sold listings for 90 days, but in that window the data is gold-standard for:

- **Reseller pricing decisions** before buying or listing
- **Insurance and estate appraisals** with defensible "fair market value" backed by recent comps
- **Collectibles valuation** for cards, vintage, watches, art, sneakers
- **Inventory buy-vs-pass decisions** using `sellThroughRate` and `velocityScore`
- **Repricing engines** that adjust active listings against the latest sold-comp band

eBay doesn't expose a public sold-listings API for non-commercial users. This actor handles the search + variant-grouping + condition normalization + comps math.

### Who needs this?

- **Resellers** pricing buys and listings (clothing, electronics, collectibles, watches, sneakers)
- **Pawnshop and consignment operators** appraising buy-side offers
- **Insurance adjusters** building defensible "fair market value" claims with sold-comp evidence
- **Estate appraisers** valuing inherited collections
- **Inventory acquisition teams** using `sellThroughRate` to filter slow-moving SKUs
- **Repricing tool builders** integrating eBay sold-comp data into Vendoo / List Perfectly / Crosslist
- **AI shopping / arbitrage agents** comparing sold-comp median against local goodwill / estate / Marketplace finds
- **Trend researchers** tracking velocity changes by category over time

### How to use eBay Sold Comps Scraper

1. Open the **Input** tab on the actor page
2. Add search queries to `searchQueries` (one per line)
3. Optionally filter `conditions` or set `lookbackDays` (default 30, max 90)
4. Set `maxItemsPerQuery` (default 50)
5. Optionally enable `emitCompsSummary` (default `true`)
6. Click **Start**

### How much will scraping eBay sold comps cost?

This actor is priced per event:

- **Actor Start**: $0.01 once per run
- **eBay record (sold_listing or comps_summary)**: tiered, charged per record written

| Apify plan | $/1000 records |
|---|---|
| FREE | $30.00 |
| BRONZE | $25.50 |
| SILVER | $21.00 |
| GOLD | $18.00 |
| PLATINUM | $18.00 |
| DIAMOND | $16.20 |

A daily reseller workflow on 10 SKUs returns ~510 records. Roughly $9 per run on GOLD — sub-$0.02 per SKU comp lookup.

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

Yes, eBay sold listings are publicly accessible to anyone in a browser without logging in. This actor reads the same public sold-search results with proper rate-limiting. It does not log into seller accounts, does not access buyer-side data, and does not bypass any technical access control.

For commercial redistribution of raw datasets, consult eBay's terms and your legal counsel. For internal pricing tools, repricing engines, AI training, and comparison-shopping research, the scraped data is treated like any other public web content.

### Examples

#### Example 1: iPhone 15 Pro 256GB comps

```json
{
  "searchQueries": ["iphone 15 pro 256gb"],
  "lookbackDays": 30,
  "maxItemsPerQuery": 50
}
````

#### Example 2: Reseller bulk-SKU repricing feed

```json
{
  "searchQueries": [
    "rolex submariner 116610",
    "omega speedmaster 311",
    "iphone 15 pro 256gb",
    "macbook pro m3 14"
  ],
  "lookbackDays": 60,
  "maxItemsPerQuery": 50
}
```

#### Example 3: Pre-owned only (no parts/broken)

```json
{
  "searchQueries": ["airpods pro 2"],
  "conditions": ["PRE_OWNED", "LIKE_NEW", "NEW"],
  "lookbackDays": 30,
  "maxItemsPerQuery": 100
}
```

#### Example 4: Insurance/appraisal claim

```json
{
  "searchQueries": ["lego star wars 75313 imperial star destroyer"],
  "lookbackDays": 90,
  "maxItemsPerQuery": 50
}
```

The `comps_summary` gives you `medianUsd` ± `p10Usd`/`p90Usd` ready for an insurance or estate claim.

#### Example 5: Velocity-based inventory buy filter

```json
{
  "searchQueries": ["pokemon charizard 4/102"],
  "lookbackDays": 90,
  "maxItemsPerQuery": 100
}
```

Filter `velocityScorePerDay > 1` (sells more than once per day) before buying.

#### Example 6: Variant pricing for a multi-SKU product

```json
{
  "searchQueries": ["nintendo switch oled"],
  "lookbackDays": 30,
  "maxItemsPerQuery": 200
}
```

`byVariant[]` breaks comps by `(color, condition)` tuple so White-LIKE\_NEW vs Neon-PRE\_OWNED gets its own price band.

#### Example 7: Trend research over weeks

```json
{
  "searchQueries": ["air jordan 1 chicago"],
  "lookbackDays": 90,
  "maxItemsPerQuery": 200
}
```

Run weekly; chart `medianUsd` and `velocityScorePerDay` over time.

#### Example 8: AI arbitrage agent feed

```json
{
  "searchQueries": ["sony wh-1000xm5", "dyson v15 detect"],
  "lookbackDays": 30,
  "maxItemsPerQuery": 50,
  "emitCompsSummary": true
}
```

The agent reads `medianUsd - shippingCost - eBayFees` and compares against local find prices.

### Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | string\[] | required | Search terms |
| `conditions` | enum\[] | `[]` | `NEW`, `LIKE_NEW`, `PRE_OWNED`, `GOOD`, `FOR_PARTS` |
| `lookbackDays` | int | `30` | Sold-listing window (max 90) |
| `maxItemsPerQuery` | int | `50` | Per-query cap |
| `emitCompsSummary` | bool | `true` | Also emit one `comps_summary` per query |
| `useApifyProxy` | bool | `true` | Apify residential proxy. Recommended. |

### eBay Sold Comps output format

The dataset has two record types. Filter by `recordType`.

#### `sold_listing`

| Field | Type | Description |
|---|---|---|
| `outputSchemaVersion`, `recordType`, `recordId` | string | Discriminated identity |
| `itemId`, `url` | string | eBay item ID + URL |
| `title` | string | Listing title |
| `soldPriceUsd`, `soldPriceRaw` | float / string | Numeric mirror + raw |
| `shippingCostUsd` | float | Shipping cost (`0` if free) |
| `totalPriceUsd` | float | `soldPriceUsd + shippingCostUsd` |
| `currency` | string | Currency code |
| `condition` | enum | `NEW`, `LIKE_NEW`, `PRE_OWNED`, `GOOD`, `FOR_PARTS`, `UNKNOWN` |
| `conditionRaw` | string | Original eBay condition string |
| `soldDate` | ISO 8601 | When it sold |
| `sellerName`, `sellerFeedbackPercent`, `sellerFeedbackCount` | string / float / int | Seller info |
| `imageUrls` | string\[] | Listing photos |
| `itemSpecifics` | object | Brand, model, storage, color, etc. |
| `searchQuery` | string | The query that found this listing |
| `fieldCompletenessScore`, `agentMarkdown` | int / string | Quality + LLM-ready summary |

#### `comps_summary`

| Field | Type | Description |
|---|---|---|
| `outputSchemaVersion`, `recordType`, `recordId` | string | Discriminated identity (`ebay:comps:<query-slug>`) |
| `searchQuery`, `lookbackDays` | string / int | Query context |
| `sampleSize` | int | Number of sold listings used |
| `confidence` | enum | `high` (≥30), `medium` (10-29), `low` (<10) |
| `medianUsd`, `p10Usd`, `p90Usd`, `meanUsd`, `stdDevUsd` | float | Comps math |
| `byCondition` | array | `[{ condition, count, medianUsd, p10Usd, p90Usd }]` |
| `byVariant` | array | `[{ variant: { brand, model, storage, color }, count, medianUsd, p10Usd, p90Usd }]` |
| `sellThroughRate` | float | Active-listings-that-actually-sold proxy |
| `velocityScorePerDay` | float | Sold per day in the lookback window |
| `daysToSellMedian` | float | Median days from list to sold |
| `agentMarkdown` | string | LLM-ready summary |

#### eBay Sold Comps scraper output example (sold\_listing)

```json
{
  "outputSchemaVersion": "2026-05-08",
  "recordType": "sold_listing",
  "recordId": "ebay:listing:325918765432",
  "itemId": "325918765432",
  "url": "https://www.ebay.com/itm/325918765432",
  "title": "Apple iPhone 15 Pro 256GB Natural Titanium Unlocked",
  "soldPriceUsd": 749,
  "shippingCostUsd": 11.35,
  "totalPriceUsd": 760.35,
  "condition": "PRE_OWNED",
  "soldDate": "2026-05-08T19:42:53.000Z",
  "sellerName": "techreseller_88",
  "sellerFeedbackPercent": 99.4,
  "sellerFeedbackCount": 4123,
  "itemSpecifics": {
    "brand": "Apple",
    "model": "iPhone 15 Pro",
    "storage": "256 GB",
    "color": "Natural Titanium"
  },
  "fieldCompletenessScore": 100,
  "agentMarkdown": "**📦 Apple iPhone 15 Pro 256GB Natural Titanium Unlocked**\n- 💰 $749 + $11.35 ship = $760.35\n- 🏷 PRE_OWNED · sold 2026-05-08\n- 👤 techreseller_88 (99.4% / 4123 reviews)\n- 🔗 https://www.ebay.com/itm/325918765432"
}
```

#### eBay Sold Comps scraper output example (comps\_summary)

```json
{
  "outputSchemaVersion": "2026-05-08",
  "recordType": "comps_summary",
  "recordId": "ebay:comps:iphone-15-pro-256gb",
  "searchQuery": "iphone 15 pro 256gb",
  "lookbackDays": 30,
  "sampleSize": 47,
  "confidence": "high",
  "medianUsd": 749,
  "p10Usd": 619,
  "p90Usd": 879,
  "meanUsd": 752.41,
  "byCondition": [
    { "condition": "PRE_OWNED", "count": 31, "medianUsd": 729, "p10Usd": 619, "p90Usd": 849 },
    { "condition": "LIKE_NEW", "count": 12, "medianUsd": 829, "p10Usd": 779, "p90Usd": 879 }
  ],
  "byVariant": [
    { "variant": { "storage": "256 GB", "color": "Natural Titanium" }, "count": 18, "medianUsd": 779 }
  ],
  "sellThroughRate": 0.83,
  "velocityScorePerDay": 1.6,
  "daysToSellMedian": 4.2,
  "agentMarkdown": "**🛒 iphone 15 pro 256gb · 30d comps**\n- 📊 n=47 (high confidence)\n- 💰 median $749 · P10 $619 · P90 $879\n- ⚡ 1.6 sold/day · 83% sell-through · median 4.2 days to sell"
}
```

### During the Actor run

The actor uses Playwright with the Apify residential proxy to fetch each query's sold-results page (eBay's sold-listings filter requires a Playwright-style request). Each listing card is parsed for sold price, shipping, condition, sold date, seller info, and item specifics. After fetching all listings for a query, the actor computes the comps\_summary record.

The actor writes:

1. **`OUTPUT`** — run summary
2. **`AGENT_BRIEFING`** — top queries by sample size + median price
3. **`WATCHLIST_STATE`** — (when `watchlistMode: true`) seen item IDs

### FAQ

#### How does eBay Sold Comps Scraper work?

The actor uses Playwright + Apify residential proxy + stealth fingerprinting to fetch eBay's sold-listings results pages. Each card is parsed for sold price, condition, shipping, sold date, seller info, and item specifics. The comps math runs after all listings for a query are fetched.

#### How fresh is the data?

eBay updates sold-listings within minutes. This actor reads the live sold-search, so data is at most 1-2 minutes stale.

#### Can I get older sold listings beyond 90 days?

No — eBay only retains sold-listings data in their public search for 90 days. Platform limit, not an actor gap.

#### Can I filter by condition?

Yes. `conditions: ["PRE_OWNED", "LIKE_NEW"]` to skip parts/broken units and brand-new units.

#### Can I get the byVariant breakdown?

Yes. Set `emitCompsSummary: true` (default). Each `comps_summary` record includes a `byVariant` array grouped by `itemSpecifics` tuple.

#### Can I use this with the Apify API?

Yes. POST to `https://api.apify.com/v2/acts/skootle~ebay-sold-comps/runs`.

#### Can I integrate with Make / Zapier / n8n / Slack?

Yes. Click **Integrations** on the actor page.

#### Why does this actor cost more than free eBay scrapers?

This actor ships normalized condition + variant tuples, computed `medianUsd`/`p10Usd`/`p90Usd` per query, `sellThroughRate`, `velocityScorePerDay`, `byCondition`+`byVariant` breakdowns, agent-ready markdown summaries. Free scrapers return only raw HTML — you'd write all the comps math yourself.

#### Your feedback

Hit a bug or want a feature? Open an issue on the [Issues tab](https://apify.com/skootle/ebay-sold-comps/issues/open) rather than the reviews page, and we'll fix it fast (typically within 48 hours).

### Why choose eBay Sold Comps Scraper

- **Comps math built-in** — `medianUsd`, `p10Usd`, `p90Usd`, `meanUsd`, `stdDevUsd` per query
- **`byVariant` block** — comps grouped by `itemSpecifics` tuple (storage, color, condition)
- **`byCondition` block** — separate price bands per condition tier
- **`sellThroughRate` + `velocityScorePerDay`** — buy-vs-pass signals built in
- **Condition enum** — `NEW`, `LIKE_NEW`, `PRE_OWNED`, `GOOD`, `FOR_PARTS`, `UNKNOWN`
- **Numeric mirrors** — `soldPriceUsd`, `shippingCostUsd`, `totalPriceUsd` ready for analytics
- **Discriminated union** — `sold_listing` + `comps_summary` in one dataset
- **Versioned schema** — `outputSchemaVersion: '2026-05-08'`
- **Idempotent record IDs** — `ebay:listing:<id>`, `ebay:comps:<query-slug>` stable across runs
- **Agent-grade output** — `agentMarkdown` ready to paste into an LLM context

### Other Skootle actors you might want to check

- **[Vinted Comps · Variant Pricing](https://apify.com/skootle/resale-marketplace-comps)** — same comps pattern for fashion resale
- **[Reddit Subreddit Scraper](https://apify.com/skootle/reddit-subreddit-monitor)** — sentiment + trend signals on r/Flipping, r/PowerSellersUnite
- **[Shopify App Store Scraper](https://apify.com/skootle/shopify-app-store-scraper)** — Shopify app intelligence
- **[Apple App Store Reviews Monitor](https://apify.com/skootle/app-store-reviews)** — App Store reviews + metadata
- **[Hacker News Watchlist](https://apify.com/skootle/hackernews-watchlist)** — tech discourse stream

### Support and contact

File issues on this actor's page — replies within 48 hours.

# Actor input Schema

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

Free-text eBay searches, e.g. \['iphone 15 pro 256gb', 'nintendo switch oled']. One run handles multiple queries; comps are computed per query.

## `ebaySite` (type: `string`):

Which eBay regional site to query.

## `daysToScrape` (type: `integer`):

How far back to look for sold listings. eBay caps this at 90 days.

## `itemsPerPage` (type: `integer`):

How many results per fetched page (eBay accepts 25, 50, 60, 120, 240).

## `maxItems` (type: `integer`):

Maximum sold-listing records to save. Default is conservative so the daily auto-test fits Apify's 5-minute window. Raise for production.

## `emitComps` (type: `boolean`):

When true, the actor writes one comps\_summary record per search query with median/P10-P90, by-condition bands, and by-variant bands grouped by itemSpecifics.

## `measureSellThrough` (type: `boolean`):

When true, the actor also fetches active listings for each query to compute sell-through rate (sold-last-30d / (sold-last-30d + currently-listed)).

## `conditionIds` (type: `array`):

Optional eBay condition IDs to filter by. 1000=New, 1500=New (Other), 1750=Open Box, 2000=Certified Refurb, 2500=Seller Refurb, 3000=Used, 7000=For Parts.

## `category` (type: `string`):

Optional eBay category ID to scope the search.

## `useApifyProxy` (type: `boolean`):

Use Apify residential proxy. Recommended for production; safer against rate limits. The free Apify plan includes a small proxy budget.

## `apifyProxyGroups` (type: `array`):

Apify proxy groups. RESIDENTIAL is recommended. Override only if your account has dedicated groups.

## Actor input object example

```json
{
  "searchQueries": [
    "iphone 15 pro 256gb"
  ],
  "ebaySite": "EBAY_US",
  "daysToScrape": 30,
  "itemsPerPage": 60,
  "maxItems": 10,
  "emitComps": true,
  "measureSellThrough": true,
  "conditionIds": [],
  "category": "",
  "useApifyProxy": true,
  "apifyProxyGroups": [
    "RESIDENTIAL"
  ]
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Sold-listing rows AND per-query comps summaries. Filter by recordType in your downstream code.

## `agentBriefing` (type: `string`):

Markdown digest of the run with comps and top-10 sold rows. Pipe to Slack or feed to an LLM.

## `runSummary` (type: `string`):

Compact OUTPUT object with row counts and per-stage error counts.

# 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": [
        "iphone 15 pro 256gb"
    ],
    "conditionIds": [],
    "apifyProxyGroups": [
        "RESIDENTIAL"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("skootle/ebay-sold-comps").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": ["iphone 15 pro 256gb"],
    "conditionIds": [],
    "apifyProxyGroups": ["RESIDENTIAL"],
}

# Run the Actor and wait for it to finish
run = client.actor("skootle/ebay-sold-comps").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": [
    "iphone 15 pro 256gb"
  ],
  "conditionIds": [],
  "apifyProxyGroups": [
    "RESIDENTIAL"
  ]
}' |
apify call skootle/ebay-sold-comps --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🛒 eBay Sold Comps Scraper",
        "description": "Scrape eBay sold listings (90-day window) for any query. Sold price, condition, shipping, sold date, seller info. Plus computed comps: median, P10/P90, byVariant grouped by storage/color/condition, sell-through rate, velocity. Export, run via API, schedule, or integrate with other tools.",
        "version": "0.1",
        "x-build-id": "1mClYWE856UR6wifr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/skootle~ebay-sold-comps/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-skootle-ebay-sold-comps",
                "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/skootle~ebay-sold-comps/runs": {
            "post": {
                "operationId": "runs-sync-skootle-ebay-sold-comps",
                "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/skootle~ebay-sold-comps/run-sync": {
            "post": {
                "operationId": "run-sync-skootle-ebay-sold-comps",
                "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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Free-text eBay searches, e.g. ['iphone 15 pro 256gb', 'nintendo switch oled']. One run handles multiple queries; comps are computed per query.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ebaySite": {
                        "title": "eBay marketplace",
                        "enum": [
                            "EBAY_US",
                            "EBAY_GB",
                            "EBAY_DE",
                            "EBAY_FR",
                            "EBAY_IT",
                            "EBAY_ES",
                            "EBAY_AU",
                            "EBAY_CA"
                        ],
                        "type": "string",
                        "description": "Which eBay regional site to query.",
                        "default": "EBAY_US"
                    },
                    "daysToScrape": {
                        "title": "Sold-listings window (days)",
                        "minimum": 1,
                        "maximum": 90,
                        "type": "integer",
                        "description": "How far back to look for sold listings. eBay caps this at 90 days.",
                        "default": 30
                    },
                    "itemsPerPage": {
                        "title": "Items per page",
                        "minimum": 25,
                        "maximum": 240,
                        "type": "integer",
                        "description": "How many results per fetched page (eBay accepts 25, 50, 60, 120, 240).",
                        "default": 60
                    },
                    "maxItems": {
                        "title": "Max sold rows",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum sold-listing records to save. Default is conservative so the daily auto-test fits Apify's 5-minute window. Raise for production.",
                        "default": 10
                    },
                    "emitComps": {
                        "title": "Emit comps_summary record per query",
                        "type": "boolean",
                        "description": "When true, the actor writes one comps_summary record per search query with median/P10-P90, by-condition bands, and by-variant bands grouped by itemSpecifics.",
                        "default": true
                    },
                    "measureSellThrough": {
                        "title": "Measure sell-through rate",
                        "type": "boolean",
                        "description": "When true, the actor also fetches active listings for each query to compute sell-through rate (sold-last-30d / (sold-last-30d + currently-listed)).",
                        "default": true
                    },
                    "conditionIds": {
                        "title": "Condition filter (eBay condition IDs)",
                        "type": "array",
                        "description": "Optional eBay condition IDs to filter by. 1000=New, 1500=New (Other), 1750=Open Box, 2000=Certified Refurb, 2500=Seller Refurb, 3000=Used, 7000=For Parts.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category ID (_sacat)",
                        "type": "string",
                        "description": "Optional eBay category ID to scope the search.",
                        "default": ""
                    },
                    "useApifyProxy": {
                        "title": "Use Apify proxy",
                        "type": "boolean",
                        "description": "Use Apify residential proxy. Recommended for production; safer against rate limits. The free Apify plan includes a small proxy budget.",
                        "default": true
                    },
                    "apifyProxyGroups": {
                        "title": "Apify proxy groups",
                        "type": "array",
                        "description": "Apify proxy groups. RESIDENTIAL is recommended. Override only if your account has dedicated groups.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```