# Trustpilot Scraper (`trakk/trustpilot-review-intelligence-scraper`) Actor

Request-first Trustpilot scraper for reviews, company profiles, ratings, logos, contacts, sentiment, topics, replies, delta monitoring, and clean analytics-ready datasets

- **URL**: https://apify.com/trakk/trustpilot-review-intelligence-scraper.md
- **Developed by:** [Blynx](https://apify.com/trakk) (community)
- **Categories:** Lead generation, E-commerce, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.35 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Review Intelligence Scraper

Scrape Trustpilot company reviews, company profiles, contact details, logos, and review intelligence in one Apify Actor.

The Actor is built for reputation monitoring, competitor research, ecommerce due diligence, agency reports, customer experience analysis, and lead intelligence. It extracts review data, company metadata, phone/email contacts when Trustpilot exposes them, TrustScore fields, reviewer metadata, company replies, sentiment, topics, risk signals, delta monitoring, and run quality metrics.

The scraper is HTTP-first. It tries lightweight requests first, then uses an optimized Playwright browser fallback when Trustpilot serves a WAF verification page. For blocked Trustpilot pages, enable `fastBrowserMode` to skip the HTTP preflight and use the optimized browser path directly.

### Features

- Scrape reviews by company domain, for example `discountfilters.com`, or by full Trustpilot review URL.
- Search Trustpilot companies by keyword, then scrape matched company review pages.
- Extract review title, text, rating, dates, language, reviewer name, country, review count, likes, source type, verification status, and company replies.
- Extract company name, domain, website, TrustScore, star rating, review count, categories, claim status, logo, rating image, phone, email, address, country, and rating distribution when available.
- Generate `reviewImageUrl`, a Trustpilot share-card image URL for each review when the review ID and business unit ID are known.
- Add deterministic intelligence fields: sentiment, sentiment score, topics, risk signals, issue severity, reply rate, verified rate, and company-level summaries.
- Track review changes between runs with delta monitoring.
- Keep a stable dataset table: missing optional fields stay as `null`, `[]`, or `{}` instead of disappearing.
- Write alias datasets for `companies`, `changes`, and `summary`.

### Recommended Input

Fast mode for normal Store-style testing:

```json
{
  "mode": "REVIEWS",
  "companyDomains": [
    "lineaverdegiardino.it",
    "discountfilters.com",
    "madeinparadis.nl",
    "shift.com",
    "www.edplace.com",
    "aimlapi.com",
    "playeurolotto.com",
    "flightdelayrefunds.com",
    "giftexpress.com",
    "accointing.com"
  ],
  "maxResults": 50,
  "maxReviewsPerCompany": 5,
  "maxPagesPerCompany": 1,
  "sort": "recency",
  "stars": [],
  "verified": "",
  "includeCompanyProfile": true,
  "includeSearchResults": false,
  "enableDeltaMonitoring": false,
  "rawOutput": false,
  "browserFallback": true,
  "fastBrowserMode": true,
  "maxConcurrency": 3,
  "maxRetries": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

For Store runs, use **2048 MB memory**. The Actor can run on 512 MB, but browser fallback is forced into a one-page-at-a-time stability mode, which is much slower on Trustpilot. With 2048 MB, the Actor can safely fetch two browser pages in parallel and the recommended input above is much faster.

For larger runs, keep `browserFallback` enabled and start with `maxConcurrency` between `3` and `5`. Higher concurrency can be slower if Trustpilot's WAF starts throttling browser pages.

### Input Modes

Use `REVIEWS` when you already know the company domains:

```json
{
  "mode": "REVIEWS",
  "companyDomains": ["www.amazon.com", "www.apple.com"],
  "maxResults": 100,
  "maxReviewsPerCompany": 50,
  "maxPagesPerCompany": 3,
  "sort": "recency",
  "includeCompanyProfile": true,
  "browserFallback": true,
  "fastBrowserMode": true
}
```

Use `SEARCH` when you want to discover companies first:

```json
{
  "mode": "SEARCH",
  "searchQueries": ["amazon", "shopify"],
  "maxResults": 100,
  "maxReviewsPerCompany": 25,
  "maxPagesPerCompany": 2,
  "includeSearchResults": true,
  "includeCompanyProfile": true,
  "browserFallback": true,
  "fastBrowserMode": true
}
```

Filter reviews by star rating or verification state:

```json
{
  "mode": "REVIEWS",
  "companyDomains": ["www.example.com"],
  "stars": ["1", "2"],
  "verified": "true",
  "maxResults": 100
}
```

### Main Settings

- `mode`: `AUTO`, `REVIEWS`, or `SEARCH`.
- `companyDomains`: Trustpilot business domains or full Trustpilot review URLs.
- `businessUnitIds`: optional Trustpilot business unit IDs, either plain IDs or `id:domain` pairs.
- `startUrls`: Trustpilot review URLs or Trustpilot search URLs.
- `searchQueries`: company search keywords for `SEARCH` mode.
- `maxResults`: maximum output items in the default dataset.
- `maxReviewsPerCompany`: maximum reviews collected per company.
- `maxPagesPerCompany`: pagination safety limit per company.
- `sort`: Trustpilot review sort order, `recency` or `relevance`.
- `stars`: optional star filters from `1` to `5`.
- `verified`: optional verification filter, `true`, `false`, or empty.
- `includeCompanyProfile`: attach company profile and reputation fields to every review.
- `includeSearchResults`: in `SEARCH` mode, also output matched company items.
- `enableDeltaMonitoring`: compare current reviews with the previous run.
- `rawOutput`: include selected parser debug fields.
- `browserFallback`: use a real browser when HTTP requests hit Trustpilot's WAF.
- `fastBrowserMode`: skip the HTTP preflight for Trustpilot HTML pages and use the optimized browser fetcher directly.
- `maxConcurrency`: maximum parallel fetches. For fast browser mode, `3` to `5` is usually the best speed/stability range.
- `maxRetries`: retry budget for HTTP 429/5xx/parse errors. Block and proxy errors have separate handling.
- `proxyConfiguration`: Apify proxy settings.

### Output

The default dataset contains one item per review. If `includeSearchResults` is enabled in `SEARCH` mode, matched company records are also written to the default dataset. Failed pages are written as diagnostic `error` items, so a run does not silently return an empty dataset.

Review rows use a stable schema. A `null` value usually means Trustpilot did not expose that field for that review or company.

Example review item:

```json
{
  "type": "review",
  "reviewId": "rev_001",
  "reviewUrl": "https://www.trustpilot.com/reviews/rev_001",
  "sourceUrl": "https://www.trustpilot.com/review/www.example.com",
  "companyId": "46d6a890000064000500e0c3",
  "companyName": "Example Store",
  "companyDomain": "www.example.com",
  "companyUrl": "https://www.trustpilot.com/review/www.example.com",
  "companyWebsite": "https://www.example.com",
  "companyEmail": "support@example.com",
  "companyEmails": ["support@example.com"],
  "companyPhone": "+1 555 0100",
  "companyPhones": ["+1 555 0100"],
  "companyAddress": "1 Market Street",
  "companyCountry": "US",
  "companyLogo": "https://consumersiteimages.trustpilot.net/business-units/46d6a890000064000500e0c3-198x149-1x.jpg",
  "companyProfileImageUrl": "https://consumersiteimages.trustpilot.net/business-units/46d6a890000064000500e0c3-198x149-2x.jpg",
  "companyRatingImageUrl": "https://share.trustpilot.com/images/company-rating?locale=en-US&businessUnitId=46d6a890000064000500e0c3&preset=consumersite",
  "reviewImageUrl": "https://share.trustpilot.com/images/review?locale=en-US&reviewId=rev_001&businessUnitId=46d6a890000064000500e0c3",
  "trustScore": 4.3,
  "companyRating": 4.5,
  "companyReviewCount": 1234,
  "companyCategories": ["Electronics Store"],
  "companyClaimed": true,
  "rating": 1,
  "title": "Refund never arrived",
  "text": "Customer service promised a refund, but billing charged me again.",
  "language": "en",
  "datePublished": "2026-05-17T08:00:00.000Z",
  "dateExperienced": "2026-05-14T00:00:00.000Z",
  "dateUpdated": null,
  "isVerified": true,
  "reviewSource": "invited",
  "consumerName": "Alex Buyer",
  "consumerId": "user_001",
  "consumerCountry": "US",
  "consumerReviewCount": 7,
  "consumerImageUrl": "https://user-images.trustpilot.com/user_001/73x73.png",
  "companyReplyText": "We are sorry and have escalated your refund.",
  "companyReplyDate": "2026-05-18T12:30:00.000Z",
  "hasCompanyReply": true,
  "likes": 5,
  "reviewTags": ["Verified", "Invited"],
  "sentiment": "negative",
  "sentimentScore": -1.0,
  "topics": ["customer_service", "refund_billing"],
  "issueSeverity": "high",
  "riskSignals": ["low_rating", "strong_negative_language", "unanswered_negative_review"],
  "reviewLength": 68,
  "changeStatus": "new",
  "changedFields": [],
  "scrapedAt": "2026-05-25T12:00:00.000000+00:00"
}
```

Company summary items are written to the `companies` dataset:

```json
{
  "type": "company",
  "companyId": "46d6a890000064000500e0c3",
  "companyName": "Example Store",
  "companyDomain": "www.example.com",
  "companyUrl": "https://www.trustpilot.com/review/www.example.com",
  "companyWebsite": "https://www.example.com",
  "companyEmail": "support@example.com",
  "companyPhone": "+1 555 0100",
  "companyAddress": "1 Market Street",
  "companyCountry": "US",
  "companyLogo": "https://consumersiteimages.trustpilot.net/business-units/46d6a890000064000500e0c3-198x149-1x.jpg",
  "companyRatingImageUrl": "https://share.trustpilot.com/images/company-rating?locale=en-US&businessUnitId=46d6a890000064000500e0c3&preset=consumersite",
  "trustScore": 4.3,
  "companyRating": 4.5,
  "companyReviewCount": 1234,
  "ratingDistribution": {},
  "companyCategories": ["Electronics Store"],
  "companyClaimed": true,
  "companyVerified": null,
  "companyDescription": null,
  "reviewsScraped": 100,
  "averageScrapedRating": 3.72,
  "positiveReviews": 61,
  "neutralReviews": 12,
  "negativeReviews": 27,
  "replyRate": 0.44,
  "verifiedRate": 0.78,
  "topTopics": [
    { "topic": "customer_service", "count": 31 },
    { "topic": "delivery_shipping", "count": 19 }
  ],
  "scrapedAt": "2026-05-25T12:00:00.000000+00:00"
}
```

Error item example:

```json
{
  "type": "error",
  "errorType": "reviewPageError",
  "sourceUrl": "https://www.trustpilot.com/review/missing.example",
  "companyDomain": "missing.example",
  "page": 1,
  "error": "Blocked by target site, status=403",
  "detectedAt": "2026-05-25T12:00:00.000000+00:00"
}
```

### Understanding Null Values

`null` is not automatically a parsing error. Common cases:

- `companyPhone`: Trustpilot often exposes email and address but no phone.
- `consumerImageUrl`: many reviewers use initials instead of a profile photo.
- `companyReplyText` and `companyReplyDate`: the business did not reply to that review.
- `dateUpdated`: the review was never edited.
- `dateExperienced`: older reviews may not expose a separate experience date.
- `companyHeroImage`: many Trustpilot company profiles do not expose a hero/banner image in page data.
- `changeStatus` and `changedFields`: populated only when `enableDeltaMonitoring` is enabled.
- `topics` and `riskSignals`: empty arrays mean the deterministic enrichment did not detect a matching topic or risk signal.

Phone and email are extracted from Trustpilot company/contact data, not from arbitrary review text. This avoids collecting customer phone numbers or unrelated emails mentioned inside reviews.

### Review Source Values

`reviewSource` can be:

- `invited`: Trustpilot indicates the review came from an invitation flow.
- `verified`: Trustpilot indicates the review is verified.
- `unprompted`: Trustpilot shows Organic, Unprompted, Not verified, or similar source markers.
- `null`: Trustpilot did not expose a usable source marker.

### Performance

For arbitrary companies, the fastest stable configuration is usually:

```json
{
  "browserFallback": true,
  "fastBrowserMode": true,
  "maxConcurrency": 3,
  "maxRetries": 0,
  "maxPagesPerCompany": 1
}
```

Recommended Apify run memory: **2048 MB**.

Memory behavior:

- `512 MB`: stable fallback mode, one browser page at a time, lower cost but slower.
- `2048 MB`: recommended default, two browser pages at a time, best speed/stability balance.
- `4096 MB+`: useful only for larger batches; do not raise `maxConcurrency` too aggressively.

The optimized browser fetcher:

- Reuses one browser context.
- Warms the context with the first Trustpilot page.
- Opens later pages in parallel.
- Blocks non-essential images, media, fonts, and analytics requests.
- Reads embedded Trustpilot page data as soon as `__NEXT_DATA__` appears.

For larger workloads, increase `maxConcurrency` carefully from `3` to `4` or `5`. Very high concurrency can trigger WAF slowdowns and become slower overall.

### Proxy Recommendation

Trustpilot can return WAF verification pages to low-trust or datacenter IPs. The Actor includes browser fallback for those cases. For larger or long-running Apify jobs, residential proxies may improve stability:

```json
{
  "useApifyProxy": true,
  "apifyProxyGroups": ["RESIDENTIAL"],
  "apifyProxyCountry": "US"
}
```

If you target a specific market, match the proxy country to that market when possible.

### Technical Notes

- HTTP requests use Chrome-like TLS/HTTP2 impersonation through `curl_cffi`.
- Browser fallback uses Playwright only when needed, or directly when `fastBrowserMode` is enabled.
- The parser supports embedded Next.js data, DOM fallbacks, and JSON-LD fallbacks.
- Company logo and profile image URLs are generated from Trustpilot business unit IDs when possible.
- `reviewImageUrl` is a Trustpilot share image URL, not the review text. The review text is in `text`, and the review title is in `title`.
- Apify quality-test runs Actors from the prefilled input schema. The schema prefill is intentionally tiny: one company, one page, one review, no residential proxy, and delta monitoring disabled.

### Local Development

Run local validation:

```bash
python -m json.tool .actor/input_schema.json
python -m compileall src scripts
python scripts/smoke_test.py
```

The smoke test uses local Trustpilot-like fixtures, so it validates parsing and output shape without depending on live Trustpilot access.

Deploy manually when ready:

```bash
deploy.bat
```

### Limitations

- Available fields depend on what Trustpilot exposes for each company and review.
- Some companies do not expose phone, email, logos, categories, replies, reviewer profile images, or reviewer profile details.
- Local direct HTTP requests may hit Trustpilot's WAF; use browser fallback or residential proxies for real runs.
- Sentiment, topics, and risk signals are deterministic rule-based enrichments, not paid AI inference.
- Delta monitoring compares reviews collected by this Actor across runs. If a run collects no reviews, previous state is not overwritten.

# Actor input Schema

## `mode` (type: `string`):

AUTO detects mode from input. REVIEWS fetches company review pages. SEARCH finds companies from search queries.

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

Trustpilot business domains, e.g. trustpilot.com, www.amazon.com, apple.com, shopify.com.

## `businessUnitIds` (type: `array`):

Optional Trustpilot business unit IDs. Advanced fallback for widget/API mode. Use either plain IDs or id:domain pairs.

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

Trustpilot review URLs or search URLs.

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

Trustpilot company search queries.

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

Maximum review/company items in the default dataset.

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

Maximum number of reviews to collect per company.

## `maxPagesPerCompany` (type: `integer`):

Safety limit for Trustpilot review pagination.

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

Trustpilot review sort order.

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

Optional Trustpilot star filters. Leave empty for all ratings.

## `verified` (type: `string`):

Filter reviews by Trustpilot verification state when supported.

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

Attach company reputation/profile fields to every review.

## `includeSearchResults` (type: `boolean`):

When using SEARCH mode, also output matched company items.

## `enableDeltaMonitoring` (type: `boolean`):

Compare current reviews with the previous run stored in the default key-value store.

## `rawOutput` (type: `boolean`):

Include selected raw parser/debug fields. This can increase dataset size.

## `browserFallback` (type: `boolean`):

Use a real browser only when HTTP requests hit Trustpilot's WAF. Keep enabled for arbitrary companies; widget/API requests are still tried first.

## `fastBrowserMode` (type: `boolean`):

Skip the HTTP preflight for Trustpilot HTML pages and use the optimized browser fetcher directly. Faster when Trustpilot blocks HTTP for most targets.

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

Maximum parallel fetches. For fast browser mode, 3-5 is usually the best speed/stability range.

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

Main retry budget for HTTP 429/5xx/parse errors. Proxy and block retries have separate budgets.

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

Residential proxies are recommended. US or target-market residential IPs work best.

## Actor input object example

```json
{
  "mode": "REVIEWS",
  "companyDomains": [
    "trustpilot.com",
    "www.amazon.com",
    "www.apple.com"
  ],
  "businessUnitIds": [
    "46d6a890000064000500e0c3:trustpilot.com"
  ],
  "startUrls": [
    {
      "url": "https://www.trustpilot.com/review/www.amazon.com"
    }
  ],
  "searchQueries": [
    "amazon",
    "shopify"
  ],
  "maxResults": 1,
  "maxReviewsPerCompany": 1,
  "maxPagesPerCompany": 1,
  "sort": "recency",
  "stars": [
    "1",
    "2"
  ],
  "verified": "",
  "includeCompanyProfile": true,
  "includeSearchResults": false,
  "enableDeltaMonitoring": true,
  "rawOutput": false,
  "browserFallback": true,
  "fastBrowserMode": true,
  "maxConcurrency": 1,
  "maxRetries": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "mode": "REVIEWS",
    "companyDomains": [
        "trustpilot.com"
    ],
    "businessUnitIds": [],
    "startUrls": [],
    "searchQueries": [],
    "maxResults": 1,
    "maxReviewsPerCompany": 1,
    "maxPagesPerCompany": 1,
    "sort": "recency",
    "stars": [],
    "verified": "",
    "includeCompanyProfile": true,
    "includeSearchResults": false,
    "enableDeltaMonitoring": false,
    "rawOutput": false,
    "browserFallback": true,
    "fastBrowserMode": false,
    "maxConcurrency": 1,
    "maxRetries": 1,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("trakk/trustpilot-review-intelligence-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 = {
    "mode": "REVIEWS",
    "companyDomains": ["trustpilot.com"],
    "businessUnitIds": [],
    "startUrls": [],
    "searchQueries": [],
    "maxResults": 1,
    "maxReviewsPerCompany": 1,
    "maxPagesPerCompany": 1,
    "sort": "recency",
    "stars": [],
    "verified": "",
    "includeCompanyProfile": True,
    "includeSearchResults": False,
    "enableDeltaMonitoring": False,
    "rawOutput": False,
    "browserFallback": True,
    "fastBrowserMode": False,
    "maxConcurrency": 1,
    "maxRetries": 1,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("trakk/trustpilot-review-intelligence-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 '{
  "mode": "REVIEWS",
  "companyDomains": [
    "trustpilot.com"
  ],
  "businessUnitIds": [],
  "startUrls": [],
  "searchQueries": [],
  "maxResults": 1,
  "maxReviewsPerCompany": 1,
  "maxPagesPerCompany": 1,
  "sort": "recency",
  "stars": [],
  "verified": "",
  "includeCompanyProfile": true,
  "includeSearchResults": false,
  "enableDeltaMonitoring": false,
  "rawOutput": false,
  "browserFallback": true,
  "fastBrowserMode": false,
  "maxConcurrency": 1,
  "maxRetries": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call trakk/trustpilot-review-intelligence-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Scraper",
        "description": "Request-first Trustpilot scraper for reviews, company profiles, ratings, logos, contacts, sentiment, topics, replies, delta monitoring, and clean analytics-ready datasets",
        "version": "0.1",
        "x-build-id": "9PwpgG21O7HOR928n"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trakk~trustpilot-review-intelligence-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trakk-trustpilot-review-intelligence-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/trakk~trustpilot-review-intelligence-scraper/runs": {
            "post": {
                "operationId": "runs-sync-trakk-trustpilot-review-intelligence-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/trakk~trustpilot-review-intelligence-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-trakk-trustpilot-review-intelligence-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "AUTO",
                            "REVIEWS",
                            "SEARCH"
                        ],
                        "type": "string",
                        "description": "AUTO detects mode from input. REVIEWS fetches company review pages. SEARCH finds companies from search queries.",
                        "default": "AUTO"
                    },
                    "companyDomains": {
                        "title": "Company domains",
                        "type": "array",
                        "description": "Trustpilot business domains, e.g. trustpilot.com, www.amazon.com, apple.com, shopify.com.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "trustpilot.com"
                        ]
                    },
                    "businessUnitIds": {
                        "title": "Business unit IDs",
                        "type": "array",
                        "description": "Optional Trustpilot business unit IDs. Advanced fallback for widget/API mode. Use either plain IDs or id:domain pairs.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Trustpilot review URLs or search URLs.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Trustpilot company search queries.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxResults": {
                        "title": "Maximum output items",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum review/company items in the default dataset.",
                        "default": 100
                    },
                    "maxReviewsPerCompany": {
                        "title": "Max reviews per company",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect per company.",
                        "default": 100
                    },
                    "maxPagesPerCompany": {
                        "title": "Max pages per company",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Safety limit for Trustpilot review pagination.",
                        "default": 10
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "recency",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Trustpilot review sort order.",
                        "default": "recency"
                    },
                    "stars": {
                        "title": "Star filters",
                        "type": "array",
                        "description": "Optional Trustpilot star filters. Leave empty for all ratings.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "verified": {
                        "title": "Verified filter",
                        "enum": [
                            "",
                            "true",
                            "false"
                        ],
                        "type": "string",
                        "description": "Filter reviews by Trustpilot verification state when supported.",
                        "default": ""
                    },
                    "includeCompanyProfile": {
                        "title": "Include company profile",
                        "type": "boolean",
                        "description": "Attach company reputation/profile fields to every review.",
                        "default": true
                    },
                    "includeSearchResults": {
                        "title": "Output search results",
                        "type": "boolean",
                        "description": "When using SEARCH mode, also output matched company items.",
                        "default": false
                    },
                    "enableDeltaMonitoring": {
                        "title": "Delta monitoring",
                        "type": "boolean",
                        "description": "Compare current reviews with the previous run stored in the default key-value store.",
                        "default": true
                    },
                    "rawOutput": {
                        "title": "Raw output",
                        "type": "boolean",
                        "description": "Include selected raw parser/debug fields. This can increase dataset size.",
                        "default": false
                    },
                    "browserFallback": {
                        "title": "Browser fallback",
                        "type": "boolean",
                        "description": "Use a real browser only when HTTP requests hit Trustpilot's WAF. Keep enabled for arbitrary companies; widget/API requests are still tried first.",
                        "default": true
                    },
                    "fastBrowserMode": {
                        "title": "Fast browser mode",
                        "type": "boolean",
                        "description": "Skip the HTTP preflight for Trustpilot HTML pages and use the optimized browser fetcher directly. Faster when Trustpilot blocks HTTP for most targets.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Maximum parallel fetches. For fast browser mode, 3-5 is usually the best speed/stability range.",
                        "default": 4
                    },
                    "maxRetries": {
                        "title": "Max retries",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Main retry budget for HTTP 429/5xx/parse errors. Proxy and block retries have separate budgets.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxies are recommended. US or target-market residential IPs work best.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
