# Whatnot Search Scraper (`epicscrapers/whatnot-scraper`) Actor

Scrape Whatnot.com search results, unofficial API. Extract listings, livestreams, products, and users.

- **URL**: https://apify.com/epicscrapers/whatnot-scraper.md
- **Developed by:** [Epic Scrapers](https://apify.com/epicscrapers) (community)
- **Categories:** E-commerce, Lead generation, Integrations
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.
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 Search Scraper

**[Whatnot Search Scraper](https://apify.com/jwiley84/whatnot-scraper)** is a powerful Apify Actor that extracts **listings, livestreams, products, and users** from [Whatnot.com](https://www.whatnot.com) — the fastest-growing live shopping marketplace for collectibles, trading cards, comics, and more. Whether you're a **reseller tracking prices**, a **collector monitoring rare items**, or a **market researcher analyzing trends**, this scraper gives you direct access to Whatnot's data via their GraphQL API without writing a single line of code.

With built-in **proxy rotation**, **pagination handling**, and **optional authentication**, you can scrape thousands of results reliably and export them in **JSON, CSV, or Excel** format for further analysis.

---

### ✨ What can Whatnot Search Scraper do?

- 🔍 **Search by any keyword** — Find listings, livestreams, products, or users across the entire Whatnot marketplace
- 📦 **Extract multiple data types** — Get structured data for listings, livestreams, products, users, categories, and tags in a single run
- 📄 **Automatic pagination** — Handles pagination automatically to retrieve all results (respecting your `maxResults` limit)
- 🌐 **Built-in proxy support** — Uses Apify Proxy rotation to avoid IP blocking and rate limits
- 🔐 **Optional authentication** — Add browser cookies to access restricted or personalized content
- ⚡ **Fast & efficient** — Direct GraphQL API calls for maximum speed and reliability
- 🎯 **Filter by vertical** — Narrow results to specific types: Universal, Livestreams, Products, Users, or Categories
- 📊 **Export anywhere** — Download results as JSON, CSV, Excel, or connect to 1000+ integrations via Zapier, Make, n8n

---

### 📋 What data can you extract from Whatnot?

The Actor extracts rich, structured data across **6 entity types**. Each result includes the full object data plus metadata about the search.

#### Common Fields (All Types)
| Field | Type | Description |
|-------|------|-------------|
| `type` | string | Entity type: `listing`, `livestream`, `product`, `user`, `category`, `tag` |
| `id` | string | Unique identifier (GraphQL node ID) |
| `searchQuery` | string | The search query used |
| `vertical` | string | Search vertical: `UNIVERSAL`, `LIVESTREAM`, `PRODUCT`, `USER`, `CATEGORY` |
| `cursor` | string | Pagination cursor for this result |
| `scrapedAt` | string | ISO timestamp when data was extracted |

#### Listing Fields
| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Listing title |
| `subtitle` | string | Condition or variant info (e.g., "Light Played") |
| `description` | string | Full description |
| `publicStatus` | string | Status: `ACTIVE`, `SOLD`, etc. |
| `transactionType` | string | `BUY_IT_NOW`, `AUCTION`, etc. |
| `quantity` | number | Available quantity |
| `price` | object | `{amount, currency, amountSafe}` — Price in cents (divide by 100 for dollars) |
| `currentBid` | object | Current auction bid (if applicable) |
| `currentBidCount` | number | Number of bids |
| `isLive` | boolean | Whether item is being sold in a livestream |
| `livestreamStartTime` | number | Unix timestamp for live sale |
| `user` | object | Seller info: `id`, `username`, `sellerRating` (overall + numReviews), `profileImage` |
| `images` | array | Product images with `url`, `key`, `bucket`, `label` |
| `labels` | array | Listing labels/tags |

#### Livestream Fields
| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Stream title |
| `status` | string | `created`, `playing`, `ended`, etc. |
| `startTime` | number | Unix timestamp |
| `activeViewers` | number | Current viewer count |
| `thumbnail` | object | Image URLs: `smallImage` (414×640), `biggerImage` (642×992) |
| `user` | object | Streamer info: `id`, `username`, `profileImage` |
| `tags` | array | Stream tags with `id`, `label`, `name` |
| `streamToken` | string | Stream token |
| `isAutoplayEnabled` | boolean | Autoplay status |
| `trailerUrl` | string | Trailer video URL |

#### Product Fields
| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Product name |
| `image` | object | Product image with `url`, `key`, `bucket` |
| `listingPrice` | object | Current listing price: `{amount, currency, amountSafe}` |
| `lastSalePrice` | object | Last sold price |
| `numListings` | number | Count of active listings for this product |

#### User Fields
| Field | Type | Description |
|-------|------|-------------|
| `username` | string | Username |
| `isFollowing` | boolean | Whether you follow them |
| `isFollower` | boolean | Whether they follow you |
| `followerCount` | number | Total followers |
| `soldCount` | number | Items sold |
| `isLive` | boolean | Currently streaming |
| `canGoLive` | boolean | Streamer eligibility |
| `sellerRating` | object | `{overall, numReviews}` — Rating 1-5 |
| `profileImage` | object | Profile picture URL |

#### Category Fields
| Field | Type | Description |
|-------|------|-------------|
| `type` | string | Category type |
| `label` | string | Display name |
| `isFollowing` | boolean | Whether you follow this category |
| `image` | object | Category images: `smallImage` (316×244), `biggerImage` (632×488) |

---

### 🚀 How to scrape Whatnot with Whatnot Search Scraper

Follow these steps to start extracting data from Whatnot in minutes:

#### Step 1: Open the Actor
Go to **[apify.com/epicscrapers/whatnot-scraper](https://apify.com/jwiley84/whatnot-scraper)** and click **"Try for free"** or **"Start Run"**.

#### Step 2: Configure Your Search
Fill in the input fields:
- **Search Query** (required): Enter what you're looking for (e.g., `pokemon cards`, `funko pop`, `comic books`)
- **Search Vertical**: Choose `Universal` (all types) or narrow to `Livestreams`, `Products`, `Users`, or `Categories`
- **Maximum Results**: Set a limit (default 100, or 0 for unlimited)

#### Step 3: (Optional) Configure Advanced Options
- **Include Listings/Livestreams/Products/Users**: Toggle which data types to extract
- **Cookies**: Add browser cookies if you need authenticated access (see [Authentication](#authentication) section)
- **Proxy Configuration**: Leave as default for automatic proxy rotation

#### Step 4: Run the Scraper
Click **"Start Run"**. The Actor will:
1. Paginate through all results
2. Extract and normalize data
3. Save to your Apify Dataset

#### Step 5: Download Your Data
Once complete, go to the **Dataset** tab and export as:
- **JSON** (default)
- **CSV**
- **Excel**
- **HTML Table**

Or access via API for integration with your tools.

---

### 🔧 Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `query` | string | ✅ Yes | — | Search term (e.g., "pokemon", "funko pop", "marvel comics") |
| `vertical` | string | No | `UNIVERSAL` | Search type: `UNIVERSAL`, `LIVESTREAM`, `PRODUCT`, `USER`, `CATEGORY` |
| `maxResults` | integer | No | `100` | Max results to return. Use `0` for unlimited |
| `cookies` | string | No | — | Browser cookies for authenticated requests (secret field) |
| `includeListings` | boolean | No | `true` | Include listing items in results |
| `includeLivestreams` | boolean | No | `true` | Include livestream items |
| `includeProducts` | boolean | No | `true` | Include product items |
| `includeUsers` | boolean | No | `true` | Include user items |
| `proxyConfiguration` | object | No | `{useApifyProxy: true}` | Proxy settings |

#### Example Input — Basic Search
```json
{
  "query": "pokemon cards",
  "maxResults": 100
}
````

#### Example Input — Livestreams Only

```json
{
  "query": "funko pop",
  "vertical": "LIVESTREAM",
  "maxResults": 50,
  "includeListings": false,
  "includeProducts": false,
  "includeUsers": false
}
```

#### Example Input — With Authentication

```json
{
  "query": "rare comics",
  "cookies": "usid=xxx; device=yyy; __Secure-access-token=zzz",
  "maxResults": 200
}
```

***

### 📤 Output Example

Here's a sample listing result for a Pokémon card search:

```json
{
  "type": "listing",
  "__typename": "ListingNode",
  "id": "TGlzdGluZ05vZGU6MTY0MzM2MTA0MQ==",
  "title": "Pokemon Vaporeon Holo EX Unseen Forces 19/115 Pokemon TCG",
  "subtitle": "",
  "description": "Pokemon Vaporeon Holo EX Unseen Forces 19/115 Pokemon TCG",
  "publicStatus": "ACTIVE",
  "transactionType": "BUY_IT_NOW",
  "quantity": 1,
  "price": {
    "amount": 9500,
    "currency": "USD",
    "amountSafe": 9500
  },
  "currentBid": null,
  "currentBidCount": null,
  "isLive": false,
  "livestreamStartTime": null,
  "user": {
    "id": "UHVibGljVXNlck5vZGU6MjM2NzcyMDQ=",
    "username": "theparadisecards",
    "sellerRating": {
      "overall": 5,
      "numReviews": 1207
    },
    "profileImage": {
      "url": "https://images.whatnot.com/..."
    }
  },
  "images": [
    {
      "id": "UHJvZHVjdEltYWdlOjExNjE4NDU4Mzg=",
      "url": "https://images.whatnot.com/...",
      "key": "listings/0-2c36277b-49d0-48d6-80f7-e1c68fdff1a8-a03605c3-c234-4672-ab62-a13f4a23300e.jpeg",
      "bucket": "whatnot-images",
      "label": "2c36277b-49d0-48d6-80f7-e1c68fdff1a8"
    }
  ],
  "labels": null,
  "isMyListing": false,
  "version": "01KNG1NRWR8CCVA5VA8DB01T3P",
  "searchQuery": "pokemon",
  "vertical": "UNIVERSAL",
  "cursor": "YXJyYXljb25uZWN0aW9uOjA=",
  "scrapedAt": "2026-04-07T15:17:39.659Z"
}
```

#### Export Formats

Results are stored in Apify Dataset and can be exported as:

- **JSON** (newline-delimited JSON)
- **CSV** (flattened structure)
- **Excel** (.xlsx)
- **HTML Table**
- **XML**
- **RSS**

***

### ⚖️ Is it legal to scrape Whatnot?

#### What data is collected?

This Actor only scrapes **publicly available data** from Whatnot.com:

- Public listings and their details
- Public livestreams
- Public product information
- Public user profiles and seller ratings
- Public categories and tags

**This Actor does NOT collect:**

- ❌ Private user data (emails, phone numbers)
- ❌ Private messages or communications
- ❌ Non-public account information
- ❌ Data behind login walls (unless you provide valid cookies)

#### Legal Considerations

- Whatnot's Terms of Service apply to platform usage
- This tool uses Whatnot's public GraphQL API (the same endpoint their web app uses)
- Users are responsible for complying with applicable laws and Whatnot's ToS
- The Actor includes rate limiting (500ms delay between requests) to be respectful

**Disclaimer:** This Actor is for informational purposes. Always ensure your use case complies with local laws and Whatnot's Terms of Service.

***

### 🔐 Authentication (Optional)

Some content may require authentication or may show different results when logged in. To use authenticated requests:

1. **Open Whatnot.com** in your browser and log in to your account
2. **Open DevTools** (F12 or Cmd+Option+I)
3. Go to **Application** (Chrome) or **Storage** (Firefox) → **Cookies**
4. Find cookies for `whatnot.com`
5. Copy the cookie string (or specific cookies like `usid`, `device`, `__Secure-access-token`)
6. Paste into the **Cookies** input field in the Actor (this field is marked as secret — it won't be logged)

**Note:** Cookies expire. If you get authentication errors, refresh your cookies.

***

### 🔗 Apify Platform Features

This Actor benefits from the full Apify platform:

| Feature | How It Helps |
|---------|--------------|
| ⏰ **Scheduling** | Run the scraper daily/hourly to monitor prices or new listings |
| 🔌 **API Access** | Trigger runs via REST API and get JSON results programmatically |
| 🔄 **Integrations** | Connect to Zapier, Make, n8n, Google Sheets, Airtable, Slack, and 1000+ tools |
| 🌐 **Proxy Rotation** | Automatic IP rotation via Apify Proxy to avoid blocking |
| 💾 **Cloud Storage** | Results stored in Datasets with permanent URLs |
| 📊 **Monitoring** | Get alerts when runs succeed, fail, or hit thresholds |
| 🪝 **Webhooks** | Trigger external services when scraping completes |

#### Popular Integrations

- **Google Sheets** — Auto-import results to spreadsheets
- **Airtable** — Build databases of products/listings
- **Slack/Discord** — Get alerts for new items
- **Zapier/Make** — Connect to 5000+ apps
- **SQL databases** — Sync results to PostgreSQL, MySQL

***

### ❓ FAQ

#### Q: How many results can I get?

A: There's no hard limit. The Actor handles pagination automatically. Use `maxResults: 0` for unlimited, but be mindful of your compute credits.

#### Q: Can I search for specific sellers?

A: Yes! Use the `USER` vertical with a search query like the seller's username.

#### Q: Why are prices shown as "9500" instead of "$95.00"?

A: Whatnot stores prices in cents. Divide by 100 to get the dollar amount (e.g., 9500 = $95.00).

#### Q: Do I need proxies?

A: The Actor uses Apify Proxy by default. You can disable it, but it's recommended for reliable scraping.

#### Q: Can I scrape sold/out-of-stock items?

A: The Actor captures whatever Whatnot's search returns.

#### Q: Is there an official Whatnot API?

A: Whatnot does not currently offer a public API for marketplace data. This Actor provides programmatic access via their internal GraphQL endpoint.

#### Q: How do I get only livestreams happening now?

A: Use `vertical: "LIVESTREAM"` and filter results where `status === "playing"` in your analysis.

#### Q: Can I get historical price data?

A: This Actor captures current snapshot data. For historical tracking, schedule runs daily and store results in your own database.

***

### 🛠️ Tips & Best Practices

#### For Resellers & Flippers

- Schedule runs every hour for hot categories
- Monitor `lastSalePrice` vs `listingPrice` to identify deals
- Track `sellerRating` to avoid risky transactions

#### For Collectors

- Use specific queries like `"charizard 1st edition"` for rare items
- Filter by `transactionType` to find auctions vs buy-it-now
- Set up alerts for new listings via webhooks

#### For Researchers

- Export to CSV for Excel/Tableau analysis
- Combine with scheduling for time-series data
- Use `vertical: "PRODUCT"` to analyze market trends

#### Power User Tips

1. **Start small**: Test with `maxResults: 25` before large runs
2. **Use specific queries**: `"2023 panini prizm"` is better than `"cards"`
3. **Filter on your side**: Export all data, then filter in Excel/Python
4. **Handle rate limits**: If you see 429 errors, increase delays or use residential proxies

***

### 📞 Support & Feedback

#### Need Help?

- **Issues**: Open an issue or contact via jwlben11@gmail.com
- **Email**: Contact me via jwlben11@gmail.com
- **Discord**: Join the [Apify Discord](https://discord.gg/apify) community

#### Feature Requests

Have an idea for improvement? I'm open to custom solutions and feature requests. Contact me via:

- jwlben11@gmail.com
- Issues tab

#### Found a Bug?

Please include:

1. Your input configuration (remove sensitive cookies)
2. Error message or unexpected behavior
3. Expected vs actual output
4. Post it in the issues

***

### 📚 Related Actors

Check out my other Apify Actors for marketplace and e-commerce scraping:
[Vinted Scraper](https://apify.com/epicscrapers/vinted-search-scraper)

***

### License

ISC License — See package.json for details.

***

**Ready to scrape Whatnot?** [Start your first run →](https://apify.com/jwiley84/whatnot-scraper)

# Actor input Schema

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

The search term to query on Whatnot.com. This can be any keyword, product name, username, or category you want to search for. Examples: 'pokemon cards', 'funko pop', 'mtg', '@username'. The Actor will search across all available content types unless filtered by the vertical field.

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

Filter search results to specific content types. UNIVERSAL searches across all types. Use LIVESTREAM for active streams, PRODUCT for individual items, USER for seller profiles, or CATEGORY for product categories. This works in conjunction with the include\* fields to further filter which types are extracted.

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

Maximum number of results to return across all content types. Set to 0 for unlimited results (scrapes until all pages are exhausted). The Actor paginates automatically, fetching 24 results per page. Use this to limit runtime and data volume, especially for broad searches.

## `cookies` (type: `string`):

Browser cookies from an authenticated Whatnot.com session. Required for accessing personalized results, following status, or content that requires login. To get cookies: 1) Log into Whatnot.com in Chrome/Firefox, 2) Open Dev Tools (F12), 3) Go to Network tab, 4) Reload page, 5) Find any request to whatnot.com, 6) Copy the 'Cookie' header value. Marked as secret to prevent accidental exposure.

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

Whether to extract individual item listings (buy-it-now or auction items). Listings include price, seller info, images, and status. Disable if you only want livestreams, products, or users. Works with vertical filtering: if vertical=PRODUCT but includeListings=false, no listings will be extracted.

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

Whether to extract active livestreams. Livestreams include viewer counts, streamer info, tags, and status. Disable if you only want static listings or products. Works with vertical filtering: if vertical=LIVESTREAM but includeLivestreams=false, no livestreams will be extracted.

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

Whether to extract product catalog entries (distinct from listings). Products represent items in Whatnot's catalog with aggregated data like last sale price and number of active listings. Disable if you only want individual listings or livestreams.

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

Whether to extract user/seller profiles. Users include follower counts, seller ratings, and live status. Requires cookies for accurate following/follower status. Disable if you only want item data.

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

Proxy settings to avoid IP blocking and rate limits. Uses Apify Proxy by default with automatic rotation. For residential or datacenter proxies, configure groups and country selection here. Required for large-scale scraping to maintain reliability.

## Actor input object example

```json
{
  "query": "pokemon",
  "vertical": "UNIVERSAL",
  "maxResults": 100,
  "includeListings": true,
  "includeLivestreams": true,
  "includeProducts": true,
  "includeUsers": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing all scraped Whatnot search results

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("epicscrapers/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("epicscrapers/whatnot-scraper").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 '{}' |
apify call epicscrapers/whatnot-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Whatnot Search Scraper",
        "description": "Scrape Whatnot.com search results, unofficial API. Extract listings, livestreams, products, and users.",
        "version": "0.2",
        "x-build-id": "gC8j8AooxRhioddGx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/epicscrapers~whatnot-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-epicscrapers-whatnot-scraper",
                "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/epicscrapers~whatnot-scraper/runs": {
            "post": {
                "operationId": "runs-sync-epicscrapers-whatnot-scraper",
                "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/epicscrapers~whatnot-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-epicscrapers-whatnot-scraper",
                "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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "The search term to query on Whatnot.com. This can be any keyword, product name, username, or category you want to search for. Examples: 'pokemon cards', 'funko pop', 'mtg', '@username'. The Actor will search across all available content types unless filtered by the vertical field.",
                        "default": "pokemon"
                    },
                    "vertical": {
                        "title": "Search Vertical",
                        "enum": [
                            "UNIVERSAL",
                            "LIVESTREAM",
                            "PRODUCT",
                            "USER",
                            "CATEGORY"
                        ],
                        "type": "string",
                        "description": "Filter search results to specific content types. UNIVERSAL searches across all types. Use LIVESTREAM for active streams, PRODUCT for individual items, USER for seller profiles, or CATEGORY for product categories. This works in conjunction with the include* fields to further filter which types are extracted.",
                        "default": "UNIVERSAL"
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of results to return across all content types. Set to 0 for unlimited results (scrapes until all pages are exhausted). The Actor paginates automatically, fetching 24 results per page. Use this to limit runtime and data volume, especially for broad searches.",
                        "default": 100
                    },
                    "cookies": {
                        "title": "Cookies (Optional)",
                        "type": "string",
                        "description": "Browser cookies from an authenticated Whatnot.com session. Required for accessing personalized results, following status, or content that requires login. To get cookies: 1) Log into Whatnot.com in Chrome/Firefox, 2) Open Dev Tools (F12), 3) Go to Network tab, 4) Reload page, 5) Find any request to whatnot.com, 6) Copy the 'Cookie' header value. Marked as secret to prevent accidental exposure."
                    },
                    "includeListings": {
                        "title": "Include Listings",
                        "type": "boolean",
                        "description": "Whether to extract individual item listings (buy-it-now or auction items). Listings include price, seller info, images, and status. Disable if you only want livestreams, products, or users. Works with vertical filtering: if vertical=PRODUCT but includeListings=false, no listings will be extracted.",
                        "default": true
                    },
                    "includeLivestreams": {
                        "title": "Include Livestreams",
                        "type": "boolean",
                        "description": "Whether to extract active livestreams. Livestreams include viewer counts, streamer info, tags, and status. Disable if you only want static listings or products. Works with vertical filtering: if vertical=LIVESTREAM but includeLivestreams=false, no livestreams will be extracted.",
                        "default": true
                    },
                    "includeProducts": {
                        "title": "Include Products",
                        "type": "boolean",
                        "description": "Whether to extract product catalog entries (distinct from listings). Products represent items in Whatnot's catalog with aggregated data like last sale price and number of active listings. Disable if you only want individual listings or livestreams.",
                        "default": true
                    },
                    "includeUsers": {
                        "title": "Include Users",
                        "type": "boolean",
                        "description": "Whether to extract user/seller profiles. Users include follower counts, seller ratings, and live status. Requires cookies for accurate following/follower status. Disable if you only want item data.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings to avoid IP blocking and rate limits. Uses Apify Proxy by default with automatic rotation. For residential or datacenter proxies, configure groups and country selection here. Required for large-scale scraping to maintain reliability.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```