# Whatnot Listings Scraper — Live Shop, Prices & Sellers (`crawloop/whatnot-listings-scraper`) Actor

Scrape Whatnot listings by keyword, seller shop, or URL — a Whatnot API alternative for collectors and resellers. Export price, buy-it-now vs auction, condition, live-show flags, and seller ratings as JSON.

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

## Pricing

from $0.89 / 1,000 whatnot listings

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 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 Listings Scraper — Live Shop, Prices & Sellers

> **Disclaimer:** Unofficial tool for publicly accessible Whatnot listings. **Whatnot** and related names are trademarks of Whatnot Inc. Not affiliated with, sponsored by, or endorsed by Whatnot Inc. For informational, research, aggregation, and market-intelligence use only. Respect applicable terms of use and law.

**Whatnot listings scraper** for the live-commerce marketplace — **Pokémon**, **sports cards**, **comics**, **sneakers**, and collectibles. Use it as a **Whatnot scraper**, **Whatnot API alternative**, and **Whatnot seller shop** export: search by **keyword**, walk a **seller username**, or paste **search / listing / profile URLs**. Dataset rows include **price** (major units, not cents), **buy-it-now vs auction**, **condition**, **quantity**, **live-show flags**, **seller rating**, and **image URLs**. Fast **HTTP GraphQL** — **no login**, **no headless browser**. Call from **Python**, **Node.js**, **cURL**, or **Apify MCP**.

Built for **card flippers**, **break hosts**, **reseller pricing**, **seller intelligence**, and **scheduled listing monitors**.

### Collectibles suite

| Actor | Focus |
| :--- | :--- |
| Whatnot Listings Scraper ◄── you are here | Whatnot live-commerce listings and shops |
| [eBay Active Listings Scraper](https://apify.com/crawloop/ebay-active-listings-scraper) | Live eBay BIN / auction asking prices |
| [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) | Completed eBay sold comps |
| [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence) | Recommended price and demand score |
| [Goldin Auctions Scraper](https://apify.com/crawloop/goldin-scraper) | High-end sports cards / TCG hammer + sold |
| [PriceCharting Scraper](https://apify.com/crawloop/pricecharting-scraper) | Guide prices for games, TCG, and comics |

### When to use this Actor

- You need a **Whatnot scraper** / **Whatnot listings scraper** that returns flat JSON rows
- You want **keyword search**, **seller shop walk**, and **pasted Whatnot URLs** in one run
- You track **buy-it-now vs auction**, **live-show inventory**, and **seller ratings**
- You scrape Whatnot with **Python**, **Node.js**, or **MCP** and export JSON / CSV
- You run a **daily monitor** and only want **new listing IDs** billed

### When not to use this Actor

- **eBay sold comps / fair-value reports** — use [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) (then [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence))
- **High-end auction hammer** — use [Goldin Auctions Scraper](https://apify.com/crawloop/goldin-scraper)
- **Official Whatnot Seller API** replacement — this Actor reads the public marketplace GraphQL the website uses, not seller-authenticated mutations
- **Buyer PII, DMs, or order history** — public listing and profile cards only
- **Realtime websocket bid ticks** — catalog snapshots, not in-stream hammer prices

### Key features

- **Keyword search** — `searchKeywords` across Products, Shows, Users, or all tabs
- **Seller shop inventory** — cursor-walk shop listings for a handle, not a capped search page
- **Start URL parsing** — search, listing, `/user/{handle}`, `/live/{id}`, and `/tag/{slug}`
- **Buy format + price filters** — buy-it-now vs auction, min/max price, live-only
- **Flat CSV-friendly rows** — `price` in major units, seller fields on the listing
- **Optional detail enrichment** — extra `getListing` for category, timestamps, offerable, sold counts
- **HTTP GraphQL path** — Chrome TLS impersonation, 256 MB default, no Playwright
- **Monitor mode** — named Key-Value store of seen listing IDs; later scheduled runs emit only new rows
- **Deduplicated IDs** across keywords, shops, and URLs
- **MCP / AI ready** — call from assistants via Apify MCP

### Use cases

| Use case | What you get |
| :--- | :--- |
| **Pokémon / sports-card pricing** | Current Whatnot BIN and auction listings for a set or SKU |
| **Seller shop dump** | Active inventory plus rating / sold count for a handle |
| **Live-show scouting** | Optional livestream rows with viewer counts and host username |
| **Arbitrage watch** | `monitorMode` on card or sneaker keywords; only new IDs billed |
| **Competitor sellers** | Ratings, followers, and what they have listed right now |
| **Comps workflow** | Whatnot live rows, then eBay sold listings for the same query |

### Quick start

**Keyword search:**

```json
{
  "searchKeywords": ["pokemon cards"],
  "maxItems": 50,
  "listingType": "buy_now",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

**Seller shop walk:**

```json
{
  "sellerUsernames": ["ninosrips"],
  "includeSellerProfiles": true,
  "maxItems": 100
}
```

**Pasted search URL + monitor:**

```json
{
  "startUrls": [
    { "url": "https://www.whatnot.com/search?query=pokemon%20cards&searchVertical=PRODUCT" }
  ],
  "maxItems": 150,
  "monitorMode": true,
  "monitorStoreName": "whatnot-pokemon-bin"
}
```

### Input parameters

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `searchKeywords` | Array | — | Search queries (required if no URLs/sellers) |
| `sellerUsernames` | Array | — | Shop handles to walk |
| `startUrls` | Array | — | Whatnot search, listing, seller, live, or tag URLs |
| `vertical` | String | `PRODUCT` | `PRODUCT` / `LIVESTREAM` / `USER` / `ALL` |
| `listingType` | String | `all` | `all`, `buy_now`, `auction` |
| `sort` | String | `best_match` | `best_match`, `newest`, `price_asc`, `price_desc` |
| `minPrice` / `maxPrice` | Number | — | Price band in major currency units |
| `onlyLive` | Boolean | `false` | Keep rows tied to a live show |
| `includeListingDetails` | Boolean | `false` | Extra `getListing` per row |
| `includeSellerProfiles` | Boolean | `false` | Also emit seller records |
| `includeLiveShows` | Boolean | `false` | Also query the Shows tab per keyword |
| `maxItems` | Integer | `100` | Max rows (`0` = unlimited subject to `maxPages`) |
| `maxPages` | Integer | `20` | Pagination safety cap (24 objects/page) |
| `monitorMode` | Boolean | `false` | Emit only new IDs vs previous run |
| `monitorStoreName` | String | `whatnot-listings-monitor` | Named KV store for seen IDs |
| `resetMonitorState` | Boolean | `false` | Wipe the seen-ID cache |
| `proxyConfiguration` | Object | RESIDENTIAL | Apify datacenter IPs often get empty GraphQL; residential recommended |

### Output format

Each dataset item is one listing, livestream, or seller row (`recordType`).

| Field | Type | Description |
| :--- | :--- | :--- |
| `recordType` | String | `listing`, `livestream`, or `seller` |
| `id` | String | Whatnot GraphQL id |
| `url` | String | Public listing / show / profile URL |
| `title` | String | Listing or show title |
| `subtitle` / `condition` | String | Condition / language line from the card |
| `description` | String | Short listing description |
| `category` | String | Category label when detail enrichment is on |
| `listingStatus` | String | e.g. `ACTIVE` |
| `transactionType` | String | `BUY_IT_NOW`, `ASYNC_AUCTION`, `LIVE_AUCTION` |
| `isAuction` / `isBuyNow` | Boolean | Format flags |
| `isOfferable` | Boolean | Offers enabled (detail enrichment) |
| `quantity` | Integer | Available quantity |
| `price` | Number | Price in major units (cents converted) |
| `priceMinor` | Integer | Raw minor units from Whatnot |
| `currency` | String | e.g. `USD`, `EUR` |
| `currentBid` / `currentBidCount` | Number / Integer | Auction snapshot when present |
| `isLive` | Boolean | Attached to a live show |
| `imageUrl` / `imageUrls` | String / Array | Primary and all images |
| `sellerUsername` / `sellerUrl` | String | Seller handle and profile URL |
| `sellerRating` / `sellerReviewCount` | Number / Integer | Public rating |
| `sellerFollowerCount` / `sellerSoldCount` | Integer | On shop walks and detail enrichment |
| `createdAt` / `updatedAt` | String | ISO timestamps when present |
| `searchQuery` | String | Keyword or handle that produced the row |
| `source` | String | `search`, `seller_shop`, or `listing_url` |
| `scrapedAt` | String | ISO scrape time |

**Example listing row:**

```json
{
  "recordType": "listing",
  "source": "search",
  "searchQuery": "pokemon cards",
  "id": "TGlzdGluZ05vZGU6MjEzNjkzMTA3OQ==",
  "url": "https://www.whatnot.com/listing/TGlzdGluZ05vZGU6MjEzNjkzMTA3OQ==",
  "title": "Umbreon - Sylveon - Vaporeon Pokémon Coin Set Bundle",
  "condition": "New",
  "transactionType": "BUY_IT_NOW",
  "isBuyNow": true,
  "quantity": 1,
  "price": 39.0,
  "currency": "EUR",
  "isLive": false,
  "sellerUsername": "ninosrips",
  "sellerRating": 5.0,
  "sellerReviewCount": 19
}
```

### Integration examples

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('crawloop/whatnot-listings-scraper').call({
  searchKeywords: ['pokemon cards'],
  maxItems: 50,
  listingType: 'buy_now',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 5));
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token)
run = client.actor("crawloop/whatnot-listings-scraper").call(
    run_input={
        "searchKeywords": ["pokemon cards"],
        "maxItems": 50,
        "listingType": "buy_now",
    }
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item.get("title"), item.get("price"), item.get("sellerUsername"))
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/crawloop~whatnot-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchKeywords":["pokemon cards"],"maxItems":50,"listingType":"buy_now"}'
```

### MCP and AI assistants

Use this Actor from AI tools via [Apify MCP](https://docs.apify.com/platform/integrations/mcp). Connect your Apify account, then call `crawloop/whatnot-listings-scraper`.

Example prompts:

- "Run Whatnot Listings Scraper for pokemon cards, max 50 buy-it-now, and return title, price, currency, sellerUsername, url as JSON"
- "Scrape the Whatnot shop for seller ninosrips and summarize prices and quantities"
- "Pull live Whatnot listings for jordan 1, then run eBay Sold Listings Scraper for the same query to compare comps"

### Suite next step

Whatnot is the live-commerce firehose. For **sold comps** on the same SKU (Pokémon, sports cards, sneakers), run [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) next. For recommended list price and demand score, continue with [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence). For graded high-end hammer, add [Goldin Auctions Scraper](https://apify.com/crawloop/goldin-scraper); for guide prices, [PriceCharting Scraper](https://apify.com/crawloop/pricecharting-scraper).

### FAQ

**Is this an official Whatnot API?**\
No. It calls the same public GraphQL the website uses (`search`, `getListing`, `getUser` shop) and returns structured dataset rows — a practical **Whatnot API alternative** for pipelines.

**Can I scrape a Whatnot seller shop by username?**\
Yes — set `sellerUsernames` (or paste a `/user/{handle}` URL in `startUrls`). The Actor walks shop inventory with pagination.

**Can I paste a Whatnot search URL?**\
Yes — `startUrls` accepts search links (query + vertical parsed), listing URLs, seller/shop URLs, live show URLs, and tag URLs.

**Do I need a Whatnot login?**\
No — public marketplace data only.

**Does it need a residential proxy?**\
On Apify, **yes — residential**. Datacenter IPs often receive empty GraphQL (`data: null`). Local runs can omit the proxy. Use `apifyProxyGroups: ["RESIDENTIAL"]`.

**Are prices in cents?**\
`price` / `currentBid` are converted to major units (e.g. 3900 → 39.00 EUR). `priceMinor` keeps the raw integer.

**Buy-it-now vs auction?**\
Filter with `listingType`: `buy_now`, `auction`, or `all`. Each row has `transactionType`, `isBuyNow`, and `isAuction`.

**What is monitor mode?**\
With `monitorMode: true`, seen listing IDs are stored in a named Key-Value store. The first run is the baseline. Later scheduled runs push and charge only IDs not seen before.

**Python / Node.js / MCP?**\
Yes — use the Apify client examples above or Apify MCP prompts.

**How many listings per search?**\
Whatnot paginates 24 objects per page. Raise `maxPages` / `maxItems` or add more keywords and seller shops.

### Related Actors

| Actor | Focus |
| :--- | :--- |
| Whatnot Listings Scraper ◄── you are here | Whatnot listings, shops, optional shows |
| [eBay Active Listings Scraper](https://apify.com/crawloop/ebay-active-listings-scraper) | Live eBay listings |
| [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) | eBay sold comps |
| [eBay Sold Price Intelligence](https://apify.com/crawloop/ebay-sold-price-intelligence) | Recommended price / demand |
| [Goldin Auctions Scraper](https://apify.com/crawloop/goldin-scraper) | Sports cards / TCG auctions |
| [PriceCharting Scraper](https://apify.com/crawloop/pricecharting-scraper) | TCG / games / comics guides |
| [Kleinanzeigen Scraper](https://apify.com/crawloop/kleinanzeigen-scraper) | German classifieds |
| [Marktplaats Scraper](https://apify.com/crawloop/marktplaats-scraper) | Dutch classifieds |

# Actor input Schema

## `searchKeywords` (type: `array`):

Whatnot search queries (e.g. pokemon cards, jordan 1, panini prizm). Each keyword is searched separately; results are merged and deduplicated by listing ID.

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

Walk each seller's Whatnot shop inventory (active listings). Handles without @, e.g. ninosrips.

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

Whatnot search, listing, seller/shop, live-show, or tag URLs. Query and vertical are parsed from search links.

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

Whatnot search tab for keyword jobs. PRODUCT = shop listings (default). LIVESTREAM = live/upcoming shows. USER = seller profiles. ALL = product + shows + users.

## `listingType` (type: `string`):

Keep buy-it-now, auctions, or both.

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

Whatnot search sort. Best match is the site default.

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

Drop listings cheaper than this (major currency units, e.g. 10 = $10 / €10).

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

Drop listings more expensive than this (major currency units).

## `onlyLive` (type: `boolean`):

Keep rows attached to a currently live Whatnot show.

## `includeListingDetails` (type: `boolean`):

One extra GraphQL request per listing (category, created/updated, seller sold count, offerable flag). Off by default for speed.

## `includeSellerProfiles` (type: `boolean`):

Also push seller records (followers, sold count, rating) when walking shops or USER search. Listing rows already include seller username and rating.

## `includeLiveShows` (type: `boolean`):

For each keyword, also query the Shows tab (LIVESTREAM vertical) and emit livestream rows.

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

Maximum rows to collect across all keywords, shops, and URLs. 0 = unlimited (subject to maxPages).

## `maxPages` (type: `integer`):

Safety cap on Whatnot cursor pagination (24 objects per page).

## `monitorMode` (type: `boolean`):

On a schedule, push and charge only IDs not seen in a previous run. First run delivers the full match set (baseline). Pair with an Apify Schedule and a stable monitorStoreName.

## `monitorStoreName` (type: `string`):

Named Key-Value store for seen listing IDs across scheduled runs. Use a distinct name per watch (e.g. pokemon-bin vs jordan-shops).

## `resetMonitorState` (type: `boolean`):

Clear the seen-ID cache before this run (next run becomes a new baseline).

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

Recommended on Apify: RESIDENTIAL. Datacenter IPs often get empty GraphQL from Whatnot. Local runs can leave proxy off.

## Actor input object example

```json
{
  "searchKeywords": [
    "pokemon cards"
  ],
  "startUrls": [
    {
      "url": "https://www.whatnot.com/search?query=pokemon%20cards&searchVertical=PRODUCT"
    }
  ],
  "vertical": "PRODUCT",
  "listingType": "all",
  "sort": "best_match",
  "onlyLive": false,
  "includeListingDetails": false,
  "includeSellerProfiles": false,
  "includeLiveShows": false,
  "maxItems": 100,
  "maxPages": 20,
  "monitorMode": false,
  "monitorStoreName": "whatnot-listings-monitor",
  "resetMonitorState": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Default dataset items.

# 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 = {
    "searchKeywords": [
        "pokemon cards"
    ],
    "startUrls": [
        {
            "url": "https://www.whatnot.com/search?query=pokemon%20cards&searchVertical=PRODUCT"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawloop/whatnot-listings-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 = {
    "searchKeywords": ["pokemon cards"],
    "startUrls": [{ "url": "https://www.whatnot.com/search?query=pokemon%20cards&searchVertical=PRODUCT" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawloop/whatnot-listings-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 '{
  "searchKeywords": [
    "pokemon cards"
  ],
  "startUrls": [
    {
      "url": "https://www.whatnot.com/search?query=pokemon%20cards&searchVertical=PRODUCT"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call crawloop/whatnot-listings-scraper --silent --output-dataset

```

## MCP server setup

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