# Trustpilot Reviews Scraper: TrustScore, Stars, Replies (`arcadium/trustpilot-reviews`) Actor

Trustpilot reviews for company domains or URLs: stars, date, verified flag, company reply; $0.52 per 1,000 on the free plan. Company mode: every company in a category with TrustScore, review count and country, $2 per 1,000. Watch mode for changes. No reviewer names.

- **URL**: https://apify.com/arcadium/trustpilot-reviews.md
- **Developed by:** [Arcadium Data](https://apify.com/arcadium) (community)
- **Categories:** Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.27 / 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: TrustScore, Stars, Replies

Give it company domains or Trustpilot review pages and it returns one row per company (TrustScore, review count, star split, categories, reply rate) and one JSON row per review: stars, title, text, date, language, the verified flag and the company's reply with its date. From $0.52 per 1,000 reviews on the free plan, and you pay only for the review rows you get.

Company mode: give it Trustpilot categories (`bank`, `electronics_store`, any sub-category) and countries, and it returns every listed company with TrustScore, stars, review count, categories, city and country, $2 per 1,000 companies on the free plan. Or switch reviews off and get only the company rows for your own company list.

**Why this actor**

- **Drop-in input.** Input written for `automation-lab/trustpilot`, `memo23/trustpilot-scraper-ppe` or `blackfalcondata/trustpilot-reviews-scraper` works as it is (see "Coming from another Trustpilot scraper?").
- **Tiered price per review**: $0.52 per 1,000 on the free plan, down to $0.27 on Business (Platinum and Diamond also pay $0.27). The start fee is $0.005 per GB of memory ($0.01 at the default 2 GB).
- **More than 200 reviews per company via filter combinations.** Trustpilot shows an anonymous visitor at most 10 pages (200 reviews) per filter combination. When you ask for more, the actor also reads each star rating on its own, the other sort order and date windows, and drops repeats. The free coverage row says when the site's limit was reached.
- **Company mode for lead lists and market maps**: every company of a Trustpilot category (top level, sub-category or leaf, up to 10,000 per category and country) at $2 per 1,000 on the free plan, down to $1.50, sorted the way Trustpilot ranks them, deduplicated across categories and countries. Input written for `shareze001/trustpilot-companies-by-category`, `data_direct/trustpilot-category-companies-scraper`, `khadinakbar/trustpilot-company-scraper` or `saswave/trustpilot-company-infos` works too.
- **Company row included with reviews, free**: TrustScore, stars, review count, the star split from 1 to 5, review counts per language, categories, claimed status and reply statistics.
- `onlyNewReviews` for monitoring: a run returns only reviews it has not delivered before, and repeats are not charged.
- Reviewer names, avatars, profile links, countries and review counts are never collected, the reviewer's name is removed from the review and reply text, and company contact details are dropped. Free error rows with a machine-readable `code` (`not_found`, `blocked`, `unavailable`, `invalid_input`), so an agent knows whether to retry.

Built by Arcadium Data: public data, dated and agent-ready, never personal data.

### Use with AI agents

Returns Trustpilot company ratings and reviews for company domains. Agents can call it through the Apify MCP server (`https://mcp.apify.com`, open source as `apify/actors-mcp-server`) as `arcadium/trustpilot-reviews`: the input schema is read from the actor, the result is a dataset of JSON rows.

Input example (minimal):

```json
{
  "companies": ["www.bestbuy.com"],
  "maxReviewsPerCompany": 100
}
```

What comes back: one free `company` row per company, one `review` row per review (charged), a free `coverage` row per company (stated total vs delivered) and a free `error` row for an input that could not be read. Filter on the `rowType` field. The error row carries `rowType: "error"`, a `code`, a `message` and the `input` it is about. Retry on `blocked` and `unavailable` later; do not retry `not_found` or `invalid_input` with the same input.

Cost of the call above: 100 reviews at $0.52 per 1,000 plus the $0.01 start fee is about $0.062 on the free plan; paid plans pay less.

Company mode (the first 200 banks Trustpilot lists for the UK):

```json
{
  "categories": ["bank"],
  "countries": ["GB"],
  "maxCompaniesPerCategory": 200
}
```

That returns 200 charged `company` rows plus one free `coverage` row (`stated` = the companies Trustpilot lists, `delivered`, `stopReason`): 200 x $0.002 + $0.01 = $0.41 on the free plan. For company rows of your own list without reviews: `{ "companies": ["www.bestbuy.com"], "includeReviews": false }`.

### Input

| Field | What it does |
| --- | --- |
| `companies` | Company domains (`bestbuy.com`, `www.zalando.co.uk`) or Trustpilot review URLs on any country subdomain. Company names are not looked up: give the domain. |
| `maxReviewsPerCompany` | Reviews per company, up to 50,000 (0 = as many as the site shows). Default 100. |
| `stars` | Only these star ratings (1 to 5), filtered by Trustpilot. |
| `languages` | Only these languages (two-letter codes). Empty = every language. |
| `sort` | `recency` (newest first, default) or `relevance`. |
| `date` | Trustpilot's date filter: `last30days`, `last3months`, `last6months`, `last12months`. |
| `dateFrom` | Only reviews published on or after a date (`2026-01-01` or `30 days`). |
| `verified`, `withReplies` | Only verified reviews; only reviews with a company reply. |
| `includeCompanyInfo` | The free company row (default on). |
| `splitFilters` | More than 200 reviews per company via filter combinations (default on). |
| `onlyNewReviews`, `stateKey` | Incremental mode for monitoring. |
| `categories` | Company mode: category ids (`bank`, `electronics_technology`, `hi-fi_shop`) or category pages (`https://www.trustpilot.com/categories/bank?country=DE`). Ids are the last part of the category page URL. |
| `countries` | Two-letter codes the categories are listed for (`US`, `GB`, `DE`, ...). Default `US`. |
| `companySort` | `most_relevant` (default), `reviews_count` or `latest_review`. |
| `claimedOnly` | Only companies that claimed their profile. |
| `maxCompaniesPerCategory` | Companies per category and country, up to 10,000. Default 200. |
| `includeReviews` | Off: the `companies` list gives charged company rows and no reviews. Default on. |
| `watch`, `watchKey` | Watch mode: only new or changed reviews and companies (see below). |

### What you get

Review rows:

| Field | What it holds |
| --- | --- |
| `reviewId` | `Trustpilot___` plus Trustpilot's own review id. Stable between runs, so you can dedupe exports. |
| `reviewUrl` | Link to the single review. |
| `ratingOverall` | Stars, 1 to 5. |
| `title`, `text` | Headline and review text, with the reviewer's name, emails and phone numbers removed. |
| `date` | Publication date, ISO `yyyy-mm-dd`; the full timestamp is `extras.publishedAt`. |
| `language` | Language code of the review. |
| `reviewerVerified` | Whether Trustpilot marks the review as verified; `extras.verificationLevel` and `extras.verificationSource` say how. |
| `vendorResponse` | The company's reply, with the reviewer's name removed; `extras.vendorResponseDate` is its date. |
| `helpfulVotes` | "Useful" votes. |
| `extras.experiencedDate` | Date of the experience the reviewer gives. |
| `extras.reviewSource` | How the review came in (`Organic`, an invitation tool). |
| `product` | Company summary repeated on every row: name, TrustScore, review count, primary category, website. |

Company rows (`rowType: "company"`): `entityId` (the Trustpilot domain), `name`, `url`, `website`, `trustScore`, `stars`, `reviewCount`, `reviewCountLast12Months`, `starSplit` (`{ "1": 6315, ..., "5": 415 }`), `languages` (`{ "en": 6842, "fr": 162 }`), `primaryCategory`, `categories`, `categoryPath`, `country`, `isClaimed`, `claimedDate`, `isClosed`, `isCollectingReviews`, `usesPaidFeatures`, `replyPercentage`, `averageDaysToReply`, `negativeReviewsWithReplies`, `negativeReviewsTotal`, `lastReplyToNegativeReview`, `hasConsumerAlert`, `alertType`, `isVerified`. The same data is in the key-value store record `COMPANY`.

Company rows from a category (`source: "category"`) carry what the category listing shows: `businessUnitId`, `entityId`, `name`, `url`, `website`, `trustScore`, `stars`, `reviewCount`, `categories`, `primaryCategory`, `city`, `country`, `hasConsumerAlert`, `alertType`, `isGamblingRelated`, `isRecommendedInCategories`, `isClaimed` (true with `claimedOnly`, else null), and where it was found: `listingCategory`, `listingCountry`, `listingRank`. Profile-only fields (star split, reply statistics, claimed date) are null there; run the domains with `includeReviews: false` to get them. Profile rows have `source: "profile"`. Email addresses, phone numbers and street addresses are never output.

Output example (company row from a category, shortened):

```json
{
  "rowType": "company",
  "source": "category",
  "businessUnitId": "5d2f4f05dc509f00010c9b44",
  "entityId": "itrustcapital.com",
  "name": "iTrustCapital",
  "url": "https://www.trustpilot.com/review/itrustcapital.com",
  "trustScore": 5,
  "stars": 5,
  "reviewCount": 9946,
  "primaryCategory": "Software Company",
  "country": "US",
  "hasConsumerAlert": true,
  "alertType": "InfoHighRiskInvestment",
  "listingCategory": "electronics_technology",
  "listingCountry": "US",
  "listingRank": 1
}
```

Output example (review row, shortened):

```json
{
  "rowType": "review",
  "platform": "trustpilot",
  "productName": "Best Buy",
  "entityId": "www.bestbuy.com",
  "reviewId": "Trustpilot___6ad7fab995ae7024fff4278e",
  "reviewUrl": "https://www.trustpilot.com/reviews/6ad7fab995ae7024fff4278e",
  "ratingOverall": 1,
  "title": "BUYERS BEWARE: BEST BUY TOOK MY $249 AND I NEVER RECEIVED MY LAPTOP!",
  "date": "2026-10-21",
  "language": "en",
  "reviewerVerified": false,
  "vendorResponse": null,
  "extras": { "experiencedDate": "2026-09-25", "verificationLevel": "not-verified", "reviewSource": "Organic" }
}
```

### Coming from another Trustpilot scraper?

| Their field | Ours |
| --- | --- |
| `companyUrls` (automation-lab), `startUrls` (memo23, blackfalcondata), `companyDomains`, `companyDomain` (blackfalcondata) | `companies` (all of them are merged) |
| `maxReviewsPerCompany` (0 = all), `maxResults`, `maxItems` | `maxReviewsPerCompany` |
| `filterStars`, `filterLanguages`, `filterDateRange`, `filterVerifiedOnly`, `filterRepliesOnly` (memo23) | `stars`, `languages`, `date`, `verified`, `withReplies` |
| `sortBy` (`recent`, `relevancy`, `auto`) | `sort` |
| `publishedAfter`, `startDate`, `lastDays`, `lookbackDays` | `dateFrom` |
| `includeCompanyDetails` | `includeCompanyInfo` |
| `scrapeAllReviews` | `splitFilters` |
| `incrementalMode` | `onlyNewReviews` |

`maxItems` is a per-run total in memo23's actor; here it becomes the per-company limit.

Company scrapers:

| Their field | Ours |
| --- | --- |
| `categoryId` (shareze001), `category_id` (data_direct), `/categories/...` entries in `queries` (khadinakbar) | `categories` |
| `domains` (saswave), other `queries` entries (khadinakbar) | `companies` |
| `country` | `countries` |
| `size` (shareze001), `maxResultsPerQuery` (khadinakbar) | `maxCompaniesPerCategory` |
| `sort` (`reviews_count`, `latest_review`), `sort_by` (`recommended`, `recently_reviewed`) | `companySort` |
| `claimed` | `claimedOnly` |
| `mode` (khadinakbar) | `includeReviews: false` |

TrustScore minimum filters (`trustscore`, `min_rating`) are not applied: filter on `trustScore` in the output.

### Pricing

| Plan | Per 1,000 reviews | Per 1,000 companies (company mode) |
| --- | --- | --- |
| Free | $0.52 | $2.00 |
| Bronze | $0.45 | $1.80 |
| Silver | $0.35 | $1.60 |
| Gold | $0.27 | $1.50 |
| Platinum | $0.27 | $1.50 |
| Diamond | $0.27 | $1.50 |

Plus a start fee of $0.005 per GB of memory ($0.01 at the default 2 GB). A company is charged once per run, however many categories or countries list it. The company row that comes with reviews, coverage, error and summary rows are free.

Watch mode (below): new and changed reviews and companies are charged as above; each unchanged review or company costs $0.06 per 1,000 (`watch-check`), on every plan, from the second run of a watch key on. The first run of a watch key is a normal run, charged normally.

### Watch mode: pay only for changes

Set `"watch": true` and a `watchKey` (for example `"weekly-competitors"`), then run the same input on an Apify schedule. The first run has nothing to compare with: it is a normal run, returns every review up to `maxReviewsPerCompany` and is charged normally, and it saves a snapshot. Every later run with the same key reads the newest reviews again (newest first) and returns only:

- new reviews (`change.type: "new"`), and
- reviews whose stars, title, text, company reply or verified flag changed (`change.type: "changed"`).

```json
{
  "type": "changed",
  "fields": [{ "field": "rating", "old": 2, "new": 4 }, { "field": "companyReply" }],
  "previousCheckAt": "2026-10-31T13:04:42.969Z"
}
```

Stars and the verified flag show old -> new; title, text and company reply are named only (the row carries the new text). Unchanged reviews are not delivered; they cost only the small `watch-check` above, because the run still has to read them. Every watch run also adds one free `watch-summary` row: `checked`, `unchanged`, `changed`, `new`, `gone` (in the last snapshot, not found now), `delivered`, `checksCharged`, `firstRun`, `previousCheckAt` and `complete` (false when the run stopped early, e.g. at your cost limit: then nothing counts as gone and changes that were not delivered come again next run). A review counts as `gone` only when its company was read to the end and the review is newer than the oldest review read, so reviews that just moved past `maxReviewsPerCompany` do not count. The snapshot is kept in a named store (`trustpilot-reviews-watch`) in your account; use one `watchKey` per company list. Watch mode replaces `onlyNewReviews` (it also reports edits and removals).

Watch mode works for company rows too (a weekly TrustScore panel of a category, or of your competitor list with `includeReviews: false`): a company row comes back only when it is new or its `trustScore`, `stars`, `reviewCount` or consumer alert changed (profile rows also `isClaimed` and `replyPercentage`); the listing rank is not compared. Company rows get their own free `watch-summary` row with `scope: "companies"`. A company counts as `gone` only when its category listing was read to the end in this run.

### Weekly digest

Add `"digest": true` to a watch run to get one more free row, `rowType: "watch-digest"`, that sums up the changes of the last `digestDays` days (default 7, up to 90) for this `watchKey`: `new`, `changed`, `gone`, `byType` (counts per change type), `tags.newOneStar` and `tagsByLabel.newOneStar` (new 1-star reviews in total and per company), `topMoves` (the 5 biggest moves per metric and direction, largest relative change first, each with `label`, `old`, `new`, `delta`, `pct`), `runs` in the window, `windowStart`, `windowEnd`, `previousDigestAt` and `summary`: one plain-text line an AI agent or a workflow can paste into an email or Slack message as it is. The window is rolling: put the watch on a daily schedule and every run's digest covers the last 7 days, or run weekly and read one digest a week. The first run of a key only saves the baseline and its rows are not counted as changes. The window is kept as a second record in the same key-value store as the snapshot. The digest row is free; there is no extra event.

Change types: `new_review`, `rating_changed`, `reply_changed`, `edited`. `topMoves` ranks each company's TrustScore (`trustScore`) and total review count (`reviewCount`) from the first to the last run in the window; labels are company domains.

In company mode (categories, or `includeReviews: false`) the company rows get their own digest row with `scope: "companies"`: change types `new_company`, `trustscore_drop`, `trustscore_rise`, `consumer_alert`, `review_count`, and `topMoves` for `trustScore`, `reviewCount` and `stars` of every delivered company. Example `summary` (illustrative values):

```text
trustpilot watch "competitors", last 7 days (7 runs): 41 new, 2 changed, 1 gone. new reviews 41, star ratings changed 2. new 1-star reviews: 6 (www.example-a.com 4, www.example-b.com 2). Biggest TrustScore drop: www.example-a.com 4.2 -> 4.1, -2.4%. Biggest review count rise: www.example-a.com 1200 -> 1241, +3.4%.
```

### Related actors

- [Yelp Reviews Scraper: All Languages, Owner Replies](https://apify.com/arcadium/yelp-reviews)
- [Review Monitor: Negative Review Alerts and Rating Drift](https://apify.com/arcadium/reputation-monitor)

### Limitations

- Trustpilot shows an anonymous visitor 10 pages per filter combination; reading further would need a login, which this actor never does. With `splitFilters` the actor reaches more reviews through other combinations, not all of them for very large profiles: the coverage row then says `stopReason: "cap"`.
- With several languages or `splitFilters`, rows are not in one date order; sort on `date` if you need it.
- Category listings stop at 10,000 companies per category and country (Trustpilot's own limit, coverage `stopReason: "cap"`); list sub-categories to reach more. Trustpilot's TrustScore filter is not applied.
- Public data only. No login, no personal data, no contact details.

# Actor input Schema

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

Company domains (bestbuy.com, www.zalando.co.uk) or Trustpilot review pages (https://www.trustpilot.com/review/www.bestbuy.com, any country subdomain). One per line. Inputs that are not a domain produce a free error row. The field names companyUrls, companyDomains, companyDomain and startUrls are accepted too.

## `categories` (type: `array`):

Company mode: Trustpilot category ids or pages, one per line, at any level, e.g. electronics_technology, bank or https://www.trustpilot.com/categories/bank?country=DE. One charged company row per listed company (TrustScore, stars, review count, categories, city, country; no contact details). A company in several categories or countries is charged once. categoryId and category_id are accepted too.

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

Maximum number of reviews to collect for each company (up to 50,000; 0 = as many as the site shows). Trustpilot shows at most 200 reviews per filter combination; above that the actor reads further combinations (see 'More than 200 reviews per company'). Default: 100.

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

Only reviews with these star ratings, filtered by Trustpilot. Leave empty for all.

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

Only reviews written in these languages, as two-letter codes, for example en, de or fr. Leave empty for every language. Each language is read on its own, so several languages also raise the 200-review limit.

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

Newest first (recency) or Trustpilot's most relevant first (relevance). Newest first enables the date stop and the incremental mode. Default: recency.

## `date` (type: `string`):

Trustpilot's own date filter. Empty = any time.

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

Only keep reviews published on or after this date (YYYY-MM-DD, or a relative span such as 30 days or 2 months; empty = no filter). The narrowest Trustpilot date filter that contains it is applied too, and newest-first reading stops once reviews are older.

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

Only reviews Trustpilot marks as verified.

## `withReplies` (type: `boolean`):

Only reviews the company has replied to.

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

Add one free row per company (rowType 'company'): TrustScore, star rating, review count, star split, review counts by language, categories, reply rate, claimed status. No contact details.

## `splitFilters` (type: `boolean`):

Trustpilot shows anonymous visitors at most 200 reviews (10 pages) per filter combination. When you ask for more, the actor also reads each star rating on its own, the other sort order and date windows, and drops repeats. The coverage row says when the site's limit was reached. Default: on.

## `countries` (type: `array`):

Two-letter country codes the categories are listed for (Trustpilot ranks companies per country), for example US, GB, DE. Each category is read once per country. A category URL with ?country= uses its own country. Default: US.

## `companySort` (type: `string`):

Order of companies in a category: Trustpilot's most relevant, most reviews first, or most recently reviewed first. Decides which companies a limit keeps.

## `claimedOnly` (type: `boolean`):

Only companies that have claimed their Trustpilot profile (Trustpilot's own filter).

## `maxCompaniesPerCategory` (type: `integer`):

Maximum companies read from each category in each country (up to 10,000, Trustpilot's own limit per category and country; list sub-categories to go further). Default: 200.

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

On (default): the companies list gives reviews plus a free company row. Off: the companies list gives one charged company row per company (TrustScore, star split, reply rate, claimed and verified flags) and no reviews. Categories never give reviews.

## `watch` (type: `boolean`):

Compare with the last run of the same watch key and output only new or changed rows: reviews whose stars, title, text, company reply or verified flag changed; companies whose TrustScore, stars, review count or consumer alert changed. Each row has a change object (old -> new). Unchanged rows are not output and pay only a small check event. A free watch-summary row counts them. The first run is a normal run, charged normally.

## `watchKey` (type: `string`):

Name of the saved snapshot for watch mode (letters, digits, - and \_, up to 60). Use one key per monitored company list, for example "weekly-check". A new key starts a new baseline. The snapshot is kept in a key-value store in your account.

## `digest` (type: `boolean`):

Watch mode only. Adds one free watch-digest row per run that sums up the changes of the last digest days for this watch key: counts by change type, new 1-star reviews per company, the biggest TrustScore and review-count moves, and a one-line plain-text summary you can paste into an email or Slack. No extra charge.

## `digestDays` (type: `integer`):

How many days the digest row covers (rolling window, 1-90). Runs older than this drop out of the digest.

## `onlyNewReviews` (type: `boolean`):

Skip reviews delivered by earlier runs that used the same state key, and do not charge for them. Forces newest-first order.

## `stateKey` (type: `string`):

Name of the incremental state (letters, digits and dashes). Change it to start over. State is kept in a key-value store in your account. Example: weekly-monitoring.

## `includeErrorRows` (type: `boolean`):

Add one row per company that could not be read, with the reason. These rows are free.

## `includeCoverageRows` (type: `boolean`):

Add one free row with rowType 'coverage' per company: the review total Trustpilot states for your filters, how many were delivered, why reading stopped and whether anything is missing. Not charged.

## `markEdited` (type: `boolean`):

With 'Only new reviews': also deliver reviews seen before whose text changed in the last 7 days, marked extras.changeType 'edited'. Edited reviews are charged like new ones.

## `maxRetries` (type: `integer`):

How many times a failed request is retried.

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

Advanced: use your own proxy. By default the actor picks the cheapest route that works.

## Actor input object example

```json
{
  "companies": [
    "www.bestbuy.com"
  ],
  "maxReviewsPerCompany": 20,
  "sort": "recency",
  "includeCompanyInfo": true,
  "splitFilters": true,
  "countries": [
    "US"
  ],
  "companySort": "most_relevant",
  "maxCompaniesPerCategory": 20,
  "includeReviews": true,
  "watch": false,
  "watchKey": "default",
  "digest": false,
  "digestDays": 7,
  "stateKey": "default",
  "includeErrorRows": true,
  "includeCoverageRows": true,
  "markEdited": true,
  "maxRetries": 3
}
```

# Actor output Schema

## `results` (type: `string`):

All rows of this run in the default dataset.

## `view_overview` (type: `string`):

No description

## `view_companies` (type: `string`):

No description

## `view_errors` (type: `string`):

No description

## `view_coverage` (type: `string`):

No description

## `record_stats` (type: `string`):

Requests, data volume, retries and cost per result for this run.

## `record_company` (type: `string`):

One entry per company: TrustScore, review count, star split, languages, categories and reply statistics.

# 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.bestbuy.com"
    ],
    "maxReviewsPerCompany": 20,
    "sort": "recency",
    "verified": false,
    "withReplies": false,
    "includeCompanyInfo": true,
    "splitFilters": true,
    "companySort": "most_relevant",
    "claimedOnly": false,
    "maxCompaniesPerCategory": 20,
    "onlyNewReviews": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("arcadium/trustpilot-reviews").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.bestbuy.com"],
    "maxReviewsPerCompany": 20,
    "sort": "recency",
    "verified": False,
    "withReplies": False,
    "includeCompanyInfo": True,
    "splitFilters": True,
    "companySort": "most_relevant",
    "claimedOnly": False,
    "maxCompaniesPerCategory": 20,
    "onlyNewReviews": False,
}

# Run the Actor and wait for it to finish
run = client.actor("arcadium/trustpilot-reviews").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 '{
  "companies": [
    "www.bestbuy.com"
  ],
  "maxReviewsPerCompany": 20,
  "sort": "recency",
  "verified": false,
  "withReplies": false,
  "includeCompanyInfo": true,
  "splitFilters": true,
  "companySort": "most_relevant",
  "claimedOnly": false,
  "maxCompaniesPerCategory": 20,
  "onlyNewReviews": false
}' |
apify call arcadium/trustpilot-reviews --silent --output-dataset

```

## MCP server setup

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

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/GcTIB97B8PYDSrweB/builds/XcN3LvBRczdqHhHfo/openapi.json