# 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:** 12 total users, 6 monthly users, 94.9% 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/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 Listings Scraper — Live Shop, Prices & Sellers

> **Disclaimer:** Unofficial tool — not affiliated with, sponsored by, or endorsed by Whatnot Inc or its affiliates. Data is read from publicly accessible pages only. No login. You are responsible for complying with applicable law (including GDPR where personal data appears) and the site’s terms. No warranty on accuracy or availability. Provided for informational and research use.

**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 / live / tag 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 |
| :--- | :--- |
| [TCGPlayer Listings Scraper](https://apify.com/crawloop/tcgplayer-listings-scraper) | US TCG seller listings and shops |
| [Cardmarket Listings Scraper](https://apify.com/crawloop/cardmarket-listings-scraper) | EU TCG seller offers and shops |
| [Fanatics Collect Scraper](https://apify.com/crawloop/fanatics-collect-scraper) | Weekly / Premier auctions, Buy Now, sold comps |
| [Goldin Auctions Scraper](https://apify.com/crawloop/goldin-scraper) | High-end sports cards / TCG hammer + sold |
| [PSA Population Report Scraper](https://apify.com/crawloop/psa-pop-report-scraper) | Set-level PSA pop census and gem rate |
| Whatnot Listings Scraper ◄── you are here | Whatnot live-commerce listings and shops |
| [PriceCharting Scraper](https://apify.com/crawloop/pricecharting-scraper) | Guide prices for games, TCG, and comics |
| [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 |

### 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))
- **US / EU TCG seller books** — use [TCGPlayer Listings Scraper](https://apify.com/crawloop/tcgplayer-listings-scraper) or [Cardmarket Listings Scraper](https://apify.com/crawloop/cardmarket-listings-scraper)
- **Weekly auction hammer** — use [Fanatics Collect Scraper](https://apify.com/crawloop/fanatics-collect-scraper)
- **High-end auction hammer** — use [Goldin Auctions Scraper](https://apify.com/crawloop/goldin-scraper)
- **PSA 10 pop / gem rate** — use [PSA Population Report Scraper](https://apify.com/crawloop/psa-pop-report-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, optionally filtered with `shopQuery`
- **Start URL parsing** — search, listing, `/user/{handle}`, `/live/{id}` (fetched by id), and `/tag/{name}` (that tag's live-show feed)
- **Buy format + price filters** — buy-it-now vs auction, min/max price, live-only (search and seller shops)
- **Sort** — best match, newly listed (`CREATION_TIME`), lowest / highest price (search and seller shops)
- **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 for a handle; `shopQuery` to keep one SKU / set |
| **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** (omit `shopQuery` for full inventory):

```json
{
  "sellerUsernames": ["ninosrips"],
  "includeSellerProfiles": true,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

Add `"shopQuery": "vaporeon"` to keep only shop listings matching that keyword.

**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",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Input parameters

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `searchKeywords` | Array | — | Search queries (required if no URLs/sellers) |
| `sellerUsernames` | Array | — | Shop handles to walk |
| `shopQuery` | String | — | Filter each seller shop by keyword (Whatnot shop search). Empty = full inventory |
| `startUrls` | Array | — | Whatnot search, listing, seller, live, or tag URLs (`/tag/{name}` = that tag's show feed) |
| `vertical` | String | `PRODUCT` | `PRODUCT` / `LIVESTREAM` / `USER` / `ALL` |
| `listingType` | String | `all` | `all`, `buy_now`, `auction` — search and seller shops |
| `sort` | String | `best_match` | `best_match`, `newest` (Newly Listed), `price_asc`, `price_desc` — search and seller shops |
| `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 (sku, offerable, extra seller sold count) |
| `includeSellerProfiles` | Boolean | `false` | Also emit seller records on shop walks (USER / ALL search already includes them) |
| `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 from the listing card |
| `listingStatus` | String | e.g. `ACTIVE` |
| `transactionType` | String | `BUY_IT_NOW`, `ASYNC_AUCTION`, `LIVE_AUCTION` |
| `isAuction` / `isBuyNow` | Boolean | Format flags |
| `isOfferable` | Boolean | Offers enabled (often already on the card; enrichment fills gaps) |
| `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 | Listing on a live show, or show `status` is PLAYING / LIVE |
| `status` | String | Livestream status (`PLAYING`, `ENDED`, …) |
| `activeViewers` | Integer | Current viewers on livestream rows |
| `tags` | Array | Livestream tags / categories |
| `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`, `listing_url`, `live_url`, or `tag_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',
  proxyConfiguration: { useApifyProxy: true, apifyProxyGroups: ['RESIDENTIAL'] },
});
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",
        "proxyConfiguration": {
            "useApifyProxy": True,
            "apifyProxyGroups": ["RESIDENTIAL"],
        },
    }
)
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","proxyConfiguration":{"useApifyProxy":true,"apifyProxyGroups":["RESIDENTIAL"]}}'
```

### 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, residential proxy, and return title, price, currency, sellerUsername, url as JSON"
- "Scrape the Whatnot shop for seller ninosrips, filter shopQuery vaporeon, residential proxy, and summarize prices and quantities"
- "Run Whatnot Listings Scraper on https://www.whatnot.com/tag/sudden\_death and return live show titles, viewer counts, and host usernames"
- "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 live TCG marketplace asks, chain [TCGPlayer Listings Scraper](https://apify.com/crawloop/tcgplayer-listings-scraper) or [Cardmarket Listings Scraper](https://apify.com/crawloop/cardmarket-listings-scraper). For weekly auction hammer, add [Fanatics Collect Scraper](https://apify.com/crawloop/fanatics-collect-scraper); for graded high-end, [Goldin Auctions Scraper](https://apify.com/crawloop/goldin-scraper); for gem rate, [PSA Population Report Scraper](https://apify.com/crawloop/psa-pop-report-scraper).

### FAQ

**Is this an official Whatnot API?**\
No. It calls the same public GraphQL the website uses (`search`, `getListing`, `liveStream`, `getUser` shop, `getLivestreamTagByName`) 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. Add `shopQuery` to keep only listings matching that shop search (same as the seller's shop search box).

**Can I paste a Whatnot search URL?**\
Yes — `startUrls` accepts search links (query + vertical parsed), listing URLs, seller/shop URLs, live show URLs (`/live/{id}` via `liveStream(id)`), and tag URLs (`/tag/{name}` walks that tag's live-show feed).

**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`). The Actor injects `RESIDENTIAL` on the platform when `proxyConfiguration` is omitted (API / MCP / cURL). 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 |
| [TCGPlayer Listings Scraper](https://apify.com/crawloop/tcgplayer-listings-scraper) | US TCG listings and shops |
| [Cardmarket Listings Scraper](https://apify.com/crawloop/cardmarket-listings-scraper) | EU TCG listings and shops |
| [Fanatics Collect Scraper](https://apify.com/crawloop/fanatics-collect-scraper) | Weekly / Premier auctions + sold |
| [PSA Population Report Scraper](https://apify.com/crawloop/psa-pop-report-scraper) | PSA pop census and gem rate |
| [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) | eBay sold comps |
| [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 |

# 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. Optional shopQuery filters each shop.

## `shopQuery` (type: `string`):

When walking seller shops (usernames or /user/ URLs), only keep listings matching this shop-search query. Leave empty for full inventory. Does not apply to marketplace keyword search.

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

Whatnot search, listing, seller/shop, live-show, or tag URLs. Search links parse query + vertical. Live URLs fetch the show by id. Tag URLs (/tag/{name}) walk that tag's live-show feed.

## `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. Applies to keyword search and seller shop walks.

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

Whatnot sort for keyword search and seller shops. Newly listed uses CREATION\_TIME (same as the website). Best match omits GraphQL sort.

## `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. USER / ALL search already emits seller rows from the Users tab. 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/8otYbeNG2VKgwABm4/openapi.json