# Whatnot Live Stream Scraper (`romy/whatnot-livestream-scraper`) Actor

Scrape live and upcoming Whatnot streams by category, tag or keyword: title, viewers, seller, tags and start time, plus each show's shop items with price and format. No account needed.

- **URL**: https://apify.com/romy/whatnot-livestream-scraper.md
- **Developed by:** [Romy](https://apify.com/romy) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.01 / 1,000 live stream rows

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Whatnot Live Stream Scraper

**Whatnot Live Stream Scraper** collects live and upcoming [Whatnot](https://www.whatnot.com) streams by category, tag or keyword — title, current viewers, start time, tags, categories, seller and thumbnail — and can also pull every item being sold in each show's shop (price, buy-it-now or auction, quantity, images). It reads the same public data the Whatnot mobile app shows to a signed-out user, so no account, app or device is needed.

Spun off from the [Whatnot All-in-One API](https://github.com/RomySaputraSihananda/whatnot-all-in-one-api) for teams that want a run-and-export dataset instead of a live standby API.

### Why use this Actor?

- **Live-commerce monitoring** — which shows are live in a category right now, and how many people are watching.
- **Seller and lead discovery** — find active sellers (with rating and verification) in a niche such as trading cards.
- **Market research** — what is being sold in live shows: formats, prices, quantities.
- **Trend tracking** — schedule it to see how viewer counts and categories move over the day.

### Input

| Field                                   | Description                                                                                                                                                   |
| --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `mode`                                  | `discover` (live feeds) or `search` (keyword search over live and upcoming shows).                                                                            |
| `categories`, `tags`                    | Discover mode: category ids (e.g. `149` = Trading Card Games) and tag ids. Each id is one source. With none of them, the logged-out **For You** feed is read. |
| `queries`                               | Search mode: keywords. Each keyword is one source.                                                                                                            |
| `status`, `sort`                        | Search mode: `PLAYING` (live) or `CREATED` (scheduled); sort by viewers (approximate: counts change while paging).                                            |
| `maxStreamsPerSource`                   | New streams to collect per category, tag or keyword (default 100).                                                                                            |
| `minViewers`                            | Keep only streams with at least this many viewers right now.                                                                                                  |
| `includeShopItems`, `maxItemsPerStream` | Also output each stream's shop items (default off, up to 50 per stream).                                                                                      |

Category and tag ids come from the [Whatnot All-in-One API](https://github.com/RomySaputraSihananda/whatnot-all-in-one-api)'s `GET /categories` and `GET /tags`.

#### How it handles Whatnot's feeds

- Live feeds are **re-ranked on every page**, so a stream can repeat: rows are de-duplicated by id, across pages **and across sources** (a stream is output once, under the first source that found it).
- Category and tag feeds **never report the end of the list**, so collection stops when a page brings no new streams (or at `maxStreamsPerSource`).

### Output

One dataset row per stream, and — with `includeShopItems` — one row per shop item:

```json
{
    "recordType": "livestream",
    "sourceType": "category",
    "sourceValue": "149",
    "scrapedAt": "2026-09-21T02:30:00.000Z",
    "id": "0d7bfba5-0080-46ef-a96e-2ca74cee7e21",
    "title": "MASSIVE TECH SHOW",
    "status": "PLAYING",
    "activeViewers": 515,
    "startTime": 1789907302538,
    "tags": [{ "label": "Gaming" }],
    "user": { "username": "example_seller", "sellerRating": { "overall": 4.8 }, "isVerifiedSeller": false }
}
```

```json
{
    "recordType": "listing",
    "livestreamId": "0d7bfba5-0080-46ef-a96e-2ca74cee7e21",
    "title": "3 CHANNEL 4K DASHCAM",
    "price": { "amountMinor": 100, "currency": "USD" },
    "transactionType": "AUCTION",
    "listingStatus": "created",
    "quantity": 86
}
```

Money is `{ amountMinor, currency }` in minor units (44000 USD = $440.00) in the seller's own currency.

### Pricing / Cost estimation

Billed **pay-per-event**: a flat run-start fee plus one `livestream` event per stream row and one `listing` event per shop-item row actually saved. Example: 100 streams without shop items = 100 `livestream` events. See the Actor's page for the current per-event prices.

### What is not available

Whatnot does not expose to signed-out users: **past shows**, **sold prices and bid history**, followers, or personalized feeds. Only live and scheduled shows are returned.

### FAQ, disclaimers, and support

This is an **unofficial** Actor, not affiliated with or endorsed by Whatnot Inc. It reads only data that Whatnot shows to signed-out users in its own app; no credentials, private data or bypassed authentication are involved. Use responsibly and in line with Whatnot's Terms of Service and applicable law.

Found an issue or need a custom field? Use the **Issues** tab on this Actor's page.

# Actor input Schema

## `mode` (type: `string`):

discover reads live feeds; search runs a keyword search over live and upcoming shows.

## `categories` (type: `array`):

Whatnot category ids, e.g. 149 = Trading Card Games (numeric or global id). Each id is one source. Leave categories and tags empty to read the logged-out For You feed.

## `tags` (type: `array`):

Whatnot tag ids, e.g. 3199 = Gaming (numeric or global id). Each id is one source.

## `queries` (type: `array`):

Keywords to search live and upcoming shows for. Required in search mode.

## `status` (type: `string`):

Only shows that are live now or scheduled. Leave empty for both. Search mode only.

## `sort` (type: `string`):

Order by current viewers. Leave empty for best match. Search mode only.

## `maxStreamsPerSource` (type: `integer`):

Stop each category, tag or keyword after this many new streams. Streams already returned by an earlier source are skipped.

## `minViewers` (type: `integer`):

Only keep streams with at least this many viewers right now.

## `includeShopItems` (type: `boolean`):

Also output the items being sold in each stream (price, title, buy-it-now or auction, quantity). Billed as separate rows.

## `maxItemsPerStream` (type: `integer`):

Only used with Include shop items.

## Actor input object example

```json
{
  "mode": "discover",
  "categories": [
    "149"
  ],
  "maxStreamsPerSource": 20,
  "minViewers": 0,
  "includeShopItems": false,
  "maxItemsPerStream": 50
}
```

# Actor output Schema

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

No description

# 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 = {
    "categories": [
        "149"
    ],
    "maxStreamsPerSource": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("romy/whatnot-livestream-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 = {
    "categories": ["149"],
    "maxStreamsPerSource": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("romy/whatnot-livestream-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 '{
  "categories": [
    "149"
  ],
  "maxStreamsPerSource": 20
}' |
apify call romy/whatnot-livestream-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,romy/whatnot-livestream-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/rrPtavaaiPXonk3d2/builds/hwWInoUNgpchmoyL4/openapi.json
