# Trustpilot Reviews Scraper — All Reviews + Company Profile (`buff_pineapple/trustpilot-reviews-scraper`) Actor

Scrape every Trustpilot review for any company by domain or profile URL. Returns reviewer name, country, star rating, title, text, date of experience, owner reply, verified flag, likes and language — plus the company TrustScore profile. Filter by stars, language, date, verified and keyword.

- **URL**: https://apify.com/buff\_pineapple/trustpilot-reviews-scraper.md
- **Developed by:** [yossef Nagy](https://apify.com/buff_pineapple) (community)
- **Categories:** Lead generation, Business, E-commerce
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 1 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

Scrape **every Trustpilot review** for any company — plus the company's TrustScore profile — by domain or Trustpilot profile URL. No login, no API key.

### What it does

Give it one or more companies and it returns, for each:

- **Every review**, paginated automatically: reviewer name, country, star rating, review title, full review text, date of experience, published date, verified flag, company reply (text + date), like count and review language.
- **The company profile** (optional): TrustScore, star rating, total review count, categories, claimed status and contact info (email, phone, address) — pushed as one extra item per company.

It works by driving a real browser to pass Trustpilot's AWS WAF bot challenge, then reading the server-rendered review data directly — fast, and it never misses reviews to lazy-loading.

### Use cases

- **Reputation monitoring** — pull all recent reviews for your own brand and watch your TrustScore.
- **Competitor analysis** — scrape competitors' reviews to find what customers praise and complain about.
- **Negative-review triage** — filter to 1–2 star reviews only and route complaints to support.
- **Lead qualification** — check a prospect's or supplier's Trustpilot standing before doing business.
- **Voice-of-customer / NLP** — export thousands of reviews as structured JSON for sentiment analysis.
- **Owner-response audits** — filter to reviews with (or without) a company reply to measure response coverage.

### Input

| Field | Type | Description |
|---|---|---|
| `companies` | array | Domains (`www.amazon.com`), Trustpilot profile URLs, or business-unit slugs. **Required.** |
| `maxReviewsPerCompany` | integer | Reviews to return per company. `0` = every available review. Default `200`. |
| `sort` | string | `recency` (newest first) or `relevance`. Default `recency`. |
| `stars` | array | Only these star ratings, e.g. `["1","2"]`. Empty = all. |
| `language` | string | Review language ISO code (`en`, `de`, …) or `all`. Default `all`. |
| `dateRange` | string | `last30days`, `last3months`, `last6months`, `last12months`, or empty for any time. |
| `verifiedOnly` | boolean | Only reviews Trustpilot marks as verified. |
| `repliesOnly` | boolean | Only reviews that have a company reply. |
| `searchKeyword` | string | Only reviews matching this keyword (Trustpilot's on-site search). |
| `includeCompanyProfile` | boolean | Push one company-profile item per company. Default `true`. |
| `proxyConfiguration` | object | Proxy. Defaults to Apify **RESIDENTIAL** (required to pass AWS WAF reliably). |
| `maxConcurrency` | integer | Companies processed in parallel. Default `2`. |

All filters map to Trustpilot's own on-site filters, so results match exactly what you'd see on the website with those filters applied.

### Output

Each **review** item:

```json
{
  "_kind": "review",
  "review_id": "6a04ea7842c3f9dc9623eb92",
  "company_name": "Amazon",
  "company_domain": "www.amazon.com",
  "rating": 1,
  "title": "I can not sign in due to change of my number",
  "text": "I can not sign in due to change of my contact number...",
  "author_name": "Kalpana Kamal",
  "author_country": "DE",
  "author_review_count": 1,
  "experienced_date": "2026-05-13T00:00:00.000Z",
  "published_date": "2026-05-13T23:17:44.000Z",
  "is_verified": false,
  "verification_level": "not-verified",
  "likes": 0,
  "language": "en",
  "reply_text": null,
  "reply_date": null,
  "has_reply": false,
  "review_url": "https://www.trustpilot.com/reviews/6a04ea7842c3f9dc9623eb92",
  "scrapedAt": "2026-05-14T21:40:00.000Z"
}
````

Each **company** item (`_kind: "company"`): `company_name`, `company_domain`, `website_url`, `trust_score`, `stars`, `total_reviews`, `is_claimed`, `categories`, `primary_category`, `contact_email`, `contact_phone`, `contact_address`, `profile_url`.

### Pricing

Pay per result:

- **$0.002** per review scraped
- **$0.01** per company profile (only when `includeCompanyProfile` is on)

You only pay for data you actually receive.

### Notes

- Trustpilot is protected by AWS WAF. This actor passes the challenge with a real browser, so a **residential proxy is strongly recommended** (it's the default) — datacenter IPs are challenged far more aggressively.
- Pagination, sorting and filtering all use Trustpilot's native parameters, so the actor returns exactly the reviews the site would show for that filter combination.

# Actor input Schema

## `companies` (type: `array`):

Companies to scrape. Each entry can be a domain (e.g. "www.amazon.com" or "amazon.com"), a Trustpilot profile URL (e.g. "https://www.trustpilot.com/review/www.amazon.com"), or a Trustpilot business unit slug. One run can cover many companies.

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

Alias for `companies` — Trustpilot profile URLs are merged in. Provided for compatibility with other actors.

## `maxReviewsPerCompany` (type: `integer`):

How many reviews to return per company. Trustpilot serves 20 per page; the actor paginates automatically. Set 0 to scrape every available review.

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

Order in which reviews are returned. "recency" = newest first; "relevance" = Trustpilot's default relevance ranking.

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

Only return reviews with these star ratings. Leave empty for all ratings. Example: \[1, 2] for negative reviews only.

## `language` (type: `string`):

Filter reviews by language ISO code (e.g. "en", "de", "fr"), or "all" for every language.

## `dateRange` (type: `string`):

Only return reviews published within this window.

## `verifiedOnly` (type: `boolean`):

If enabled, only return reviews Trustpilot marks as verified.

## `repliesOnly` (type: `boolean`):

If enabled, only return reviews that have a reply from the company.

## `searchKeyword` (type: `string`):

Only return reviews whose text matches this keyword (uses Trustpilot's on-site review search).

## `includeCompanyProfile` (type: `boolean`):

If enabled, push one extra item per company with its TrustScore, total review count, rating distribution, categories and contact info.

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

Required. Trustpilot is behind AWS WAF, so the actor defaults to RESIDENTIAL proxy to reliably pass the bot challenge.

## `maxConcurrency` (type: `integer`):

Number of companies processed in parallel. Each uses its own browser context.

## Actor input object example

```json
{
  "companies": [
    "www.amazon.com"
  ],
  "startUrls": [],
  "maxReviewsPerCompany": 200,
  "sort": "recency",
  "stars": [],
  "language": "all",
  "dateRange": "",
  "verifiedOnly": false,
  "repliesOnly": false,
  "searchKeyword": "",
  "includeCompanyProfile": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 2
}
```

# 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 = {
    "companies": [
        "www.amazon.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("buff_pineapple/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 = {
    "companies": ["www.amazon.com"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("buff_pineapple/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 '{
  "companies": [
    "www.amazon.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call buff_pineapple/trustpilot-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Reviews Scraper — All Reviews + Company Profile",
        "description": "Scrape every Trustpilot review for any company by domain or profile URL. Returns reviewer name, country, star rating, title, text, date of experience, owner reply, verified flag, likes and language — plus the company TrustScore profile. Filter by stars, language, date, verified and keyword.",
        "version": "0.1",
        "x-build-id": "MLffWYtAGkwogYqLk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/buff_pineapple~trustpilot-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-buff_pineapple-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/buff_pineapple~trustpilot-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-buff_pineapple-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/buff_pineapple~trustpilot-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-buff_pineapple-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": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Companies",
                        "type": "array",
                        "description": "Companies to scrape. Each entry can be a domain (e.g. \"www.amazon.com\" or \"amazon.com\"), a Trustpilot profile URL (e.g. \"https://www.trustpilot.com/review/www.amazon.com\"), or a Trustpilot business unit slug. One run can cover many companies.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (alias)",
                        "type": "array",
                        "description": "Alias for `companies` — Trustpilot profile URLs are merged in. Provided for compatibility with other actors.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerCompany": {
                        "title": "Max reviews per company",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "How many reviews to return per company. Trustpilot serves 20 per page; the actor paginates automatically. Set 0 to scrape every available review.",
                        "default": 200
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "recency",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Order in which reviews are returned. \"recency\" = newest first; \"relevance\" = Trustpilot's default relevance ranking.",
                        "default": "recency"
                    },
                    "stars": {
                        "title": "Star ratings",
                        "type": "array",
                        "description": "Only return reviews with these star ratings. Leave empty for all ratings. Example: [1, 2] for negative reviews only.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ]
                        },
                        "default": []
                    },
                    "language": {
                        "title": "Review language",
                        "type": "string",
                        "description": "Filter reviews by language ISO code (e.g. \"en\", \"de\", \"fr\"), or \"all\" for every language.",
                        "default": "all"
                    },
                    "dateRange": {
                        "title": "Date range",
                        "enum": [
                            "",
                            "last30days",
                            "last3months",
                            "last6months",
                            "last12months"
                        ],
                        "type": "string",
                        "description": "Only return reviews published within this window.",
                        "default": ""
                    },
                    "verifiedOnly": {
                        "title": "Verified reviews only",
                        "type": "boolean",
                        "description": "If enabled, only return reviews Trustpilot marks as verified.",
                        "default": false
                    },
                    "repliesOnly": {
                        "title": "Reviews with company reply only",
                        "type": "boolean",
                        "description": "If enabled, only return reviews that have a reply from the company.",
                        "default": false
                    },
                    "searchKeyword": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Only return reviews whose text matches this keyword (uses Trustpilot's on-site review search).",
                        "default": ""
                    },
                    "includeCompanyProfile": {
                        "title": "Include company profile",
                        "type": "boolean",
                        "description": "If enabled, push one extra item per company with its TrustScore, total review count, rating distribution, categories and contact info.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Required. Trustpilot is behind AWS WAF, so the actor defaults to RESIDENTIAL proxy to reliably pass the bot challenge."
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Number of companies processed in parallel. Each uses its own browser context.",
                        "default": 2
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
