# Whatnot Scraper - Shows, Listings & Seller Intel (`webdatalabs/whatnot-marketplace-intelligence`) Actor

Scrape Whatnot live-shopping shows, listings with live prices, and seller business intelligence by category, show URL, or seller. HTTP-first, no login. Export CSV/JSON.

- **URL**: https://apify.com/webdatalabs/whatnot-marketplace-intelligence.md
- **Developed by:** [WebDataLabs](https://apify.com/webdatalabs) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 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.
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

## Whatnot Scraper — Live Shows, Listings & Seller Intelligence

Scrape [Whatnot](https://www.whatnot.com) — the fast-growing live-shopping marketplace — for **live and upcoming shows**, the **listings for sale inside them (with prices)**, and **seller business intelligence**. Search by category, show URL, or seller. No login, no browser automation — export to CSV, JSON, or Excel.

### What you get

Whatnot is where resellers and collectors buy and sell trading cards, sports cards, comics, sneakers, coins and more via live streams. This scraper turns that firehose into clean, structured data you can act on:

- **Find live inventory and price it** — what's for sale right now, at what price, in which show, by whom.
- **Track sellers as businesses** — follower count, **total items sold**, rating, review count and Premier-Shop status — the signals that tell you who actually moves volume.
- **Monitor a category** — every live and upcoming show in `trading_card_games`, `sports_cards`, `comics`, `sneakers` and 250+ more.

It reads Whatnot's own data API directly (the same source the site uses), so it returns complete, structured records — not a scrape of rendered HTML that breaks on every redesign.

### Three modes

| Mode | You provide | You get (one flat record each) |
|---|---|---|
| **Shows** | category names | live/upcoming shows: title, seller, status, viewers, start time, categories |
| **Listings** | category names or show URLs | items for sale: title, **price**, currency, auction/buy-now, seller, show |
| **Sellers** | usernames or profile URLs | **followers, items sold, rating, reviews, Premier status**, recent shows |

Turn on **"Also fetch each show's listings"** in Shows mode to get shows *and* their live inventory in one run.

### Example output (seller)

```json
{
  "recordType": "seller",
  "username": "topmtg",
  "url": "https://www.whatnot.com/user/topmtg",
  "followerCount": 16025,
  "soldCount": 30190,
  "sellerRating": 5,
  "reviewCount": 5460,
  "isPremierShop": true,
  "isLive": true,
  "liveShowCount": 1,
  "categories": ["Magic: The Gathering"],
  "recentShows": [
    { "showId": "8adb0fc7-…", "title": "HUGE MARVEL SALE", "status": "PLAYING", "url": "https://www.whatnot.com/live/8adb0fc7-…" }
  ],
  "scrapedAt": "2026-07-04T12:00:00.000Z"
}
````

### Example output (listing)

```json
{
  "recordType": "listing",
  "title": "SINGLES AT $1",
  "price": 1.0,
  "currency": "USD",
  "listingStatus": "ACTIVE",
  "transactionType": "AUCTION",
  "isAuction": true,
  "currentBid": null,
  "currentBidCount": null,
  "quantity": 1,
  "sellerUsername": "nooga_sportscards",
  "sellerRating": 4.9,
  "sellerReviewCount": 1366,
  "showTitle": "$1 START GEM RIP & SHIP",
  "url": "https://www.whatnot.com/listing/…",
  "scrapedAt": "2026-07-04T12:00:00.000Z"
}
```

`price` is the listed / starting price (auctions on Whatnot typically start at $1). `GIVEAWAY` listings have `price: 0`. Live bid values (`currentBid`) update over the auction stream in real time and aren't part of the static catalog — see the FAQ below.

### How to use it (quick start)

1. Pick a **mode** — Shows, Listings, or Sellers.
2. Enter **categories** (e.g. `trading_card_games`), **show URLs**, or **seller usernames**.
3. Set **Max results** and run. Export from the **Shows / Listings / Sellers** dataset views.

### Common questions

#### Which categories can I use?

Any Whatnot category slug, e.g. `trading_card_games`, `sports_cards`, `pokemon_cards`, `comics`, `sneakers`, `coins_and_money`, `electronics`. You can also paste a `/tag/<name>` URL.

#### Does it need a proxy?

Yes — Whatnot's catalog is US-first and anti-bot protected. The actor defaults to Apify **US residential** proxy, which is required. You can change the country under Advanced.

#### Can it get sold prices / live auction bids?

The actor captures each listing's **listed / starting price** (and buy-now prices). Whatnot's **live auction bids and final sold prices** are broadcast in real time over the auction stream and are *ephemeral* — they are not part of the static catalog, so `currentBid` is usually empty. Continuous live-bid and sold-price capture is a separate live-monitor use case.

#### Is this compliant?

The actor collects **public, logged-out marketplace and business data only** — show, listing and seller-shop metrics. It does **not** collect private contact details, buyer identities, or reviewer personal data.

### Leave a review

Is this actor saving you time? A quick review on the Store helps other people find it — and tells us which fields to add next. **[Rate this actor →](https://apify.com/webdatalabs/whatnot-marketplace-intelligence)**

# Actor input Schema

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

Shows = live/upcoming livestreams in a category. Listings = individual items for sale (with live prices) from shows. Sellers = seller business profiles.

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

Whatnot category names, e.g. "trading\_card\_games", "sports\_cards", "comics", "sneakers". Used by the Shows and Listings modes. Accepts a /tag/<name> URL too.

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

Direct Whatnot URLs. For Listings: live show URLs (https://www.whatnot.com/live/<id>). For Sellers: profile URLs (https://www.whatnot.com/user/<name>).

## `sellers` (type: `array`):

Whatnot seller usernames or @handles (e.g. "topmtg"). Used by the Sellers mode.

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

Maximum records to return across all inputs. Keep low for a cheap trial run.

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

In Shows mode, also pull the items for sale (with prices) inside every show. Increases result count and cost.

## `country` (type: `string`):

Residential proxy country. Whatnot's catalog is US-first; keep US for the largest catalog and USD prices.

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

Defaults to Apify residential (required — Whatnot is geo-gated and anti-bot protected).

## `maxRetries` (type: `integer`):

Fresh-IP retries when a request is challenged or throttled.

## `debug` (type: `boolean`):

Verbose logs for blocks, rotations and parse issues.

## Actor input object example

```json
{
  "mode": "shows",
  "categories": [
    "trading_card_games",
    "sports_cards"
  ],
  "startUrls": [
    "https://www.whatnot.com/user/topmtg"
  ],
  "sellers": [
    "topmtg",
    "001spades"
  ],
  "maxItems": 100,
  "includeListings": false,
  "country": "US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxRetries": 6,
  "debug": false
}
```

# Actor output Schema

## `shows` (type: `string`):

No description

## `listings` (type: `string`):

No description

## `sellers` (type: `string`):

No description

## `full` (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": [
        "trading_card_games"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdatalabs/whatnot-marketplace-intelligence").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": ["trading_card_games"] }

# Run the Actor and wait for it to finish
run = client.actor("webdatalabs/whatnot-marketplace-intelligence").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 '{
  "categories": [
    "trading_card_games"
  ]
}' |
apify call webdatalabs/whatnot-marketplace-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=webdatalabs/whatnot-marketplace-intelligence",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Whatnot Scraper - Shows, Listings & Seller Intel",
        "description": "Scrape Whatnot live-shopping shows, listings with live prices, and seller business intelligence by category, show URL, or seller. HTTP-first, no login. Export CSV/JSON.",
        "version": "1.0",
        "x-build-id": "dTClmJxM7DmhIz4Wc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdatalabs~whatnot-marketplace-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdatalabs-whatnot-marketplace-intelligence",
                "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/webdatalabs~whatnot-marketplace-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-webdatalabs-whatnot-marketplace-intelligence",
                "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/webdatalabs~whatnot-marketplace-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-webdatalabs-whatnot-marketplace-intelligence",
                "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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "What to scrape",
                        "enum": [
                            "shows",
                            "listings",
                            "sellers"
                        ],
                        "type": "string",
                        "description": "Shows = live/upcoming livestreams in a category. Listings = individual items for sale (with live prices) from shows. Sellers = seller business profiles.",
                        "default": "shows"
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Whatnot category names, e.g. \"trading_card_games\", \"sports_cards\", \"comics\", \"sneakers\". Used by the Shows and Listings modes. Accepts a /tag/<name> URL too.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Show or seller URLs",
                        "type": "array",
                        "description": "Direct Whatnot URLs. For Listings: live show URLs (https://www.whatnot.com/live/<id>). For Sellers: profile URLs (https://www.whatnot.com/user/<name>).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sellers": {
                        "title": "Seller usernames",
                        "type": "array",
                        "description": "Whatnot seller usernames or @handles (e.g. \"topmtg\"). Used by the Sellers mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum records to return across all inputs. Keep low for a cheap trial run.",
                        "default": 100
                    },
                    "includeListings": {
                        "title": "Also fetch each show's listings",
                        "type": "boolean",
                        "description": "In Shows mode, also pull the items for sale (with prices) inside every show. Increases result count and cost.",
                        "default": false
                    },
                    "country": {
                        "title": "Proxy country",
                        "enum": [
                            "US",
                            "GB",
                            "AU",
                            "DE",
                            "FR"
                        ],
                        "type": "string",
                        "description": "Residential proxy country. Whatnot's catalog is US-first; keep US for the largest catalog and USD prices.",
                        "default": "US"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Defaults to Apify residential (required — Whatnot is geo-gated and anti-bot protected).",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "maxRetries": {
                        "title": "Max retries per request",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Fresh-IP retries when a request is challenged or throttled.",
                        "default": 6
                    },
                    "debug": {
                        "title": "Debug logging",
                        "type": "boolean",
                        "description": "Verbose logs for blocks, rotations and parse issues.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```