# Trustpilot Reviews Scraper (`api-ninja/trustpilot-reviews-scraper`) Actor

Collect Trustpilot reviews with filters and automatic pagination.

- **URL**: https://apify.com/api-ninja/trustpilot-reviews-scraper.md
- **Developed by:** [API ninja](https://apify.com/api-ninja) (community)
- **Stats:** 9 total users, 7 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What is Trustpilot Reviews Scraper?

**Trustpilot Reviews Scraper** collects customer reviews for a list of company website domains. Extract **review text, star ratings, publication dates, reviewer profiles, and company replies** to analyze customer feedback, compare competitors, or monitor your brand.

To try it, enter a domain such as `coolify.io`, choose how many reviews to collect, and start the Actor. You can add several companies to the same run; each company is processed in order and its reviews are labeled with the original input domain.

#### What can this Actor do?

- **Collect reviews from multiple companies** in one run, with a separate result limit for each company.
- **Filter customer feedback** by star rating, language, keyword, publication date, review verification, or company reply.
- **Choose recent or detailed reviews** and automatically paginate through matching results.
- **Resolve domain mismatches** by trying the `www.` version and the domain returned by company details.
- **Preserve original review data**, including nested reviewer information, null values, and additional API fields.
- **Browse readable dataset views** with formatted dates, clickable review and profile links, and reviewer columns.
- **Avoid duplicate reviews** within a run and save progress for resumed runs.

On Apify, you can inspect run logs, access results through the API, [schedule recurring runs](https://docs.apify.com/actors/running/schedules), and connect the Actor to your existing workflows.

### How to scrape Trustpilot reviews

1. Open the Actor in [Apify Console](https://console.apify.com/) and go to the **Input** tab.
2. Add one or more **Company domains**, such as `coolify.io` and `google.com`. Enter domains without `https://` or a path.
3. Set **Maximum reviews**. This limit applies to each company separately. Start with 20 reviews per company to check the output.
4. Apply any filters you need. Leave optional filters empty or disabled to include all matching reviews.
5. Click **Start** and follow the run in the **Log** tab.
6. Open **Output** to browse the results. Use Apify's dataset export controls or API to bring the data into your analysis tools.

For repeatable monitoring, save your configuration as a task and schedule it. A new scheduled run collects a fresh dataset; duplicate removal applies within a run, so use `review_id` to identify reviews already collected in earlier runs.

### Input

#### Collect reviews from several companies

```json
{
    "domain": ["coolify.io", "google.com"],
    "maxResults": 100,
    "parseAll": false
}
```

This input collects **up to 100 reviews per company**, for up to 200 reviews in total. The actual count depends on available matching reviews.

#### Focus on recent negative feedback

```json
{
    "domain": ["coolify.io", "google.com"],
    "maxResults": 50,
    "rating_is": ["1", "2"],
    "lang": "en",
    "date_range": "last_30_days",
    "sort_by": "most_recent"
}
```

This configuration requests up to 50 English reviews rated one or two stars per company, published within the last 30 days.

#### Input settings

| Field               | Default       | What it does                                                                                                           |
| ------------------- | ------------- | ---------------------------------------------------------------------------------------------------------------------- |
| `domain`            | Required      | List of company website domains, such as `["coolify.io", "google.com"]`.                                               |
| `maxResults`        | `100`         | Maximum reviews to save **per company**. Must be a positive integer.                                                   |
| `parseAll`          | `false`       | Collect all available matching reviews for every company. Overrides `maxResults`.                                      |
| `verified_only`     | `false`       | When enabled, include only verified reviews.                                                                           |
| `has_company_reply` | `false`       | When enabled, include only reviews with a company reply.                                                               |
| `lang`              | `""`          | Review language code, such as `en` or `fr`. Empty means all languages.                                                 |
| `query`             | `""`          | Keyword used to filter review content. Empty means no keyword filter.                                                  |
| `rating_is`         | `[]`          | Select one or more star ratings, such as `["1", "2"]` or `["4", "5"]`. Empty means all ratings.                        |
| `date_range`        | `""`          | Publication date filter: `last_12_months`, `last_6_months`, `last_3_months`, or `last_30_days`. Empty means all dates. |
| `sort_by`           | `most_recent` | Choose `most_recent` or `detailed_reviews`.                                                                            |
| `locale`            | `en-US`       | Trustpilot localization. Select a supported locale in the input form.                                                  |

All companies use the same filters. `lang` controls the language of the reviews; `locale` controls Trustpilot localization and does not translate review content. Date filtering applies to the publication date, rather than the experience date.

Domains are trimmed and converted to lowercase. Repeated entries are removed while preserving input order. Use an array even when collecting reviews for just one company: `"domain": ["coolify.io"]`.

### Output

The Actor saves **one dataset item per review**. Each item contains the original review fields returned by the API, plus two fields that identify your request:

- `inputDomain`: the original normalized company domain you supplied, before any domain fallback.
- `inputQuery`: your keyword filter, or an empty string when no keyword was supplied.

Review content, timestamps, line breaks, null values, and the nested `reviewer` object are preserved. Additional API fields are retained too. Pagination metadata and page-level rating or language distributions are not included in review items.

#### Example review item

The following example corresponds to the `coolify.io` domain in the first input example. Fields and their availability depend on the API response.

```json
{
    "review_id": "6abd26c58fda06cb8e41c08f",
    "review_link": "https://www.trustpilot.com/reviews/6abd26c58fda06cb8e41c08f",
    "title": "Super experience sur coolify",
    "text": "Super experience sur coolify, très bonne alternative opensource a vercel. Surtout en self hosted !",
    "rating": 5,
    "language": "fr",
    "is_verified": false,
    "is_pending": false,
    "source": "Organic",
    "published_at_date": "2026-09-30T17:12:05.000Z",
    "experience_date": "2026-03-05T00:00:00.000Z",
    "likes_count": 0,
    "company_reply": null,
    "company_reply_date": null,
    "reviewer": {
        "id": "6abd26b91b99029a2b86071c",
        "profile_link": "https://www.trustpilot.com/users/6abd26b91b99029a2b86071c",
        "name": "Tyler",
        "country_code": "FR",
        "is_verified": false,
        "avatar_url": "https://user-images.trustpilot.com/6abd26b91b99029a2b86071c/73x73.png",
        "total_reviews": 1,
        "reviews_on_this_company": 1
    },
    "inputDomain": "coolify.io",
    "inputQuery": ""
}
```

#### Dataset views

| View                        | Best for                                                                                 |
| --------------------------- | ---------------------------------------------------------------------------------------- |
| **All fields (normalized)** | Default view: all documented fields, with nested reviewer details expanded into columns. |
| **Reviews**                 | Reading review text, ratings, dates, language, and review verification.                  |
| **Reviewers**               | Browsing reviewer names, countries, avatars, profile links, and review activity.         |
| **Company replies**         | Reading customer feedback alongside company replies and reply dates.                     |

Normalization affects the table presentation. Stored JSON keeps the original nested structure. For complete review objects, use the dataset's JSON export or the results API link. Apify also provides [dataset export options](https://docs.apify.com/storage/dataset) for formats such as CSV and Excel.

### Pricing

#### How much does scraping Trustpilot reviews cost?

Starting **October 12, 2026**, this Actor uses **pay-per-event pricing**: a **$0.01 Actor start fee**, plus a charge for each review saved to the dataset. **Platform usage costs are included**; you do not pay separate platform usage costs for this Actor.

| Pricing tier | Price per 1,000 reviews | Actor start fee |
| ------------ | ----------------------- | --------------- |
| No discount  | **$3.00**               | $0.01           |
| Bronze       | **$0.30**               | $0.01           |
| Silver       | **$0.30**               | $0.01           |
| Gold         | **$0.30**               | $0.01           |

Each saved review is one result event (`apify-default-dataset-item`). The start fee is charged through the `apify-actor-start` event. Review charges apply to the actual number of results saved, rather than the number requested; the start fee applies even when a run returns no reviews.

#### Example costs

The examples below include one Actor start and the stated number of saved reviews, across any number of input domains.

| Reviews saved in one run | No discount | Bronze, Silver, or Gold |
| ------------------------ | ----------- | ----------------------- |
| 100                      | **$0.31**   | **$0.04**               |
| 1,000                    | **$3.01**   | **$0.31**               |
| 10,000                   | **$30.01**  | **$3.01**               |

To estimate the maximum number of results, multiply the number of unique input domains by `maxResults`. For example, 10 domains with a limit of 100 reviews can produce up to 1,000 reviews: **$3.01 without a discount**, or **$0.31 with a Bronze, Silver, or Gold discount**, including one start fee. The actual count can be lower if fewer reviews match your filters.

Keep **Parse all** disabled when you want a fixed review limit per company. Enabling it removes that limit and can increase the number of billed results. Check the Actor's **Pricing** tab for the current rates and the discount that applies to your account.

### API and integrations

#### Use the Actor as a Trustpilot reviews API

Open the Actor's **API** tab for its ID and ready-to-use request examples. Send the same JSON input you use in Console and retrieve the resulting dataset from your application.

For short jobs, Apify provides an endpoint to [run an Actor and return its dataset items](https://docs.apify.com/api/v2/actor-run-sync-get-dataset-items-post). For larger collections, start an asynchronous run and retrieve the dataset after it finishes. You can use the REST API or Apify's JavaScript and Python clients.

#### Automate review monitoring

Use [Apify integrations](https://docs.apify.com/integrations) with Make, Zapier, or n8n to trigger runs and send results to the next step in your workflow. You can also use webhooks to notify your application when a run finishes.

Typical workflows include tracking recent feedback for several brands, collecting low-rated reviews for customer support analysis, and comparing how companies respond to customers. Sentiment analysis and summaries can be added downstream using the original review text.

### FAQ and support

#### Why does a domain return “Not Found”?

The reviews API may recognize a company under a different domain. The Actor first tries your supplied domain, then its `www.` version when applicable. If reviews are still not found, it requests company details and tries the response's top-level `domain`.

If all attempts fail, check that the company has a Trustpilot profile and that you entered its website domain correctly. An unresolved request ends the run; reviews saved before the failure remain in the dataset. Inspect the run log to see where collection stopped.

#### Why did I receive fewer reviews than requested?

`maxResults` is a maximum per company. A company may have fewer reviews, or your filters may match only a small subset. Try removing keyword, date, language, or verification filters to broaden the results. A company with no matching reviews does not prevent collection from continuing to the next company.

#### Are verified reviews and verified reviewers the same?

They are separate fields. `is_verified` describes the review, while `reviewer.is_verified` describes the reviewer profile. The **Verified reviews only** filter applies to reviews.

#### Can an interrupted run resume?

The Actor saves the current company, pagination, collected review IDs, and resolved domain in a checkpoint. Resuming a run with its existing storage and unchanged input continues from the saved progress. A new run with new storage starts a fresh collection.

#### What should I do if a run fails?

Check the **Log** tab for the error and inspect any partial output. The Actor retries network and other request failures up to three times with one-second delays. Persistent authentication, rate-limit, or upstream errors can still stop a run.

To report an issue, use the Actor's **Issues** tab. Include the affected domain, your filter settings, the run ID, and what you expected to receive. Keep API keys and other credentials out of the report.

# Actor input Schema

## `domain` (type: `array`):

Company website domains to process one after another, such as coolify.io and google.com. Enter domains without URL schemes or paths. Each company has its own maximum review limit. Missing domains are retried with www and company details.

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

Maximum number of reviews to save per company domain. Ignored when Parse all is enabled.

## `parseAll` (type: `boolean`):

Fetch all available matching reviews for each company domain until the API reports no more results.

## `verified_only` (type: `boolean`):

When enabled, return only verified reviews. When disabled, do not apply this filter.

## `has_company_reply` (type: `boolean`):

When enabled, return only reviews with company replies.

## `lang` (type: `string`):

Optional language code such as en, es, fr, or de. Empty means all languages.

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

Optional keyword to filter review content. Empty means no keyword filter.

## `rating_is` (type: `array`):

Select one or more star ratings to include. Leave empty to include all ratings.

## `date_range` (type: `string`):

Filter by when reviews were posted; choose all dates for no date filter.

## `sort_by` (type: `string`):

Choose most recent reviews or detailed reviews.

## `locale` (type: `string`):

Trustpilot language-country localization; independent of the review language filter.

## Actor input object example

```json
{
  "domain": [
    "coolify.io"
  ],
  "maxResults": 100,
  "parseAll": false,
  "verified_only": false,
  "has_company_reply": false,
  "lang": "",
  "query": "",
  "rating_is": [],
  "date_range": "",
  "sort_by": "most_recent",
  "locale": "en-US"
}
```

# Actor output Schema

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

Complete dataset items as JSON. Browse all fields with reviewer columns expanded, reviews, reviewers, and company replies in the Output tab.

# 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 = {
    "domain": [
        "coolify.io"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-ninja/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 = { "domain": ["coolify.io"] }

# Run the Actor and wait for it to finish
run = client.actor("api-ninja/trustpilot-reviews-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 '{
  "domain": [
    "coolify.io"
  ]
}' |
apify call api-ninja/trustpilot-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,api-ninja/trustpilot-reviews-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/UZbgfVtM2fKV9lykV/builds/aChp2lQlgZwLxhwZk/openapi.json