# Whatnot Seller Review Scraper — Extract Ratings & Reviews (`epicscrapers/whatnot-seller-review-scraper`) Actor

Scrape Whatnot seller reviews and ratings in bulk — average rating, review text, shipping rating, reviewer username, and seller response. No API key needed. Export as JSON, CSV, or Excel. Ideal for seller reputation analysis, competitor monitoring, and market research on Whatnot.com.

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

## Pricing

from $1.00 / 1,000 reviews

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 Seller Review Scraper — Extract Customer Reviews & Ratings

Extract customer reviews and ratings from any Whatnot seller profile in bulk. Get average rating, review text, shipping rating, reviewer usernames, seller responses, and more — without an API key.

---

### 🎯 Why Scrape Whatnot Seller Reviews?

Seller reviews reveal the true reputation behind a Whatnot profile. Whether you're a buyer doing due diligence, a seller researching competitors, or a data analyst tracking marketplace trends, review data gives you the signal you need.

**Use cases:**

- **Seller reputation analysis** — Verify a seller's track record before buying high-value items
- **Competitor monitoring** — Track how competing sellers are rated on shipping, packaging, and overall experience
- **Market research** — Analyze review sentiment across categories (sneakers, trading cards, collectibles, vintage)
- **Lead validation** — Screen potential wholesale partners or suppliers by their review history
- **Buyer protection** — Spot patterns in negative reviews (slow shipping, inaccurate descriptions) at a glance

---

### 📊 What Data You Get

Every review record includes:

| Field | Description |
|---|---|
| `sellerId` | Numeric Whatnot seller ID |
| `sellerUsername` | Seller's handle on Whatnot |
| `averageRating` | Overall star rating (1.0–5.0) |
| `overallReview` | Full review text written by buyer |
| `reviewedOn` | Date the review was posted |
| `ratingOverall` | Overall rating numeric value |
| `ratingShipping` | Shipping rating numeric value |
| `reviewedBy` | Username of the buyer who left the review |
| `sellerResponse` | Seller's reply to the review (if any) |
| `fetchedAt` | Timestamp when data was collected |

---

### 🚀 How It Works

1. **Enter sellers** — Provide a list of Whatnot usernames or user IDs
2. **Set your limit** — Choose how many recent reviews to pull per seller
3. **Run it** — Reviews are fetched and flattened into individual records
4. **Export** — Download the data as JSON, CSV, or Excel

No authentication, no login, no API key required. Just seller data, fast.

---

### 📝 Example Output

```json
{
	"sellerId": "41626782",
	"sellerUsername": "club404",
	"averageRating": 5,
	"overallReview": "Achat nikel et envoie rapide. Une petite tâche sur la J4RM à l'arrivé mais rien de méchant et dû au transporteur (certainement un colis qui a percé le plastique de protectiom). RAS merci la team",
	"reviewedOn": "Sun, 17 May 2026 12:58:02 GMT",
	"ratingOverall": 5,
	"ratingShipping": 5,
	"reviewedBy": "lassyl",
	"sellerResponse": null,
	"fetchedAt": "2026-05-17T17:55:38.061Z"
}
````

*Paste your actual output here.*

***

### 💡 Who Is This For?

- **Whatnot buyers** — Research sellers before you bid
- **Resellers & collectors** — Vet trading partners and find reputable sellers
- **E-commerce analysts** — Track seller performance metrics over time
- **Data teams** — Build dashboards on marketplace seller health
- **Due diligence specialists** — Audit seller reputation at scale

***

### ✨ Features

- **Bulk seller lookup** — Usernames or user IDs, one batch or many
- **Flattened records** — Each review is its own clean row, ready for analysis
- **All reviews paginated** — No hard limits beyond what you set
- **No API key** — Works against Whatnot's public data layer
- **Export ready** — Clean structured data for spreadsheets or databases

# Actor input Schema

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

List of seller usernames

## `sellerUserIds` (type: `array`):

List of seller user ids

## `maxReviewsPerSeller` (type: `integer`):

Number of reviews to scrape per seller

## Actor input object example

```json
{
  "sellerUsernames": [
    "club404"
  ],
  "maxReviewsPerSeller": 100
}
```

# Actor output Schema

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

Flattened review records, one per review, enriched with seller context. Fields: sellerId, sellerUsername, averageRating, overallReview, reviewedOn, ratingOverall, ratingShipping, reviewedBy, sellerResponse, fetchedAt.

# 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 = {
    "sellerUsernames": [
        "club404"
    ],
    "maxReviewsPerSeller": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("epicscrapers/whatnot-seller-review-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 = {
    "sellerUsernames": ["club404"],
    "maxReviewsPerSeller": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("epicscrapers/whatnot-seller-review-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 '{
  "sellerUsernames": [
    "club404"
  ],
  "maxReviewsPerSeller": 100
}' |
apify call epicscrapers/whatnot-seller-review-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Whatnot Seller Review Scraper — Extract Ratings & Reviews",
        "description": "Scrape Whatnot seller reviews and ratings in bulk — average rating, review text, shipping rating, reviewer username, and seller response. No API key needed. Export as JSON, CSV, or Excel. Ideal for seller reputation analysis, competitor monitoring, and market research on Whatnot.com.",
        "version": "0.0",
        "x-build-id": "JCWaoSYJWgdrmFwq3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/epicscrapers~whatnot-seller-review-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-epicscrapers-whatnot-seller-review-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-seller-review-scraper/runs": {
            "post": {
                "operationId": "runs-sync-epicscrapers-whatnot-seller-review-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-seller-review-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-epicscrapers-whatnot-seller-review-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": [
                    "maxReviewsPerSeller"
                ],
                "properties": {
                    "sellerUsernames": {
                        "title": "Seller Usernames",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "List of seller usernames",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sellerUserIds": {
                        "title": "Seller User IDs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "List of seller user ids",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerSeller": {
                        "title": "Max Reviews Per Seller",
                        "type": "integer",
                        "description": "Number of reviews to scrape per seller",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
