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

Scrape Trustpilot reviews easily by company domain. Extract detailed customer feedback including review text, ratings, verified status, business replies, and reviewer details. sentiment analysis, competitor research, and brand reputation monitoring.

- **URL**: https://apify.com/burbn/trustpilot-reviews-scraper.md
- **Developed by:** [Kevin](https://apify.com/burbn) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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 | Scrape Trustpilot Reviews API

Scrape Trustpilot reviews by company domain. Extract review text, title, rating, verification status, consumer details, likes, and business replies. Filter by verified reviews, date posted, specific ratings, keywords, and sort by relevance or recency. The best Trustpilot reviews scraper for sentiment analysis, brand monitoring, and customer feedback research.

### ❓ What is Trustpilot Reviews Scraper?

**Trustpilot Reviews Scraper** is a powerful Apify actor that lets you extract all reviews from any company on **Trustpilot** using its domain name. Perfect for brand monitoring, sentiment analysis, and customer feedback research.

With this Trustpilot reviews tool, you can:

- 🏢 **Scrape by domain** — Enter any company domain (e.g., "apify.com", "amazon.com")
- ✅ **Verified reviews only** — Filter to only show verified purchase reviews
- 💬 **With replies only** — Only get reviews that have business owner replies
- ⭐ **Rating filter** — Filter by specific star ratings (e.g., "1" or "4,5")
- 📅 **Date filter** — Get reviews from last 30 days, 3 months, 6 months, or 12 months
- 🔎 **Keyword search** — Search for specific keywords within reviews
- 🔃 **Sort options** — Sort by most relevant or most recent
- 🌍 **Multi-locale support** — Search across 22 regions (en-US, de-DE, fr-FR, ja-JP, etc.)
- 📄 **Automatic pagination** — Scrape thousands of reviews with page-based pagination

### 🎯 What Data Can You Extract from Trustpilot Reviews?

| Field | Description |
|-------|-------------|
| `reviewId` | Unique Trustpilot review identifier |
| `reviewTitle` | Review title/headline |
| `reviewText` | Full review text |
| `reviewRating` | Star rating (1-5) |
| `isVerified` | Whether the review is verified |
| `isPending` | Whether the review is pending |
| `likes` | Number of likes on the review |
| `language` | Review language code |
| `timePosted` | When the review was posted |
| `timeExperienced` | When the experience occurred |
| `replyText` | Business owner's reply text |
| `consumerId` | Reviewer's Trustpilot user ID |
| `consumerName` | Reviewer's display name |
| `consumerImage` | Reviewer's profile image URL |

### 🚀 How to Use Trustpilot Reviews Scraper

#### Step 1: Enter Company Domain

Enter the domain of the company whose reviews you want to scrape.

#### Step 2: Set Filters (Optional)

| Input | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `company_domain` | String | ✅ Yes | `apify.com` | Company domain to scrape reviews for |
| `maxResults` | Integer | ❌ No | `100` | Maximum total reviews (1-5000) |
| `sort` | Enum | ❌ No | `most_relevant` | Sort by: most_relevant, recency |
| `date_posted` | Enum | ❌ No | `any` | Date range: any, last 30 days, 3/6/12 months |
| `verified` | Boolean | ❌ No | — | Only verified reviews |
| `with_replies` | Boolean | ❌ No | — | Only reviews with owner replies |
| `rating` | String | ❌ No | — | Specific ratings (e.g., "1" or "4,5") |
| `query` | String | ❌ No | — | Keyword search within reviews |
| `locale` | Enum | ❌ No | `en-US` | Region/language (22 locales supported) |
| `cookie` | String | ❌ No | — | Login cookie (required for pages > 10) |

#### Step 3: Run and Download Results

Click **Start** to run the scraper. Results are available in JSON, CSV, Excel, XML, and RSS formats.

### 📋 Example Input

```json
{
  "company_domain": "apify.com",
  "sort": "recency",
  "date_posted": "last_3_months",
  "verified": true,
  "maxResults": 200
}
````

### 📋 Example Output

```json
  {
    "reviewId": "69e145ef514b2fe2a00241bd",
    "reviewTitle": "The best web scraper !",
    "reviewText": "I finally found a way to scrape some precious data for my business and be able to dodge powerful anti-spam protections! I recommand using Apify, it really does the job!",
    "reviewRating": 5,
    "isVerified": false,
    "isPending": false,
    "likes": 0,
    "language": "en",
    "timePosted": "2026-04-16T22:26:23.000Z",
    "timeExperienced": "2026-04-16T00:00:00.000Z",
    "replyText": null,
    "consumerId": "69e13bdd9478c69b69e3eb10",
    "consumerName": "Mouad Belmoughreb",
    "consumerImage": "https://user-images.trustpilot.com/69e13bdd9478c69b69e3eb10/73x73.png"
  }
```

### 🎨 Dataset Views

| View | Description |
|------|-------------|
| 📊 **Reviews Overview** | Reviewer name, title, rating, verified status, date |
| 📋 **Full Reviews** | All fields including review text, likes, language, and business replies |

### 💡 Use Cases

- **Sentiment Analysis** — Analyze customer sentiment across thousands of reviews
- **Brand Monitoring** — Track customer feedback and satisfaction trends over time
- **Competitor Analysis** — Compare review ratings and feedback across competitors
- **Customer Feedback Research** — Identify common complaints and praise points
- **Product Research** — Evaluate companies/products before purchase decisions
- **Quality Assurance** — Monitor service quality through customer reviews

### 🔧 Tips for Best Results

1. **Use verified filter** — Filter for verified reviews for more authentic feedback
2. **Sort by recency** — Get the latest reviews for up-to-date analysis
3. **Use date filters** — Focus on recent months for current trends
4. **Search by keyword** — Find reviews mentioning specific products or issues
5. **Use rating filter** — Analyze specific star ratings (e.g., only 1-star for complaint analysis)
6. **Increase maxResults** — Set to 5000 for comprehensive analysis

### 🔗 Related Actors

If you're looking for more Trustpilot data, check out our other scrapers:

- [**Trustpilot Search Scraper**](https://apify.com/burbn/trustpilot-search-scraper) 🔍 — Search and discover Trustpilot companies with ratings and contact info.

### 🏷️ Tags

`trustpilot` `trustpilot scraper` `trustpilot reviews` `review scraper` `trustpilot api` `customer reviews` `sentiment analysis` `trustpilot crawler` `trustpilot extractor` `brand monitoring` `review analysis` `customer feedback` `reputation management` `product reviews` `review data`

### 🎁 Get $5 Free Apify Credits

New to Apify? [Sign up using this link](https://apify.com?fpr=free-credits) and get **$5 free credits** to start scraping Trustpilot right away! No credit card required.

### 📞 Support

For questions, feedback, or issues, please contact us through Apify or open an issue.

***

**Happy scraping Trustpilot reviews! 📝✨**

# Actor input Schema

## `company_domain` (type: `string`):

The domain of the company to scrape reviews for (e.g., apify.com).

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

Maximum total reviews to scrape.

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

Criterion to sort the reviews.

## `date_posted` (type: `string`):

Filter by date ranges.

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

Only scrape verified reviews.

## `with_replies` (type: `boolean`):

Only scrape reviews that have an owner reply.

## `rating` (type: `string`):

Filter reviews by specific star ratings.

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

Search for specific keywords inside the reviews.

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

Select the region/language for Trustpilot reviews.

## `cookie` (type: `string`):

Login cookie. Required if you need to fetch pages > 10.

## Actor input object example

```json
{
  "company_domain": "apify.com",
  "maxResults": 100,
  "sort": "most_relevant",
  "date_posted": "any",
  "rating": "",
  "locale": "en-US"
}
```

# Actor output Schema

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

View reviews with reviewer name, title, rating, verification, and date.

## `detailed` (type: `string`):

View full review details including text, likes, language, and business replies.

# 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 = {
    "company_domain": "apify.com",
    "maxResults": 100,
    "locale": "en-US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("burbn/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 = {
    "company_domain": "apify.com",
    "maxResults": 100,
    "locale": "en-US",
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Reviews Scraper",
        "description": "Scrape Trustpilot reviews easily by company domain. Extract detailed customer feedback including review text, ratings, verified status, business replies, and reviewer details. sentiment analysis, competitor research, and brand reputation monitoring.",
        "version": "1.0",
        "x-build-id": "oexHzYPef2kzcryNj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/burbn~trustpilot-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-burbn-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/burbn~trustpilot-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-burbn-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/burbn~trustpilot-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-burbn-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",
                "required": [
                    "company_domain"
                ],
                "properties": {
                    "company_domain": {
                        "title": "🏢 Company Domain",
                        "type": "string",
                        "description": "The domain of the company to scrape reviews for (e.g., apify.com).",
                        "default": "apify.com"
                    },
                    "maxResults": {
                        "title": "🎯 Maximum Results",
                        "minimum": 10,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum total reviews to scrape.",
                        "default": 100
                    },
                    "sort": {
                        "title": "🔃 Sort By",
                        "enum": [
                            "most_relevant",
                            "recency"
                        ],
                        "type": "string",
                        "description": "Criterion to sort the reviews.",
                        "default": "most_relevant"
                    },
                    "date_posted": {
                        "title": "📅 Date Posted",
                        "enum": [
                            "any",
                            "last_12_months",
                            "last_6_months",
                            "last_3_months",
                            "last_30_days"
                        ],
                        "type": "string",
                        "description": "Filter by date ranges.",
                        "default": "any"
                    },
                    "verified": {
                        "title": "✅ Verified Only",
                        "type": "boolean",
                        "description": "Only scrape verified reviews."
                    },
                    "with_replies": {
                        "title": "💬 With Replies Only",
                        "type": "boolean",
                        "description": "Only scrape reviews that have an owner reply."
                    },
                    "rating": {
                        "title": "⭐ Specific Ratings",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5",
                            "1,2",
                            "1,2,3",
                            "4,5",
                            "3,4,5"
                        ],
                        "type": "string",
                        "description": "Filter reviews by specific star ratings.",
                        "default": ""
                    },
                    "query": {
                        "title": "🔎 Keyword Query",
                        "type": "string",
                        "description": "Search for specific keywords inside the reviews."
                    },
                    "locale": {
                        "title": "🌍 Locale/Region",
                        "enum": [
                            "en-US",
                            "en-GB",
                            "en-AU",
                            "en-CA",
                            "en-IE",
                            "en-NZ",
                            "da-DK",
                            "de-AT",
                            "de-CH",
                            "de-DE",
                            "es-ES",
                            "fi-FI",
                            "fr-BE",
                            "fr-FR",
                            "it-IT",
                            "ja-JP",
                            "nb-NO",
                            "nl-BE",
                            "nl-NL",
                            "pl-PL",
                            "pt-BR",
                            "pt-PT",
                            "sv-SE"
                        ],
                        "type": "string",
                        "description": "Select the region/language for Trustpilot reviews.",
                        "default": "en-US"
                    },
                    "cookie": {
                        "title": "🍪 Session Cookie",
                        "type": "string",
                        "description": "Login cookie. Required if you need to fetch pages > 10."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
