# eBay Product & Sold Scraper (`cirkit/ebay-product-scraper`) Actor

Scrape eBay search results, listing details, and SOLD/completed listing history. Built-in price-band partitioning to break past the 10-page (600-result) cap. Confirmed sold prices, not asking prices.

- **URL**: https://apify.com/cirkit/ebay-product-scraper.md
- **Developed by:** [Crikit](https://apify.com/cirkit) (community)
- **Categories:** E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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 Product & Sold Scraper

Programmatic access to eBay search results, listing details, and the **sold/completed listings dataset** — the same data Terapeak charges for, exported as clean JSON / CSV for reseller arbitrage, sold-comp research, repricing engines, and market analytics.

### What this actor returns

Confirmed **sold prices**, not asking prices. Every listing returned by an eBay sold search is structured as:

- `listingId`, `title`, `itemUrl`, `imageUrl` (1600 px)
- `price` (USD numeric), `priceText`, `priceCurrency`, `priceUsdApprox`
- `soldDate` (ISO), `isSold`, `finalPriceHidden` (for "Best offer accepted")
- `condition`, `subtitle`, `bidCount`, `listingType`
- `shippingText`, `epid`, `seller` (name + feedback count + feedback %)
- `searchQuery`, `searchUrl`, `searchRank`, `scrapedAt`
- Optional `detail` block when `scrapeItemDetails` is enabled (item specifics, watchers, full photo list, shipping/returns/location, breadcrumb)

### How to use it

Two input modes:

1. **Search mode** — pass `searchQueries` (a list of keyword queries). Each query runs through eBay's search results pages and the actor extracts every listing.
2. **Detail-only mode** — pass `itemUrls` (a list of eBay `/itm/<id>` URLs). The actor pulls each item detail page directly.

Both modes can be combined in a single run.

#### Sold-only example

```jsonc
{
  "searchQueries": ["pokemon charizard psa 10", "iphone 15 pro 256gb"],
  "mode": "sold",
  "maxResultsPerQuery": 200,
  "sortBy": "recently_ended",
  "scrapeItemDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
````

#### Cross-listing comp research with details

```jsonc
{
  "searchQueries": ["air jordan 1 chicago 1985"],
  "mode": "both",
  "maxResultsPerQuery": 600,
  "scrapeItemDetails": true,
  "condition": "used"
}
```

### Pricing

Pay per result. **$0.003 per listing ($3 per 1,000 results).** Flat fee, no tiers. Apify subscription discounts apply automatically.

Detail-only mode (`itemUrls`) is the same per-result price even though it costs more compute, because each detail record packs roughly 4–6x the data of a search hit.

### Coverage and limits

- **eBay caps search at 600 results per query** (10 pages × 60). This actor automatically partitions queries by price band when you ask for more than 600, so a single `searchQueries` entry can yield 1000+ unique listings.
- **"Best offer accepted" sold prices are hidden by eBay** for non-buyers (about 3% of sold listings). The actor flags these with `finalPriceHidden: true` and leaves `price` null. There is no public way to recover the accepted offer amount.
- **Per-sale history for multi-quantity listings is not exposed by eBay's public surfaces.** The actor reports the most-recent sale price plus the total `quantitySold`.

### How it works under the hood

eBay protects its surface with Akamai Bot Manager and JA3 / JA4 TLS fingerprinting. This actor uses `curl_cffi` with rotating browser impersonation profiles (chrome131, chrome124, safari17\_0), warms each session with an eBay homepage GET to seed the Akamai bot-management cookies, and routes traffic through Apify's residential US proxy. Datacenter IPs do not work against eBay's SRP and detail endpoints.

### Output format

Every record is pushed to the run's default dataset. Export as JSON, CSV, XLSX, or HTML. The dataset Overview view in the Apify Console shows the highest-value fields in a sortable table.

### Use cases

- **Reseller arbitrage** — find products selling well above your buy-side cost.
- **Sold-comp research** — pricing for collectibles, sneakers, trading cards, vintage electronics.
- **Repricing** — feed sold-price medians into automated repricer pipelines.
- **Market velocity** — group listings by EPID to measure sell-through speed for a SKU.
- **Listing optimization** — pull top-selling competitor titles and item specifics for a product you're listing.

### FAQ

**Q. How is this different from eBay's Browse API?**
The Browse API only exposes currently active listings, requires OAuth, and is capped at 5,000 calls per day on the free tier. This actor covers **sold + completed** listings (the high-value dataset) without OAuth, with no daily cap.

**Q. Does it work for non-US eBay marketplaces?**
This release covers ebay.com. International marketplaces (`ebay.co.uk`, `ebay.de`, etc.) are on the roadmap.

**Q. Is it safe / compliant?**
The actor only reads pages that any eBay user can view in a browser. No login, no cookies pasted by the customer, no scraping behind authenticated walls.

### Support

Open an issue from the Apify Console actor page.

# Actor input Schema

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

Keyword searches to run. Each query runs independently. Quotes and minus signs work the same as in the eBay search box.

## `itemUrls` (type: `array`):

Direct eBay item URLs (https://www.ebay.com/itm/<id>) to scrape detail-only, skipping search. Works for active or ended listings.

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

What kind of listings to return.

## `maxResultsPerQuery` (type: `integer`):

Hard cap per query. The eBay SRP itself caps at 600 results per query (10 pages × 60); to exceed, the actor automatically partitions by price band.

## `scrapeItemDetails` (type: `boolean`):

If true, fetch each search hit's detail page for extra fields (condition description, item specifics, shipping, watchers, full photo list). Roughly doubles cost and run time.

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

Filter by item condition.

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

Filter by auction or Buy It Now.

## `priceMin` (type: `integer`):

Lower price bound.

## `priceMax` (type: `integer`):

Upper price bound.

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

Sort order applied to the eBay search results page.

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

Residential US proxy is REQUIRED — eBay blocks datacenter IPs at the Akamai layer.

## Actor input object example

```json
{
  "searchQueries": [
    "iphone 15 pro"
  ],
  "itemUrls": [],
  "mode": "sold",
  "maxResultsPerQuery": 60,
  "scrapeItemDetails": false,
  "condition": "any",
  "listingType": "any",
  "sortBy": "recently_ended",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

Listings extracted from eBay search results and item detail pages.

## `datasetCsv` (type: `string`):

CSV export of the run's listings.

# 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"
    ],
    "mode": "sold",
    "maxResultsPerQuery": 60,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cirkit/ebay-product-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": ["iphone 15 pro"],
    "mode": "sold",
    "maxResultsPerQuery": 60,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("cirkit/ebay-product-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": [
    "iphone 15 pro"
  ],
  "mode": "sold",
  "maxResultsPerQuery": 60,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call cirkit/ebay-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Product & Sold Scraper",
        "description": "Scrape eBay search results, listing details, and SOLD/completed listing history. Built-in price-band partitioning to break past the 10-page (600-result) cap. Confirmed sold prices, not asking prices.",
        "version": "0.1",
        "x-build-id": "cmBQmiFqHdlrsTEIp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/cirkit~ebay-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-cirkit-ebay-product-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/cirkit~ebay-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-cirkit-ebay-product-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/cirkit~ebay-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-cirkit-ebay-product-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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keyword searches to run. Each query runs independently. Quotes and minus signs work the same as in the eBay search box.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "itemUrls": {
                        "title": "Item URLs (detail-only mode)",
                        "type": "array",
                        "description": "Direct eBay item URLs (https://www.ebay.com/itm/<id>) to scrape detail-only, skipping search. Works for active or ended listings.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "mode": {
                        "title": "Listing mode",
                        "enum": [
                            "sold",
                            "active",
                            "both"
                        ],
                        "type": "string",
                        "description": "What kind of listings to return.",
                        "default": "sold"
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per search query",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Hard cap per query. The eBay SRP itself caps at 600 results per query (10 pages × 60); to exceed, the actor automatically partitions by price band.",
                        "default": 200
                    },
                    "scrapeItemDetails": {
                        "title": "Scrape full item details",
                        "type": "boolean",
                        "description": "If true, fetch each search hit's detail page for extra fields (condition description, item specifics, shipping, watchers, full photo list). Roughly doubles cost and run time.",
                        "default": false
                    },
                    "condition": {
                        "title": "Item condition",
                        "enum": [
                            "any",
                            "new",
                            "open_box",
                            "refurbished",
                            "used",
                            "parts"
                        ],
                        "type": "string",
                        "description": "Filter by item condition.",
                        "default": "any"
                    },
                    "listingType": {
                        "title": "Listing type",
                        "enum": [
                            "any",
                            "auction",
                            "buy_it_now"
                        ],
                        "type": "string",
                        "description": "Filter by auction or Buy It Now.",
                        "default": "any"
                    },
                    "priceMin": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lower price bound."
                    },
                    "priceMax": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Upper price bound."
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "best_match",
                            "recently_ended",
                            "recently_listed",
                            "price_low_high",
                            "price_high_low"
                        ],
                        "type": "string",
                        "description": "Sort order applied to the eBay search results page.",
                        "default": "recently_ended"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Residential US proxy is REQUIRED — eBay blocks datacenter IPs at the Akamai layer.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
