# eBay Product Scraper (`scraptivo/ebay-scraper`) Actor

Collects eBay product listings from search queries or start URLs. Returns titles, prices, sellers, shipping, and optional item-page details.

- **URL**: https://apify.com/scraptivo/ebay-scraper.md
- **Developed by:** [Scraptivo](https://apify.com/scraptivo) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.97 / 1,000 product scrapeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Scraper** collects product listings from eBay and turns them into structured data for price monitoring, catalog building, and seller research. Provide a search query or an eBay search, category, or item URL, run the Actor, and export titles, prices, sellers, shipping, and item IDs to JSON, CSV, Excel, or your preferred integration. Use it to compare asking prices, watch sold comps, and automate recurring catalog collection. Pricing starts at **$1.00 per 1,000 products**, with optional item-page details at **$1.50 per 1,000**.

### What can you automate with eBay Product Scraper?

- **Build product catalogs** — Turn a keyword or eBay URL into a dataset of item IDs, titles, prices, conditions, and sellers.
- **Monitor asking prices** — Track price, shipping notes, watchers, and bid counts across US, UK, Germany, and other eBay sites.
- **Filter before you export** — Narrow constructed searches by buying format, condition, price range, item location, and sold vs active listings.
- **Enrich selected items** — Turn on product details to add description, image gallery, item specifics, brand, and shipping cost.
- **Collect sold comps** — Enable sold listings on constructed searches to capture completed sales instead of active inventory.
- **Schedule recurring snapshots** — Cap volume with `maxItems` and re-run the same query on a schedule.

### Who is this scraper for?

| Team | Workflow |
|---|---|
| Ecommerce and pricing teams | Comparing asking prices and shipping for the same product across marketplaces. |
| Sourcing and catalog operators | Building item lists with IDs, URLs, conditions, and seller feedback. |
| Market researchers | Watching which sellers appear for a query and where items ship from. |
| Agencies | Collecting structured eBay data for client reports without clicking through listings. |

### What data can you collect from eBay?

| Data group | Example fields | How it helps |
|---|---|---|
| Listing identity | `itemId`, title, URL | Deduplicate and reopen the exact listing. |
| Price | `price`, `formattedPrice`, currency | Compare asking prices across a search. |
| Offer and condition | `condition`, `buyingFormat`, watchers, bid count | Separate auctions from Buy It Now and see demand. |
| Seller and shipping | Seller name, feedback stats, shipping snippet, item location | Qualify the seller and estimate delivery. |
| Source | Marketplace, `sourceQuery`, `sourceUrl` | Know which site and search produced the row. |
| Item-page details | Description, `itemSpecifics`, image gallery, brand, MPN, model, shipping cost, payment methods | Appear when **Include Product Details** is enabled. |

Card-level fields such as title, price, seller, and `itemId` are returned on every product. Description, gallery, item specifics, and checkout fields appear only when product details are enabled.

### How to use eBay Product Scraper

1. Open the [eBay Product Scraper](https://apify.com/scraptivo/ebay-scraper) on Apify.
2. Paste eBay search, category, or item URLs in **Start URLs**, or leave URLs empty and set **Search Queries** plus a marketplace.
3. Choose a limit and optional filters — buying format, condition, price range, sold listings, or product details.
4. Run the Actor and wait for product records to appear in the dataset.
5. Export JSON, CSV, or Excel, or connect the dataset to your workflow.

```json
{
    "searchQueries": ["bike"],
    "marketplace": "EBAY_US",
    "maxItems": 10,
    "includeProductDetails": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
```

### Example workflow

#### Watch US bike prices every Monday

1. Schedule a weekly run with `searchQueries` = `["bike"]`, `marketplace` = `EBAY_US`, and `soldListings` = `false`.
2. Keep `includeProductDetails` off for a cheap card-level snapshot, then turn it on only for items you want to inspect.
3. Send new records to Google Sheets through a webhook.
4. Deduplicate user-side against the stable `itemId` field.

### Automate and integrate your results

- **Schedules** — eBay inventory turns over quickly. Run **daily** for sourcing and **weekly** for price research. Create a separate scheduled task per query and marketplace.
- **Webhooks** — Push completed datasets into Sheets, Slack, or a catalog tool.
- **Exports and API** — Download from the Apify Console or start a run from the API:

```shell
curl "https://api.apify.com/v2/acts/scraptivo~ebay-scraper/runs?token=YOUR-APIFY-TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["bike"],
    "marketplace": "EBAY_US",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
  }'
```

- **Deduplication** — The Actor appends results on every run. Use `itemId` as the stable key when merging datasets.

### Input reference

| Field | Type | Required | Default | What it controls |
|---|---|---:|---|---|
| `startUrls` | Array of URLs | No | — | eBay search, category/browse, or item URLs. When set, these URLs are used instead of constructed searches. |
| `searchQueries` | Array of strings | No | — | Product search terms. Used only when Start URLs are empty. |
| `marketplace` | String | No | `EBAY_US` | eBay site for constructed searches (`EBAY_US`, `EBAY_UK`, `EBAY_DE`, `EBAY_AU`, `EBAY_CA`, and other listed sites). Start URLs keep the host from the URL. |
| `category` | String | No | `0` | eBay category ID for constructed searches. Ignored when Start URLs are set. |
| `buyingFormat` | String | No | `all` | `all`, `buy_it_now`, `auction`, or `best_offer`. |
| `condition` | String | No | `any` | `any`, `new`, `open_box`, `certified_refurbished`, `seller_refurbished`, `used`, or `for_parts`. |
| `sortBy` | String | No | `best_match` | `best_match`, `ending_soonest`, `newly_listed`, `price_shipping_lowest`, `price_shipping_highest`, or `nearest`. |
| `itemLocation` | String | No | `default` | `default`, `domestic`, `worldwide`, or `local` (nearby, uses ZIP). |
| `zipCode` | String | No | — | Postal code for nearby searches. |
| `distance` | Integer | No | — | Search radius in miles around the ZIP. Used with Item Location = Nearby. |
| `minPrice` / `maxPrice` | Number | No | — | Price range on constructed searches. |
| `soldListings` | Boolean | No | `false` | Collect completed/sold listings instead of active ones (constructed searches only). |
| `maxItems` | Integer | No | `0` | Maximum products across all URLs and queries (`0` = unlimited). |
| `includeProductDetails` | Boolean | No | `false` | Open each item page for description, images, specifics, and shipping. Charges `product-details`. |
| `detailConcurrency` | Integer | No | `8` | Parallel detail fetches (1–15). |
| `proxyConfiguration` | Proxy object | No | Apify proxy, RESIDENTIAL | Residential proxies are recommended. |

Provide `startUrls` and/or `searchQueries` (or a category other than All Categories). When Start URLs are set, query filters are not used to build the search.

#### Do Start URLs override search queries?

Yes. When `startUrls` is provided, the Actor uses those URLs and does not build a search from `searchQueries` and the filter fields.

### Output example

Each dataset item is one product:

```json
{
    "itemId": "125459703651",
    "title": "Chopper Lowrider beach Stretch cruiser bike Coaster Brakes Big Fat Bicycle",
    "url": "https://www.ebay.com/itm/125459703651",
    "price": 664.99,
    "currency": "USD",
    "formattedPrice": "$664.99",
    "condition": "Brand New",
    "buyingFormat": "Buy It Now",
    "shipping": "Shipping not specified",
    "itemLocation": "United States",
    "seller": "reignbike",
    "sellerFeedbackPercent": 99.8,
    "sellerFeedbackCount": 2100,
    "watchers": 98,
    "marketplace": "EBAY_US",
    "sourceType": "search",
    "sourceQuery": "bike"
}
```

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

The Actor uses pay-per-event pricing plus a small Actor-start event ($0.00005 per start, scaled by memory):

- **$1.00 / 1,000 products** — a `dataset-item` event for every product written to the dataset.
- **$1.50 / 1,000 product details** — a `product-details` event only when **Include Product Details** is enabled.

A search-only run of 1,000 products costs **$1.00**. Enriching the same 1,000 products with details costs **$2.50**. Volume discounts on Apify paid plans reduce the per-1,000 rate (for example **$0.97 per 1,000 products** and **$1.20 per 1,000 details** at the Gold plan). Compute units consumed are deducted from your Apify plan.

### Reliability and responsible use

- **Proxy requirement** — Residential proxies are recommended. The default input uses the Apify RESIDENTIAL group.
- **Conditional fields** — Description, gallery, item specifics, brand, and shipping cost appear only when product details are enabled. eBay also leaves some card fields empty.
- **Sold listings** — `soldListings` applies to constructed searches only, not to pasted Start URLs.
- **Public listings** — The Actor collects publicly visible eBay listing data.
- **Responsible use** — Only use the data in ways that comply with eBay's terms and applicable law.

### Frequently asked questions

#### Can I scrape eBay by keyword and marketplace?

Yes. Leave Start URLs empty, set `searchQueries` such as `["iphone 13"]`, and choose a `marketplace` such as `EBAY_US` or `EBAY_UK`. You can also restrict the run with category, condition, buying format, and price range.

#### Can I schedule eBay Product Scraper to run automatically?

Yes. Open the **Scheduler** tab in Apify Console. Daily suits sourcing; weekly suits price research. Create a separate schedule per query and marketplace.

#### What counts as one result?

Each product saved to the dataset is one `dataset-item` event ($1.00 per 1,000). If product details are enabled, each enriched product also counts as a `product-details` event ($1.50 per 1,000).

#### Why are some fields empty?

Brand, description, item specifics, gallery URLs, and shipping cost are collected only when **Include Product Details** is enabled. eBay also omits watchers, bids, or shipping text on some cards.

#### How do I avoid duplicate records?

The Actor does not deduplicate across runs. Use `itemId` as the stable key. `maxItems` caps the size of a single run.

#### Do I need a proxy?

Residential proxies are recommended and are the default. If a run returns unusually few products, confirm the proxy group is RESIDENTIAL.

### Related Scraptivo automations

- [Amazon Scraper](https://apify.com/scraptivo/amazon-scraper) — product listings from Amazon.
- [Flipkart Scraper](https://apify.com/scraptivo/flipkart-scraper) — product listings from Flipkart.
- [Target Scraper](https://apify.com/scraptivo/target-scraper) — product listings from Target.
- [Best Buy Scraper](https://apify.com/scraptivo/best-buy-scraper) — product listings from Best Buy.

### Support and custom workflows

Need a different field, source, or delivery workflow? Contact Scraptivo at scraptivo@gmail.com. Include the Actor name, sample URL, required fields, and expected volume so we can assess the request.

# Actor input Schema

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

eBay search, category/browse, or item URLs (e.g. https://www.ebay.com/sch/i.html?\_nkw=bike, https://www.ebay.com/b/Cars-Trucks/6001/bn\_1865117, https://www.ebay.com/itm/389640259363). When provided, these URLs are used instead of building a search from queries and filters.

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

Product search terms (e.g. "bike", "iphone 13"). Used only when Start URLs are empty. Combine with category, location, and the filters below.

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

eBay site used for search queries and filters. Start URLs keep the host from the URL.

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

eBay category applied to constructed searches. Ignored when Start URLs are set.

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

Limit constructed searches to Buy It Now, Auction, or Best Offer listings.

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

Item condition filter for constructed searches.

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

How to sort constructed search results.

## `itemLocation` (type: `string`):

Prefer items located in the selected marketplace country, worldwide, or near a postal code.

## `zipCode` (type: `string`):

Postal code used for nearby / local searches (e.g. "10001", "SW1A 1AA").

## `distance` (type: `integer`):

Search radius around the ZIP / postal code. Used with Item Location = Nearby.

## `minPrice` (type: `number`):

Exclude listings below this price on constructed searches.

## `maxPrice` (type: `number`):

Exclude listings above this price on constructed searches.

## `soldListings` (type: `boolean`):

When enabled, scrape completed/sold listings instead of active ones (constructed searches only).

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

Maximum number of products to scrape across all URLs and queries (0 = unlimited).

## `includeProductDetails` (type: `boolean`):

When enabled, open each item page for description, images, item specifics, seller, and shipping. Charged as the product-details event in addition to each dataset item.

## `detailConcurrency` (type: `integer`):

How many product-detail fetches to run at the same time. Each worker uses its own rotating proxy. Higher is faster.

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

Proxy settings. Apify Residential proxies are recommended for reliable eBay access.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.ebay.com/sch/i.html?_nkw=bike"
    }
  ],
  "searchQueries": [
    "bike"
  ],
  "marketplace": "EBAY_US",
  "category": "0",
  "buyingFormat": "all",
  "condition": "any",
  "sortBy": "best_match",
  "itemLocation": "default",
  "soldListings": false,
  "maxItems": 10,
  "includeProductDetails": false,
  "detailConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset of scraped eBay products

## `runStats` (type: `string`):

Record count and timestamps for this run

# 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 = {
    "startUrls": [
        {
            "url": "https://www.ebay.com/sch/i.html?_nkw=bike"
        }
    ],
    "searchQueries": [
        "bike"
    ],
    "maxItems": 10,
    "detailConcurrency": 8,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraptivo/ebay-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 = {
    "startUrls": [{ "url": "https://www.ebay.com/sch/i.html?_nkw=bike" }],
    "searchQueries": ["bike"],
    "maxItems": 10,
    "detailConcurrency": 8,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scraptivo/ebay-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.ebay.com/sch/i.html?_nkw=bike"
    }
  ],
  "searchQueries": [
    "bike"
  ],
  "maxItems": 10,
  "detailConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scraptivo/ebay-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraptivo/ebay-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0Rk5Ppi09BpZgcor1/builds/5lrExXvguzgiltKox/openapi.json