# eBay Active Listings Scraper — Live Listings, BIN/Auction (`crawloop/ebay-active-listings-scraper`) Actor

Scrape eBay active/live listings by keyword. Export current price, BIN/auction format, shipping, watchers, quantity sold, seller feedback across 20+ regional sites. Fast curl\_cffi scraper — residential proxy ready.

- **URL**: https://apify.com/crawloop/ebay-active-listings-scraper.md
- **Developed by:** [Andrej Kiva](https://apify.com/crawloop) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 3 total users, 1 monthly users, 86.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 active listing scrapeds

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 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 Active Listings Scraper — Live Listings, BIN/Auction & Competition

> **Disclaimer:** Unofficial integration for publicly accessible eBay active listings. **eBay** and related names are trademarks of eBay Inc. Not affiliated with, sponsored by, or endorsed by eBay Inc. Provided for informational and research purposes only.

Scrape **eBay active listings** and **live marketplace offers** by keyword across **20+ regional sites**. Export **current price**, **listing type (Buy It Now / Auction)**, **shipping cost**, **item condition**, **watcher count**, **quantity sold**, **time remaining**, and **seller feedback** as clean JSON — ideal for **pricing intelligence**, **dropshipping catalogues**, **market research**, and **competitor tracking**.

> **Crawloop eBay E-commerce & Resale Suite** — live active listings, completed sold comps, and pricing intelligence.

| Active listings | Sold listings | Pricing intelligence |
| :--- | :--- | :--- |
| **eBay Active Listings Scraper** ◄── you are here | [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) | [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence) |
| Live listings, BIN/auction, watchers, competition | Completed sales, raw sold rows, sold dates | Recommended price, demand score, CSV/report |

### Key Features

- **Live market data** — current asking prices, bid counts, and time remaining on active listings
- **Competition & velocity** — watcher count ("X watching") and quantity sold ("X sold") from search cards
- **Triple layout fallback** — parses `.s-item`, `.s-item-card`, and `.s-card` search layouts
- **Fast HTTP scraping** — `curl_cffi` Chrome TLS impersonation; no headless browser
- **20+ regional marketplaces** — US, UK, DE, FR, IT, ES, CA, AU, PL, NL, SG, MY, PH, HK with localized currency and condition mapping
- **Advanced filters** — condition, format (Auction / Buy It Now), price range, category, free shipping, seller blocklist
- **High-volume runs** — up to 240 listings per page; batch dataset export for large keyword pulls

### When to use this Actor

- **Competitor price tracking** — monitor live listings, discounts, and original vs sale prices
- **Dropshipping research** — build product catalogues by keyword with thumbnail URLs
- **Demand signals** — watcher counts and sales velocity before you list or source inventory
- **Cross-border pricing** — same keyword on `ebay.com`, `ebay.de`, or `ebay.co.uk`
- **Arbitrage sourcing** — compare live ask prices against your target buy range

### When not to use this Actor

- **Historical sold comps** — use [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) for completed transaction history
- **Recommended list price & demand reports** — use [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence) for analytics and CSV/Markdown exports

### Input Parameters

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `keywords` | Array | *(Required)* | Search queries; each runs in parallel |
| `count` | Integer | `100` | Max listings to collect per keyword |
| `ebaySite` | String | `"ebay.com"` | Regional eBay domain |
| `sortOrder` | String | `"bestMatch"` | `bestMatch`, `endingSoonest`, `newlyListed`, `pricePlusPostageLowest`, `pricePlusPostageHighest`, `distanceNearest` |
| `itemCondition` | String | `"any"` | `any`, `new`, `used`, `refurbished` |
| `listingType` | String | `"any"` | `any`, `auction`, `buy_it_now` |
| `freeShippingOnly` | Boolean | `false` | Only return free shipping items |
| `excludeSellers` | Array | `[]` | Usernames of sellers to filter out |
| `categoryId` | String | `"0"` | Filter by main eBay category |
| `minPrice` / `maxPrice` | Number | — | Listing price limits |
| `proxyConfiguration` | Object | Residential | Apify Proxy settings |

#### Input Example

```json
{
  "keywords": ["rtx 4080", "iphone 15"],
  "count": 50,
  "ebaySite": "ebay.com",
  "sortOrder": "bestMatch",
  "itemCondition": "used",
  "listingType": "buy_it_now",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

### Output Format

Each row in the dataset represents a single active eBay listing card.

| Field | Type | Description |
| :--- | :--- | :--- |
| `itemId` | String | Unique listing ID |
| `title` | String | Cleaned listing title |
| `url` | String | Clean item URL |
| `price` / `currency` | String | Current price / bid and currency |
| `originalPrice` / `originalCurrency` | String | Original price before discount (if on sale) |
| `listingType` | String | `buy_it_now` or `auction` |
| `bidsCount` | Integer | Number of bids (auctions only) |
| `watchCount` | Integer | User watch count indicator |
| `quantitySold` | Integer | Number of items sold from this listing |
| `timeLeft` | String | Remaining listing time (e.g. `4d 18h left`) |
| `isSponsored` | Boolean | True if the card is a sponsored listing |
| `shippingPrice` / `shippingType` | String | Shipping cost and type (`free`, `paid`, `pickup`, `unknown`) |
| `sellerUsername` | String | Seller username |
| `sellerPositivePercent` | Number | Seller positive feedback % |
| `sellerFeedbackScore` | Integer | Seller feedback score |
| `sellerType` | String | Business vs private when detectable |
| `thumbnailUrl` | String | Image URL |
| `keyword` | String | Search query that found this listing |

#### Output Example

```json
{
  "itemId": "386901847125",
  "url": "https://www.ebay.com/itm/386901847125",
  "title": "ASUS TUF Gaming GeForce RTX 4080 16GB GDDR6X",
  "price": "980.00",
  "currency": "USD",
  "originalPrice": "1199.00",
  "originalCurrency": "USD",
  "listingType": "buy_it_now",
  "watchCount": 14,
  "quantitySold": 3,
  "timeLeft": "4d 18h left",
  "isSponsored": false,
  "shippingPrice": "0.00",
  "shippingType": "free",
  "sellerUsername": "computermart",
  "sellerPositivePercent": 99.8,
  "sellerFeedbackScore": 4512,
  "sellerType": "business",
  "keyword": "rtx 4080"
}
```

### Supported Marketplaces

`ebay.com` (US) · `ebay.co.uk` (UK) · `ebay.de` (DE) · `ebay.fr` (FR) · `ebay.it` (IT) · `ebay.es` (ES) · `ebay.ca` (CA) · `ebay.com.au` (AU) · `ebay.at` (AT) · `ebay.ch` (CH) · `ebay.ie` (IE) · `ebay.pl` (PL) · `ebay.nl` (NL) · `ebay.be` (BE) · `ebay.com.sg` (SG) · `ebay.com.my` (MY) · `ebay.ph` (PH) · `ebay.com.hk` (HK)

### Use cases

| Use case | What you get |
| :--- | :--- |
| **Competitor tracking** | Live ask prices, discounts, watchers, time left |
| **Dropshipping catalogues** | Keyword product pulls with thumbnails and seller data |
| **Demand before sourcing** | Watcher counts and quantity-sold velocity signals |
| **Cross-border pricing** | Same keyword on `.com` / `.de` / `.co.uk` |
| **AI / MCP workflows** | Run via Apify API, clients, or MCP and summarize live comps |

### Integration examples

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('crawloop/ebay-active-listings-scraper').call({
  keywords: ['rtx 4080'],
  count: 50,
  ebaySite: 'ebay.com',
  itemCondition: 'used',
  listingType: 'buy_it_now',
  proxyConfiguration: {
    useApifyProxy: true,
    apifyProxyGroups: ['RESIDENTIAL'],
    apifyProxyCountry: 'US',
  },
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 5));
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token)
run = client.actor("crawloop/ebay-active-listings-scraper").call(
    run_input={
        "keywords": ["rtx 4080", "iphone 15"],
        "count": 50,
        "ebaySite": "ebay.com",
        "sortOrder": "bestMatch",
        "proxyConfiguration": {
            "useApifyProxy": True,
            "apifyProxyGroups": ["RESIDENTIAL"],
            "apifyProxyCountry": "US",
        },
    }
)
items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(len(items), items[:3])
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/crawloop~ebay-active-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["rtx 4080"],
    "count": 50,
    "ebaySite": "ebay.com",
    "proxyConfiguration": {
      "useApifyProxy": true,
      "apifyProxyGroups": ["RESIDENTIAL"],
      "apifyProxyCountry": "US"
    }
  }'
```

### MCP and AI assistants

Use this Actor from AI tools via [Apify MCP](https://docs.apify.com/platform/integrations/mcp). Connect your Apify account, then call `crawloop/ebay-active-listings-scraper`.

Example prompts:

- "Run eBay Active Listings Scraper for keyword rtx 4080 on ebay.com, max 50 rows, and return title, price, watchCount, and url as JSON"
- "Scrape active eBay listings for iphone 15 used Buy It Now and summarize the cheapest 10 offers"
- "Chain eBay Active Listings Scraper then eBay Sold Listings Scraper for rtx 4080 and compare live ask vs recent sold prices"

### Suite next step

After live competition data, pull **completed sales** with [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper), or skip to recommended list price with [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence).

### FAQ

#### How is this different from the Sold Listings Scraper?

This Actor returns **live active listings** with current prices and competition signals. [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) returns **completed sales** with sold dates and final sold prices.

#### How is this different from Sold Price Intelligence?

[eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence) analyzes completed sales and outputs recommended price, demand level, confidence score, and ready-made reports — not live listing rows.

#### Do I need proxies?

Residential proxies are **recommended** for US and UK. Defaults to geo-targeted Apify Residential Proxy per marketplace.

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

Yes — pass an array in `keywords`; each query runs in parallel with the same filters.

### Related Actors

| Actor | Use for |
| :--- | :--- |
| **eBay Active Listings Scraper** ◄── you are here | Live ask prices, watchers, competition |
| [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) | Raw completed sales / sold comps |
| [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence) | Recommended price, demand, CSV/report |

# Actor input Schema

## `keywords` (type: `array`):

One or more eBay search keywords for active/live listings. Each keyword runs as a separate parallel search with the same filters.

## `count` (type: `integer`):

Maximum number of active listings to collect for each keyword.

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

eBay category filter (use '0' for all categories).

## `subcategoryId` (type: `string`):

Optional subcategory filter. If set, overrides the main Category field.

## `ebaySite` (type: `string`):

Regional eBay domain for active listing search — e.g. ebay.com (US), ebay.co.uk, ebay.de, ebay.fr.

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

Sort order for active search results.

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

Minimum item price filter (in site currency).

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

Maximum item price filter (in site currency).

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

Search items based on seller's location.

## `itemCondition` (type: `string`):

Filter by item condition.

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

Filter by buy-it-now or auction format.

## `freeShippingOnly` (type: `boolean`):

Only return listings that offer free shipping.

## `excludeSellers` (type: `array`):

List of seller usernames to exclude from the results.

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

Select proxies to bypass eBay bot protection. Apify Residential Proxies recommended.

## Actor input object example

```json
{
  "keywords": [
    "rtx 4080"
  ],
  "count": 100,
  "categoryId": "0",
  "subcategoryId": "",
  "ebaySite": "ebay.com",
  "sortOrder": "bestMatch",
  "itemLocation": "default",
  "itemCondition": "any",
  "listingType": "any",
  "freeShippingOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `activeListings` (type: `string`):

Dataset of live listing cards (price, format, watchers, shipping, seller).

# 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 = {
    "keywords": [
        "rtx 4080"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawloop/ebay-active-listings-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 = {
    "keywords": ["rtx 4080"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawloop/ebay-active-listings-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 '{
  "keywords": [
    "rtx 4080"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call crawloop/ebay-active-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Lvqo8XxcSzl56SWrW/builds/KIWOYNn0JLXhuxRar/openapi.json