# eBay Search Scraper 2026 (`devcake/ebay-search-scraper`) Actor

eBay Scraper built for dropshippers. Extract titles, prices, watch counts, sold volumes, delivery costs, and seller locations to find winning products and analyze competition.

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

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Search Results Scraper

**Extract eBay product data** — prices, watcher counts, sold volumes, delivery costs, and seller locations from search results. Multi-keyword support with proxy rotation for reliable large-scale data collection.

[eBay.com](https://www.ebay.com)

---

### What is eBay Search Scraper?

eBay Search Scraper is a powerful tool that **extracts product listing data** from [eBay.com](https://www.ebay.com). With just a few clicks, you can **collect prices, watch counts, sold amounts, and seller locations** without any coding.

Perfect for resellers researching inventory, dropshippers building product databases, and market analysts tracking demand signals.

---

### Why use eBay Search Scraper?

- **Anti-bot bypass** — Stealth browser technology avoids detection and blocks
- **Proxy rotation** — Automatically rotates residential proxies to avoid rate limits
- **Session warmup** — Establishes valid cookies before scraping for higher success rates
- **Bandwidth efficient** — Blocks tracking domains and unnecessary resources
- **Multi-keyword support** — Run up to 10 search terms in a single job

**Works with the Apify Platform** — Your scraper runs on Apify's infrastructure with automatic proxy rotation, monitoring, scheduling, and integrations.

---

### What data can eBay Search Scraper extract?

| Field | Description |
|-------|-------------|
| `item_id` | Unique eBay listing identifier |
| `title` | Full product title from search card |
| `price` | Current price including shipping |
| `condition` | Item condition (New, Used, etc.) |
| `listing_type` | Buy It Now, Auction, or Best Offer |
| `watch_count` | Number of watchers (handles 1.2K format) |
| `sold_count` | Number of items sold |
| `delivery` | Delivery cost or "Free delivery" |
| `location` | Seller's country |
| `image_url` | Primary product image URL |
| `free_returns` | Boolean flag for free returns |
| `url` | Direct link to eBay listing |
| `queries` | Search terms that matched this item |

---

### How to scrape eBay?

1. **Open the Actor** — Go to the eBay Search Results Scraper page on Apify Store
2. **Enter your search terms** — Add keywords in the input field (e.g., "monster high", "vintage cameras")
3. **Set max items** — Choose how many results per keyword (60–3000)
4. **Click Run** — The actor fetches a residential proxy, warms up a browser session, and scrapes search pages
5. **Download results** — Export your data in JSON, CSV, or other formats

---

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `keyword` | array | Yes | — | Search terms to scrape |
| `maxItems` | integer | No | 60 | Max items per keyword (60–3000) |
| `proxyConfiguration` | object | No | Residential | Proxy settings (leave default for Apify residential) |

**Advanced options:** `itemsPerPage`, `minDelayMs`, `maxDelayMs`, `maxPagesPerSession`, `maxSessionRotations`, `maxConsecutiveFailedPages`, `warmupMode`, `renderWaitMs`.

---

### Example

#### Input

```json
{
  "keyword": ["monster high"],
  "maxItems": 120
}
````

#### Output

```json
{
  "item_id": "255123456789",
  "title": "Monster High Frankie Stein Doll",
  "price": "$24.99",
  "condition": null,
  "listing_type": "Buy It Now",
  "watch_count": 47,
  "sold_count": 128,
  "delivery": "+$5.99 delivery",
  "location": "United Kingdom",
  "image_url": "https://i.ebayimg.com/...",
  "free_returns": true,
  "url": "https://www.ebay.com/itm/255123456789",
  "queries": ["monster high"]
}
```

***

### Is it legal to scrape eBay?

Our scraper extracts **publicly available listing data** that eBay displays on search result pages. When used for legitimate purposes such as market research, competitor analysis, or product research, this is generally acceptable.

However, you should ensure your use complies with eBay's Terms of Service. Results may contain personal data — always handle such data in accordance with privacy regulations like GDPR. If you're unsure, consult legal counsel.

***

### FAQ

#### Can I scrape multiple keywords at once?

Yes. The `keyword` parameter accepts an array of up to 10 search terms. Each keyword is scraped independently and results are merged into a single dataset.

#### How does proxy rotation work?

The actor uses Apify's residential proxy pool automatically. Each session gets a fresh proxy IP to avoid detection and rate limits.

#### What happens if a page is blocked?

The actor has built-in shell-page detection. If a page returns an anti-bot challenge, it automatically rotates to a new session and retries.

#### Can I use this with other marketplace scrapers?

Yes. eBay listing data pairs well with product data from other platforms. Check out the related actors below for complementary scrapers.

***

### 🔗 Related Actors

If you scrape other marketplaces, check out these related tools:

🛒 **[Alibaba Products Scraper](https://apify.com/devcake/alibaba-products-scraper)** — Extract wholesale product data and pricing from Alibaba.com for B2B sourcing and supplier research

🏭 **[Alibaba Supplier Scraper](https://apify.com/devcake/alibaba-supplier-scraper)** — Extract detailed supplier profiles from Alibaba.com including factory size, certifications, and response rates

🛍️ **[AliExpress Products Scraper](https://apify.com/devcake/aliexpress-products-scraper)** — Scrape AliExpress search results to find best-selling products with prices, ratings, and order counts

🏪 **[1688 Listings Scraper](https://apify.com/piotrv1001/1688-listings-scraper)** — Extract wholesale product data from 1688.com (Alibaba's domestic China B2B marketplace) — factory-direct prices, tiered bulk pricing, and MOQ

📱 **[TikTok Shop Search Scraper](https://apify.com/pratikdani/tiktok-shop-search-scraper)** — Scrape TikTok Shop search results for product data, prices, sellers, ratings, and media URLs

🎨 **[Etsy Search Scraper](https://apify.com/devcake/etsy-search-scraper)** — Extract Etsy product listings including prices, heart counts, seller names, and images from search results — great for handmade and vintage product research

***

### Need Help?

- **Documentation**: Check the Input tab for all configuration options
- **Issues**: Report bugs or unexpected behavior in the Apify Store reviews
- **Feature requests**: Contact us through the Apify Store page

***

**eBay Search Scraper** is built for product researchers, resellers, and e-commerce professionals who need eBay data at scale.

# Actor input Schema

## `keyword` (type: `array`):

List of search terms to scrape (each becomes a separate query)

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

Maximum number of items to scrape per query

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

Leave as default for residential proxy (recommended)

## Actor input object example

```json
{
  "keyword": [
    "monster high"
  ],
  "maxItems": 60,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Complete scraped data in tabular view

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

Table view with photo, title, price, watchers, sold, location

## `full` (type: `string`):

Detailed view with item ID, all fields, delivery, free returns

# 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 = {
    "keyword": [
        "monster high"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("devcake/ebay-search-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 = { "keyword": ["monster high"] }

# Run the Actor and wait for it to finish
run = client.actor("devcake/ebay-search-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 '{
  "keyword": [
    "monster high"
  ]
}' |
apify call devcake/ebay-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Search Scraper 2026",
        "description": "eBay Scraper built for dropshippers. Extract titles, prices, watch counts, sold volumes, delivery costs, and seller locations to find winning products and analyze competition.",
        "version": "1.0",
        "x-build-id": "GcepoRvof22c3QQar"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devcake~ebay-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devcake-ebay-search-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/devcake~ebay-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-devcake-ebay-search-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/devcake~ebay-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-devcake-ebay-search-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": [
                    "keyword"
                ],
                "properties": {
                    "keyword": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "List of search terms to scrape (each becomes a separate query)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 60,
                        "maximum": 3000,
                        "type": "integer",
                        "description": "Maximum number of items to scrape per query",
                        "default": 60
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Leave as default for residential proxy (recommended)",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
