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

Scrape all Trustpilot reviews for any company. Extract star ratings, review text, dates, author details, verification status, and company responses. Search companies by name, category, or URL.

- **URL**: https://apify.com/clawdeus/trustpilot-reviews-scraper.md
- **Developed by:** [Odysseus Clawdeus](https://apify.com/clawdeus) (community)
- **Categories:** Marketing
- **Stats:** 2 total users, 1 monthly users, 0.0% 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

## Trustpilot Reviews Scraper - Extract Reviews, Ratings & Company Responses

Scrape **all reviews** from any company on Trustpilot. Extract star ratings, review text, dates, author details, verification status, and company responses. Search companies by name or provide a direct URL.

### ✨ Features

- 🔍 **Search companies** by name — automatically finds and scrapes matching businesses
- ⭐ **All review data** — rating, title, full text, dates, author info
- 💬 **Company responses** — captures reply text and date when available
- ✅ **Verification status** — know if reviews are verified or organic
- 🌍 **Language filtering** — scrape reviews in specific languages
- 📊 **Star filtering** — focus on specific ratings (e.g., only 1-star reviews)
- 📦 **Clean output** — structured JSON/CSV ready for analysis

### 🚀 How to Use

#### Scrape reviews by company URL
```json
{
    "companyUrl": "https://www.trustpilot.com/review/amazon.com",
    "maxReviews": 500
}
````

#### Scrape reviews by domain name

```json
{
    "companyUrl": "netflix.com",
    "maxReviews": 200
}
```

#### Search and scrape multiple companies

```json
{
    "searchQuery": "food delivery",
    "maxSearchResults": 10,
    "maxReviews": 50
}
```

#### Get only negative reviews

```json
{
    "companyUrl": "uber.com",
    "filterStars": "1,2",
    "maxReviews": 1000
}
```

#### Get reviews in a specific language

```json
{
    "companyUrl": "booking.com",
    "filterLanguage": "de",
    "maxReviews": 200
}
```

### 📄 Output Example

Each review in the dataset contains:

```json
{
    "reviewId": "69cfba015570fd985fe782c2",
    "rating": 1,
    "title": "Warning",
    "text": "Warning! Do not buy anything! You will probably get nothing at all...",
    "language": "en",
    "authorName": "Jack",
    "authorCountry": "SE",
    "authorReviewCount": 19,
    "isVerified": false,
    "verificationSource": "Organic",
    "experienceDate": "2026-03-08T00:00:00.000Z",
    "publishedDate": "2026-04-03T15:00:49.000Z",
    "updatedDate": null,
    "companyReply": null,
    "companyReplyDate": null,
    "likes": 0,
    "reviewUrl": "https://www.trustpilot.com/reviews/69cfba015570fd985fe782c2",
    "companyName": "Amazon",
    "companyDomain": "www.amazon.com",
    "companyTrustScore": 1.7,
    "companyTotalReviews": 44865
}
```

### 📊 Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `companyUrl` | string | - | Trustpilot URL or domain name |
| `searchQuery` | string | - | Search for companies by name |
| `maxReviews` | integer | 100 | Max reviews per company (0 = all) |
| `filterStars` | string | - | Filter by stars (e.g., "1,2,3") |
| `filterLanguage` | string | all | Language filter (ISO code) |
| `sortBy` | string | recency | Sort: "recency" or "relevance" |
| `includeCompanyInfo` | boolean | true | Add company metadata to rows |
| `maxSearchResults` | integer | 5 | Companies to scrape from search |

### 💡 Use Cases

- **Market Research** — Analyze competitor reviews and customer sentiment
- **Brand Monitoring** — Track your company's review trends over time
- **Competitor Analysis** — Compare ratings across companies in your industry
- **Customer Feedback** — Export reviews for internal analysis
- **Academic Research** — Collect review data for NLP/sentiment studies

### ⚙️ Technical Details

- Extracts data from Trustpilot's server-rendered pages (no API key needed)
- Handles pagination automatically
- Respectful rate limiting with random delays
- Retries on temporary errors

### 📝 Notes

- Trustpilot shows up to 20 reviews per page
- Very large scrapes (10,000+ reviews) may take several minutes
- The actor respects Trustpilot's rate limits to avoid blocks

# Actor input Schema

## `companyUrl` (type: `string`):

Trustpilot company page URL (e.g., 'https://www.trustpilot.com/review/amazon.com') or just the domain (e.g., 'amazon.com')

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

Search for companies by name (e.g., 'Netflix'). Returns reviews for all matching companies.

## `maxReviews` (type: `integer`):

Maximum number of reviews to scrape per company (0 = all available)

## `filterStars` (type: `string`):

Only scrape reviews with specific star ratings (comma-separated, e.g., '1,2' for negative reviews)

## `filterLanguage` (type: `string`):

Filter reviews by language (ISO code, e.g., 'en', 'de', 'fr'). Default: all languages.

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

How to sort reviews

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

Include company metadata (trust score, total reviews, categories) in each review row

## `maxSearchResults` (type: `integer`):

When searching by query, maximum number of companies to scrape

## Actor input object example

```json
{
  "maxReviews": 100,
  "filterLanguage": "all",
  "sortBy": "recency",
  "includeCompanyInfo": true,
  "maxSearchResults": 5
}
```

# 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 = {};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Reviews Scraper",
        "description": "Scrape all Trustpilot reviews for any company. Extract star ratings, review text, dates, author details, verification status, and company responses. Search companies by name, category, or URL.",
        "version": "1.0",
        "x-build-id": "RZC4QG0ZQPQycPtjJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/clawdeus~trustpilot-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-clawdeus-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/clawdeus~trustpilot-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-clawdeus-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/clawdeus~trustpilot-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-clawdeus-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": {
                    "companyUrl": {
                        "title": "Company URL or Domain",
                        "type": "string",
                        "description": "Trustpilot company page URL (e.g., 'https://www.trustpilot.com/review/amazon.com') or just the domain (e.g., 'amazon.com')"
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for companies by name (e.g., 'Netflix'). Returns reviews for all matching companies."
                    },
                    "maxReviews": {
                        "title": "Max Reviews Per Company",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per company (0 = all available)",
                        "default": 100
                    },
                    "filterStars": {
                        "title": "Filter by Star Rating",
                        "type": "string",
                        "description": "Only scrape reviews with specific star ratings (comma-separated, e.g., '1,2' for negative reviews)"
                    },
                    "filterLanguage": {
                        "title": "Language",
                        "type": "string",
                        "description": "Filter reviews by language (ISO code, e.g., 'en', 'de', 'fr'). Default: all languages.",
                        "default": "all"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "recency",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "How to sort reviews",
                        "default": "recency"
                    },
                    "includeCompanyInfo": {
                        "title": "Include Company Info",
                        "type": "boolean",
                        "description": "Include company metadata (trust score, total reviews, categories) in each review row",
                        "default": true
                    },
                    "maxSearchResults": {
                        "title": "Max Search Results",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "When searching by query, maximum number of companies to scrape",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
