# Whop Reviews Scraper API (`lurkapi/whop-reviews-scraper-api`) Actor

Scrape every public Whop review at scale. Filter by stars, date, keyword, reviewer. Rank oldest or by rating. Enrich with company, product, reviewer, and attachment details on demand.

- **URL**: https://apify.com/lurkapi/whop-reviews-scraper-api.md
- **Developed by:** [LurkAPI](https://apify.com/lurkapi) (community)
- **Categories:** Agents, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 review scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Whop Reviews Scraper API

Pull every public review from a Whop company into one clean, normalized dataset. Filter by rating, date range, text, reviewer, or attachments. Rank oldest first or by stars. Enrich with public company, product, reviewer, and attachment details on demand.

_A DIY reputation table for creators screening a niche, agencies checking competitor sentiment, and analysts benchmarking Whop brands._

### 🎯 What it does

Whop shows reviews one company at a time, buried behind a scroll. This scraper flattens the whole review feed into one export so you can sort, filter, and compare reviews the way a spreadsheet lets you.

- **Company scan**: paste a public company URL and pull up to 10,000 reviews per company, up to 50,000 per run
- **Product URL support**: a product URL resolves to its owning company's reviews
- **Signal filters**: keep only 5-star reviews, only reviews inside a date range, only reviews that mention a keyword, or only reviews from a specific reviewer
- **Rank by rating or age**: source order is free; oldest, highest-rating, and lowest-rating sorts are paid
- **Deterministic enrichments**: turn on public company details, requested product details, reviewer profile, or review attachments per run

Built for creators screening a niche, agencies benchmarking competitor sentiment, and market analysts studying the Whop ecosystem.

### 📋 How to use it

#### Step 1: Pick your inputs

Paste public URLs, one per line:

- Company URL: `https://whop.com/fit-method/`
- Product URL: `https://whop.com/fit-method/beginner-plan/`

A product URL resolves to its owning company. Reviews come back with `reviewScope: "company"`.

#### Step 2: Filter and sort

Combine any of these filters (each counts once per emitted row):

- **Star ratings** (any of 1–5)
- **Published-date range** (inclusive)
- **Review text contains** (case-insensitive title + body)
- **Paid for product** (yes / no)
- **Has attachments** (yes / no)
- **Reviewer contains** (case-insensitive name or username)

Sort options:

- **Source / newest** (default, free)
- **Oldest**
- **Highest rating**
- **Lowest rating**

Filtering or non-default sorting can scan up to 10,000 candidates per company before trimming to your requested output size.

#### Step 3: Run and read results

Click **Start**. The Output tab has two ready-made views:

- **Reviews**: rating, text, publish date, reviewer, and company at a glance
- **Review details**: nested company, product, reviewer, and attachment enrichments

Always check the `status` field first. `success` means the row is a real review. Anything else explains what happened and is not billed.

#### Example output

A complete row from a company scan with every paid enrichment turned on.

```json
{
    "status": "success",
    "reviewId": "rev_01H8PZQK9F5C",
    "reviewScope": "company",
    "stars": 5,
    "text": "Great funding program. Their support desk actually answered on day one.",
    "reviewTitle": "Worth every dollar",
    "createdAt": "2026-06-10T21:05:05.000Z",
    "publishedAt": "2026-06-11T09:00:00.000Z",
    "paidForProduct": true,
    "reviewStatus": "PUBLISHED",
    "reviewerName": "T. Ryan",
    "reviewerUsername": "tryan",
    "companyId": "biz_MTlVhWWwhRjY9S",
    "companyTitle": "Fit Method",
    "companyUrl": "https://whop.com/fit-method/",
    "requestedUrls": ["https://whop.com/fit-method/beginner-plan/"],
    "inputTypes": ["product"],
    "company": {
        "id": "biz_MTlVhWWwhRjY9S",
        "title": "Fit Method",
        "url": "https://whop.com/fit-method/",
        "route": "fit-method",
        "verified": true,
        "memberCount": 4720,
        "reviewsAverage": 4.7,
        "publishedReviewsCount": 189,
        "createdAt": "2023-08-01T12:00:00.000Z",
        "businessType": "brand",
        "industryGroup": "health",
        "industryType": "fitness",
        "logoUrl": "https://cdn.whop.com/company-logo.png"
    },
    "products": [
        {
            "id": "prod_abc123",
            "title": "Fit Method Beginner Plan",
            "url": "https://whop.com/fit-method/beginner-plan/",
            "route": "beginner-plan",
            "headline": "Guided beginner training program",
            "description": "Beginner-friendly training program for new members.",
            "verified": true,
            "createdAt": "2024-05-11T18:22:03.000Z",
            "firstApprovedAt": "2024-05-12T09:00:00.000Z",
            "category": { "id": "mcat_fitness", "name": "Fitness" },
            "pricing": {
                "planId": "plan_1",
                "planType": "renewal",
                "currency": "usd",
                "initialPrice": 49,
                "renewalPrice": 49,
                "currentPriceUsd": 49,
                "period": "month",
                "free": false
            },
            "metrics": {
                "reviewsAverage": 4.8,
                "publishedReviewsCount": 312,
                "activeUsersCount": 1284,
                "whopRanking": 7,
                "productGmvUsd": 152430.25
            }
        }
    ],
    "reviewer": {
        "id": "user_29AB",
        "name": "T. Ryan",
        "username": "tryan",
        "accountCreatedAt": "2024-03-15T00:00:00.000Z",
        "joinedAt": "2025-03-14T00:00:00.000Z",
        "profilePictureUrl": "https://cdn.whop.com/avatars/tryan.png"
    },
    "attachments": [
        { "id": "att_01", "contentType": "image/png", "filename": "screenshot.png", "url": "https://cdn.whop.com/att/screenshot.png" }
    ],
    "scrapedAt": "2026-07-23T04:05:42.328Z",
    "error": null
}
````

### 💎 Add-ons

Optional extras, all off by default. Turn on only what a run needs.

- **Company details** *(paid)*: adds public verification, member count, aggregate ratings, industry fields, creation date, and logo. Charged only for rows where enrichment succeeded.
- **Requested product details** *(paid)*: for product URL inputs, adds public product identity, category, pricing, and marketplace metrics. Reviews stay company-scoped. Charged only for rows where enrichment succeeded.
- **Reviewer profile details** *(paid)*: adds the public reviewer ID, account and membership timestamps, and profile image. Charged only for rows where reviewer details were available.
- **Review attachments** *(paid)*: adds public attachment IDs, file metadata, and URLs. Charged only for rows containing at least one attachment with a usable URL.

### 💰 Pricing

Pay only for results you actually get back. No subscription, no minimum.

| Event | Price | When |
|---|---|---|
| Review scraped | **$0.49 per 1,000 reviews** | per normalized review row emitted to the dataset |
| Filter applied | **$0.10 per 1,000 results** | per active filter, per emitted row (multiple choices inside one filter still count as one) |
| Sort applied | **$0.10 per 1,000 results** | per emitted row, when a non-default sort is used |
| Company details | **$0.99 per 1,000 results** | per emitted row where company enrichment succeeded |
| Product details | **$0.99 per 1,000 results** | per emitted row where at least one requested product was enriched |
| Reviewer details | **$0.99 per 1,000 results** | per emitted row where reviewer details were available |
| Attachments | **$0.99 per 1,000 results** | per emitted row where at least one public attachment URL was returned |

No charge for filtered-out reviews, invalid input, empty results, unavailable exact URLs, or explanatory status rows. Apify's default start event may still apply.

### 💡 Good to know

- **Default 100 reviews per company.** Raise up to 10,000 per company and 50,000 per run.
- **Runs are independent.** No cross-run history is kept. Schedule runs and compare `reviewId` in your own tool to track new reviews.
- **Dedup is automatic.** The same company reached through a company URL and product URL is fetched and billed once. Review IDs are also deduped inside a company.
- **Reviews are company-scoped on Whop.** Rows are always tagged `reviewScope: "company"`.
- **Filtering and non-default sorting scan up to 10,000 candidates per company** before trimming to your `maxReviewsPerCompany` value. Highly restrictive filters can therefore return fewer rows than the limit even when more distant reviews exist.
- **Field coverage matches the source.** If Whop did not publish a value, the field comes back `null`. Toggles that are off omit the field from the row entirely.
- **Output toggles** let you trim each row to just the fields you actually need. Core status, scope, review ID, rating, text, company, requested URLs, timestamp, and error always stay on.
- Files and datasets live in your Apify storage. How long they are kept depends on your Apify plan.

### ❓ FAQ

**Are the reviews tied to a specific product?**
No. Whop's public review feed is company-scoped. A product URL resolves to its owning company. The Actor keeps the requested product URL and product-details enrichment attached to the row for traceability.

**Does it track a review over time?**
No. Every run is a current public snapshot. To watch a company, schedule runs and compare `reviewId` values across snapshots in your own tool.

**Why is a field null?**
Not every review publishes every value. `null` means the field was requested but the public page did not include it at scrape time.

**Do I need a Whop account?**
No. Only public review pages are read.

**Can I scrape private, paid, or member-only content?**
No. Login-gated, chat, member-only, and paid content are out of scope.

**Which proxy should I use?**
Nothing on your side. Networking is managed by the Actor automatically.

**Can I run this on a schedule?**
Yes. Use Apify Schedules to run the Actor on any cadence (hourly, daily, custom cron).

**How long are my results stored?**
Results live in your Apify dataset. How long they are kept depends on your Apify plan.

### ⚖️ Legal Disclaimer

This Actor is for educational, research, and market-intelligence use. It extracts public commercial data (review text, ratings, timestamps, public reviewer identity, and public attachments) from publicly accessible Whop pages. The developer does not host, store, or possess any output; all data is delivered to your Apify dataset. No login-gated or private user data is collected.

By running this Actor, **you assume full responsibility** for compliance with applicable laws, Whop's Terms of Service, and any data-protection regulations in your target jurisdiction (e.g. GDPR, CCPA). The developer assumes **no liability** for platform blocks, bans, regulatory actions, or any other consequences of your use.

This software is provided **"as-is"** with no warranty. Ratings, review text, aggregate metrics, and other exposed values are public snapshots, not audited figures. Data availability depends on the source at run time.

**Keywords:** Whop scraper, Whop reviews scraper, Whop review API, Whop company scraper, review sentiment tracker, review dataset, marketplace reviews, creator economy data, competitor review spy, reputation tracker, Whop reviews export, review dataset for research, Whop review filter, review dataset for LLM.

# Actor input Schema

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

Direct public Whop company or product URLs, one per line.

## `maxReviewsPerCompany` (type: `integer`):

How many reviews to return for each resolved company. Run-wide safety cap is 50,000 reviews.

## `ratings` (type: `array`):

Keep reviews with any selected star rating. Multiple stars inside this filter still count as one filter.

## `publishedAfter` (type: `string`):

Earliest review publication date, inclusive. Setting either date bound activates one paid date filter.

## `publishedBefore` (type: `string`):

Latest review publication date, inclusive.

## `searchText` (type: `string`):

Case-insensitive match against the public review title and body.

## `paidForProduct` (type: `string`):

Keep all reviews, only reviews marked as paid for a product, or only reviews not marked that way.

## `hasAttachments` (type: `string`):

Keep all reviews, only reviews with public attachments, or only reviews without attachments.

## `reviewerSearch` (type: `string`):

Case-insensitive match against the public reviewer display name or username.

## `sortBy` (type: `string`):

Source / newest order is free. Any other sort costs one sorting event per emitted review.

## `includeCompanyDetails` (type: `boolean`):

Adds public company verification, member count, aggregate review metrics, industry, creation date, and logo. Charged only for rows where enrichment succeeded.

## `includeProductDetails` (type: `boolean`):

For product URL inputs, adds public product identity, category, pricing, and marketplace metrics. Reviews stay company-scoped. Charged only for rows where enrichment succeeded.

## `includeReviewerDetails` (type: `boolean`):

Adds public reviewer ID, account and membership timestamps, and profile image. Charged only for rows where reviewer details were available.

## `includeAttachments` (type: `boolean`):

Adds public attachment IDs, file metadata, and URLs. Charged only for rows containing at least one attachment with a usable URL.

## `outputReviewTitle` (type: `boolean`):

Include the optional public review title.

## `outputCreatedAt` (type: `boolean`):

Include when the review was originally created.

## `outputPublishedAt` (type: `boolean`):

Include when the review was publicly published.

## `outputPaidForProduct` (type: `boolean`):

Include the public paid-for-product indicator when available.

## `outputReviewStatus` (type: `boolean`):

Include the review's public source status.

## `outputReviewerName` (type: `boolean`):

Include the public reviewer display name.

## `outputReviewerUsername` (type: `boolean`):

Include the public reviewer username.

## `outputJoinedAt` (type: `boolean`):

Include when the reviewer joined the company or product (public purchase timestamp).

## `outputMembershipDuration` (type: `boolean`):

Include the integer number of days between the reviewer's join date and the review's publish date. Whop UI shows this as 'N months after purchase'.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://whop.com/creator-camp/"
    }
  ],
  "maxReviewsPerCompany": 100,
  "ratings": [],
  "paidForProduct": "any",
  "hasAttachments": "any",
  "sortBy": "source",
  "includeCompanyDetails": false,
  "includeProductDetails": false,
  "includeReviewerDetails": false,
  "includeAttachments": false,
  "outputReviewTitle": true,
  "outputCreatedAt": true,
  "outputPublishedAt": true,
  "outputPaidForProduct": true,
  "outputReviewStatus": true,
  "outputReviewerName": true,
  "outputReviewerUsername": true,
  "outputJoinedAt": true,
  "outputMembershipDuration": true
}
```

# Actor output Schema

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

One public company review per result row.

# 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 = {
    "startUrls": [
        {
            "url": "https://whop.com/creator-camp/"
        }
    ],
    "maxReviewsPerCompany": 100,
    "sortBy": "source"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lurkapi/whop-reviews-scraper-api").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 = {
    "startUrls": [{ "url": "https://whop.com/creator-camp/" }],
    "maxReviewsPerCompany": 100,
    "sortBy": "source",
}

# Run the Actor and wait for it to finish
run = client.actor("lurkapi/whop-reviews-scraper-api").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 '{
  "startUrls": [
    {
      "url": "https://whop.com/creator-camp/"
    }
  ],
  "maxReviewsPerCompany": 100,
  "sortBy": "source"
}' |
apify call lurkapi/whop-reviews-scraper-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Whop Reviews Scraper API",
        "description": "Scrape every public Whop review at scale. Filter by stars, date, keyword, reviewer. Rank oldest or by rating. Enrich with company, product, reviewer, and attachment details on demand.",
        "version": "0.0",
        "x-build-id": "fhoWmM7w4Bdqjgcc9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lurkapi~whop-reviews-scraper-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lurkapi-whop-reviews-scraper-api",
                "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/lurkapi~whop-reviews-scraper-api/runs": {
            "post": {
                "operationId": "runs-sync-lurkapi-whop-reviews-scraper-api",
                "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/lurkapi~whop-reviews-scraper-api/run-sync": {
            "post": {
                "operationId": "run-sync-lurkapi-whop-reviews-scraper-api",
                "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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Whop company or product URLs",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Direct public Whop company or product URLs, one per line.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "description": "Direct public Whop company or product URL.",
                                    "type": "string",
                                    "minLength": 1,
                                    "maxLength": 2000
                                }
                            }
                        }
                    },
                    "maxReviewsPerCompany": {
                        "title": "Maximum reviews per company",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "How many reviews to return for each resolved company. Run-wide safety cap is 50,000 reviews.",
                        "default": 100
                    },
                    "ratings": {
                        "title": "Star ratings ($)",
                        "maxItems": 5,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep reviews with any selected star rating. Multiple stars inside this filter still count as one filter.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "1 star",
                                "2 stars",
                                "3 stars",
                                "4 stars",
                                "5 stars"
                            ]
                        },
                        "default": []
                    },
                    "publishedAfter": {
                        "title": "Published on or after ($)",
                        "type": "string",
                        "description": "Earliest review publication date, inclusive. Setting either date bound activates one paid date filter."
                    },
                    "publishedBefore": {
                        "title": "Published on or before ($)",
                        "type": "string",
                        "description": "Latest review publication date, inclusive."
                    },
                    "searchText": {
                        "title": "Review text contains ($)",
                        "maxLength": 200,
                        "type": "string",
                        "description": "Case-insensitive match against the public review title and body."
                    },
                    "paidForProduct": {
                        "title": "Paid for product ($)",
                        "enum": [
                            "any",
                            "yes",
                            "no"
                        ],
                        "type": "string",
                        "description": "Keep all reviews, only reviews marked as paid for a product, or only reviews not marked that way.",
                        "default": "any"
                    },
                    "hasAttachments": {
                        "title": "Has attachments ($)",
                        "enum": [
                            "any",
                            "yes",
                            "no"
                        ],
                        "type": "string",
                        "description": "Keep all reviews, only reviews with public attachments, or only reviews without attachments.",
                        "default": "any"
                    },
                    "reviewerSearch": {
                        "title": "Reviewer contains ($)",
                        "maxLength": 100,
                        "type": "string",
                        "description": "Case-insensitive match against the public reviewer display name or username."
                    },
                    "sortBy": {
                        "title": "Sort reviews",
                        "enum": [
                            "source",
                            "oldest",
                            "highestRating",
                            "lowestRating"
                        ],
                        "type": "string",
                        "description": "Source / newest order is free. Any other sort costs one sorting event per emitted review.",
                        "default": "source"
                    },
                    "includeCompanyDetails": {
                        "title": "Company details ($)",
                        "type": "boolean",
                        "description": "Adds public company verification, member count, aggregate review metrics, industry, creation date, and logo. Charged only for rows where enrichment succeeded.",
                        "default": false
                    },
                    "includeProductDetails": {
                        "title": "Requested product details ($)",
                        "type": "boolean",
                        "description": "For product URL inputs, adds public product identity, category, pricing, and marketplace metrics. Reviews stay company-scoped. Charged only for rows where enrichment succeeded.",
                        "default": false
                    },
                    "includeReviewerDetails": {
                        "title": "Reviewer profile details ($)",
                        "type": "boolean",
                        "description": "Adds public reviewer ID, account and membership timestamps, and profile image. Charged only for rows where reviewer details were available.",
                        "default": false
                    },
                    "includeAttachments": {
                        "title": "Review attachments ($)",
                        "type": "boolean",
                        "description": "Adds public attachment IDs, file metadata, and URLs. Charged only for rows containing at least one attachment with a usable URL.",
                        "default": false
                    },
                    "outputReviewTitle": {
                        "title": "Output: review title",
                        "type": "boolean",
                        "description": "Include the optional public review title.",
                        "default": true
                    },
                    "outputCreatedAt": {
                        "title": "Output: created date",
                        "type": "boolean",
                        "description": "Include when the review was originally created.",
                        "default": true
                    },
                    "outputPublishedAt": {
                        "title": "Output: published date",
                        "type": "boolean",
                        "description": "Include when the review was publicly published.",
                        "default": true
                    },
                    "outputPaidForProduct": {
                        "title": "Output: paid-for-product indicator",
                        "type": "boolean",
                        "description": "Include the public paid-for-product indicator when available.",
                        "default": true
                    },
                    "outputReviewStatus": {
                        "title": "Output: source review status",
                        "type": "boolean",
                        "description": "Include the review's public source status.",
                        "default": true
                    },
                    "outputReviewerName": {
                        "title": "Output: reviewer name",
                        "type": "boolean",
                        "description": "Include the public reviewer display name.",
                        "default": true
                    },
                    "outputReviewerUsername": {
                        "title": "Output: reviewer username",
                        "type": "boolean",
                        "description": "Include the public reviewer username.",
                        "default": true
                    },
                    "outputJoinedAt": {
                        "title": "Output: reviewer joined date",
                        "type": "boolean",
                        "description": "Include when the reviewer joined the company or product (public purchase timestamp).",
                        "default": true
                    },
                    "outputMembershipDuration": {
                        "title": "Output: days as member at review",
                        "type": "boolean",
                        "description": "Include the integer number of days between the reviewer's join date and the review's publish date. Whop UI shows this as 'N months after purchase'.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
