# Whatnot Scraper - Listings, Live Shows and Sellers (`dami_studio/whatnot-scraper`) Actor

Search Whatnot like its own search box and get rows: listings with price, format, status and seller; live and upcoming shows with viewers and start time; seller profiles with followers, sold count and rating. Every filter Whatnot's search offers. No login or API key.

- **URL**: https://apify.com/dami\_studio/whatnot-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** E-commerce, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.95 / 1,000 result returneds

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?

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

## Whatnot Scraper

Search Whatnot the way its own search box works and get the results as rows. You pick one of three things:

- **Listings**: the item, its price and currency, Buy It Now or auction, status, quantity, the current bid, the category, and the seller with their rating.
- **Live shows**: the title, the seller, categories and tags, when it starts, whether it's live now or coming up, and how many people are watching.
- **Sellers**: username, followers, items sold, rating and number of reviews, whether they're live right now, and how many days they usually take to ship.

No Whatnot account and no API key. It reads the same search a visitor who isn't logged in gets.

### Worth knowing before you run it

**Whatnot only lets a search go so deep.** It will tell you a search has 10,000 listings, then stop handing them over after roughly the first thousand. When that happens the status message says so. More specific words, or a category, get you further.

**Prices stay in the seller's currency.** Whatnot has sellers in the US, the UK, Canada, Australia, much of Europe and Japan, and a card priced in yen stays in yen. One search can mix six currencies. If you need one, pick a single country under Ships from.

**Viewer counts move while you read them.** Whatnot orders shows by viewers at the moment it builds the list, and the counts keep changing, so a "most viewers" run comes back roughly in order. In one check of 100 live shows, 38 steps went up instead of down, most of them by fewer than ten viewers.

**It's a snapshot.** You get the listings for sale when the run happens, and shows that are live or scheduled. Finished shows and past sale prices aren't in it.

### Input

**What to get.** Listings, Live shows or Sellers.

**Search words.** One search per line, as you'd type it on Whatnot: `pokemon`, `jordan 1`, `funko pop`.

**Seller usernames.** With or without the @, or a link to the profile. What they do depends on what you're getting:

| What to get | With seller usernames |
|---|---|
| Listings | what's in each seller's shop, searched with your words if you gave any |
| Live shows | each seller's live and upcoming shows (search words aren't used here) |
| Sellers | each seller's profile; search words find more sellers on top |

**Results per search** caps what one search word or one seller brings back (100 unless you change it). **Results in total** caps the whole run (1,000 unless you change it, 10,000 at most).

```json
{
  "searchFor": "listings",
  "keywords": ["charizard"],
  "buyingFormat": "buyItNow",
  "shipsFrom": ["US"],
  "minPrice": 20,
  "maxPrice": 150,
  "sortBy": "priceLowToHigh",
  "maxResultsPerSearch": 200
}
```

#### Filters

The same choices Whatnot's filter panel offers.

| Filter | Listings | Live shows |
|---|---|---|
| Category | yes | yes |
| Minimum seller rating (4.0, 4.5, 5 stars) | yes | yes |
| Premier shops only | yes | yes |
| Ships from | yes | yes |
| Buying format: Buy It Now or auction | yes | |
| Minimum and maximum price | yes | |
| Condition | yes | |
| Graded only, Autographed only | yes | |
| More item details: Language, Set, Rarity, Grade, Grading Service and so on | yes | |
| Show status: live now or upcoming | | yes |
| Show format: auction, breaks, Buy It Now, graded, singles, surprise sets | | yes |
| Brands, Tags | | yes |
| Sort | price, newly listed | viewers |

Categories, brands and tags go by name, the way Whatnot shows them, such as `Pokémon Cards`. Each search looks the name up in Whatnot's own panel for that search, so a category also brings in everything under it. If Whatnot doesn't offer your category for a search, that search returns nothing and the status says which one. You won't get other categories instead.

Condition and the item details are labels sellers type themselves, so "Near Mint" and "near mint" both exist. The actor sends every spelling of what you wrote.

A price range is in each listing's own currency, and Whatnot compares it in hundredths. That's right for dollars, pounds and euros. Yen have no hundredths, so for yen listings set Ships from to Japan alone and give the range in yen. In any other price-range search, yen listings are left out rather than returned at a price you didn't ask for.

### Output

One row per listing, show or seller. The dataset has a view for each.

**Listings**

| Field | Example | Notes |
|---|---|---|
| `title` | `Pokemon CGC 8.5 Dark Steelix #10 Reverse Foil` | |
| `price`, `currency` | `399`, `CAD` | the seller's currency |
| `format` | `buyItNow` | or `auction` |
| `status` | `ACTIVE` | as Whatnot gives it |
| `quantity`, `currentBid`, `bidCount` | `1`, `null`, `null` | bids only on auctions |
| `category` | `Pokémon Cards` | |
| `sellerUsername`, `sellerRating`, `sellerReviews` | `johtojoe`, `5`, `10` | |
| `url` | `https://www.whatnot.com/listing/TGlzdGluZ05vZGU6MjI0NDQzNjk2NQ%3D%3D` | the listing page |

Also `listingId`, `subtitle`, `description`, `inLiveShow`, `labels`, `sellerPremierShop`, `imageUrl`, `sellerUrl`, `searchedFor` and `scrapedAt`.

**Live shows**

| Field | Example | Notes |
|---|---|---|
| `title` | `Rapid Fire Sudden Death Pokemon Slabs` | |
| `sellerUsername`, `sellerRating` | `pokemonwizard`, `5` | |
| `status` | `upcoming` | or `live` |
| `startTime` | `2026-09-14T19:30:00.000Z` | UTC |
| `viewers` | `0` | people watching when the run read it |
| `categories`, `tags` | `["Pokémon Cards"]`, `["Pokémon"]` | |
| `url` | `https://www.whatnot.com/live/2f77a938-46fc-4de9-9c2d-93f739433e14` | |

Also `showId`, `sellerReviews`, `sellerPremierShop`, `thumbnailUrl`, `sellerUrl`, `searchedFor` and `scrapedAt`.

**Sellers**

| Field | Example | Notes |
|---|---|---|
| `username`, `displayName` | `pokemonwizard`, `Wiz` | |
| `followers`, `following` | `290403`, `753` | |
| `soldCount` | `362724` | empty for accounts that haven't sold |
| `rating`, `reviews` | `5`, `65709` | |
| `isLive`, `verifiedSeller`, `premierShop` | `false`, `false`, `true` | |
| `averageShipDays` | `1` | |
| `url` | `https://www.whatnot.com/user/pokemonwizard` | |

Also `bio`, `profileImageUrl`, `userId`, `searchedFor` and `scrapedAt`.

The run also leaves `RUN_REPORT` in its key-value store: each search with what Whatnot listed and what came back, filters Whatnot didn't offer, rows skipped and why, and why the run stopped.

### What you pay

Each row in your dataset is one charge, whether it's a listing, a show or a seller. Nothing else costs anything: not a search that finds nothing, not a search Whatnot didn't answer, not a row that didn't match your filters, and not a repeat of something you already got in the same run. If you set a maximum charge for the run, it stops when that's reached, and every row you get has been paid for. The price is on the Pricing tab.

### Limits

- 20 search words, 100 seller usernames and 500 searches per run. Usernames times words counts as searches when you give both for listings.
- 10,000 rows per run.
- Expect a minute or two before the first rows arrive. Whatnot usually makes a new run wait before it answers, and the actor waits and asks again rather than giving up, for up to about five minutes at a time. You aren't charged for the wait.
- Once it's going, it reads one page of up to 50 at a time, about one page a second, so 1,000 listings take around half a minute more.
- Searches Whatnot still won't answer are named in the status, and nothing is charged for them.

### Where the data comes from

Whatnot's public search, the one its website uses for visitors who aren't logged in. Whatnot has nothing to do with this actor. Its terms of service restrict automated use of the app, so check them against what you plan to do with the data.

### Questions

**Can I watch a seller's shop every day?** Put the username under Seller usernames, choose Listings, and schedule the actor. Each run returns what's in the shop that day.

**Why did I get fewer rows than Whatnot's count?** Either Whatnot stopped handing results over (the status says so), or rows didn't match your filters and were skipped (the status says how many), or you hit Results per search.

**Why is a price in CAD or JPY?** Each listing keeps the seller's own currency. Use Ships from to keep to one country.

**Does it log in or see anything private?** No. It sees what a visitor who isn't logged in sees.

# Actor input Schema

## `searchFor` (type: `string`):

Listings are items for sale. Live shows are Whatnot's streams, live now or scheduled. Sellers are profiles with followers, items sold and rating.

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

What you'd type into Whatnot's search box, one search per line. Leave it empty if you only want the sellers below.

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

Whatnot usernames, with or without the @, or links to their profiles. For listings you get what's in each seller's shop (searched with your words if you gave any). For live shows, each seller's live and upcoming shows. For sellers, their profiles.

## `maxResultsPerSearch` (type: `integer`):

The most rows from one search word or one seller. Whatnot itself stops a listing search after roughly the first thousand results.

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

The most rows in the whole run. Each row returned is one charge.

## `category` (type: `array`):

Category names as Whatnot shows them, such as Pokémon Cards or Sneakers. Each search uses the ones Whatnot offers for it. A search where none of yours appear returns nothing, rather than other categories.

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

Only sellers rated at least this well.

## `premierShopsOnly` (type: `boolean`):

Only sellers Whatnot has made Premier Shops.

## `shipsFrom` (type: `array`):

Only sellers shipping from these countries. Leave it empty for all.

## `sortBy` (type: `string`):

Price and newly listed are for listings, viewers for live shows. Whatnot sorts prices as numbers, so a list that mixes currencies isn't in true price order; pick one country under Ships from if that matters.

## `buyingFormat` (type: `string`):

Buy It Now items, or items sold at auction in a live show.

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

In each listing's own currency, such as 10 for $10.00 or €10.00.

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

In each listing's own currency. Yen listings rarely fit a range meant for dollars; see the README.

## `condition` (type: `array`):

Condition labels as sellers write them, such as Near Mint, New or Used. Whatnot matches the label, so spelling counts.

## `gradedOnly` (type: `boolean`):

Only items the seller marked as graded.

## `autographedOnly` (type: `boolean`):

Only items the seller marked as autographed.

## `itemDetails` (type: `object`):

Other details Whatnot filters on, by name, for example {"Language": \["Japanese"], "Set": \["Base Set"]}. For trading cards Whatnot offers Language, Product Type, Set, Card Number, Rarity, Grade, Grading Service and Cert. Other categories can have their own.

## `showStatus` (type: `string`):

Shows streaming right now, or shows scheduled for later.

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

The kind of show, as the seller set it up.

## `brands` (type: `array`):

Brands Whatnot tags shows with, such as Disney or Nike.

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

Show tags as Whatnot shows them, such as $1 Starts or Vintage.

## Actor input object example

```json
{
  "searchFor": "listings",
  "keywords": [
    "pokemon"
  ],
  "maxResultsPerSearch": 50,
  "maxResults": 100,
  "minSellerRating": "any",
  "premierShopsOnly": false,
  "sortBy": "relevance",
  "buyingFormat": "any",
  "gradedOnly": false,
  "autographedOnly": false,
  "showStatus": "any"
}
```

# Actor output Schema

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

One row per listing, live show or seller, depending on what you searched for.

## `report` (type: `string`):

What each search found and returned, filters Whatnot didn't offer, rows skipped and why, and why the run stopped.

# 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": [
        "pokemon"
    ],
    "maxResultsPerSearch": 50,
    "maxResults": 100
};

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

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

```

## MCP server setup

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