# Whatnot Scraper (`easyapi/whatnot-scraper`) Actor

Scrape Whatnot search results, seller profiles, reviews, live shows, shop listings, and categories.

- **URL**: https://apify.com/easyapi/whatnot-scraper.md
- **Developed by:** [EasyApi](https://apify.com/easyapi) (community)
- **Categories:** Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

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 Scraper

Turn Whatnot into structured marketplace data. Search by keyword or search URL for listings, live shows, and sellers. Look up known sellers for profile stats, buyer reviews, upcoming / live shows, and shop inventory. Browse top-level categories or trending livestream tags with viewer counts. Built for card dealers, resellers, lead gen, and market research — no Whatnot account required.

### Features

- **Three modes** — `search`, `seller`, and `category` in one Actor
- **Search** — keywords or pasted search URLs; verticals: `PRODUCT`, `LIVESTREAM`, `USER`, `CATEGORY`, `UNIVERSAL`
- **Seller profiles** — followers, sold count, rating, shipping days, verification, bio
- **Buyer reviews** — overall / shipping scores, text, date, seller reply
- **Live & upcoming shows** — title, status, viewers, start time
- **Shop listings** — buy-it-now and auction asking prices from a seller shop
- **Categories** — top-level category list, or trending tags sorted by viewers
- Optional Cookie header for signed-in sessions (public data works without it)
- Export Dataset as JSON, CSV, Excel, or Google Sheets

### Modes

#### Search

Use `searchQueries` and / or `searchUrls`. Text queries use the `vertical` field; each search URL keeps its own `query` and `searchVertical` from the link.

| Vertical | Typical rows |
| --- | --- |
| `PRODUCT` | Listings (buy-it-now / auction) |
| `LIVESTREAM` | Live and recent shows |
| `USER` | Seller / user accounts |
| `CATEGORY` | Related tags / categories |
| `UNIVERSAL` | Mixed feed |

Include toggles (`includeListings`, `includeLivestreams`, `includeUsers`, `includeCategories`) filter which result types are kept for text queries. Users and categories are off by default so listing / show searches stay clean.

#### Seller

Pass `usernames` (or profile URLs) and / or numeric / Relay `userIds`. Toggle profile, reviews, shows, and shop independently. Optional `query` filters shop listings by text. `showStatus` filters shows to `live`, `upcoming`, or `all`.

#### Category

- `list` — top-level marketplace categories
- `trending` — livestream tags with `viewerCount` / `livestreamCount` (sortable)

### Input

| Field | Mode | Default | Description |
| --- | --- | --- | --- |
| `mode` | All | `search` | `search`, `seller`, or `category` |
| `searchQueries` | Search | — | Keywords, each run separately |
| `searchUrls` | Search | — | Whatnot search page URLs |
| `vertical` | Search | `PRODUCT` | Result type for text queries |
| `includeListings` / `includeLivestreams` | Search | `true` | Keep listings / shows |
| `includeUsers` / `includeCategories` | Search | `false` | Keep users / tags |
| `maxResultsPerQuery` | Search | `100` | Cap per query and per URL |
| `usernames` / `userIds` | Seller | — | Sellers to look up |
| `includeProfile` / `includeShows` / `includeReviews` | Seller | `true` / `true` / `true` | Sections to fetch |
| `includeShop` | Seller | `false` | Active shop listings |
| `query` | Seller | — | Optional shop text filter |
| `maxReviews` / `maxListings` / `maxShows` | Seller | `50` / `50` / `25` | Per-seller caps |
| `showStatus` | Seller | `all` | `live`, `upcoming`, or `all` |
| `categoryView` | Category | `list` | `list` or `trending` |
| `maxCategories` | Category | `50` | Category / tag cap |
| `sortBy` | Category | `VIEWER_COUNT` | Trending sort |
| `cookies` | All | — | Optional Cookie header |
| `proxyConfiguration` | All | — | Proxies recommended for production |

#### Example — search listings

```json
{
  "mode": "search",
  "searchQueries": ["pokemon cards"],
  "vertical": "PRODUCT",
  "maxResultsPerQuery": 20,
  "includeListings": true
}
```

#### Example — seller with reviews and shop

```json
{
  "mode": "seller",
  "usernames": ["ah_sneakers"],
  "includeProfile": true,
  "includeReviews": true,
  "includeShows": true,
  "includeShop": true,
  "maxReviews": 20,
  "maxListings": 20,
  "maxShows": 10
}
```

#### Example — trending categories

```json
{
  "mode": "category",
  "categoryView": "trending",
  "sortBy": "VIEWER_COUNT",
  "maxCategories": 25
}
```

### Output

One Dataset row per entity. Discriminator field: `type`.

| `type` | Description |
| --- | --- |
| `listing` | Buy-it-now or auction listing (`price`, `currentBid`, `transactionType`, seller, images, `url`) |
| `user` | Search hit for a user / seller |
| `seller` | Full seller profile metrics |
| `review` | Buyer review with ratings and text |
| `livestream` | Live or scheduled show |
| `category` | Category or livestream tag |
| `error` | Skipped / invalid target |

Prices are returned as Whatnot sends them (`amount` / `currency` / `amountSafe`). Treat them as asking prices or bids, not confirmed sale prices. `soldCount` is a seller total, not revenue.

#### Listing example

```json
{
  "type": "listing",
  "id": "TGlzdGluZ05vZGU6MjQ1NDY4MzM0OQ==",
  "title": "Pokemon 30th AR Complete set",
  "transactionType": "BUY_IT_NOW",
  "price": { "amount": 7000, "currency": "JPY", "amountSafe": 7000 },
  "user": { "username": "nako_cardclub_japan" },
  "url": "https://www.whatnot.com/listing/2454683349",
  "searchQuery": "pokemon cards",
  "vertical": "PRODUCT",
  "scrapedAt": "2026-10-23T05:50:00.000Z"
}
```

### Tips

- Start with one query or one username and a small limit (`maxResultsPerQuery: 10`) to validate output shape.
- Residential proxies are recommended for production and higher volume.
- Schedule seller runs daily and diff `soldCount` / `followerCount` between runs to track growth.
- This Actor collects public marketplace data only — not private orders, payouts, or completed sale histories.
- Category deep-dive leaderboards (per-tag ranked sellers) are not included in this version; use `list` / `trending` plus seller mode for follow-up.

### Related use cases

- Price-check a trading card across sellers before buying
- Build a lead list of niche sellers (`vertical: USER`) then enrich with seller mode
- Monitor competitors' ratings, reviews, and upcoming shows on a schedule

# Actor input Schema

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

Choose what to scrape. Fill only the fields for that mode.

• Search: keyword or search-URL results (listings, shows, users, categories).
• Seller: profile, reviews, shows, and optional shop listings.
• Category: top-level category tree.

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

Keywords for Search mode, e.g. "pokemon cards". Each query runs separately against the Search vertical below.

## `searchUrls` (type: `array`):

Whatnot search URLs, e.g. https://www.whatnot.com/search?query=pokemon\&searchVertical=PRODUCT. Each URL keeps its own query and vertical; the vertical toggle below does not apply to URLs.

## `vertical` (type: `string`):

Result type for text queries. Search URLs use their own searchVertical parameter instead.

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

Keep buy-it-now and auction listing rows from search.

## `includeLivestreams` (type: `boolean`):

Keep livestream rows from search.

## `includeProducts` (type: `boolean`):

Keep catalog product stubs when present in the feed.

## `includeUsers` (type: `boolean`):

Keep matching user / seller profiles from search. Off by default for PRODUCT searches.

## `includeCategories` (type: `boolean`):

Keep related category tags from search. Off by default.

## `maxResultsPerQuery` (type: `integer`):

Maximum results for each search query and each search URL (not a run total).

## `usernames` (type: `array`):

Seller usernames, e.g. ah_sneakers. Each seller returns one profile row plus optional reviews / shows / shop rows.

## `userIds` (type: `array`):

Numeric or relay seller IDs. Use instead of, or together with, usernames.

## `includeProfile` (type: `boolean`):

Return profile metrics: bio, rating, followers, sold count, and more.

## `includeShows` (type: `boolean`):

Return the seller's live and upcoming shows.

## `includeReviews` (type: `boolean`):

Return buyer reviews with overall and shipping ratings.

## `includeShop` (type: `boolean`):

Return active shop listings (buy-it-now / auction) when the seller has a public shop feed. Off by default.

## `query` (type: `string`):

Optional. When Include shop listings is on, keep only shop rows whose title matches this text.

## `maxReviews` (type: `integer`):

Maximum buyer reviews for each seller.

## `maxListings` (type: `integer`):

Maximum active shop listings for each seller.

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

Filter seller shows: live (playing), upcoming (scheduled), or all.

## `maxShows` (type: `integer`):

Maximum shows for each seller.

## `categoryView` (type: `string`):

What category data to fetch.

• List: top-level categories with subcategories.
• Trending / Explore / Deep dive: MVP returns the same category tree (leaderboards not included yet).

## `maxCategories` (type: `integer`):

Maximum top-level categories to return.

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

Residential proxies recommended for production.

## Actor input object example

```json
{
  "mode": "search",
  "searchQueries": [
    "pokemon cards"
  ],
  "vertical": "PRODUCT",
  "includeListings": true,
  "includeLivestreams": true,
  "includeProducts": false,
  "includeUsers": false,
  "includeCategories": false,
  "maxResultsPerQuery": 20,
  "usernames": [
    "ah_sneakers"
  ],
  "includeProfile": true,
  "includeShows": true,
  "includeReviews": true,
  "includeShop": false,
  "maxReviews": 50,
  "maxListings": 50,
  "showStatus": "all",
  "maxShows": 25,
  "categoryView": "list",
  "maxCategories": 50
}
```

# Actor output Schema

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

Table view of scraped rows.

## `rawResults` (type: `string`):

All dataset items as JSON.

# 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 = {
    "mode": "search",
    "searchQueries": [
        "pokemon cards"
    ],
    "vertical": "PRODUCT",
    "maxResultsPerQuery": 20,
    "usernames": [
        "ah_sneakers"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("easyapi/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 = {
    "mode": "search",
    "searchQueries": ["pokemon cards"],
    "vertical": "PRODUCT",
    "maxResultsPerQuery": 20,
    "usernames": ["ah_sneakers"],
}

# Run the Actor and wait for it to finish
run = client.actor("easyapi/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 '{
  "mode": "search",
  "searchQueries": [
    "pokemon cards"
  ],
  "vertical": "PRODUCT",
  "maxResultsPerQuery": 20,
  "usernames": [
    "ah_sneakers"
  ]
}' |
apify call easyapi/whatnot-scraper --silent --output-dataset

```

## MCP server setup

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