# Trustpilot Scraper — All Reviews, Contacts & No 200 Cap (`corvuslab/trustpilot-scraper`) Actor

Scrape every Trustpilot review — past the 200-review page cap — with ratings, full text, verification, reviewer profiles, company replies, TrustScore and the full star distribution. Find companies by keyword or category with email, phone and address. Incremental monitoring and alerts.

- **URL**: https://apify.com/corvuslab/trustpilot-scraper.md
- **Developed by:** [Corvuslab](https://apify.com/corvuslab) (community)
- **Categories:** Business, Lead generation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.40 / 1,000 results

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### What does Trustpilot Scraper do?

Scrape **every review** a company has on [Trustpilot](https://www.trustpilot.com) — not the ~200 a public listing
will hand over. Each record carries the star rating, full text, verification status,
reviewer profile, company reply and a **complete company panel**: TrustScore, the full
1–5 star distribution, reply rate, categories and contact details.

Switch modes and the same actor becomes a **B2B prospecting tool** — find companies by
keyword or browse a whole Trustpilot category and get **email, phone and address** for
every business it returns.

**No Trustpilot account, cookie or proxy setup needed.**

### 📚 What data can you extract from Trustpilot?

This actor reads Trustpilot's own page data (no HTML scraping, no fragile selectors)
and returns structured records with **100+ fields**, organised into six groups:

| Group | What you get |
|---|---|
| **Review core** | Star rating, title, full text, published / experienced / updated / submitted dates, language, likes, review URL, review location |
| **Verification** | Verified flag, verification level and source, verification date, review source (organic vs invited), complaint / pending / filtered flags, unhandled reports |
| **Reviewer** | Display name, country, lifetime review count, verified flag, profile image, author ID, and **how many times this reviewer has reviewed this company** |
| **Company reply** | Reply text, reply date, updated date, plus the company's overall reply rate and average days to reply |
| **Company panel** | TrustScore, stars, total reviews, reviews in the last 12 months, **full 1–5 star distribution**, description, category path, claimed status and date, closed / collecting-reviews flags, paid-plan and AI-reply flags, Google & payment verification, consumer alerts |
| **Contacts & discovery** | Email, phone, address, ZIP, city, country, website — on every company, in every mode |

Turn on the optional blocks and you also get:

- **Transparency report** — how many reviews were organic vs invited, how many were
  reported, how many were taken offline, and how many were reinstated.
- **Review summary** — Trustpilot's own summary of what reviewers say, plus per-topic
  breakdowns (delivery, refunds, customer service…).
- **Similar companies** — the competitor list from the profile, each with its TrustScore
  and review count.

### ✨ Key features

- 🚫 **No 200-review ceiling** — a public Trustpilot listing stops at ~200 reviews.
  This actor splits the listing into narrower views automatically and reads each one to
  its own limit, so a company with 100,000 reviews is genuinely reachable.
- ⭐ **Real star distribution** — `companyRating1Star` … `companyRating5Star` are filled
  in with actual counts, not left null.
- 🌍 **Every language, by default** — most tools quietly return English only. This one
  reads every language Trustpilot holds for the company, and lets you narrow it.
- 🔎 **Server-side keyword search** — search inside review text (`keyword`) and Trustpilot
  can also filter by topic, star, language, date and replies **before** anything reaches
  your dataset, so filtered-out reviews never cost you.
- 🏢 **Company discovery + contacts** — find companies by keyword or browse an entire
  category, with email, phone and address on each one. Gate the results by TrustScore,
  review count, claimed status and country.
- 🔍 **Transparency signals** — organic vs invited review mix, reports raised, reviews
  taken offline. The numbers you need to judge whether a rating was earned.
- 🤖 **Review summaries** — Trustpilot's own digest of what customers say, plus per-topic
  summaries for delivery, refunds, customer service and more.
- 📅 **Exact date cut-offs** — `startDate` or `lastDays` stop a listing the moment it
  drops below your window, so back-fills and daily watches stay cheap.
- ♻️ **Incremental mode** — recurring runs emit only what changed. Unchanged reviews are
  recognised and skipped before they are ever billed.
- 🔔 **Notifications** — push new reviews to Telegram, Slack, Discord or any webhook.
- 🪶 **AI-friendly output** — `compact` mode and `excludeEmptyFields` keep records lean
  for LLM and MCP pipelines.
- ⚡ **Fast and cheap** — the run reads structured JSON, not rendered HTML, and needs no
  paid proxy bandwidth.

### How to scrape more than 200 reviews from one company

A public Trustpilot review listing stops after **10 pages — about 200 reviews**. Ask for
page 11 and the site answers with a sign-in wall instead of data. That ceiling is why
most exports of a big brand top out at 200.

Every *distinct filter combination*, though, gets its own 200-review window. This actor
uses that automatically:

1. It reads the listing you asked for, newest first, to the bottom of its window.
2. If you asked for more, it splits by **star rating** — a review has exactly one, so
   the five slices are disjoint and together cover everything.
3. If a star slice is still bigger than one window, it splits again by **review
   language**, largest first.

Windows are read one page at a time in round-robin and de-duplicated by review ID, so a
run that stops early still comes back with an even spread rather than everything from a
single slice.

| You ask for | What you get |
|---|---|
| 200 or fewer | The newest N, in strict recency order — a single window, no splitting |
| 1,000 | The newest 200, then the slices fill in the rest, balanced across ratings |
| `0` (everything) | Every review reachable through the split, up to the actor's safety limits |

Nothing to configure — just raise **Max results**.

### 🚀 How to scrape Trustpilot

1. **Click "Start"** on this actor page, or open it from the [Apify Console](https://console.apify.com).
2. **Enter a company domain** — `booking.com`, `amazon.com`, or paste any Trustpilot
   review-page URL. Add a bulk list to do dozens of companies in one run.
3. **Set your filters** — star ratings, languages, a date window, a keyword inside the
   review text, topics, verified-only, replies-only, reviewer country.
4. **Set Max results** — anything above 200 automatically reads past Trustpilot's
   public page limit.
5. **Export your data** — JSON, CSV or Excel, or connect straight to Google Sheets,
   Zapier, Make, n8n or your own API.

That's it. No login, no cookies, no proxy configuration.

#### Quick-start example input

```json
{
    "companyDomain": "booking.com",
    "maxResults": 1000,
    "sort": "recency",
    "lastDays": 30,
    "stars": ["1", "2"],
    "keyword": "refund",
    "includeTransparency": true
}
```

This pulls up to 1,000 one- and two-star reviews from the last 30 days that mention
"refund", each with the full company panel and the transparency figures.

### ⚙️ Input

#### 🎯 Mode

| Field | Type | Description |
|---|---|---|
| `mode` | enum | `reviews` (default), `companies` (one profile record per company), `search` (find companies by keyword), `category` (browse a whole category). |

#### 🏢 Companies

| Field | Type | Description |
|---|---|---|
| `companyDomain` | string | Company domain as used on Trustpilot, e.g. `booking.com`. Or paste a Trustpilot URL. |
| `companyDomains` | array | Bulk list — scrape many companies in one run. |
| `startUrls` | array | Trustpilot URLs to read directly: review pages, `/search?query=…` or `/categories/…`. |

#### 🔎 Company discovery

| Field | Type | Description |
|---|---|---|
| `searchQuery` / `searchQueries` | string / array | Keywords to search the Trustpilot company directory, e.g. `"car insurance"`. |
| `categoryId` / `categoryIds` | string / array | Category to browse, e.g. `electronics_technology`. |
| `country` | string | ISO country code for a category listing, e.g. `GB`. |
| `minTrustScore` | number | Keep only companies at or above this TrustScore (decimals allowed). |
| `minReviews` | integer | Keep only companies with at least this many reviews. |
| `onlyClaimed` | boolean | Only companies that have claimed their profile. |

#### 🎚️ Review filters

| Field | Type | Description |
|---|---|---|
| `sort` | enum | `recency` (default) or `relevance`. |
| `stars` | array | Star ratings to keep, `1`–`5`. |
| `languages` | array | Review language ISO codes. Empty means every language. |
| `date` | enum | Trustpilot's rolling window: last 30 days / 3 / 6 / 12 months. |
| `startDate` | string | Only reviews published on or after this date (`YYYY-MM-DD`). |
| `lastDays` | integer | Only reviews from the last N days — recalculated every run. |
| `keyword` | string | Full-text search inside the reviews. Applied server-side. |
| `topics` | array | Trustpilot topic tags, e.g. `refund`, `customer_service`. |
| `verified` | boolean | Only reviews Trustpilot marks as verified. |
| `withReplies` | boolean | Only reviews that have a company reply. |
| `reviewerCountries` | array | Keep only reviewers from these countries. |

#### 📄 Output

| Field | Type | Description |
|---|---|---|
| `maxResults` | integer | Records per company (or per keyword / category). `0` takes everything reachable. Default 200. |
| `includeCompanyInfo` | boolean | Attach the full company panel to every review. Default `true`. |
| `includeTransparency` | boolean | Add the transparency report (organic vs invited, removals). |
| `includeAiSummary` | boolean | Add Trustpilot's review summary and per-topic breakdowns. |
| `includeSimilarCompanies` | boolean | Add the competitor list from the profile. |
| `compact` | boolean | Core fields only — ideal for AI agents and MCP clients. |
| `excludeEmptyFields` | boolean | Drop null / empty fields from each record. |

#### ♻️ Incremental monitoring

| Field | Type | Description |
|---|---|---|
| `incrementalMode` | boolean | Emit only NEW / UPDATED records on recurring runs. |
| `stateKey` | string | Stable name for the tracking state (auto-derived if blank). |
| `emitUnchanged` / `emitExpired` | boolean | Also emit UNCHANGED / EXPIRED records. |

#### 🔔 Notifications

Credentials are stored encrypted and **never written to the run log**. A built-in
redaction layer scrubs secrets from error messages before they can surface.

| Field | Type | Description |
|---|---|---|
| `telegramToken` + `telegramChatId` | string | Telegram bot token + chat ID. |
| `slackWebhookUrl` | string | Slack Incoming Webhook URL. |
| `discordWebhookUrl` | string | Discord channel webhook URL. |
| `webhookUrl` + `webhookHeaders` | string / object | POST structured JSON anywhere. Ideal for n8n, Make, Zapier. |
| `notificationLimit` | integer | Max records listed per message (default 5). |

#### ⚙️ Advanced

| Field | Type | Description |
|---|---|---|
| `proxyConfiguration` | object | Leave empty. The actor routes traffic itself and only escalates when it has to. |

…and **42 inputs** in total — the tables above cover the ones people actually reach for.

### 📤 Output

Each record is pushed to the run's default dataset. Example review record (abridged):

```json
{
    "recordType": "review",
    "reviewId": "6aa0602a35495980003e6e1e",
    "reviewUrl": "https://www.trustpilot.com/reviews/6aa0602a35495980003e6e1e",
    "rating": 1,
    "title": "Not returning refund agreed by the hotel",
    "text": "Still waiting for a refund that was processed by the hotel in early August…",
    "publishedDate": "2026-09-08T21:21:14.000Z",
    "experiencedDate": "2026-09-04T00:00:00.000Z",
    "language": "de",
    "isVerified": false,
    "verificationLevel": "not-verified",
    "reviewSource": "Organic",

    "reviewerName": "Dino Ga",
    "reviewerCountry": "RS",
    "reviewerTotalReviews": 2,
    "reviewerReviewsOnThisCompany": 1,
    "authorId": "69deff5e0a02e75d9d77393d",

    "hasCompanyReply": false,
    "replyText": null,

    "companyName": "Booking.com",
    "companyDomain": "www.booking.com",
    "companyTrustScore": 1.5,
    "companyTotalReviews": 126233,
    "companyReviewsLast12Months": 21611,
    "companyRating1Star": 92269,
    "companyRating2Star": 4242,
    "companyRating3Star": 2589,
    "companyRating4Star": 4875,
    "companyRating5Star": 22258,
    "companyDescription": "Offering secure, easy booking since 1996, Booking.com is the world's most popular hotel reservations website…",
    "companyContactEmail": "customer.service@booking.com",
    "companyContactPhone": "+31 20 712 5600",
    "companyContactAddress": "Herengracht 597",
    "companyCity": "Amsterdam",
    "companyCountryCode": "NL",
    "companyCategoryPath": ["Travel & Vacation", "Activities & Tours", "Travel Aggregator"],
    "companyIsClaimed": true,
    "companyReplyRate": 0,
    "companyVerifiedPaymentMethod": true,

    "transparencyOrganicReviews": 21607,
    "transparencyInvitedReviews": 2,
    "transparencyOrganicShare": 0.9998,
    "transparencyReviewsTakenOffline": 0,

    "source": "trustpilot.com",
    "scrapedAt": "2026-09-08T21:26:54.987Z",
    "contentHash": "3b3dd1512629c91ef600ecb362a7e8ea"
}
```

In discovery modes each record is a company instead, tagged `"recordType": "company"`
and carrying the profile plus contact columns.

The Output tab ships four ready-made views: **Reviews**, **Company intelligence** (the
star distribution, reply behaviour and transparency figures), **Contacts** (the lead-gen
columns) and **Changes** (the incremental tracking fields).

In **compact** mode each record is trimmed to the ~18 fields needed to read, attribute
and triage a review — ideal for LLM agents and MCP pipelines.

### ♻️ How to monitor Trustpilot with incremental mode

Running on a schedule? Turn on `incrementalMode`. The **first run builds a baseline**;
every run after that emits — and charges for — **only what actually changed**.

| | First run (baseline) | Second run (nothing changed) |
|---|---|---|
| Reviews read | all | all |
| Records emitted & charged | all | **none** |

Your cost after the baseline scales with how much the review flow changes, not with how
many reviews you monitor:

| Daily churn | Records per run (after baseline) | Saving vs full re-scrape |
|---|---|---|
| 5% (quiet brand) | ~5% | ~95% |
| 15% (moderate) | ~15% | ~85% |
| 30% (busy brand) | ~30% | ~70% |

#### Setting up scheduled monitoring

1. Configure the scraper with your company (or companies) and filters.
2. Turn on **Incremental mode**.
3. Run it once — this creates the baseline.
4. Go to the **Schedules** tab and set a recurring run (e.g. every hour).
5. Optionally add a notification channel (Telegram, Slack, Discord or webhook).

Pair it with **Last N days** set to `1` and a daily watch costs barely more than the
start fee.

### 🔔 How to set up Trustpilot alerts

Get alerted the moment a review lands. Fill in only the channels you want:

| Channel | What to configure |
|---|---|
| ✈️ **Telegram** | `telegramToken` (from @BotFather) + `telegramChatId` |
| 💬 **Slack** | `slackWebhookUrl` (Incoming Webhook URL) |
| 🎮 **Discord** | `discordWebhookUrl` (channel webhook URL) |
| 🪝 **Webhook** | `webhookUrl` receives structured JSON — ideal for n8n / Make / Zapier |

Every channel fires independently. A broken channel cannot stop the scrape or the other
channels. Combine with **Incremental mode** and `stars: ["1", "2"]` to be paged only
when a genuinely new negative review appears.

### 💡 What can you do with Trustpilot data?

#### Reputation monitoring

Watch your brand — or your clients' brands — and get paged the moment a one-star review
appears. Incremental mode plus `lastDays: 1` keeps a daily watch near-free.

#### Competitive intelligence

Compare TrustScores, star distributions, review volume and reply behaviour across a
whole set of competitors in one batch run. Turn on similar companies and Trustpilot will
tell you who it thinks the competitors are.

#### Review-authenticity checks

The transparency block shows the organic-vs-invited mix, how many reviews were reported,
and how many were taken offline. A 4.9 built on invited reviews reads very differently
from a 4.9 built on organic ones.

#### B2B lead generation

Browse a category or search a keyword and export every company with its email, phone,
address, TrustScore and review count. Gate by TrustScore and review count to skip empty
profiles.

#### Sentiment and theme analysis

Feed review text, ratings and the per-topic summaries into NLP or LLM pipelines to
surface recurring complaints and praise. Server-side keyword and topic filters let you
pull just the reviews about refunds, delivery or support.

#### Vendor due diligence

Pull verified reviews, reply rate and average days to reply to judge a supplier, partner
or acquisition target before you sign.

#### Feed AI agents and LLM pipelines

Compact JSON straight into an LLM context, MCP tool or vector store. `excludeEmptyFields`
and `compact` keep token costs low.

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

This Actor uses Apify's **pay-per-event** model: a small fee when a run starts, plus a
per-record fee. See the Actor's **Pricing** tab for the current numbers — they're rendered
live, so this page never goes stale.

Two things cut your bill further:

- **Site-side filters** — records you filtered out are never fetched and never billed.
- **Incremental mode** — after the baseline run you pay only for what actually changed.

| Daily churn | of 1,000 tracked | billable records | you save |
|---|---|---|---|
| 5 % | 1,000 | 50 | **95 %** |
| 15 % | 1,000 | 150 | **85 %** |
| 30 % | 1,000 | 300 | **70 %** |

You only pay for records you actually receive. Star, language, date, keyword, topic and
replies filters are applied by Trustpilot *before* anything is billed. With
`incrementalMode` on, a run that finds nothing new costs only the start fee.

One per-record fee buys the **whole record** — the full company panel, the star
distribution, the reviewer profile, the reply and the contact details. There is no
enrichment add-on, no per-field surcharge and no separate fee for company records: a
business found through search or category browse bills exactly the same as a review.

### 🔌 Integrations & export

Export your data anywhere:

- **JSON, CSV, Excel** — download directly from the Output tab
- **Apify API** — stream results via the REST API or the
  [JavaScript](https://docs.apify.com/api/client/js) /
  [Python](https://docs.apify.com/api/client/python) SDK
- **Google Sheets** — connect via the Apify integration
- **Zapier / Make / n8n** — use the generic webhook or Apify's built-in integrations
- **Slack / Discord / Telegram** — built-in notifications, no middleware needed
- **AI agents** — use this actor as an
  [MCP tool](https://docs.apify.com/platform/integrations/mcp) for Claude, ChatGPT or any
  MCP-compatible agent

#### Using the API

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run_input = {
    "companyDomain": "booking.com",
    "maxResults": 1000,
    "sort": "recency",
}

run = client.actor("corvuslab/trustpilot-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### 🔗 Using the API

Run this Actor from your own code. Example with the Apify Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run = client.actor("corvuslab/trustpilot-scraper").call(run_input={
        "keyword": "example",
        "maxResults": 50,
    })

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

It also works with the JavaScript/TypeScript client, the Apify CLI and the REST API.

### ❓ FAQ

**Do I need a Trustpilot account or a proxy?**
No. Everything this actor reads is public. It routes its own traffic and only escalates
to paid proxy if it has to, so there is nothing to configure.

**Can I really get more than 200 reviews?**
Yes. Trustpilot's public listing stops at ~200, but every filter combination gets its
own window, and the actor walks those windows for you. Set Max results above 200 — or to
`0` — and it happens automatically.

**Why are some reviews not in English?**
Because by default you get *all* of them. Trustpilot serves English only unless asked
otherwise; this actor asks for every language the company has. Set `languages` to narrow
it back down.

**Why did `verified: true` return so few reviews?**
"Verified" on Trustpilot means the review came through the company's own invitation
flow. Brands that don't send invitations (Amazon, for example) have almost none —
their reviews are organic. The transparency block shows that split per company.

**What's the difference between the four modes?**
`reviews` returns reviews. `companies` returns one profile record per company you name —
useful when you want the panel but not the reviews. `search` finds companies by keyword,
`category` lists every company in a Trustpilot category; both return contact details.

**Does `minTrustScore` work on searches too?**
Yes. Trustpilot only offers two score thresholds on its own pages, so this actor applies
the gate to every company it finds instead — any value from 0 to 5, decimals included.

**Can I scrape several companies in one run?**
Yes — use `companyDomains`. Max results applies per company, and every record is tagged
with its `companyDomain`.

**How do I get a Trustpilot category ID?**
Open [trustpilot.com/categories](https://www.trustpilot.com/categories), click a
category, and take the last part of the URL — e.g.
`/categories/electronics_technology` → `electronics_technology`. You can also paste the
whole URL into `startUrls`.

**Is my data kept private?**
All credentials (notification tokens, webhook URLs) are marked as secret inputs — they
are encrypted at rest, masked in the Apify UI, and never appear in run logs. A built-in
redaction layer scrubs secrets from error messages before they can surface.

**Is it legal to scrape Trustpilot?**
This actor extracts publicly available data. 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 and regulations — in particular any
personal information in reviews, and the GDPR where it applies.

***

*This is an unofficial actor and is not affiliated with, endorsed by, or connected to
Trustpilot. "Trustpilot" is a trademark of its respective owner and is used here only to
describe the site this actor works with.*

***

**Keywords:** trustpilot scraper · trustpilot.com scraper · trustpilot reviews scraper · trustpilot api · scrape trustpilot reviews · trustpilot review export · trustpilot TrustScore · trustpilot star distribution · trustpilot company data · trustpilot transparency report · trustpilot company search · trustpilot category scraper · review scraper · reputation monitoring · competitor review analysis · b2b lead generation · export trustpilot to CSV · export trustpilot to Excel · trustpilot MCP tool · trustpilot review alerts

# Actor input Schema

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

Reviews — every review for the companies you name. Company profiles — one profile record per company, no reviews. Company search — find companies by keyword. Category browse — list every company in a Trustpilot category.

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

Company domain as used on Trustpilot, e.g. 'booking.com' or 'www.amazon.com'. Or paste a full Trustpilot URL.

## `companyDomains` (type: `array`):

Scrape multiple companies in one run. Accepts Trustpilot domains or full review URLs. Each result is tagged with its companyDomain.

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

Trustpilot URLs to read directly — review pages, /search?query=… pages or /categories/… pages. Paste a search or category URL and the actor switches to that mode by itself.

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

Keyword to search the Trustpilot company directory, e.g. 'car insurance', 'web hosting', 'solar panels'.

## `searchQueries` (type: `array`):

Run several keyword searches in one go. Companies are de-duplicated across searches.

## `categoryId` (type: `string`):

Trustpilot category id, e.g. 'insurance\_agency', 'electronics\_technology', 'bank'. Open trustpilot.com/categories, click a category and take the last part of the URL — or just paste the whole category URL.

## `categoryIds` (type: `array`):

Browse several categories in one run.

## `country` (type: `string`):

Restrict a category listing to one market, as an ISO country code (e.g. 'US', 'GB', 'DE'). Category browse only — Trustpilot's keyword search is global.

## `minTrustScore` (type: `number`):

Only keep companies at or above this TrustScore (0-5, decimals allowed). Applied to every company found, in both discovery modes.

## `minReviews` (type: `integer`):

Only keep companies with at least this many reviews — filters out empty profiles when building prospect lists.

## `onlyClaimed` (type: `boolean`):

Only return companies that have claimed their Trustpilot profile — usually the ones worth contacting.

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

Maximum records per company (Reviews mode) or per keyword/category (discovery modes). Set 0 for everything reachable. Above 200 the actor automatically splits the listing into narrower views to read past Trustpilot's public page limit.

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

Review sort order. 'recency' returns newest first (best for monitoring). 'relevance' returns Trustpilot's algorithmic picks.

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

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

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

Filter by review language ISO codes, e.g. 'en', 'de', 'fr'. Leave empty to read every language Trustpilot holds for the company.

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

Trustpilot's own rolling date filter. For an exact cut-off use 'Published after' or 'Last N days' below instead.

## `startDate` (type: `string`):

Only reviews published on or after this date (YYYY-MM-DD). Reading stops as soon as a listing drops below it, so back-fills stay cheap.

## `lastDays` (type: `integer`):

Only reviews published in the last N days — 1 for a daily watch, 7 for a weekly one. The window is recalculated on every run and overrides 'Published after'.

## `keyword` (type: `string`):

Full-text search inside the reviews, e.g. 'refund' or 'delivery'. Applied by Trustpilot, so non-matching reviews are never billed.

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

Trustpilot topic tags to keep, e.g. 'refund', 'customer\_service', 'delivery\_service', 'booking\_process'. Leave empty for all.

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

Return only reviews Trustpilot marks as verified.

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

Return only reviews that have a reply from the company.

## `reviewerCountries` (type: `array`):

Keep only reviews written by consumers in these countries, as ISO codes (e.g. 'US', 'GB', 'DE').

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

Add the company profile (TrustScore, full star distribution, categories, reply rate, contact details) to every review record.

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

Add Trustpilot's published transparency figures: how many reviews were organic vs invited, how many were reported, and how many were taken offline. One extra lookup per company.

## `includeAiSummary` (type: `boolean`):

Add Trustpilot's own summary of what reviewers say, plus the per-topic breakdowns (delivery, refunds, customer service…).

## `includeSimilarCompanies` (type: `boolean`):

Add the competitor list Trustpilot shows on the profile, each with its TrustScore and review count.

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

Emit only the core fields. Ideal for AI agents and MCP clients.

## `excludeEmptyFields` (type: `boolean`):

Remove null, empty-string and empty-array fields from each record.

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

Track state between runs and tag every record with a changeType (NEW / UPDATED / UNCHANGED / EXPIRED).

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

Stable name for the tracked search. Leave empty to derive one automatically.

## `emitUnchanged` (type: `boolean`):

Also emit records that have not changed since the previous run.

## `emitExpired` (type: `boolean`):

Emit records for items present last run but gone now.

## `telegramToken` (type: `string`):

Bot token from @BotFather.

## `telegramChatId` (type: `string`):

Chat or channel ID.

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL.

## `discordWebhookUrl` (type: `string`):

Discord incoming-webhook URL.

## `webhookUrl` (type: `string`):

Any HTTPS endpoint. Receives a JSON POST with the matched records.

## `webhookHeaders` (type: `object`):

Extra headers for the webhook request.

## `notificationLimit` (type: `integer`):

How many records to include in each notification message.

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

Leave empty — the actor routes traffic itself and only escalates to paid proxy when needed. Only set this to use your own proxies.

## Actor input object example

```json
{
  "mode": "reviews",
  "companyDomain": "booking.com",
  "onlyClaimed": false,
  "maxResults": 200,
  "sort": "recency",
  "date": "",
  "verified": false,
  "withReplies": false,
  "includeCompanyInfo": true,
  "includeTransparency": false,
  "includeAiSummary": false,
  "includeSimilarCompanies": false,
  "compact": false,
  "excludeEmptyFields": false,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "notificationLimit": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `company` (type: `string`):

No description

## `leads` (type: `string`):

No description

## `allItems` (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": 200
};

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

# Run the Actor and wait for it to finish
run = client.actor("corvuslab/trustpilot-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "companyDomain": "booking.com",
  "maxResults": 200
}' |
apify call corvuslab/trustpilot-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,corvuslab/trustpilot-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/DuAdzSHhfcDwPoQ0V/builds/SEbxhja5PfsWNzO6o/openapi.json