# 🚀 Whatnot Livestream Scraper · 5,000 Free Shows/Month (`omkar-cloud/whatnot-livestream-scraper`) Actor

Whatnot Livestream Scraper gets you Whatnot live shows ⚡ fast, 🎯 100% accurate and 🔍 ridiculously detailed — viewers, start times, categories, tags, hosts and shop items. 💰 $1 per 1,000 shows, no start fee. Scrape your first 5,000 shows free every month 🚀

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

## Pricing

from $1.00 / 1,000 show or shop item 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/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 Livestream Scraper

Whatnot Livestream Scraper by Omkar Cloud gets you 🎯 accurate, 🔍 detailed data on Whatnot live and upcoming shows.

Whatnot is built for watching on a phone, not for exporting. There is no download button for who is live, how many people are watching, or what is in each show's shop.

Whatnot Livestream Scraper gets you that data as clean JSON, CSV or Excel, so you can successfully complete your project.

**$1 per 1,000 shows.** And with Apify's free plan you get $5 of credit every month, so your first **~5,000 shows each month are free**.

This is an excellent Actor made by Omkar Cloud, which is Rated Excellent — [4.7 based on 30 reviews on Trustpilot](https://www.trustpilot.com/review/omkar.cloud).

👉 [**Try Whatnot Livestream Scraper free**](https://apify.com/omkar-cloud/whatnot-livestream-scraper) — your first ~5,000 shows are Free.

### What can I get

- 🔍 **Shows by keyword** — every live and upcoming show matching "pokemon", "jordan 1", "funko"…
- 🗂️ **Shows by category** — sports cards, sneakers, Pokémon cards, or any other Whatnot category
- 👀 **Live numbers** — viewers right now, saves, start time, live or upcoming status
- 🧑‍💼 **The host** — username, rating, review count, verified and Premier Shop flags
- 🏷️ **Categories & tags** — plus language and ships-from country of every show
- 🛒 **Shop items (optional)** — title, price, quantity, buying format, flash sales, breaks and auction rules of the items in each show's shop
- 🎛️ **Filters** — status, sort by viewers, show format, tags, seller rating, Premier Shops, seller country

### Why Whatnot Livestream Scraper

Most other Whatnot scrapers fail you in one of four ways:

- 🗄️ **Inaccurate, cached, stale data** — useless for a live marketplace
- 🧩 **Low-detail data** — a title and a link, never the full picture
- 💸 **Pay more to get the same data** — $2–$3 per 1,000 results, plus a fee every time a run starts
- 🪦 **Works today, breaks next month** — nobody maintains it

Whatnot Livestream Scraper is scraped live on every run, priced honestly, and actively maintained.

### Input Examples

**Live Pokémon shows, biggest audience first**

```json
{
  "searchQueries": ["pokemon"],
  "status": "live",
  "sort": "viewers_high_to_low",
  "maxResults": 100
}
```

**Upcoming shows in two categories, top-rated US sellers only**

```json
{
  "categories": ["sports_cards", "https://www.whatnot.com/tag/sneakers_streetwear"],
  "status": "upcoming",
  "minSellerRating": "4.5",
  "sellerCountry": "US",
  "maxResults": 500
}
```

**Live auction shows with the items in each shop**

```json
{
  "searchQueries": ["funko"],
  "status": "live",
  "showFormat": ["auction"],
  "includeShopItems": true,
  "maxItemsPerShow": 50,
  "maxResults": 20
}
```

| Field | What it does |
|---|---|
| `searchQueries` | Keywords — each is searched separately |
| `categories` | Category slugs (`sports_cards`) or whatnot.com category links |
| `status` | `all` (default — live and upcoming), `live` or `upcoming` |
| `sort` | `recommended` (default), `viewers_high_to_low`, `viewers_low_to_high` |
| `showFormat` | Any of `auction`, `breaks`, `buy_it_now`, `graded`, `singles`, `mystery_bags` |
| `tag` | Comma-separated show tag IDs (every show row lists its `tag_ids`) |
| `minSellerRating` | `4`, `4.5` or `5` |
| `premierShopOnly` | Keep only Whatnot Premier Shop sellers |
| `sellerCountry` | Comma-separated 2-letter codes, e.g. `US,GB` |
| `maxResults` | Max shows per keyword or category (default 100) |
| `includeShopItems` | Also scrape the items in every show's shop (default off) |
| `maxItemsPerShow` | Max shop items per show (default 50) |

Add at least one keyword or one category. A show found by two inputs is returned — and billed — only once.

### Example: A Whatnot Show

```json
{
  "type": "livestream",
  "search_query": "pokemon",
  "source_category": null,
  "id": "dc46af2c-5e85-496c-9011-82c053949cb0",
  "title": "🇺🇸 Vintage Mayhem 🎥 Primed Up Boxes $1 Starts w/ Zack",
  "link": "https://www.whatnot.com/live/dc46af2c-5e85-496c-9011-82c053949cb0",
  "status": "live",
  "is_live": true,
  "viewer_count": 155,
  "saved_count": 354,
  "language_code": "en",
  "language_name": "English",
  "ships_from_country": "US",
  "is_explicit": true,
  "is_hidden": false,
  "categories": ["Pokémon Cards"],
  "category_slugs": ["pokemon_cards"],
  "product_categories": ["Pokémon Cards"],
  "tags": ["Pokémon", "$1 Starts", "Vintage"],
  "tag_slugs": ["pokemon", "one_dollar_starts", "vintage"],
  "tag_ids": [97, 2290, 33],
  "seller_id": 1944023,
  "seller_username": "collectibletags",
  "seller_link": "https://www.whatnot.com/user/collectibletags",
  "seller_rating": 5.0,
  "seller_review_count": 70710,
  "seller_is_live": true,
  "seller_is_verified": false,
  "seller_is_premier_shop": true,
  "starts_at": "2026-10-05T07:27:36Z",
  "ended_at": null
}
```

### Example: A Shop Item

Turn on **Include Shop Items** and every item in a show's shop becomes its own row, linked to its show by `livestream_id`.

```json
{
  "type": "shop_item",
  "livestream_id": "a6ed3616-7e21-4829-a1cd-48d4b7397c73",
  "livestream_title": "🇺🇸 💥DAY6! 30TH BREAKS AND WILD JAPANESE BOX BREAKS! W BIG O!",
  "id": 2314960298,
  "title": "*0. 1 x Japanese 30th Anniversary Booster Box",
  "subtitle": "New ∙ Japanese",
  "description": "One booster box rip or shipped sealed.",
  "link": "https://www.whatnot.com/listing/TGlzdGluZ05vZGU6MjMxNDk2MDI5OA==",
  "status": "active",
  "buying_format": "buy_it_now",
  "price": 250.0,
  "currency": "USD",
  "quantity": 2,
  "is_live": true,
  "is_pending_payment": false,
  "variants": [],
  "sale_type": "flash_sale",
  "sale_price": 250.0,
  "sale_original_price": 279.0,
  "sale_currency": "USD",
  "sale_is_available_at_full_price": true,
  "sale_ends_at": "2026-10-05T11:15:30Z",
  "accepts_offers": false,
  "product_id": 609713313,
  "structure": "individual_item",
  "auction_duration_seconds": null,
  "auction_is_sudden_death": null,
  "created_at": "2026-09-17T00:45:40Z",
  "updated_at": "2026-10-05T10:45:30Z"
}
```

*Both trimmed for readability* — image links, the host's username on shop items, break details and more are in the full rows. Every row is flat — each value is its own column, so CSV and Excel exports need no clean-up.

### Get Started with 5,000 Free Shows

1. [Hit **Try for Free Button**](https://apify.com/omkar-cloud/whatnot-livestream-scraper) — the input is pre-filled with a "pokemon" search example.
2. Enjoy your data 😎.

### Pricing

High value, Low price.

| What | Price | What you get |
|---|---|---|
| **Show** | **$1 per 1,000** | Title, status, viewers, saves, start time, categories, tags, language, ships-from country and the host with rating |
| **Shop item** (optional) | **$1 per 1,000** | Title, price, quantity, buying format, images, flash sale, variants, break and auction rules |

One price for every Apify plan. No start fee — you pay only for the rows you get.

**What a run costs**

| Run | Rows | Cost |
|---|---|---|
| 100 live Pokémon shows | 100 | $0.10 |
| 1,000 shows across 5 categories | 1,000 | $1.00 |
| 100 shows + 50 shop items each | 100 + 5,000 | $5.10 |
| 10,000 shows | 10,000 | $10.00 |

Control your spend with **Max Shows per Keyword / Category** and **Max Shop Items per Show**.

💡 Apify's free plan includes $5 of credit every month — about **5,000 free shows, every month**.

👉 [**Scrape your first 5,000 shows free**](https://apify.com/omkar-cloud/whatnot-livestream-scraper)

### Run It from Code

Grab your API token from [Integrations Settings here](https://console.apify.com/settings/integrations) and replace `<YOUR_API_TOKEN>` below.

**Python** (`pip install apify-client`)

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("omkar-cloud/whatnot-livestream-scraper").call(run_input={
    "searchQueries": ["pokemon"],
    "status": "live",
    "sort": "viewers_high_to_low",
    "maxResults": 50,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["title"], row["viewer_count"], row["seller_username"])
```

**Node.js** (`npm install apify-client`)

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('omkar-cloud/whatnot-livestream-scraper').call({
    categories: ['sports_cards'],
    includeShopItems: true,
    maxResults: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### FAQs

#### How much does it cost?

$1 per 1,000 rows. A show is one row; a shop item (only when you turn on Include Shop Items) is one row. There is no start fee and no monthly rental, and the price is the same on every Apify plan. Apify's free plan gives you $5 of credit a month, which is about 5,000 shows.

#### Does it include live bid amounts?

No. For auction items you get the auction rules — the timer length (`auction_duration_seconds`), whether it is sudden death (`auction_is_sudden_death`) — and the starting price in `price`. The running bid is not included: `current_bid` and `bid_count` are in the output but are empty for almost every item.

#### Can I get upcoming shows, not just live ones?

Yes. Show Status defaults to live and upcoming together. Set it to Live now only or Upcoming only to narrow it down. Upcoming shows carry their scheduled time in `starts_at` and 0 viewers.

#### How do I find a category slug?

Open the category on whatnot.com — the slug is the last part of the link (`whatnot.com/tag/sports_cards` → `sports_cards`). You can also paste the whole link. Every show row lists its own `category_slugs`, so one run gives you slugs for the next.

#### How do I tell shows and shop items apart?

Every row has a `type` column: `livestream` or `shop_item`. Shop items carry `livestream_id`, `livestream_title` and the host's `seller_username`, so you can join them back to their show. The dataset also has ready-made **Livestreams** and **Shop Items** views.

#### Will I be billed twice for the same show?

No. If two keywords or categories find the same show, it is returned and billed once per run.

#### Are some columns empty?

Yes, and honestly so: you get what Whatnot shows publicly. Columns such as `max_shipping_cost`, `has_free_shipping`, `labels`, `compare_at_price` and `bookmark_count` are filled only when Whatnot publishes them for that show or item, which is rare.

#### How fresh is the data?

Every run scrapes Whatnot live. Viewer counts and statuses are the values at the moment of the run. Schedule the Actor on Apify to track shows over time.

#### Which formats can I export?

JSON, CSV, Excel, XML and HTML, or read the dataset through the Apify API.

### 💬 Have Questions? We Have Answers.

[![Message Us on WhatsApp](https://raw.githubusercontent.com/omkarcloud/assets/master/images/whatsapp-us.png)](https://api.whatsapp.com/send?phone=918178804274\&text=I%20need%20help%20with%20using%20the%20Whatnot%20Livestream%20Scraper%20Actor.)
[![Ask Us on Email](https://raw.githubusercontent.com/omkarcloud/assets/master/images/ask-on-email.png)](mailto:happy.to.help@omkar.cloud?subject=Help%20with%20Whatnot%20Livestream%20Scraper%20Actor\&body=I%20need%20help%20with%20using%20the%20Whatnot%20Livestream%20Scraper%20Actor.)
You are important to us — just message us and we will solve your problem ✅ within 1 working day. 🩷 Pinky Promise 🤙!

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords matched against Whatnot shows — each is searched separately. Rows carry a `search_query` field so you can tell keywords apart. Leave empty to scrape only categories.

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

Category slugs (the last part of a whatnot.com/tag/… link, e.g. `sports_cards`) or full whatnot.com category links. Rows carry a `source_category` field.

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

Which shows to return: live right now, scheduled (upcoming), or both.

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

Order of the shows.

## `showFormat` (type: `array`):

Only shows of these formats. Leave empty for every format.

## `tag` (type: `string`):

Only shows carrying these Whatnot show tags: comma-separated tag IDs, max 10 (e.g. `97,2290`). Every show row lists its tags in `tags` with the matching IDs in `tag_ids`.

## `minSellerRating` (type: `string`):

Only shows hosted by sellers rated at least this many stars.

## `premierShopOnly` (type: `boolean`):

Keep only shows hosted by Whatnot Premier Shop sellers.

## `sellerCountry` (type: `string`):

Only sellers shipping from these countries: comma-separated 2-letter country codes, max 10 (e.g. `US,GB`).

## `maxResults` (type: `integer`):

Maximum number of shows to scrape per keyword or category. Use this to control your cost (1,000 shows ≈ $1).

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

When enabled, the items in every show's shop are scraped too — one `shop_item` row per item with title, price, quantity, buying format, sale, break and auction rules. Each shop item is one more row at the same rate (1,000 rows ≈ $1). Runs take longer because each show's shop is fetched separately.

## `maxItemsPerShow` (type: `integer`):

Maximum number of shop items to scrape per show. Only used when Include Shop Items is on.

## Actor input object example

```json
{
  "searchQueries": [
    "pokemon"
  ],
  "categories": [
    "sports_cards",
    "sneakers_streetwear"
  ],
  "status": "all",
  "sort": "recommended",
  "showFormat": [
    "singles",
    "breaks"
  ],
  "tag": "97,2290",
  "minSellerRating": "",
  "premierShopOnly": false,
  "sellerCountry": "US,GB",
  "maxResults": 100,
  "includeShopItems": false,
  "maxItemsPerShow": 50
}
```

# Actor output Schema

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

Every row with every field.

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

Row type, title, status, price, host and link of every show and shop item.

## `livestreams` (type: `string`):

Viewers, start time, categories, tags, language, shipping country and host of every show.

## `shop_items` (type: `string`):

Price, quantity, buying format, sale, break and auction rules of every shop item.

# 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 = {
    "searchQueries": [
        "pokemon"
    ],
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("omkar-cloud/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 = {
    "searchQueries": ["pokemon"],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("omkar-cloud/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 '{
  "searchQueries": [
    "pokemon"
  ],
  "maxResults": 100
}' |
apify call omkar-cloud/whatnot-livestream-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,omkar-cloud/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/S1koZWHkMgsfZOWVU/builds/jpn3Fh8fy5GFthbOY/openapi.json