# Trustpilot Reviews Scraper $0.20/1K (`vant47/trustpilot-reviews-scraper-cheap`) Actor

Scrape Trustpilot reviews and profiles for Wise, airlines or online stores. Get ratings, text, dates, replies and TrustScores. $0.20 per 1,000 reviews. On HTTP, 100 reviews total $0.02805 with fees. Browser warm-up may cost extra. Filter by date, stars or language. No login.

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

## Pricing

from $0.16 / 1,000 reviews

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

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

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

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

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

# README

## Trustpilot Reviews Scraper $0.20/1K

Export Trustpilot reviews and company profiles for support monitoring, market research and vendor due diligence. Enter a domain such as wise.com, search for a company name, or collect reviews for businesses in a Trustpilot category. Each review row includes its rating, text, dates and any public business reply.

**A review costs $0.0002. For example, 1,000 reviews cost $0.20 in review charges.** A company profile costs $0.001. With HTTP session reuse, 100 reviews total $0.02805, including a $0.008 successful-run fee and Apify start at the default memory. If the Actor launches a browser and saves results, it also charges $0.0686 for warm-up. Plan discounts apply to reviews and profiles. A Trustpilot login or API key is unnecessary.

### What you get

Trustpilot Reviews Scraper saves an exportable Apify dataset. A single run can return reviews and optional company profiles together, with the domain on both row types. Duplicate review IDs and company domains are delivered and charged once per run, including when the same company appears in your direct inputs, search results and categories.

Open **Reviews** to see rating, text, publication date, language and reply columns. Open **Companies** for TrustScore, ratings and public contact details. The **Run summary** shows the result counts. The views choose columns. In a JSON export, filter on `type` to select `review`, `company`, `note` or `summary` rows. Use the separate `SUMMARY` record to read per-input results through the API.

| Review field | Meaning |
|---|---|
| `summary` | A readable string with the rating and company domain |
| `type` | `review` for an individual public review |
| `reviewId` | Trustpilot's review identifier, suitable for joining or upserting exports |
| `domain` | The reviewed company's Trustpilot domain |
| `rating` | The review's numeric rating from 1 through 5 |
| `title`, `text` | The public review headline and body, when shared |
| `language` | Trustpilot's language code for this review |
| `publishedAt` | UTC publication timestamp |
| `experiencedAt` | The date of experience supplied on the review |
| `verified` | Trustpilot's verification flag, when supplied |
| `reviewer` | Public display name, country code and review count, when available |
| `companyReply` | Public company reply text and published date, when available |
| `likes` | Public count of likes supplied with the review |
| `url` | Link to the individual Trustpilot review |
| `scrapedAt` | UTC timestamp for this observation |

| Company field | Meaning |
|---|---|
| `type` | `company` for an optional company profile |
| `name`, `domain` | Company's displayed name and the stable reviewed domain |
| `trustScore`, `rating` | Exact TrustScore and displayed star rating. Trustpilot can show different values in these fields. |
| `reviewsCount` | Total published profile review count reported by Trustpilot |
| `starDistribution` | Counts of reviews rated 1 through 5 when the source provides the breakdown |
| `category`, `categories` | Primary or first available category and all supplied category names and IDs |
| `claimed` | Public company-claim status when supplied |
| `countryCode` | Published company country when available |
| `website`, `phone`, `email`, `address` | Public business contact fields, when available |
| `contact` | The website, phone, email and address together for JSON exports |
| `url`, `scrapedAt` | Public company profile URL and observation timestamp |

Missing values are `null`. Review text can be empty when the source supplies a rating without written content. A profile's total review count describes the company, while `SUMMARY.reviews` counts the rows this run saved.

In a cloud run on 18 November 2026, the Wise profile returned a TrustScore of 4.3, a displayed rating of 4.5 and 306,052 reviews. Its five-star count was 245,351. The profile and review rows have the same company domain, so you can join them without matching names.

### Three steps

1. Choose a starting point. Paste a Trustpilot company link, use a business domain, or enter a company name or category.
2. Set the maximum reviews per company. Optionally choose ratings, languages, a date or a company profile export.
3. Start the run and open the dataset. Export JSON, CSV, Excel or another Apify format. Read the run summary for counts and any input that needs attention.

#### Reviews from two companies

The preset collects up to 100 reviews each for Back Market and ASOS.

```json
{
  "domains": ["backmarket.com", "asos.com"],
  "maxReviewsPerCompany": 100,
  "sortBy": "newest"
}
```

#### Monitor critical reviews

```json
{
  "companyUrls": [{"url": "https://uk.trustpilot.com/review/wise.com"}],
  "stars": [1, 2],
  "languages": ["en"],
  "dateFrom": "2026-11-01",
  "maxReviewsPerCompany": 100
}
```

#### Discover companies by category

```json
{
  "categoryUrls": [{"url": "https://www.trustpilot.com/categories/money_transfer_service"}],
  "maxCompaniesPerSearch": 10,
  "maxReviewsPerCompany": 0,
  "includeCompanyProfile": true
}
```

Use company names in `searchQueries` to discover matching domains. A search containing an exact domain goes directly to its public company profile. If the exact domain is already known, put it in `domains` to go directly to the company's reviews. Choose a low discovery cap when trying a broad name search for the first time.

### Inputs

| Input | Effect |
|---|---|
| `companyUrls` | Public Trustpilot company review links. Apify URL objects and URL strings are accepted. |
| `domains` | List of business domains. For example, `["wise.com"]`. |
| `categoryUrls` | Trustpilot category URLs. Preserves the storefront and supported location, country and category filters in the URL. |
| `searchQueries` | Company names or domains to find on Trustpilot |
| `maxCompaniesPerSearch` | Maximum companies per category or search. The default is 10. |
| `maxReviewsPerCompany` | Maximum matching reviews per company. The default is 100. Use zero for a profile-only run. |
| `stars` | One or more rating numbers from 1 through 5. An empty list includes every rating. |
| `languages` | Review language codes such as `en`, `fr` and `de`. An empty list includes any language the public page returns. |
| `dateFrom` | Inclusive publication time as a UTC date or an ISO timestamp with a timezone |
| `sortBy` | `newest` for the source's recent ordering or `mostRelevant` for Trustpilot relevance |
| `includeCompanyProfile` | Add company rows. The default is false. |
| `locationQuery` | Two-letter storefront country such as US, GB, CA, DE or AU. A pasted Trustpilot link selects its own storefront. |
| `proxyConfiguration` | Automatic selection tries Apify datacenter first. Explicit proxy disable, country, groups and custom proxies are preserved. |

Compatible search inputs are `searchStringsArray` and `keywords`. If supplied, `searchQueries` takes precedence, followed by `searchStringsArray`, then `keywords`. The smallest supplied review cap wins between `maxReviewsPerCompany`, `maxReviews` and `maxResults`. The smaller cap wins between `maxCompaniesPerSearch` and `maxCrawledPlacesPerSearch`. A single `language` can stand in for the `languages` list. Set `includeReviews` to false to request profiles alone, together with `includeCompanyProfile: true`.

### Pricing

| Apify plan | One review | One company profile |
|---|---:|---:|
| Free or undiscounted | $0.0002 | $0.001 |
| Bronze | $0.00019 | $0.00095 |
| Silver | $0.00018 | $0.00090 |
| Gold, Platinum or Diamond | $0.00016 | $0.00080 |

Set an Apify maximum charge to control the total on a run. The Actor saves affordable rows and stops before the next row that would exceed it. Your saved results stay available. Empty results, notes, duplicates and retries carry no review or profile charge. The $0.008 successful-run fee applies once after the first review or profile is saved. The $0.0686 browser warm-up applies at most once per run when the Actor launches a browser and saves a review or profile. HTTP-only runs pay the successful-run fee, Apify start and the rows delivered. Empty runs carry only the Apify platform start charge. Platform usage is included in the listed prices.

At undiscounted rates and default memory, an HTTP-only run costs $0.02805 for 100 reviews, $0.01805 for ten profiles, or $0.20805 for 1,000 reviews. A run that needs a browser warm-up and saves 100 reviews costs $0.09665. An Apify maximum charge below the combined price allows any affordable HTTP results and skips browser launch if the warm-up and first result cannot fit.

### Schedule review monitoring

Save the input as an Apify task. In Schedules, choose the task and the frequency that matches your workflow. A recurring run with a fixed `dateFrom` continues to include reviews from that date onward. For a rolling window, compute the desired UTC cutoff in your scheduler or workflow and send it in the run input. Export before an unnamed dataset's retention period ends.

With automatic proxy selection, the Actor keeps a signed-out session in the named `trustpilot-reviews-public-sessions-v1` key-value store in your Apify account. It tries HTTP with existing session state and falls back when Trustpilot no longer accepts that state. Browser warm-up may recur as cookies or proxy sessions expire. An explicit proxy choice uses a fresh session for each run.

Use `reviewId` as the unique key in your destination. When reviews are edited or receive replies, update the saved record using the same ID and the latest `scrapedAt`. An overlapping cutoff helps catch delayed updates. Retain the freshest reply or review text according to your monitoring policy.

Use Apify integrations to send the results to Google Sheets, a webhook, Make, Zapier or n8n. Filter `type` before mapping rows to a table. Keep company profiles in a separate table joined by domain. Review the `SUMMARY` record before advancing your monitoring checkpoint. A status of `incomplete` identifies a source request that did not finish or an older source page that a signed-out visitor could not read.

### API

Use your Apify account token in the request header. The synchronous endpoint returns dataset rows and suits small collections.

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/vant47~trustpilot-reviews-scraper-cheap/run-sync-get-dataset-items' \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domains":["wise.com"],"maxReviewsPerCompany":10}'
```

Python using the standard library:

```python
import json
import os
import urllib.request

url = "https://api.apify.com/v2/acts/vant47~trustpilot-reviews-scraper-cheap/run-sync-get-dataset-items"
body = {"domains": ["wise.com"], "maxReviewsPerCompany": 10}
req = urllib.request.Request(
    url,
    data=json.dumps(body).encode(),
    headers={"Authorization": "Bearer " + os.environ["APIFY_TOKEN"],
             "Content-Type": "application/json"},
)
with urllib.request.urlopen(req) as response:
    for row in json.load(response):
        if row["type"] == "review":
            print(row["reviewId"], row["rating"], row["publishedAt"])
```

JavaScript using the Apify client:

```javascript
import { ApifyClient } from "apify-client";

const apify = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await apify.actor("vant47/trustpilot-reviews-scraper-cheap").call({
  domains: ["wise.com"],
  maxReviewsPerCompany: 25,
  includeCompanyProfile: true
});
const { items } = await apify.dataset(run.defaultDatasetId).listItems();
const reviews = items.filter(row => row.type === "review");
```

For large collections, start an asynchronous run and read its `defaultDatasetId` in pages. The `SUMMARY` record is in the run's `defaultKeyValueStoreId`.

### Use with AI agents (MCP)

Connect to the Apify MCP server with `https://mcp.apify.com/?tools=vant47/trustpilot-reviews-scraper-cheap` and authenticate with Apify. Ask the agent to fetch the Actor's input schema before starting.

Example request. Collect the 25 most recent English one- and two-star Trustpilot reviews for wise.com, including review text and company replies. Return the dataset and its summary.

### Limits

Trustpilot limits deep pagination for signed-out visitors. On newest-first jobs, the Actor can use available public rating and language filters to collect more distinct reviews. Rows from additional filters follow the first pages in the dataset. Sort the exported rows by `publishedAt` for a single timeline. Complete historical coverage depends on what the source publishes to signed-out visitors. Source visibility, counts and reply fields may vary by company and storefront.

Search and category results follow Trustpilot's ranking and available pages. A named company search can match several similar businesses. Use the exact domain when you know it. Ratings, profile details and review totals can change between requests.

### FAQ

**Can I get only company profiles?**\
Set `includeCompanyProfile` to true and `maxReviewsPerCompany` to zero.

**Will a repeated run bill for the same review?**\
Each run bills for its own unique delivered rows. Apply `dateFrom` to narrow each run and join by `reviewId` in your destination.

**How can I distinguish a valid empty run from an interruption?**\
Open `SUMMARY`. `no_matches` means there were no results for the selected inputs or filters. `incomplete` identifies a source limitation or unavailable page. `spending_limit` means the next row could not fit your spending cap.

**What do the verification and claim flags mean?**\
They reflect Trustpilot's public disclosures for each review or profile. They describe the source's labels at the time of collection.

Use this Trustpilot reviews scraper for scheduled review monitoring, company profiles, ratings and public reply exports.

# Actor input Schema

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

Enter public company review pages. The locale in a link selects its Trustpilot storefront.

## `domains` (type: `array`):

Use website domains such as wise.com. Multiple domains can be monitored together.

## `categoryUrls` (type: `array`):

Find businesses in one or more Trustpilot categories. Country and available category filters in a link are retained.

## `searchQueries` (type: `array`):

Company names or domains to search on Trustpilot.

## `maxCompaniesPerSearch` (type: `integer`):

Maximum company matches considered for each search or category. Default 10.

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

Maximum matching reviews for each company. Default 100. Use 0 for profiles only.

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

Filter to one or more ratings from 1 through 5. Empty includes every rating.

## `languages` (type: `array`):

Language codes such as en, de or fr. Empty includes all languages.

## `dateFrom` (type: `string`):

Inclusive UTC date YYYY-MM-DD or ISO timestamp with timezone. Use for review monitoring.

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

Newest uses published time. Most relevant uses Trustpilot ordering.

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

Export company details as individually priced rows.

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

Automatic uses Apify datacenter first with residential fallback if needed. Explicit proxy options are preserved.

## `locationQuery` (type: `string`):

Two-letter Trustpilot storefront country, such as US, GB, CA, DE or AU. Explicit company and category links retain their storefront.

## `searchStringsArray` (type: `array`):

Compatible search alias. An explicitly supplied searchQueries takes precedence.

## `keywords` (type: `array`):

Compatible search alias after searchQueries and searchStringsArray.

## `maxCrawledPlacesPerSearch` (type: `integer`):

Alias for maxCompaniesPerSearch. The smaller cap wins if both are supplied.

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

Alias for maxReviewsPerCompany. The smaller supplied cap wins.

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

Alias for maxReviewsPerCompany. The smallest supplied review cap wins.

## `includeReviews` (type: `boolean`):

Set false for profiles only. Reviews are included by default.

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

Single-code alias for languages. An explicitly supplied languages list takes precedence.

## Actor input object example

```json
{
  "domains": [
    "asos.com"
  ],
  "maxReviewsPerCompany": 20,
  "sortBy": "newest",
  "includeCompanyProfile": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `companies` (type: `string`):

No description

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

No description

## `summary` (type: `string`):

No description

# 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 = {
    "domains": [
        "asos.com"
    ],
    "maxReviewsPerCompany": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("vant47/trustpilot-reviews-scraper-cheap").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 = {
    "domains": ["asos.com"],
    "maxReviewsPerCompany": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("vant47/trustpilot-reviews-scraper-cheap").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domains": [
    "asos.com"
  ],
  "maxReviewsPerCompany": 20
}' |
apify call vant47/trustpilot-reviews-scraper-cheap --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vant47/trustpilot-reviews-scraper-cheap"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/g8p7vEi6gMsjpqMpD/builds/ECobG0OYOfcSARKTv/openapi.json
