# EBay Search Listing Scraper (`kawsar/ebay-search-listing-scraper`) Actor

eBay Search Listings Scraper that pulls prices, conditions, seller info, and shipping details from any keyword search, so you can track market prices and research competitors without manual browsing.

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

## Pricing

from $6.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.
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 Search Listings Scraper

**Turn any eBay search into a clean, structured dataset — in seconds.**

Stop copying prices into spreadsheets by hand. Stop losing track of competitor listings. This actor crawls eBay search results and hands you back everything you need: titles, prices, sellers, shipping, ratings, auction details, and more — all neatly organized, all ready to use.

Whether you're tracking market prices, scouting products to sell, or doing competitive research, this is the tool that does the heavy lifting for you.

---

###  What makes this actor worth using?

Most eBay scrapers give you a title and a price. This one gives you the **full picture**:

-  **Item title, ID, and clean listing URL** — no tracking junk in the links
-  **Current price + original crossed-out price** — so you can see the real discount at a glance
-  **Item condition** — New, Used, Refurbished, and everything in between
-  **Seller name and feedback score** — know who you're dealing with before you commit
-  **Shipping info and delivery estimate** — free shipping or $12 ground? It's all there
-  **Item location** — filter your results by geography in your own pipeline
-  **Sold count and watcher count** — real demand signals, not guesses
-  **Auction details** — bid count and time remaining for live auctions
-  **Sponsored flag** — easily separate paid ads from organic listings
-  **Ratings and review count** — see what buyers think before you analyze
-  **Program badge** — eBay Refurbished, Certified, Top Rated, etc.

> Every record also carries a `scrapedAt` UTC timestamp so you always know exactly when the data was captured.

---

### 📥 Input

Simple to configure. You only need one field to get started — everything else is optional.

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `searchKeyword` | string | **Yes** | — | The search term, e.g. `iphone 13 pro max` |
| `categoryId` | string | No | — | eBay category ID to narrow results, e.g. `9355` for Cell Phones |
| `minPrice` | number | No | — | Only return listings above this price |
| `maxPrice` | number | No | — | Only return listings below this price |
| `condition` | select | No | `any` | Filter by condition: `any` · `new` · `used` · `not_specified` |
| `sortOrder` | select | No | `best_match` | `best_match` · `lowest_price` · `highest_price` · `ending_soonest` · `newly_listed` |
| `maxItems` | integer | No | `48` | How many listings to collect — up to **1,000** |
| `requestTimeoutSecs` | integer | No | `30` | Timeout per page request in seconds |

#### Quick start example

```json
{
  "searchKeyword": "iphone 13 pro max",
  "condition": "used",
  "sortOrder": "lowest_price",
  "maxItems": 100
}
````

That's it. Hit **Start** and within moments you'll have 100 sorted, structured used iPhone listings sitting in your dataset.

***

### 📤 Output

Every listing becomes one clean record. Here's exactly what you get:

```json
{
  "itemId": "177240748616",
  "listingTitle": "Apple iPhone 13 Pro Max 128GB Unlocked Very Good",
  "price": "$431.99",
  "originalPrice": "$479.99",
  "currency": "USD",
  "itemCondition": "Very Good - Refurbished",
  "subtitle": "1-Year Warranty - Unlocked Worldwide - Ships Same Day",
  "listingUrl": "https://www.ebay.com/itm/177240748616",
  "imageUrl": "https://i.ebayimg.com/images/g/k8wAAeSwhQRoZrOO/s-l500.webp",
  "sellerName": "creo_cellular",
  "sellerFeedback": "99.3% positive (48.4K)",
  "shippingInfo": "Free delivery in 2-3 days",
  "location": "United States",
  "soldCount": null,
  "watchers": "12+ watchers",
  "isBuyItNow": true,
  "isAuction": false,
  "bidsCount": null,
  "timeLeft": null,
  "sponsored": true,
  "reviewsCount": "19 product ratings",
  "rating": "5.0 out of 5 stars",
  "programBadge": "eBay Refurbished",
  "searchKeyword": "iphone 13 pro max",
  "pageNumber": 1,
  "scrapedAt": "2025-01-15T12:34:56.789Z"
}
```

Download as **JSON**, **CSV**, or **Excel** directly from your Apify dataset. Pipe it straight into Google Sheets, a database, a dashboard, or your own app.

> Fields like `soldCount` or `bidsCount` show `null` when eBay doesn't display them — that's normal and expected.

***

### Who is this for?

#### Price trackers

Schedule this actor to run once a day on a product you care about. Watch prices move over time. Know the exact moment something drops to your target price. No manual checking, ever.

#### Dropshippers & resellers

Find products with high sold counts and strong watcher numbers — those are your winners. Filter to `newly_listed` to catch fresh inventory before competitors do. Use the `sponsored` flag to focus only on organic demand.

#### Competitor researchers

See what's selling in your niche, at what prices, and from which sellers. Check their feedback scores. Understand the market before you list a single item.

#### Analysts & developers

Get clean, structured data you can immediately import into any tool. Use the `scrapedAt` timestamp to build time-series charts. Filter by `currency`, `condition`, or `programBadge` to slice the data your way.

***

### Pagination

No extra configuration needed. The actor automatically pages through results until it hits your `maxItems` limit or eBay runs out of listings. eBay typically shows around 60 listings per page, so a `maxItems` of 300 means roughly 5 pages fetched automatically.

***

### Good to know

- **Dummy listing skipped automatically** — eBay injects a fake promotional card into every search page. The actor detects and quietly discards it so your dataset stays clean.
- **Sponsored listings are included but flagged** — they appear in your results with `"sponsored": true`, so you can keep or filter them as you see fit.
- **Auction listings** come with `"isAuction": true` and include `bidsCount` and `timeLeft` where eBay displays them.
- **Images are upgraded** — thumbnail URLs are automatically promoted to 500 px resolution for better quality.

***

### Legal

This actor is built for **research, price monitoring, and data analysis**. Please use the data responsibly and in line with [eBay's Terms of Service](https://www.ebay.com/help/home).

# Actor input Schema

## `searchKeyword` (type: `string`):

A single search term to look up on eBay (e.g. 'iphone 13 pro max'). Use 'Search keywords' below to scrape multiple keywords in one run.

## `searchKeywords` (type: `array`):

List of search keywords to scrape. Each keyword is processed separately and results are combined in the dataset. Use this instead of — or together with — the single keyword field above.

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

eBay category ID to restrict results (e.g. '9355' for Cell Phones). Leave blank to search all categories.

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

Minimum listing price filter. Leave blank for no minimum.

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

Maximum listing price filter. Leave blank for no maximum.

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

Filter by item condition.

## `sortOrder` (type: `string`):

How to sort the search results.

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

Maximum number of listings to extract per run.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "searchKeyword": "iphone 13 pro max",
  "searchKeywords": [
    "iphone 13 pro max",
    "samsung galaxy s23",
    "pixel 8 pro"
  ],
  "categoryId": "9355",
  "condition": "any",
  "sortOrder": "best_match",
  "maxItems": 48,
  "requestTimeoutSecs": 30
}
```

# 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 = {
    "searchKeyword": "iphone 13 pro max",
    "searchKeywords": [
        "iphone 13 pro max",
        "samsung galaxy s23"
    ],
    "categoryId": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/ebay-search-listing-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 = {
    "searchKeyword": "iphone 13 pro max",
    "searchKeywords": [
        "iphone 13 pro max",
        "samsung galaxy s23",
    ],
    "categoryId": "",
}

# Run the Actor and wait for it to finish
run = client.actor("kawsar/ebay-search-listing-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 '{
  "searchKeyword": "iphone 13 pro max",
  "searchKeywords": [
    "iphone 13 pro max",
    "samsung galaxy s23"
  ],
  "categoryId": ""
}' |
apify call kawsar/ebay-search-listing-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EBay Search Listing Scraper",
        "description": "eBay Search Listings Scraper that pulls prices, conditions, seller info, and shipping details from any keyword search, so you can track market prices and research competitors without manual browsing.",
        "version": "0.0",
        "x-build-id": "mqrijW7jWntdkCruC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~ebay-search-listing-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-ebay-search-listing-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/kawsar~ebay-search-listing-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-ebay-search-listing-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/kawsar~ebay-search-listing-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-ebay-search-listing-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchKeyword": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "A single search term to look up on eBay (e.g. 'iphone 13 pro max'). Use 'Search keywords' below to scrape multiple keywords in one run."
                    },
                    "searchKeywords": {
                        "title": "Search keywords (multiple)",
                        "type": "array",
                        "description": "List of search keywords to scrape. Each keyword is processed separately and results are combined in the dataset. Use this instead of — or together with — the single keyword field above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryId": {
                        "title": "Category ID",
                        "type": "string",
                        "description": "eBay category ID to restrict results (e.g. '9355' for Cell Phones). Leave blank to search all categories."
                    },
                    "minPrice": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Minimum listing price filter. Leave blank for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Maximum listing price filter. Leave blank for no maximum."
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "any",
                            "new",
                            "used",
                            "not_specified"
                        ],
                        "type": "string",
                        "description": "Filter by item condition.",
                        "default": "any"
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "best_match",
                            "lowest_price",
                            "highest_price",
                            "ending_soonest",
                            "newly_listed"
                        ],
                        "type": "string",
                        "description": "How to sort the search results.",
                        "default": "best_match"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of listings to extract per run.",
                        "default": 48
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
