# eBay Scraper — Listings, Product Details & Seller Feedback (`sian.agency/ebay-data-scraper`) Actor

Scrape eBay at scale: keyword search, category browse, deep product details with item specifics, and the only structured seller-feedback extractor on Apify. 4 operations, 20 marketplaces, one clean JSON dataset. Built for price monitoring, reseller research and seller due-diligence.

- **URL**: https://apify.com/sian.agency/ebay-data-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** E-commerce, Business, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 search result rows

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 Scraper — Listings, Product Details & Seller Feedback 🟡

[![Store-SIÁN Agency](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Store-Walmart Scraper](https://img.shields.io/badge/Store-Walmart%20Scraper-0071DC)](https://apify.com/sian.agency/walmart-data-scraper?fpr=sian) [![Store-Taobao & Tmall](https://img.shields.io/badge/Store-Taobao%20%26%20Tmall-FF4F00)](https://apify.com/sian.agency/taobao-tmall-product-scraper?fpr=sian) [![Store-Amazon Deals](https://img.shields.io/badge/Store-Amazon%20Deals-FF9900)](https://apify.com/sian.agency/amazon-influencer-deals-scraper?fpr=sian)

#### 🟢 The only eBay actor on Apify that returns structured **seller feedback** — plus search, category browse & deep product details
##### Built for price monitoring, reseller research, and seller due-diligence across 20 eBay marketplaces

---

### 📋 Overview

**Scrape eBay the easy way.** This actor turns eBay search results, category listings, full product pages, and seller feedback into clean, structured JSON datasets — no account, no API key, no proxy setup. Pick one of four operations per run and get a query-ready dataset out.

**Why professionals choose this eBay scraper:**
- 🟢 **Market-exclusive Seller Feedback** — the only eBay scraper on Apify that returns a seller's full feedback history (rating, comment, verified-purchase flag, item title, pagination). Score reseller trust before you buy or partner.
- 💎 **Deepest single-listing payload** — 30+ item specifics, seller detailed sub-ratings (accurate description, shipping cost, shipping speed, communication), breadcrumbs, payment methods, return policy, and high-res images.
- 🌍 **20 eBay marketplaces** — ebay.com, co.uk, de, ca, com.au, fr, it, es, and 12 more, all via one `domain` setting.
- ⚡ **60 listings per page** — fast, paginated keyword search and category browse with condition, buying-format, price, and sort filters.
- 💰 **Pay-per-result** — you're only charged for successful rows. Transparent, predictable, no monthly lock-in.

### ✨ Features

- 🔍 **Product Search** — keyword search across eBay with 60 listings per page, full filters (condition, buying format, min/max price, sort order).
- 🗂️ **Products by Category** — browse any eBay category by ID, paginated, with the same filter set.
- 📦 **Product Details** — deep-scrape a single listing: price, condition, 30+ item specifics, seller ratings, breadcrumbs, payment methods, return policy, and image gallery.
- 🟢 **Seller Feedback** — paginate a seller's reviews with rating, comment, verified-purchase flag, and the item each review refers to.
- 🌍 **20 marketplaces** — switch between eBay's international sites with one setting.
- 🧹 **Clean camelCase fields** — curated aliases (`itemId`, `productTitle`, `price`, `sellerFeedbackPercentage`, `itemSpecifics`, `feedbackComment`) plus every raw field spread alongside.
- 🔁 **Built-in retries** — transparent retry on transient upstream errors, so flaky pages don't break your run.
- 📄 **HTML run report** — success/error counts, success rate, pages fetched, and duration, written even on failure.

### 🎬 Quick Start

Pick an operation, give it the one input it needs, and run. Use **Product Search** to discover item IDs and seller usernames, then drill into **Product Details** per listing and **Seller Feedback** per seller.

```bash
curl -X POST "https://api.apify.com/v2/acts/sian.agency~ebay-data-scraper/runs?token=YOUR_TOKEN" \
-H "Content-Type: application/json" \
-d '{"operation": "search", "query": "vintage rolex", "maxPages": 2}'
````

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Choose an operation

Select **Product Search**, **Products by Category**, **Product Details**, or **Seller Feedback**.

#### Step 2: Provide the required input

A search `query`, a `categoryId`, an `itemId`, or a `sellerId` — the input page tells you exactly which one each operation needs.

#### Step 3: Run and export

Run the actor and download your dataset as JSON, CSV, or Excel from the Apify console.

**That's it! In under a minute, you'll have:**

- A clean, structured eBay dataset
- One row per listing, product, or feedback entry
- Curated fields ready for analysis, monitoring, or enrichment

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `operation` | string | ✅ Yes | One of `search`, `productsByCategory`, `productDetails`, `sellerFeedback` |
| `query` | string | For Search | Keyword search query (also strongly recommended for category browse) |
| `categoryId` | string | For Category | eBay category ID (the `_sacat` value in a category URL) |
| `itemId` | string | For Details | eBay item ID — the number in `ebay.com/itm/{itemId}` |
| `sellerId` | string | For Feedback | eBay seller username (appears as `sellerName` in search rows) |
| `domain` | string | No | Marketplace: `com` (default), `co.uk`, `de`, `ca`, `com.au`, … (20 markets) |
| `sortBy` | string | No | `best_match`, `ending_soonest`, `newly_listed`, `price_lowest`, `price_highest` |
| `condition` | string | No | `new`, `used`, `open_box`, `refurbished`, `for_parts` |
| `buyingFormat` | string | No | `buy_it_now`, `auction`, `accepts_offers` |
| `minPrice` / `maxPrice` | integer | No | Price-range filter for search / category |
| `maxPages` | integer | No | Pages to fetch for paginated operations (default 3, max 50) |

**Example — search:**

```json
{ "operation": "search", "query": "iphone 15 pro", "condition": "used", "sortBy": "price_lowest", "maxPages": 3 }
```

**Example — seller feedback:**

```json
{ "operation": "sellerFeedback", "sellerId": "musicmagpie", "maxPages": 2 }
```

> 💡 **Category tip:** `Products by Category` works best **with** a `query`. Without one, eBay serves a JavaScript browse page and may return only a partial first page (≤24 results). Add a keyword to get full pages of 60.

### 📤 Output

Results are saved to the Apify dataset. Fields vary by operation; here are the most valuable:

| Field | Type | Description |
|-------|------|-------------|
| `itemId` | string | eBay item ID |
| `productTitle` | string | Listing title |
| `price` / `priceRaw` | number / string | Numeric price and display price |
| `condition` | string | Item condition |
| `buyingFormat` | string | Buy It Now / auction / accepts offers |
| `sellerName` | string | Seller username |
| `sellerFeedbackPercentage` | number | Seller positive-feedback % |
| `sellerFeedbackCount` | integer | Number of seller feedbacks |
| `itemSpecifics` | array | Label/value item specifics (Details op) |
| `sellerDetailedRatings` | object | Sub-ratings: description, shipping cost, speed, communication (Details op) |
| `breadcrumbs` | array | Category breadcrumb trail (Details op) |
| `feedbackRating` | string | positive / neutral / negative (Feedback op) |
| `feedbackComment` | string | Review text (Feedback op) |
| `verifiedPurchase` | boolean | Verified-purchase flag (Feedback op) |
| `productUrl` | string | Canonical listing URL |

**Example row (search):**

```json
{
  "_operation": "search",
  "itemId": "116993977108",
  "productTitle": "Apple iPhone 15 (Great Condition) for AT&T or Cricket",
  "price": 299.89,
  "priceRaw": "$299.89",
  "buyingFormat": "buy_it_now",
  "sellerName": "nikatronics",
  "sellerFeedbackPercentage": 99.6,
  "itemsSold": 68,
  "productUrl": "https://www.ebay.com/itm/116993977108",
  "status": "success"
}
```

#### Fields by operation

Each operation returns a row shape tuned to its data. Common metadata (`_operation`, `_fetchedAt`, `_page`, `status`, `domain`, `productUrl`) appears on every row.

**🔍 Product Search & 🗂️ Products by Category** — one row per listing:

| Field | Description |
|-------|-------------|
| `itemId`, `epid` | eBay item ID and catalog product ID |
| `productTitle`, `caption`, `position` | Listing title, sub-caption, result rank |
| `price`, `priceRaw`, `originalPrice`, `discount`, `currency` | Numeric and display pricing |
| `condition`, `isEbayRefurbished`, `buyingFormat` | Condition, refurb flag, Buy-It-Now / auction / offers |
| `timeLeft`, `bidCount` | Auction time remaining and bid count |
| `sellerName`, `sellerFeedbackPercentage`, `sellerFeedbackCount` | Seller and trust signals |
| `watchers`, `itemsSold`, `rating`, `reviewCount` | Demand and review signals |
| `shipping`, `location`, `freeReturns` | Fulfilment signals |
| `image`, `imageHighRes` | Thumbnail and high-res image URLs |
| `totalResults`, `relatedSearches`, `categoryName` | Result-set metadata |

**📦 Product Details** — one rich row per listing (everything above, plus):

| Field | Description |
|-------|-------------|
| `itemSpecifics` | Array of `{label, value}` specs (often 25–32 entries) |
| `sellerDetailedRatings` | Sub-ratings: accurate description, shipping cost, shipping speed, communication |
| `sellerUrl`, `sellerItemsSold`, `sellerJoined` | Extended seller profile |
| `breadcrumbs` | Category breadcrumb trail (`{name, url}`) |
| `brand`, `model`, `color`, `mpn`, `upc`, `productType` | Catalog identifiers |
| `paymentMethods`, `returnPolicy`, `handlingTime`, `deliveryEstimate` | Purchase terms |
| `images`, `imagesOriginal`, `descriptionUrl` | Full image gallery and description link |
| `availableQuantity`, `volumePricing`, `trending`, `lastUpdated` | Inventory and trend signals |

**🟢 Seller Feedback** — one row per review:

| Field | Description |
|-------|-------------|
| `feedbackId` | Unique feedback ID |
| `feedbackRating` | `positive` / `neutral` / `negative` |
| `feedbackComment` | Full review text |
| `feedbackAuthor`, `feedbackDate` | Reviewer and date |
| `verifiedPurchase` | Verified-purchase flag |
| `feedbackItemTitle`, `feedbackItemId` | The item the review refers to |
| `sellerId`, `sellerTotalReviews` | Seller identity and lifetime feedback count |

### 💼 Use Cases & Examples

#### 1. Price & Listing Monitoring

**Retail and reseller teams tracking eBay prices over time.**
**Input:** A search query or category ID, scheduled daily.
**Output:** Price, condition, buying format, shipping, and seller per listing.
**Use:** Diff the dataset to catch price moves, new listings, and stock-outs across 20 marketplaces.

#### 2. Seller Due-Diligence & Trust Scoring

**Buyers and procurement teams vetting eBay sellers.**
**Input:** A seller username via the Seller Feedback operation.
**Output:** Rating, comment, verified-purchase flag, and item title per review.
**Use:** Build a trust score before a high-value purchase or a reseller partnership — a capability no other eBay actor on Apify offers.

#### 3. Reseller & Arbitrage Research

**Flippers and arbitrage sellers hunting underpriced inventory.**
**Input:** Keyword search with price and condition filters.
**Output:** Active listings with price, watchers, items-sold, and seller-feedback signals.
**Use:** Spot underpriced items, gauge demand, and benchmark your own listings.

#### 4. Product Catalog Enrichment

**E-commerce teams enriching a product database.**
**Input:** An item ID via the Product Details operation.
**Output:** 30+ item specifics, brand, MPN, UPC, breadcrumbs, images, and return policy.
**Use:** Fill gaps in your own catalog or build a competitive product reference.

#### 5. Category Share-of-Shelf

**Brand and marketing analysts measuring presence.**
**Input:** A category ID plus a keyword.
**Output:** Ranked listings with condition mix and seller distribution.
**Use:** Quantify brand share-of-shelf and condition spread in your segment.

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/ebay-data-scraper').call({
  operation: 'search',
  query: 'vintage rolex',
  maxPages: 2,
});

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

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/ebay-data-scraper').call(
    run_input={'operation': 'sellerFeedback', 'sellerId': 'musicmagpie', 'maxPages': 2}
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~ebay-data-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"operation": "productDetails", "itemId": "265038069230"}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger**: Schedule or webhook
2. **HTTP Request**: Call the actor API with your operation + input
3. **Process**: Handle the JSON dataset rows
4. **Action**: Save to a sheet, alert on price changes, or enrich a catalog

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- Real eBay data, full feature access, same quality
- No credit card required
- Perfect for testing search, details, and seller feedback

#### PAID Tier (Production Ready)

- Scale to thousands of listings, products, and feedback rows
- Pay-per-result: only charged for successful rows
- All four operations and 20 marketplaces included

💰 **Transparent per-result pricing** — search/category at the low end of the market, premium deep-detail and exclusive seller-feedback extraction.

🔗 [View current pricing](https://apify.com/sian.agency/ebay-data-scraper?fpr=sian)

### ❓ Frequently Asked Questions

**Q: Which operation should I start with?**
A: Product Search. It returns item IDs and seller usernames you can feed into Product Details and Seller Feedback.

**Q: Does this return SOLD listings or historical sold prices?**
A: No — it returns currently **active** eBay listings (live search, category, and item pages) plus seller feedback. It is not a sold-comps tool.

**Q: Can I scrape sellers' feedback?**
A: Yes. The Seller Feedback operation returns a seller's reviews (rating, comment, verified-purchase, item title) with pagination — the only eBay actor on Apify that does this.

**Q: Which eBay marketplaces are supported?**
A: 20: com, co.uk, com.au, de, ca, fr, it, es, at, ch, com.sg, com.my, ph, ie, pl, nl, be, com.hk, com.mx, com.br.

**Q: What output formats are available?**
A: JSON, CSV, and Excel — export directly from the Apify dataset.

**Q: Why did Products by Category return few results?**
A: Category browse works best with a `query`. Without one, eBay serves a limited JavaScript browse page. Add a keyword for full pages of 60.

**Q: Is this legal?**
A: Yes — it only extracts publicly available data. See the legal section below.

**Q: How is this different from other eBay scrapers on Apify?**
A: Most eBay actors only return search/listing cards. This one adds two things they don't: deep Product Details (30+ item specifics, seller sub-ratings, breadcrumbs) and a market-exclusive Seller Feedback operation. It also covers 20 international marketplaces in one actor.

**Q: Do I need an eBay account or developer key?**
A: No. Provide your input and run — no eBay account, no API key, no proxy configuration.

**Q: How many marketplaces and how do I switch?**
A: 20. Set the `domain` field (e.g. `co.uk`, `de`, `com.au`) — it defaults to `com` (US).

### 🆚 Why choose this eBay scraper

| | This actor | Typical eBay scraper |
|---|---|---|
| Keyword search | ✅ 60/page, full filters | ✅ |
| Category browse | ✅ | ⚠️ rare |
| Deep product details | ✅ 30+ item specifics + seller sub-ratings | ⚠️ shallow or none |
| **Seller feedback** | ✅ **market-exclusive** | ❌ |
| International marketplaces | ✅ 20 | ⚠️ 1–8 |
| Pricing | Pay-per-result | Mixed (some flat monthly) |
| Setup | Zero — no account/key/proxy | Varies |

### 🐛 Troubleshooting

**Empty or error rows**

- Confirm the required input for your operation (query / categoryId / itemId / sellerId) is set.
- Transient upstream hiccups are auto-retried; re-run if a page reports a temporary error.

**Products by Category returns ≤24 rows**

- Add a `query` keyword — eBay limits keyword-less category browse to a partial page.

**Seller Feedback stops after ~5 pages**

- eBay caps publicly available feedback at roughly 125 reviews (5 pages of 25). This is an eBay limit, not an actor limit.

**Item ID not found**

- Use the numeric ID from the listing URL (`ebay.com/itm/{itemId}`), exactly as it appears in a search result's `itemId`.

### ⚠️ Trademark Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by eBay Inc.** "eBay" and related marks are trademarks of their respective owners and are used here only to describe the data this tool helps you collect. Use this actor responsibly and in compliance with applicable laws, eBay's terms of service, and data-protection regulations (including GDPR and CCPA where applicable). You are responsible for how you use the data you extract.

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the **GDPR** in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers. You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, open an issue in the actor's Issues tab
- Check the [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `operation` (type: `string`):

🎯 **PICK ONE OPERATION PER RUN.** Each run produces one clean dataset matching the chosen mode.

- **🔍 Product Search** — keyword search across eBay listings, paginated (60 results/page)
- **🗂️ Products by Category** — listings in an eBay category ID, paginated (60 results/page — works best with a search query)
- **📦 Product Details** — deep scrape of a single listing (item specifics, seller detailed ratings, breadcrumbs, images, return policy)
- **🟢 Seller Feedback** — paginated feedback/reviews for an eBay seller (rating, comment, verified-purchase, item title) — *the only eBay seller-feedback extractor on Apify*

💡 **TIP:** Use Product Search to discover listing IDs and seller names, then drill into Product Details per listing and Seller Feedback per seller.

## `query` (type: `string`):

🔍 **Required for `Product Search`. Strongly recommended for `Products by Category`.**

Any eBay product search query.

- `vintage rolex`
- `iphone 15 pro max`
- `lego star wars`

💡 **TIP:** For `Products by Category`, always provide a query — without one, eBay serves a limited browse page (≤24 results). With a query you get full pages of 60.

⚠️ **Ignored** for Product Details and Seller Feedback.

## `categoryId` (type: `string`):

🗂️ **Required for `Products by Category` operation.**

The eBay category ID (the `_sacat` value in an eBay category URL).

- `175672` — Laptops & Netbooks
- `9355` — Cell Phones & Smartphones
- `11450` — Clothing, Shoes & Accessories

💡 **TIP:** Find category IDs in eBay category URLs (`ebay.com/b/.../{categoryId}`) or in the `breadcrumbs[].url` of any Product Details result. Pair with a `query` for best results.

⚠️ **Ignored** for all other operations.

## `itemId` (type: `string`):

📦 **Required for `Product Details` operation.**

The eBay item ID — the numeric ID in any listing URL: `https://www.ebay.com/itm/{itemId}`.

- `265038069230`

It appears as the `itemId` field in every Product Search or Products by Category result row.

💡 **TIP:** Run `Product Search` first to discover item IDs, then loop through Product Details per listing.

⚠️ **Ignored** for Search, Category, and Seller Feedback operations.

## `sellerId` (type: `string`):

🟢 **Required for `Seller Feedback` operation.**

The eBay seller username — appears as `sellerName` in every Product Search result row, and as `sellerName` in Product Details.

- `musicmagpie`
- `discountcomputerdepot`

💡 **TIP:** Run `Product Search` first to discover seller usernames, then pull their feedback history here. Returns 25 reviews per page.

⚠️ **Ignored** for all other operations.

## `domain` (type: `string`):

🌍 Which eBay marketplace to query. Default `com` = ebay.com (US). 20 markets supported.

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

Sort order for `Product Search` and `Products by Category`.

- `best_match` (default)
- `ending_soonest` — auctions ending first
- `newly_listed` — most recent first
- `price_lowest` — lowest total price first
- `price_highest` — highest total price first

Ignored for Product Details and Seller Feedback.

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

Optional. Filter `Product Search` / `Products by Category` by item condition. Leave as `any` for all conditions.

## `buyingFormat` (type: `string`):

Optional. Filter `Product Search` / `Products by Category` by buying format. Leave as `any` for all formats.

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

Optional price filter for `Product Search` / `Products by Category`. Minimum item price (in the marketplace currency). Must be lower than Max Price if both are set.

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

Optional price filter for `Product Search` / `Products by Category`. Maximum item price (in the marketplace currency). Must be higher than Min Price if both are set.

## `maxPages` (type: `integer`):

📄 **Applies to paginated operations** (Search, Products by Category, Seller Feedback). Ignored for Product Details.

- **Search / Category:** 60 listings per page
- **Seller Feedback:** 25 reviews per page (eBay caps feedback at ~5 pages / 125 reviews)

💡 **TIP:** Start small (1–3 pages) to preview results before scaling up. Pagination stops automatically when the data source reports the last page or returns an empty page.

⚠️ Hard cap: 50 pages to prevent runaway runs.

## Actor input object example

```json
{
  "operation": "search",
  "query": "vintage rolex",
  "categoryId": "175672",
  "itemId": "265038069230",
  "sellerId": "musicmagpie",
  "domain": "com",
  "sortBy": "best_match",
  "condition": "any",
  "buyingFormat": "any",
  "maxPages": 3
}
```

# Actor output Schema

## `output` (type: `string`):

Per-row results — one flat row per upstream item with curated camelCase aliases (itemId, productTitle, price, condition, sellerName, sellerFeedbackPercentage, itemSpecifics, feedbackId, feedbackComment, …) plus the raw upstream fields spread alongside.

## `report` (type: `string`):

HTML report with run status, success/error row counts, success rate, pages fetched, duration, and the inputs used — written even on fatal crash.

# 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 = {
    "query": "vintage rolex",
    "categoryId": "175672",
    "itemId": "265038069230",
    "sellerId": "musicmagpie"
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/ebay-data-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 = {
    "query": "vintage rolex",
    "categoryId": "175672",
    "itemId": "265038069230",
    "sellerId": "musicmagpie",
}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/ebay-data-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 '{
  "query": "vintage rolex",
  "categoryId": "175672",
  "itemId": "265038069230",
  "sellerId": "musicmagpie"
}' |
apify call sian.agency/ebay-data-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Scraper — Listings, Product Details & Seller Feedback",
        "description": "Scrape eBay at scale: keyword search, category browse, deep product details with item specifics, and the only structured seller-feedback extractor on Apify. 4 operations, 20 marketplaces, one clean JSON dataset. Built for price monitoring, reseller research and seller due-diligence.",
        "version": "1.0",
        "x-build-id": "HGOZbxJObMkRSVnLb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~ebay-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-ebay-data-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/sian.agency~ebay-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-ebay-data-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/sian.agency~ebay-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-ebay-data-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": [
                    "operation"
                ],
                "properties": {
                    "operation": {
                        "title": "🎯 Operation — what do you want to scrape?",
                        "enum": [
                            "search",
                            "productsByCategory",
                            "productDetails",
                            "sellerFeedback"
                        ],
                        "type": "string",
                        "description": "🎯 **PICK ONE OPERATION PER RUN.** Each run produces one clean dataset matching the chosen mode.\n\n- **🔍 Product Search** — keyword search across eBay listings, paginated (60 results/page)\n- **🗂️ Products by Category** — listings in an eBay category ID, paginated (60 results/page — works best with a search query)\n- **📦 Product Details** — deep scrape of a single listing (item specifics, seller detailed ratings, breadcrumbs, images, return policy)\n- **🟢 Seller Feedback** — paginated feedback/reviews for an eBay seller (rating, comment, verified-purchase, item title) — *the only eBay seller-feedback extractor on Apify*\n\n💡 **TIP:** Use Product Search to discover listing IDs and seller names, then drill into Product Details per listing and Seller Feedback per seller.",
                        "default": "search"
                    },
                    "query": {
                        "title": "🔍 Search Query (for Product Search / Category)",
                        "type": "string",
                        "description": "🔍 **Required for `Product Search`. Strongly recommended for `Products by Category`.**\n\nAny eBay product search query.\n- `vintage rolex`\n- `iphone 15 pro max`\n- `lego star wars`\n\n💡 **TIP:** For `Products by Category`, always provide a query — without one, eBay serves a limited browse page (≤24 results). With a query you get full pages of 60.\n\n⚠️ **Ignored** for Product Details and Seller Feedback."
                    },
                    "categoryId": {
                        "title": "🗂️ Category ID (for Products by Category)",
                        "type": "string",
                        "description": "🗂️ **Required for `Products by Category` operation.**\n\nThe eBay category ID (the `_sacat` value in an eBay category URL).\n- `175672` — Laptops & Netbooks\n- `9355` — Cell Phones & Smartphones\n- `11450` — Clothing, Shoes & Accessories\n\n💡 **TIP:** Find category IDs in eBay category URLs (`ebay.com/b/.../{categoryId}`) or in the `breadcrumbs[].url` of any Product Details result. Pair with a `query` for best results.\n\n⚠️ **Ignored** for all other operations."
                    },
                    "itemId": {
                        "title": "📦 Item ID (for Product Details)",
                        "type": "string",
                        "description": "📦 **Required for `Product Details` operation.**\n\nThe eBay item ID — the numeric ID in any listing URL: `https://www.ebay.com/itm/{itemId}`.\n- `265038069230`\n\nIt appears as the `itemId` field in every Product Search or Products by Category result row.\n\n💡 **TIP:** Run `Product Search` first to discover item IDs, then loop through Product Details per listing.\n\n⚠️ **Ignored** for Search, Category, and Seller Feedback operations."
                    },
                    "sellerId": {
                        "title": "🟢 Seller ID / Username (for Seller Feedback)",
                        "type": "string",
                        "description": "🟢 **Required for `Seller Feedback` operation.**\n\nThe eBay seller username — appears as `sellerName` in every Product Search result row, and as `sellerName` in Product Details.\n- `musicmagpie`\n- `discountcomputerdepot`\n\n💡 **TIP:** Run `Product Search` first to discover seller usernames, then pull their feedback history here. Returns 25 reviews per page.\n\n⚠️ **Ignored** for all other operations."
                    },
                    "domain": {
                        "title": "🌍 Marketplace (eBay domain)",
                        "enum": [
                            "com",
                            "co.uk",
                            "com.au",
                            "de",
                            "ca",
                            "fr",
                            "it",
                            "es",
                            "at",
                            "ch",
                            "com.sg",
                            "com.my",
                            "ph",
                            "ie",
                            "pl",
                            "nl",
                            "be",
                            "com.hk",
                            "com.mx",
                            "com.br"
                        ],
                        "type": "string",
                        "description": "🌍 Which eBay marketplace to query. Default `com` = ebay.com (US). 20 markets supported.",
                        "default": "com"
                    },
                    "sortBy": {
                        "title": "↕️ Sort Order (Search / Category)",
                        "enum": [
                            "best_match",
                            "ending_soonest",
                            "newly_listed",
                            "price_lowest",
                            "price_highest"
                        ],
                        "type": "string",
                        "description": "Sort order for `Product Search` and `Products by Category`.\n\n- `best_match` (default)\n- `ending_soonest` — auctions ending first\n- `newly_listed` — most recent first\n- `price_lowest` — lowest total price first\n- `price_highest` — highest total price first\n\nIgnored for Product Details and Seller Feedback.",
                        "default": "best_match"
                    },
                    "condition": {
                        "title": "🏷️ Condition Filter (Search / Category)",
                        "enum": [
                            "any",
                            "new",
                            "used",
                            "open_box",
                            "refurbished",
                            "for_parts"
                        ],
                        "type": "string",
                        "description": "Optional. Filter `Product Search` / `Products by Category` by item condition. Leave as `any` for all conditions.",
                        "default": "any"
                    },
                    "buyingFormat": {
                        "title": "🛒 Buying Format Filter (Search / Category)",
                        "enum": [
                            "any",
                            "buy_it_now",
                            "auction",
                            "accepts_offers"
                        ],
                        "type": "string",
                        "description": "Optional. Filter `Product Search` / `Products by Category` by buying format. Leave as `any` for all formats.",
                        "default": "any"
                    },
                    "minPrice": {
                        "title": "💲 Min Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional price filter for `Product Search` / `Products by Category`. Minimum item price (in the marketplace currency). Must be lower than Max Price if both are set."
                    },
                    "maxPrice": {
                        "title": "💲 Max Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional price filter for `Product Search` / `Products by Category`. Maximum item price (in the marketplace currency). Must be higher than Min Price if both are set."
                    },
                    "maxPages": {
                        "title": "📄 Max pages to fetch",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "📄 **Applies to paginated operations** (Search, Products by Category, Seller Feedback). Ignored for Product Details.\n\n- **Search / Category:** 60 listings per page\n- **Seller Feedback:** 25 reviews per page (eBay caps feedback at ~5 pages / 125 reviews)\n\n💡 **TIP:** Start small (1–3 pages) to preview results before scaling up. Pagination stops automatically when the data source reports the last page or returns an empty page.\n\n⚠️ Hard cap: 50 pages to prevent runaway runs.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```