# eBay Live Shows Scraper — Livestreams, Hosts & Viewers (`crawloop/ebay-live-shows-scraper`) Actor

Scrape eBay Live livestream shows and in-show lineup listings — live, upcoming, and recorded. Export host, tags, viewers, lot title, price, and auction status as JSON.

- **URL**: https://apify.com/crawloop/ebay-live-shows-scraper.md
- **Developed by:** [Andrej Kiva](https://apify.com/crawloop) (community)
- **Categories:** E-commerce, Games, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.89 / 1,000 ebay live shows

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 Live Shows Scraper — Livestreams, Hosts & Viewers

> **Disclaimer:** Unofficial integration for publicly accessible eBay Live shows. **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.

**eBay Live scraper** for livestream shopping shows — **card breaks**, **$1 starts**, **refurbished tech**, **luxury**, and collectibles. Use it as an **eBay Live API alternative** to export **currently live**, **upcoming**, and **past** streams plus **in-show lineup listings** (scheduled, active, sold): **host username**, **tags**, **viewer count**, **lot title**, **price**, **start time**, **replay URL**, and **case-break flags** as clean JSON. Fast **HTTP** scraping (`curl_cffi`) — **no login**, **no headless browser**. Call from **Python**, **Node.js**, **cURL**, or **Apify MCP**.

For detailed inputs, show and lot output examples, API snippets, MCP prompts, pricing notes, and limitations, see the [eBay Live Shows Scraper API documentation by Crawloop](https://crawloop.com/actors/ebay-live-shows-scraper).

Built for **break hosts**, **collectors**, **reseller scouting**, and **scheduled “who is live” monitors**.

> **Crawloop eBay suite** — livestream shows, live BIN/auction listings, sold comps, and pricing intelligence.

| Live shows | Active listings | Sold listings | Pricing intelligence |
| :--- | :--- | :--- | :--- |
| **eBay Live Shows Scraper** ◄── you are here | [eBay Active Listings Scraper](https://apify.com/crawloop/ebay-active-listings-scraper) | [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) | [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence) |
| Livestream hosts, tags, viewers, in-show lots | Live BIN/auction asking prices | Completed sales, sold dates | Recommended price, demand, CSV/report |

### Key features

- **Live / upcoming / past feeds** — scrape eBay Live hub states in one run
- **Event URLs** — paste `/ebaylive/events/{id}/stream` links for a single show
- **Host filter** — keep shows by eBay username
- **Channel + tag filters** — channel IDs and tags such as `$1 Starts` or `Raw Cards`
- **Case-break flag** — optional `onlyCaseBreaks` for card-break scouting
- **Optional stream enrichment** — host feedback, concurrent viewers, vendor event ID, replay HLS
- **In-show lineup listings** — scheduled/queued lots, the item on camera, and sold lots (`includeListings`)
- **Monitor mode** — scheduled runs bill only new show IDs
- **Fast HTTP path** — Chrome TLS impersonation; no Playwright

### When to use this Actor

- You need an **eBay Live scraper** / **eBay Live API alternative** for livestream **shows** and **in-show lots** (not search listings)
- You track **who is live now**, **upcoming streams**, **queued lineup items**, or **recorded replays**
- You scout **break hosts**, **$1 start** rooms, or a competitor seller’s Live calendar
- You scrape eBay Live with **Python**, **Node.js**, or **MCP** and export JSON / CSV
- You run a **schedule** and only want **new show IDs** billed

### When not to use this Actor

- **Active BIN / auction listings** — use [eBay Active Listings Scraper](https://apify.com/crawloop/ebay-active-listings-scraper)
- **Sold comps / fair-value reports** — use [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) then [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence)
- **Whatnot shops and listings** — use [Whatnot Listings Scraper](https://apify.com/crawloop/whatnot-listings-scraper)
- **In-stream bid ticks, live chat, or video download** — this Actor snapshots show cards and lineup lots, not websocket hammer prices

### Input parameters

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `showStates` | Array | `["live"]` | `live`, `upcoming`, `past`. Clear to scrape only URLs / channels / sellers |
| `sellerUsernames` | Array | — | Keep shows hosted by these eBay usernames |
| `channelIds` | Array | — | eBay Live channel IDs (`/d/ebaylive/channels/{id}`) |
| `startUrls` | Array | — | Event, hub, feed, seller, or channel URLs |
| `tagNames` | Array | — | Keep shows with at least one matching tag |
| `onlyCaseBreaks` | Boolean | `false` | Only `isCaseBreak` shows |
| `enrichDetails` | Boolean | `false` | Extra stream-page request per show |
| `includeListings` | Boolean | `true` | Fetch in-show lots (scheduled / active / sold) |
| `maxListingsPerShow` | Integer | `200` | Cap lineup lots per show (max 1000) |
| `maxItems` | Integer | `50` | Max **show** rows (0 = unlimited). Listing rows are extra |
| `monitorMode` | Boolean | `false` | Charge only new show IDs after the baseline run |
| `monitorStoreName` | String | `ebay-live-shows-monitor` | Named KV store for seen IDs |
| `proxyConfiguration` | Object | Residential | Apify Proxy; RESIDENTIAL recommended |

#### Input example

```json
{
  "showStates": ["live"],
  "maxItems": 50,
  "includeListings": true,
  "maxListingsPerShow": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

**One host + upcoming calendar:**

```json
{
  "showStates": ["live", "upcoming"],
  "sellerUsernames": ["cardvaultbreaks"],
  "maxItems": 25,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

**Pasted event URL + enrich:**

```json
{
  "showStates": [],
  "startUrls": [
    { "url": "https://www.ebay.com/ebaylive/events/ogmQWaWY9FlJDV0e/stream" }
  ],
  "enrichDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Output

Each dataset row is one **eBay Live show** (`recordType: live_show`) or one **in-show lot** (`recordType: live_listing`) when `includeListings` is on.

**Show fields**

| Field | Description |
| :--- | :--- |
| `id` | eBay Live event ID |
| `url` | Stream page URL |
| `title` / `description` | Show copy |
| `state` | `LIVE`, `UPCOMING`, or `RECORDED` |
| `startTime` / `endTime` | ISO 8601 |
| `watchedCount` | Cumulative viewers on the card |
| `concurrentViewerCount` | Current CCU (needs `enrichDetails`) |
| `isCaseBreak` | Card/case-break flag |
| `tags` / `tagsCsv` | Live tags |
| `sellerUsername` | Host account name |
| `sellerStoreName` | Store display name |
| `sellerPositivePercent` | Feedback % (enrich) |
| `thumbnailUrl` | Preview image |
| `liveUrl` / `previewLiveUrl` | HLS while live |
| `replayUrl` | Replay playlist when recorded |
| `source` | Which feed or URL produced the row |
| `scrapedAt` | UTC timestamp |

**Lineup listing fields** (`recordType: live_listing`)

| Field | Description |
| :--- | :--- |
| `listingId` / `url` | eBay item ID and `/itm/` URL |
| `eventId` / `showUrl` / `showTitle` | Parent livestream |
| `title` | Lot title |
| `lineupStatus` | `ACTIVE` (on camera), `SCHEDULED` (queued), `SOLD`, `ENDED` |
| `saleType` | Auction / BIN |
| `price` / `currency` | Current bid or BIN |
| `bidCount` | Auction bids |
| `quantityAvailable` / `quantitySold` | Stock |
| `winnerUsername` | Auction winner when sold |
| `imageUrl` / `categoryName` | Image and primary category |

#### Output example

```json
{
  "recordType": "live_show",
  "id": "SXiCmTMOlOj0J3M8",
  "url": "https://www.ebay.com/ebaylive/events/SXiCmTMOlOj0J3M8/stream",
  "title": "Friday Tech Rush: $1 Starts on Refurbished Tech",
  "state": "LIVE",
  "startTime": "2026-08-21T15:01:52Z",
  "watchedCount": 180,
  "isCaseBreak": false,
  "tags": ["$1 Starts", "Electronics"],
  "sellerUsername": "guaranteecellular",
  "source": "feed_live"
}
```

Listing row:

```json
{
  "recordType": "live_listing",
  "listingId": "287538498476",
  "url": "https://www.ebay.com/itm/287538498476",
  "eventId": "kAO8BsRCX4gHv2Xv",
  "showTitle": "First Watch Fridays",
  "title": "#001 - eBay Live - PENNY DROP - Crescent Watch Guy Watch Roll",
  "lineupStatus": "SOLD",
  "saleType": "Auction",
  "price": 0.01,
  "currency": "USD",
  "bidCount": 7,
  "winnerUsername": "96firechicken"
}
```

### Use cases

| Use case | What you get |
| :--- | :--- |
| **Who is live now** | Current eBay Live rooms with host and viewer counts |
| **Show lineup** | Scheduled, active, and sold lots inside each stream |
| **Break scouting** | `onlyCaseBreaks` + tags like Raw Cards |
| **Host calendar** | `sellerUsernames` on live + upcoming |
| **Replay archive** | `showStates: ["past"]` with replay URLs |
| **Schedule alert** | `monitorMode` — only new show IDs on later runs |
| **Comps workflow** | Spot a Live niche, then run eBay Sold listings for the same keyword |

### 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-live-shows-scraper').call({
  showStates: ['live'],
  maxItems: 50,
  includeListings: true,
  proxyConfiguration: {
    useApifyProxy: true,
    apifyProxyGroups: ['RESIDENTIAL'],
  },
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0]);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_APIFY_TOKEN")
run = client.actor("crawloop/ebay-live-shows-scraper").call(
    run_input={
        "showStates": ["live"],
        "maxItems": 50,
        "includeListings": True,
        "proxyConfiguration": {
            "useApifyProxy": True,
            "apifyProxyGroups": ["RESIDENTIAL"],
        },
    }
)
items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(len(items), items[:3])
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/crawloop~ebay-live-shows-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "showStates": ["live"],
    "maxItems": 50,
    "includeListings": true,
    "proxyConfiguration": {
      "useApifyProxy": true,
      "apifyProxyGroups": ["RESIDENTIAL"]
    }
  }'
```

### 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-live-shows-scraper`.

Example prompts:

- "Run eBay Live Shows Scraper for currently live streams and return title, host, watchedCount, and tags as JSON"
- "Scrape upcoming eBay Live shows for seller cardvaultbreaks and list start times"
- "Get the in-show lineup listings (scheduled, active, sold) for currently live eBay Live rooms"
- "Chain eBay Live Shows Scraper then eBay Sold Listings Scraper for the same collectibles keyword"

### Suite next step

After you know which hosts and categories are live, pull **search listings** with [eBay Active Listings Scraper](https://apify.com/crawloop/ebay-active-listings-scraper), then **sold comps** with [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) or a fair-value report via [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence).

### FAQ

#### Is this the same as eBay Active Listings?

No. [eBay Active Listings Scraper](https://apify.com/crawloop/ebay-active-listings-scraper) scrapes **search listings** (BIN/auction cards). This Actor scrapes **eBay Live livestream shows** on the Live hub.

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

[eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) exports **completed search sales**. [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence) turns those comps into a recommended price. Neither scrapes the Live hub.

#### Does this scrape items inside a show?

Yes — with `includeListings` (on by default). Each lot is a `live_listing` row: scheduled/queued, active on camera, or sold. Chat, websocket bid ticks, and video download are out of scope.

#### Do I need to log in?

No. Public show cards and stream pages are enough. Bidding/chat are not collected.

#### Do I need proxies?

Yes on Apify — **RESIDENTIAL**. Datacenter IPs are often blocked. Local runs can omit proxy.

#### Can I scrape a single event URL?

Yes — paste it in `startUrls` and set `showStates` to an empty list so the hub feeds are skipped.

#### What is `enrichDetails`?

One extra request per show to the stream page. Adds host feedback, concurrent viewers, `vendorEventId`, and replay URL when eBay exposes them.

#### Does this download the video?

No. Rows may include HLS playlist URLs (`liveUrl`, `replayUrl`) as metadata only.

#### Why did I get fewer rows than `maxItems`?

The live hub is small (dozens of concurrent shows, not thousands of search listings). `maxItems` caps **shows**; lineup lots are extra (`maxListingsPerShow`). Filters (seller, tag, case-break) also reduce the set.

### Related Actors

| Actor | Use for |
| :--- | :--- |
| **eBay Live Shows Scraper** ◄── you are here | Livestream shows, hosts, viewers |
| [eBay Active Listings Scraper](https://apify.com/crawloop/ebay-active-listings-scraper) | Live BIN/auction asking prices |
| [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) | Completed sold comps |
| [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence) | Recommended price and demand score |
| [Whatnot Listings Scraper](https://apify.com/crawloop/whatnot-listings-scraper) | Whatnot live-commerce listings |
| [Goldin Auctions Scraper](https://apify.com/crawloop/goldin-scraper) | High-end sports cards / TCG hammer |
| [PriceCharting Scraper](https://apify.com/crawloop/pricecharting-scraper) | Guide prices for games, TCG, comics |

# Actor input Schema

## `showStates` (type: `array`):

Which eBay Live hub feeds to scrape. Live now = currently streaming. Upcoming = scheduled. Past = recorded replays. Clear this list to scrape only pasted URLs / channels / sellers.

## `sellerUsernames` (type: `array`):

Keep only shows hosted by these eBay usernames (no @). Applied to hub feeds and start URLs.

## `channelIds` (type: `array`):

eBay Live channel IDs from /d/ebaylive/channels/{id}. Each channel feed is scraped in addition to show states.

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

eBay Live event, hub, live/upcoming/past feed, seller, or channel URLs. Event links look like https://www.ebay.com/ebaylive/events/{id}/stream

## `tagNames` (type: `array`):

Keep shows that have at least one of these eBay Live tags (e.g. $1 Starts, Raw Cards, Electronics).

## `onlyCaseBreaks` (type: `boolean`):

Keep shows flagged as case breaks (isCaseBreak).

## `enrichDetails` (type: `boolean`):

Fetch each show's stream page for host feedback, concurrent viewers, vendor event ID, and replay URL. Off by default for speed.

## `includeListings` (type: `boolean`):

After each show, fetch in-show lots (scheduled/queued, active on camera, sold). One dataset row per listing.

## `maxListingsPerShow` (type: `integer`):

Cap lineup lots fetched per show (eBay returns up to 1000). 0 = up to 1000.

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

Maximum show rows to collect across all feeds and URLs. 0 = unlimited. Lineup listing rows are extra and do not count toward this cap.

## `monitorMode` (type: `boolean`):

On a schedule, push and charge only show IDs not seen in a previous run. First run delivers the full match set (baseline).

## `monitorStoreName` (type: `string`):

Named Key-Value store for seen show IDs across scheduled runs. Use a distinct name per watch (e.g. live-breaks vs luxury-hosts).

## `resetMonitorState` (type: `boolean`):

Clear the seen-ID cache before this run (next run becomes a new baseline).

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

Recommended on Apify: RESIDENTIAL. Datacenter IPs are often blocked by eBay. Local runs can leave proxy off.

## Actor input object example

```json
{
  "showStates": [
    "live"
  ],
  "onlyCaseBreaks": false,
  "enrichDetails": false,
  "includeListings": true,
  "maxListingsPerShow": 200,
  "maxItems": 50,
  "monitorMode": false,
  "monitorStoreName": "ebay-live-shows-monitor",
  "resetMonitorState": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Default dataset items.

# 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 = {
    "showStates": [
        "live"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawloop/ebay-live-shows-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/HwHSleV0g5QMJDowQ/builds/8XuAnYUMaByafgaEi/openapi.json