# Trustpilot Scraper — Company Reviews Data (`quietparse/trustpilot-company-reviews-scraper`) Actor

Scrape customer reviews from any company's Trustpilot page. Clean typed JSON: star rating, title, full text, dates, reviewer name & country, verification, company replies & TrustScore per row.

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

## Pricing

from $4.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.

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 Scraper — Company Reviews Data

Scrape customer reviews from any company's page on **Trustpilot
(trustpilot.com)** and get clean, typed JSON: star rating as a number, review
title and full text, publication date and date of experience as ISO dates,
reviewer name and country, verification status, the company's public reply,
and the company's TrustScore on every row. No HTML parsing on your side.

### What it does

- Crawls Trustpilot **company review pages** (~20 reviews per page request —
  fast and cheap; public, logged-out pages only).
- Reads the structured JSON embedded in each page (`__NEXT_DATA__`) instead of
  brittle CSS selectors — markup redesigns don't break extraction.
- Normalizes every value: star image → `rating: 1-5`, "Date of experience:
  March 15, 2026" → `2026-03-15`, "Verified" label → `verified: true`,
  company replies → `{ text, date }`.
- Accepts plain **company domains** ("asos.com") or full Trustpilot review
  URLs; the "www." spelling is corrected automatically.
- Typical uses: brand monitoring, competitor review analysis, sentiment/ML
  datasets, churn research from 1-2★ reviews, support-quality tracking from
  reply rates, market research dashboards.

### Input

| Field | Type | Default | Description |
| ----- | ---- | ------- | ----------- |
| `companyDomains` | array of strings | `["azazie.com"]` | Company domains as they appear on Trustpilot ("asos.com", "www.asos.com"). Wrong "www." form is auto-corrected. |
| `companyUrls` | array of strings | — | Full trustpilot.com review URLs (`https://www.trustpilot.com/review/<domain>`). Combined with the domains. |
| `languages` | string | `"all"` | `"all"` or one language code ("en", "de", "fr"). |
| `sort` | string | `"recency"` | `"recency"` (newest first) or `"relevance"` (Trustpilot's default ranking). |
| `minRating` / `maxRating` | integer | — | Keep only reviews in this star range (1-5). Filtered-out reviews are **never charged**. |
| `maxReviewsPerCompany` | integer | `100` | Cap per company (max 5,000 — see Limitations for the practical site ceiling). |
| `maxResults` | integer | `100` | Hard cap across all companies (max 10,000). **Free-plan users are capped at 50.** |
| `proxyConfiguration` | object | Apify Residential proxy | Trustpilot is behind AWS WAF; residential proxy is required (datacenter IPs are blocked). |

Example input:

```json
{
    "companyDomains": ["asos.com", "boohoo.com"],
    "maxRating": 2,
    "maxReviewsPerCompany": 200,
    "maxResults": 400
}
````

### Output sample

One dataset item per review:

```json
{
    "review_id": "69bbddbadb7b31e0e7f1b0dc",
    "company_domain": "www.asos.com",
    "company_name": "ASOS",
    "company_trust_score": 1.8,
    "company_total_reviews": 190654,
    "rating": 1,
    "title": "ordered yesterday with next day…",
    "text": "ordered yesterday with next day delivery, hasn't even been dispatched...",
    "language": "en",
    "date_published": "2026-03-19T10:47:54.000Z",
    "date_of_experience": "2026-03-19",
    "reviewer_name": "Megan",
    "reviewer_country": "GB",
    "reviewer_review_count": 1,
    "verified": false,
    "company_reply": null,
    "review_url": "https://www.trustpilot.com/reviews/69bbddbadb7b31e0e7f1b0dc",
    "scraped_at": "2026-06-12T10:00:00.000Z"
}
```

Field notes: `verified` is `true` only when Trustpilot itself labeled the
review **Verified** (a confirmed business interaction) — invited and organic
reviews are `false`. `company_reply` is `{ "text": "...", "date": "..." }`
when the business replied, otherwise `null`. `date_of_experience`,
`reviewer_country`, `reviewer_review_count`, `text`, and `language` are `null`
when Trustpilot doesn't show them. `company_trust_score` and
`company_total_reviews` are snapshots at scrape time, repeated on every row so
each review is self-contained in CSV exports.

### Pricing & free-tier policy

This Actor uses **pay-per-event** pricing:

| Event | When charged |
| ----- | ------------ |
| Actor start (`apify-actor-start`) | Automatically by Apify, once per run (per GB of memory) |
| Company review (`apify-default-dataset-item`) | Automatically by Apify, per default-dataset item |

Per-item and per-start prices are shown on the Actor's **Pricing** tab in Apify
Store.

You only pay for reviews that pass output-schema validation — malformed rows
and reviews removed by your star-rating filter are never charged. Set
**Maximum cost per run** in Apify Console to cap spend; the Actor stops
gracefully at the limit and keeps everything scraped so far.

**Free tier — stated plainly:** users on the Apify free plan get up to
**50 reviews per run**. The run still finishes successfully with a clear status
message when the cap is reached. Any paid Apify plan unlocks the full
10,000-reviews-per-run limit.

### Limitations

- **Review pages only (v1).** Reviewer profile pages and Trustpilot category
  /search pages are not crawled.
- **Logged-out visitors only see a company's most recent reviews** — about
  200 per query (10 pages × 20), and Trustpilot's public star filter overlaps
  heavily with that same recency feed. The Actor splits deep requests by star
  rating to reach a little further, but the measured practical ceiling is
  **~200-300 of the most-recent reviews per company**. Full multi-year archives
  of very large companies are not reachable from public pages — by design, this
  Actor never logs in.
- **Politeness by design:** pages are loaded in a real headless browser,
  sequentially, with a randomized 2-5 s delay through rotating residential
  proxies (Trustpilot is fronted by AWS WAF, which a browser clears).
- Reviewer fields contain exactly what Trustpilot shows publicly (display
  name, country code, review count) — no enrichment, no contact details. If
  you process this data in the EU/UK, you are the controller for your use;
  handle it per GDPR.
- Reviews change constantly (edits, removals, new replies) — treat results as
  a snapshot (`scraped_at` is on every row).

### Support

Found an issue or need a field added? Open an issue on the Actor page and it
will usually be handled within a few days.

# Actor input Schema

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

Company domains as they appear on Trustpilot, e.g. "asos.com" or "www.asos.com" (the part after trustpilot.com/review/). If the "www." form is wrong, the Actor automatically tries the other variant.

## `companyUrls` (type: `array`):

Full trustpilot.com review-page URLs (https://www.trustpilot.com/review/<domain>). Combined with the domains above.

## `languages` (type: `string`):

"all" (default) for reviews in every language, or a single language code like "en", "de", "fr".

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

"recency" = newest reviews first (recommended for monitoring). "relevance" = Trustpilot's default ranking.

## `minRating` (type: `integer`):

Only keep reviews with at least this many stars (1-5). Filtered-out reviews are never charged.

## `maxRating` (type: `integer`):

Only keep reviews with at most this many stars (1-5). E.g. set max 2 to collect only negative reviews.

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

Cap per company (max 5,000). Note: Trustpilot shows logged-out visitors only their most recent reviews — in practice ~200-300 per company. The Actor splits deep queries by star rating to reach a little further, but cannot exceed what Trustpilot serves publicly.

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

Hard cap on reviews pushed to the dataset across all companies (max 10,000). Free-plan users are capped at 50 results per run.

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

Proxy to use. Trustpilot is fronted by AWS WAF, which blocks datacenter IPs — Apify Residential proxy is the default and is required for the scraper to work.

## Actor input object example

```json
{
  "companyDomains": [
    "azazie.com"
  ],
  "languages": "all",
  "sort": "recency",
  "maxReviewsPerCompany": 20,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `reviews` (type: `string`):

All extracted reviews as structured JSON items (also exportable as CSV/Excel).

# 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 = {
    "companyDomains": [
        "azazie.com"
    ],
    "maxReviewsPerCompany": 20,
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("quietparse/trustpilot-company-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 = {
    "companyDomains": ["azazie.com"],
    "maxReviewsPerCompany": 20,
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Scraper — Company Reviews Data",
        "description": "Scrape customer reviews from any company's Trustpilot page. Clean typed JSON: star rating, title, full text, dates, reviewer name & country, verification, company replies & TrustScore per row.",
        "version": "0.1",
        "x-build-id": "VuzEdHUXp3s7le1xS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/quietparse~trustpilot-company-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-quietparse-trustpilot-company-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/quietparse~trustpilot-company-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-quietparse-trustpilot-company-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/quietparse~trustpilot-company-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-quietparse-trustpilot-company-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": {
                    "companyDomains": {
                        "title": "Company domains",
                        "type": "array",
                        "description": "Company domains as they appear on Trustpilot, e.g. \"asos.com\" or \"www.asos.com\" (the part after trustpilot.com/review/). If the \"www.\" form is wrong, the Actor automatically tries the other variant.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyUrls": {
                        "title": "Trustpilot review URLs",
                        "type": "array",
                        "description": "Full trustpilot.com review-page URLs (https://www.trustpilot.com/review/<domain>). Combined with the domains above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "languages": {
                        "title": "Review languages",
                        "type": "string",
                        "description": "\"all\" (default) for reviews in every language, or a single language code like \"en\", \"de\", \"fr\".",
                        "default": "all"
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "recency",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "\"recency\" = newest reviews first (recommended for monitoring). \"relevance\" = Trustpilot's default ranking.",
                        "default": "recency"
                    },
                    "minRating": {
                        "title": "Minimum star rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only keep reviews with at least this many stars (1-5). Filtered-out reviews are never charged."
                    },
                    "maxRating": {
                        "title": "Maximum star rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only keep reviews with at most this many stars (1-5). E.g. set max 2 to collect only negative reviews."
                    },
                    "maxReviewsPerCompany": {
                        "title": "Max reviews per company",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Cap per company (max 5,000). Note: Trustpilot shows logged-out visitors only their most recent reviews — in practice ~200-300 per company. The Actor splits deep queries by star rating to reach a little further, but cannot exceed what Trustpilot serves publicly.",
                        "default": 100
                    },
                    "maxResults": {
                        "title": "Max results (all companies)",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard cap on reviews pushed to the dataset across all companies (max 10,000). Free-plan users are capped at 50 results per run.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy to use. Trustpilot is fronted by AWS WAF, which blocks datacenter IPs — Apify Residential proxy is the default and is required for the scraper to work.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
