# Trustpilot Reviews Scraper — Full Review Coverage (`blackfalcondata/trustpilot-reviews-scraper`) Actor

Scrape trustpilot.com — full review coverage beyond Trustpilot’s 200-review display limit. TrustScores, star ratings, reviewer profiles, company contact data, and transparency reports. Incremental mode detects new reviews. Compact output for AI agents.

- **URL**: https://apify.com/blackfalcondata/trustpilot-reviews-scraper.md
- **Developed by:** [Black Falcon Data](https://apify.com/blackfalcondata) (community)
- **Categories:** E-commerce, Lead generation, AI
- **Stats:** 3 total users, 2 monthly users, 97.9% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

### What does Trustpilot Reviews Scraper do?

Trustpilot Reviews Scraper extracts structured review data from [trustpilot.com](https://www.trustpilot.com) — the world's largest open review platform with over 300 million reviews across 1 million+ businesses. Extract reviews, company profiles, transparency reports, and competitive intelligence in seconds.

No login required. No credentials needed. Just enter a company domain and get structured data.

### Features

- ⭐ **Review extraction** — rating, title, full text, dates, language, likes, verification status, and reviewer profile
- 🏢 **Company profiles** — trust score, star breakdown, categories, website, city, country, and contact data (email + phone)
- 📊 **Transparency reports** — reply rates, organic vs. invited review share, flagged review counts, and monthly distributions
- 🔍 **14+ filters** — star rating, language, date range, topics, verified only, with reply, reviewer country, and keyword search
- 🌍 **Multi-language** — filter by language or extract the full language distribution for any company
- 📈 **Incremental monitoring** — only return new or changed reviews on recurring runs, saving time and cost
- 💬 **Company replies** — reply text, reply date, response rate, and average response time
- 👤 **Reviewer profiles** — name, country, total reviews, verification status, and reviews on same domain
- 🤖 **AI-ready output** — compact mode (16 fields), custom field selection, and `descriptionMaxLength` for token-efficient payloads
- 🔗 **4 modes** — Reviews, Company Info, Search Companies, and Browse Categories in a single actor
- 🔄 **Similar companies** — discover competitors based on Trustpilot's own similarity data
- 🧠 **AI summary** — extract Trustpilot's AI-generated review summary when available

### What Trustpilot review data can you extract?

Each review record includes up to 52 fields covering the review itself, the reviewer, the company, and enrichment data. Every field is always present — unavailable data points are returned as `null`, never omitted.

**Review data:** `reviewId`, `reviewUrl`, `rating`, `title`, `text`, `language`, `reviewSource` (Organic/Invitation), `likes`, `publishedDate`, `experiencedDate`, `updatedDate`, `isVerified`, `verificationLevel`

**Reviewer data:** `authorId`, `reviewerName`, `reviewerCountry`, `reviewerTotalReviews`, `reviewerIsVerified`, `reviewerImageUrl`, `reviewsOnSameDomain`

**Company reply:** `replyText`, `replyDate`, `replyUpdatedDate`

**Company profile** (when `includeCompanyInfo` is enabled): `companyTrustScore`, `companyStars`, `companyTotalReviews`, `companyWebsite`, `companyIsClaimed`, `companyCategories`, `companyCity`, `companyCountry`, `companyContactEmail`, `companyContactPhone`, `companyResponseRate`, `companyResponseTime`

**Star breakdown:** `companyRating1Star` through `companyRating5Star`

**Enrichment:** `languageDistribution`, `similarCompanies`, `aiSummary`, `productReviews`

### Input

Enter a company domain, company name, or a direct Trustpilot URL to get started. The actor resolves company names automatically.

#### Key parameters

- **`mode`** — What to scrape: `reviews` (default), `searchCompanies`, `categories`, or `companyInfo`
- **`companyDomain`** — Company domain as used on Trustpilot, e.g. `booking.com` or `wise.com`
- **`companyName`** — Company name to search for (resolved automatically to the Trustpilot domain slug)
- **`startUrls`** — Direct Trustpilot review page URLs
- **`maxResults`** — Maximum reviews to return per company. 0 = unlimited (default: 200)
- **`stars`** — Filter by star rating, e.g. `[1, 2]` for negative reviews only
- **`languages`** — Filter by review language ISO codes, e.g. `["en", "de"]`
- **`date`** — Time period: `last30days`, `last3months`, `last6months`, `last12months`, or `older`
- **`lookbackDays`** — Rolling window: only reviews from the last N days (1-365)
- **`topics`** — Topic filter: `customer_service`, `delivery_service`, `price`, `product`, and 15 more
- **`verified`** — Only verified reviews
- **`withReplies`** — Only reviews with a company reply
- **`search`** — Keyword search within review text
- **`countryOfReviewer`** — Filter by reviewer country (ISO code)
- **`includeCompanyInfo`** — Include company metadata, trust score, contact, and star breakdown (default: true)
- **`includeTransparency`** — Fetch the Trustpilot transparency report per company
- **`compact`** — Return 16 core fields only, ideal for AI agents and LLM pipelines
- **`fields`** — Return only these specific fields, e.g. `["reviewId", "rating", "text"]`. Overrides compact mode
- **`incrementalMode`** — Only return new and changed reviews compared to the previous run
- **`descriptionMaxLength`** — Truncate review text to N characters (useful for token budgets)

#### Input example

```json
{
  "companyDomain": "booking.com",
  "maxResults": 50,
  "includeCompanyInfo": true
}
````

### Output

Each run produces a dataset of structured review records. Download as JSON, CSV, or Excel from the Dataset tab, or retrieve results programmatically through the [Apify API](https://docs.apify.com/api/v2).

#### Example review record

```json
{
  "type": "review",
  "reviewId": "68362b480787ca52990267fc",
  "reviewUrl": "https://www.trustpilot.com/reviews/68362b480787ca52990267fc",
  "companyDomain": "booking.com",
  "companyName": "Booking.com",
  "rating": 1,
  "title": "Terrible customer service",
  "text": "Called support after my accommodation was cancelled. They hung up without offering an alternative.",
  "language": "en",
  "reviewSource": "Organic",
  "likes": 0,
  "publishedDate": "2025-05-27T23:14:48.000Z",
  "experiencedDate": "2025-05-27T00:00:00.000Z",
  "updatedDate": null,
  "isVerified": false,
  "verificationLevel": "not-verified",
  "authorId": "5f05eec809a036394b2d2f7c",
  "reviewerName": "Ronald",
  "reviewerCountry": "NL",
  "reviewerTotalReviews": 3,
  "reviewerIsVerified": false,
  "replyText": null,
  "replyDate": null,
  "companyTrustScore": 1.8,
  "companyStars": 2,
  "companyTotalReviews": 107769,
  "companyWebsite": "https://www.booking.com",
  "companyIsClaimed": true,
  "companyCategories": ["Travel Aggregator", "Hotel"],
  "companyCity": "Amsterdam",
  "companyCountry": "NL",
  "companyContactEmail": "customer.service@booking.com",
  "companyContactPhone": "+31 20 712 5600",
  "companyResponseRate": 0,
  "companyResponseTime": "0 days",
  "companyRating1Star": 75306,
  "companyRating2Star": 3724,
  "companyRating3Star": 2399,
  "companyRating4Star": 4713,
  "companyRating5Star": 21627,
  "portalUrl": "https://www.trustpilot.com/review/booking.com",
  "scrapedAt": "2026-04-05T13:44:12.000Z",
  "source": "trustpilot.com"
}
```

In compact mode, output is reduced to 16 core fields: `reviewId`, `reviewUrl`, `companyDomain`, `companyName`, `rating`, `title`, `text`, `language`, `publishedDate`, `experiencedDate`, `isVerified`, `reviewerName`, `reviewerCountry`, `replyText`, `companyTrustScore`, and `changeType`.

With the `fields` parameter, you pick exactly which fields you need — nothing more, nothing less.

### How to scrape Trustpilot reviews

1. Go to [Trustpilot Reviews Scraper](https://apify.com/blackfalcondata/trustpilot-reviews-scraper) in Apify Console.
2. Enter a company domain (e.g. `booking.com`) or company name.
3. Set `maxResults` to control how many reviews you need.
4. Add filters: star rating, language, date range, topics, or keyword search.
5. Click **Start** and wait for the run to finish.
6. Export the dataset as JSON, CSV, or Excel.

For large-scale extraction, set `maxResults` to `0` (unlimited) and let the actor paginate through all available reviews automatically.

### Use Trustpilot Reviews Scraper with AI agents and MCP

This actor is designed to work as a tool for AI agents through Apify's [MCP Server](https://docs.apify.com/platform/integrations/mcp). Your AI assistant can search for companies, extract reviews, and analyze sentiment — all within a single conversation.

#### Supported AI clients

Connect from **Claude Desktop**, **Cursor**, **VS Code** (GitHub Copilot), **Claude.ai**, or any MCP-compatible client. One-line setup:

```json
{
  "mcpServers": {
    "apify": { "url": "https://mcp.apify.com" }
  }
}
```

#### Why this actor is optimized for AI workflows

- **Compact mode** — 16 core fields instead of 52, keeping LLM context usage minimal
- **Custom field selection** — use the `fields` parameter to return only the exact fields your pipeline needs
- **`descriptionMaxLength`** — truncate review text to fit token budgets
- **Stable JSON schema** — every field is always present (`null` when unavailable), so agents can parse results without defensive error handling
- **4 modes in one actor** — search companies, pull reviews, fetch profiles, and get transparency reports without switching tools
- **Incremental mode** — schedule recurring runs that only return new or changed reviews, ideal for agent-driven monitoring and alerting

#### Example agent prompts

- *"Pull the last 50 reviews for booking.com and summarize the main complaints"*
- *"Compare trust scores and response rates for the top 5 car insurance companies on Trustpilot"*
- *"Monitor reviews for my company and alert me when a 1-star review mentions refund"*
- *"Find all verified negative reviews in German from the last 30 days"*

### Use cases

- **Brand reputation monitoring** — track your company's Trustpilot reviews on a schedule and get alerted to new negative reviews.
- **Competitive intelligence** — compare trust scores, star breakdowns, response rates, and review volumes across competitors.
- **Sentiment analysis** — extract review text at scale and feed it into NLP or LLM pipelines for topic detection and sentiment scoring.
- **Market research** — use Search Companies mode to discover businesses in a category and rank them by trust score.
- **Lead generation** — extract company contact data (email, phone, website) from Trustpilot company profiles.
- **Review transparency audits** — pull transparency reports to analyze the mix of organic vs. invited reviews, flagged review counts, and response behavior.
- **Multi-language analysis** — use language distribution data to understand which markets are reviewing a company.
- **Customer experience benchmarking** — export star breakdowns and response times to compare service quality across an industry.
- **AI-powered alerting** — combine incremental mode with an AI agent to automatically classify and route new reviews.
- **Data enrichment** — add Trustpilot trust scores and review counts to your existing business datasets.

### How much does it cost to scrape Trustpilot?

Trustpilot Reviews Scraper is **free to use**. There is no start fee and no per-result charge.

You only pay for the Apify platform resources your run consumes (compute and memory). A typical run extracting 1,000 reviews uses approximately 256 MB of memory and completes in under 10 seconds.

### FAQ

#### How many reviews can I extract from Trustpilot?

There is no hard limit on the number of reviews you can extract. Set `maxResults` to `0` for unlimited extraction. The actor paginates through all available reviews automatically and can extract thousands of reviews per company.

#### Does Trustpilot Reviews Scraper support scheduled monitoring?

Yes. Enable `incrementalMode` and set a `stateKey` to only receive new or changed reviews on subsequent runs. This is ideal for daily or weekly monitoring where you want to track changes without re-processing the full dataset. Incremental runs are fast because they skip unchanged reviews.

#### What are the 4 modes?

- **Reviews** (default) — extract reviews for one or more companies
- **Company Info** — fetch company profiles with trust scores, contact data, and star breakdowns
- **Search Companies** — find companies by keyword (e.g. "car insurance") and country
- **Categories** — browse a Trustpilot category page and extract all listed companies

#### How does the fields parameter work?

Three levels of output control:

| Input | Result |
|-------|--------|
| Nothing set | All 52 fields |
| `compact: true` | 16-field preset: `reviewId`, `reviewUrl`, `companyDomain`, `companyName`, `rating`, `title`, `text`, `language`, `publishedDate`, `experiencedDate`, `isVerified`, `reviewerName`, `reviewerCountry`, `replyText`, `companyTrustScore`, `changeType` |
| `fields: ["reviewId", "rating", "text"]` | Exactly those 3 fields — nothing more |

If both `compact` and `fields` are set, `fields` wins (full override).

**Unrecognized field names are silently ignored.** If you pass `fields: ["reviewId", "nonExistentField"]`, you get only `reviewId`. No error is thrown — this makes it safe to use a superset of field names across different actors.

**Example: all fields (default)**

```json
{ "companyDomain": "booking.com", "maxResults": 50 }
```

Returns 52 fields per review including company info, star breakdown, and enrichment data.

**Example: compact mode (AI/MCP preset)**

```json
{ "companyDomain": "booking.com", "maxResults": 50, "compact": true }
```

Returns 16 fields: identity, rating, text, dates, reviewer, and trust score. Designed for LLM context efficiency.

**Example: custom field selection**

```json
{ "companyDomain": "booking.com", "maxResults": 50, "fields": ["reviewId", "rating", "title", "text", "publishedDate", "reviewerCountry"] }
```

Returns exactly those 6 fields per review — ideal when you know precisely what your pipeline needs.

#### Can I integrate Trustpilot Reviews Scraper with other apps?

Yes. The actor works with Apify's [integrations](https://apify.com/integrations) to connect with tools like Zapier, Make, Google Sheets, Slack, and more. You can also use webhooks to trigger actions when a run completes.

#### Can I use Trustpilot Reviews Scraper with the Apify API?

Yes. Start runs, manage inputs, and retrieve results programmatically through the [Apify API](https://docs.apify.com/api/v2). Client libraries are available for JavaScript and Python.

#### Is it legal to scrape Trustpilot?

This actor extracts publicly available data from trustpilot.com. Web scraping of public information is generally considered legal, but you should review the target site's terms of service and ensure your use case complies with applicable laws, including GDPR where relevant.

#### Your feedback

If you have questions, need a feature, or found a bug, please [open an issue](https://apify.com/blackfalcondata/trustpilot-reviews-scraper/issues) on the actor's page in Apify Console.

# Actor input Schema

## `mode` (type: `string`):

What to scrape. reviews = review data (default). searchCompanies = find companies by keyword. categories = browse a Trustpilot category. companyInfo = company profiles only (no reviews).

## `companyDomain` (type: `string`):

Company domain as used on Trustpilot, e.g. 'booking.com' or 'www.amazon.com'.

## `companyName` (type: `string`):

Company name to search for. Resolved automatically to the Trustpilot domain slug.

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

List of Trustpilot review page URLs, e.g. https://www.trustpilot.com/review/booking.com

## `searchQuery` (type: `string`):

Company search keyword (for searchCompanies mode). E.g. 'car insurance', 'web hosting'.

## `searchCountry` (type: `string`):

ISO country code for company search results. Default: US.

## `searchMaxPages` (type: `integer`):

Max pages of search/category results to fetch (5 results per page). Default: 5.

## `categoryUrl` (type: `string`):

Trustpilot category URL for categories mode. E.g. 'https://www.trustpilot.com/categories/electronics\_technology'.

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

Maximum reviews to return per company (0 = unlimited). Default: 200.

## `stars` (type: `array`):

Only return reviews with these star ratings. Leave empty for all ratings.

## `languages` (type: `array`):

Filter by review language ISO codes, e.g. \['en', 'de', 'fr']. Leave empty for all languages.

## `date` (type: `string`):

Only return reviews from this time period.

## `lookbackDays` (type: `integer`):

Rolling window: only return reviews published within the last N days. Overrides date range when set. Use with sort=recency for efficient early termination.

## `topics` (type: `array`):

Filter by Trustpilot topic categories. Leave empty for all topics. E.g. \["customer\_service", "delivery\_service"]

## `verified` (type: `boolean`):

Return only verified reviews.

## `withReplies` (type: `boolean`):

Return only reviews that have a company reply.

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

Review sort order.

## `countryOfReviewer` (type: `string`):

Only return reviews from reviewers in this country. ISO Alpha-2 code, e.g. 'US', 'GB', 'DE'.

## `search` (type: `string`):

Keyword search within review text.

## `includeCompanyInfo` (type: `boolean`):

Include company metadata: trust score, total reviews, star breakdown, categories, website, contact, and AI summary.

## `includeProductReviews` (type: `boolean`):

Include associated product review data when available. Adds a productReviews array to each review.

## `includeTransparency` (type: `boolean`):

Fetch the Trustpilot transparency report per company (+1 request). Adds a separate record with reply rate, organic share, flagged review counts, monthly distributions, and verification status. Auto-included in companyInfo mode.

## `descriptionMaxLength` (type: `integer`):

Truncate review text to N characters. 0 = no truncation.

## `compact` (type: `boolean`):

Return core review fields only: reviewId, reviewUrl, rating, title, text, dates, reviewer, companyTrustScore. Ideal for AI pipelines and MCP integrations. Overridden by 'fields' if set.

## `fields` (type: `array`):

Return only these fields. Overrides compact mode. E.g. \["reviewId", "rating", "title", "text", "publishedDate"]. Leave empty for all fields (or use compact for the default subset).

## `incrementalMode` (type: `boolean`):

Only return new and changed reviews compared to the previous run. Requires stateKey.

## `stateKey` (type: `string`):

Unique identifier for this tracking job, e.g. 'booking-com-monitor'. Required when incrementalMode is enabled.

## `authCookiesJson` (type: `string`):

Optional Trustpilot consumer auth cookies as JSON. Accepts either the exported envelope with all\_cookies or a plain cookie object. When provided, the actor verifies page 11 access and switches to full linear pagination. Leave empty for cookieless mode.

## `requestDelayMs` (type: `integer`):

Delay between HTTP requests in milliseconds. Use to reduce rate-limit risk on large jobs. Default: 0.

## Actor input object example

```json
{
  "mode": "reviews",
  "companyDomain": "booking.com",
  "searchCountry": "US",
  "searchMaxPages": 5,
  "maxResults": 50,
  "date": "",
  "verified": false,
  "withReplies": false,
  "sort": "recency",
  "includeCompanyInfo": true,
  "includeProductReviews": false,
  "includeTransparency": false,
  "descriptionMaxLength": 0,
  "compact": false,
  "incrementalMode": false,
  "requestDelayMs": 0
}
```

# Actor output Schema

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

No description

# 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 = {
    "companyDomain": "booking.com",
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("blackfalcondata/trustpilot-reviews-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 = {
    "companyDomain": "booking.com",
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("blackfalcondata/trustpilot-reviews-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 '{
  "companyDomain": "booking.com",
  "maxResults": 50
}' |
apify call blackfalcondata/trustpilot-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Reviews Scraper — Full Review Coverage",
        "description": "Scrape trustpilot.com — full review coverage beyond Trustpilot’s 200-review display limit. TrustScores, star ratings, reviewer profiles, company contact data, and transparency reports. Incremental mode detects new reviews. Compact output for AI agents.",
        "version": "0.1",
        "x-build-id": "K7tNZGXSvSU3fv20A"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/blackfalcondata~trustpilot-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-blackfalcondata-trustpilot-reviews-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/blackfalcondata~trustpilot-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-blackfalcondata-trustpilot-reviews-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/blackfalcondata~trustpilot-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-blackfalcondata-trustpilot-reviews-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",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "reviews",
                            "searchCompanies",
                            "categories",
                            "companyInfo"
                        ],
                        "type": "string",
                        "description": "What to scrape. reviews = review data (default). searchCompanies = find companies by keyword. categories = browse a Trustpilot category. companyInfo = company profiles only (no reviews).",
                        "default": "reviews"
                    },
                    "companyDomain": {
                        "title": "Company Domain",
                        "type": "string",
                        "description": "Company domain as used on Trustpilot, e.g. 'booking.com' or 'www.amazon.com'."
                    },
                    "companyName": {
                        "title": "Company Name",
                        "type": "string",
                        "description": "Company name to search for. Resolved automatically to the Trustpilot domain slug."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "List of Trustpilot review page URLs, e.g. https://www.trustpilot.com/review/booking.com",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Company search keyword (for searchCompanies mode). E.g. 'car insurance', 'web hosting'."
                    },
                    "searchCountry": {
                        "title": "Search Country",
                        "type": "string",
                        "description": "ISO country code for company search results. Default: US.",
                        "default": "US"
                    },
                    "searchMaxPages": {
                        "title": "Search Max Pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Max pages of search/category results to fetch (5 results per page). Default: 5.",
                        "default": 5
                    },
                    "categoryUrl": {
                        "title": "Category URL",
                        "type": "string",
                        "description": "Trustpilot category URL for categories mode. E.g. 'https://www.trustpilot.com/categories/electronics_technology'."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum reviews to return per company (0 = unlimited). Default: 200.",
                        "default": 200
                    },
                    "stars": {
                        "title": "Star Ratings",
                        "type": "array",
                        "description": "Only return reviews with these star ratings. Leave empty for all ratings.",
                        "items": {
                            "type": "integer",
                            "minimum": 1,
                            "maximum": 5
                        }
                    },
                    "languages": {
                        "title": "Languages",
                        "type": "array",
                        "description": "Filter by review language ISO codes, e.g. ['en', 'de', 'fr']. Leave empty for all languages.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "date": {
                        "title": "Date Range",
                        "enum": [
                            "",
                            "last30days",
                            "last3months",
                            "last6months",
                            "last12months",
                            "older"
                        ],
                        "type": "string",
                        "description": "Only return reviews from this time period.",
                        "default": ""
                    },
                    "lookbackDays": {
                        "title": "Lookback Days",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Rolling window: only return reviews published within the last N days. Overrides date range when set. Use with sort=recency for efficient early termination."
                    },
                    "topics": {
                        "title": "Topics",
                        "type": "array",
                        "description": "Filter by Trustpilot topic categories. Leave empty for all topics. E.g. [\"customer_service\", \"delivery_service\"]",
                        "items": {
                            "type": "string"
                        }
                    },
                    "verified": {
                        "title": "Verified Reviews Only",
                        "type": "boolean",
                        "description": "Return only verified reviews.",
                        "default": false
                    },
                    "withReplies": {
                        "title": "With Company Reply Only",
                        "type": "boolean",
                        "description": "Return only reviews that have a company reply.",
                        "default": false
                    },
                    "sort": {
                        "title": "Sort Order",
                        "enum": [
                            "recency",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Review sort order.",
                        "default": "recency"
                    },
                    "countryOfReviewer": {
                        "title": "Country of Reviewer",
                        "type": "string",
                        "description": "Only return reviews from reviewers in this country. ISO Alpha-2 code, e.g. 'US', 'GB', 'DE'."
                    },
                    "search": {
                        "title": "Search within Reviews",
                        "type": "string",
                        "description": "Keyword search within review text."
                    },
                    "includeCompanyInfo": {
                        "title": "Include Company Info",
                        "type": "boolean",
                        "description": "Include company metadata: trust score, total reviews, star breakdown, categories, website, contact, and AI summary.",
                        "default": true
                    },
                    "includeProductReviews": {
                        "title": "Include Product Reviews",
                        "type": "boolean",
                        "description": "Include associated product review data when available. Adds a productReviews array to each review.",
                        "default": false
                    },
                    "includeTransparency": {
                        "title": "Include Transparency Report",
                        "type": "boolean",
                        "description": "Fetch the Trustpilot transparency report per company (+1 request). Adds a separate record with reply rate, organic share, flagged review counts, monthly distributions, and verification status. Auto-included in companyInfo mode.",
                        "default": false
                    },
                    "descriptionMaxLength": {
                        "title": "Review Text Max Length",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Truncate review text to N characters. 0 = no truncation.",
                        "default": 0
                    },
                    "compact": {
                        "title": "Compact Output (MCP/AI-agent mode)",
                        "type": "boolean",
                        "description": "Return core review fields only: reviewId, reviewUrl, rating, title, text, dates, reviewer, companyTrustScore. Ideal for AI pipelines and MCP integrations. Overridden by 'fields' if set.",
                        "default": false
                    },
                    "fields": {
                        "title": "Custom Fields",
                        "type": "array",
                        "description": "Return only these fields. Overrides compact mode. E.g. [\"reviewId\", \"rating\", \"title\", \"text\", \"publishedDate\"]. Leave empty for all fields (or use compact for the default subset).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "incrementalMode": {
                        "title": "Incremental Mode",
                        "type": "boolean",
                        "description": "Only return new and changed reviews compared to the previous run. Requires stateKey.",
                        "default": false
                    },
                    "stateKey": {
                        "title": "State Key",
                        "type": "string",
                        "description": "Unique identifier for this tracking job, e.g. 'booking-com-monitor'. Required when incrementalMode is enabled."
                    },
                    "authCookiesJson": {
                        "title": "Auth Cookies JSON",
                        "type": "string",
                        "description": "Optional Trustpilot consumer auth cookies as JSON. Accepts either the exported envelope with all_cookies or a plain cookie object. When provided, the actor verifies page 11 access and switches to full linear pagination. Leave empty for cookieless mode."
                    },
                    "requestDelayMs": {
                        "title": "Request Delay (ms)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Delay between HTTP requests in milliseconds. Use to reduce rate-limit risk on large jobs. Default: 0.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
