# Trustpilot Scraper: Reviews + Company Data + Profiles (`scavenger.agent/trustpilot-scraper`) Actor

The most feature-rich Trustpilot scraper on Apify. 35+ data fields per review, 36 company profile fields, reviewer profile scraping. Filter by stars, date, language, verified. Runs on 256 MB (4x cheaper). Brand monitoring, lead gen, sentiment analysis.

- **URL**: https://apify.com/scavenger.agent/trustpilot-scraper.md
- **Developed by:** [Anatolii Ohorodnyk](https://apify.com/scavenger.agent) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Trustpilot Scraper — Reviews, Ratings, Company Data & Reviewer Profiles

### What does Trustpilot Scraper do?

**Trustpilot Scraper** extracts reviews, ratings, company profiles, and reviewer data from [Trustpilot.com](https://www.trustpilot.com) — the world's largest review platform with **300M+ reviews** across 1M+ businesses. Enter a company domain, get structured data in seconds. No API key, no login, no browser needed.

This is the **most feature-rich Trustpilot scraper** on Apify Store:
- **35+ data fields per review** — more than any competitor
- **36 company profile fields** — including AI summaries, contact info, reply behavior
- **Reviewer profile scraping** — unique feature, scrape any user's full review history
- **Lowest memory usage (256 MB)** — runs 4x cheaper than alternatives
- **All Trustpilot filters** — stars, date range, language, verified only, with-replies only
- **Custom date range** — filter by exact dates (YYYY-MM-DD), not just presets
- **Auto-bypass 1000 review limit** — automatically splits by star rating to get up to 5,000 reviews per company

Use the Apify platform to run via API, schedule recurring scrapes, integrate with Google Sheets, Slack, Zapier, Make, or any webhook.

### Why scrape Trustpilot reviews?

- **Brand monitoring** — Track what customers say about your brand in real time
- **Competitor analysis** — Compare review scores, reply rates, and sentiment across companies
- **Lead generation** — Find businesses with low ratings that need your product/service
- **Market research** — Analyze customer pain points across entire industries
- **Sentiment analysis** — Feed review data into NLP and AI pipelines
- **Review aggregation** — Build dashboards, comparison sites, or embed reviews on your website
- **Sales intelligence** — Use company profiles (contact info, subscription status, reply behavior) for outreach
- **Reviewer behavior analysis** — Analyze specific reviewers across all companies they reviewed
- **Fake review detection** — Cross-reference reviewer profiles, verification status, and patterns

### How to scrape Trustpilot reviews

1. Click **Try for free** to open the Actor in Apify Console
2. Enter one or more company domains (e.g. `amazon.com`, `netflix.com`)
3. Set the maximum number of reviews per company
4. Optionally filter by star rating, date range, language, or verification status
5. Click **Start** and wait for results
6. Download the dataset as JSON, CSV, Excel, or connect via API

### Three scraping modes

#### Mode 1: Reviews (default)
Scrape customer reviews with full metadata — ratings, text, dates, reviewer info, verification, company replies, engagement metrics.

#### Mode 2: Company profiles only
Set `onlyCompanyInfo: true` to get rich company data without individual reviews. Perfect for lead generation at scale — scrape 100+ companies in one run and get their ratings, contact info, categories, AI summaries, reply behavior, and more.

#### Mode 3: Reviewer profiles
Provide `reviewerProfileUrls` to scrape a specific reviewer's complete review history across all companies. See their stats (total reviews, reads, likes) and every review they ever posted.

### Input parameters

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `companyUrls` | string[] | Company domains or Trustpilot URLs | `["amazon.com"]` |
| `maxReviews` | integer | Max reviews per company (0 = unlimited) | 100 |
| `filterByStars` | integer | Filter by star rating 1-5 (0 = all) | 0 |
| `dateFilter` | string | Time period: `last7days`, `last30days`, `last3months`, `last6months`, `lastyear` | all |
| `dateFrom` | string | Custom start date `YYYY-MM-DD` (e.g. `2025-01-01`) | - |
| `dateTo` | string | Custom end date `YYYY-MM-DD` (e.g. `2025-12-31`) | - |
| `autoBypassLimit` | boolean | Auto-bypass 1000 review limit by splitting star ratings | true |
| `onlyVerified` | boolean | Only verified reviews | false |
| `onlyWithReplies` | boolean | Only reviews with company reply | false |
| `includeCompanyInfo` | boolean | Add company details to each review row | true |
| `sortBy` | string | Sort: `recency` or `relevance` | recency |
| `language` | string | Language filter: `en`, `de`, `fr`, `es`, `nl`, etc. | all |
| `onlyCompanyInfo` | boolean | Only company profile, no reviews | false |
| `reviewerProfileUrls` | string[] | Reviewer profile URLs or IDs | [] |
| `proxyConfiguration` | object | Proxy for large runs | off |

#### Example input — reviews

```json
{
    "companyUrls": ["amazon.com", "netflix.com"],
    "maxReviews": 500,
    "filterByStars": 0,
    "dateFilter": "last3months",
    "sortBy": "recency"
}
````

#### Example input — company profiles for lead gen

```json
{
    "companyUrls": ["amazon.com", "netflix.com", "spotify.com", "uber.com"],
    "onlyCompanyInfo": true
}
```

#### Example input — reviewer profile

```json
{
    "reviewerProfileUrls": ["https://www.trustpilot.com/users/5f8e7b0d17dfec001a3df052"],
    "maxReviews": 0
}
```

### Output — review data (35 fields)

You can download the dataset in various formats: **JSON, CSV, HTML, XML, Excel, RSS**.

```json
{
    "reviewId": "69cff61baaad976eef842487",
    "rating": 1,
    "title": "I was trying to order articles over $35…",
    "text": "I was trying to order articles over $35 to get free shipping...",
    "language": "en",
    "reviewerName": "Gary Parsons",
    "reviewerId": "69cff51c2c7036f9a589d79a",
    "reviewerCountry": "CA",
    "reviewerTotalReviews": 1,
    "reviewerReviewsOnDomain": 1,
    "reviewerIsVerified": false,
    "reviewerHasImage": true,
    "reviewerImageUrl": "https://user-images.trustpilot.com/.../73x73.png",
    "reviewerProfileUrl": "https://www.trustpilot.com/users/69cff51c2c7036f9a589d79a",
    "date": "2026-04-03T19:17:15.000Z",
    "experienceDate": "2026-04-02T00:00:00.000Z",
    "updatedDate": null,
    "isVerified": false,
    "verificationLevel": "not-verified",
    "verificationSource": "invitation",
    "reviewSourceName": "Organic",
    "hasReply": false,
    "replyText": "",
    "replyDate": null,
    "likes": 0,
    "source": "Organic",
    "isFiltered": false,
    "isPending": false,
    "productReviews": [],
    "location": null,
    "reviewUrl": "https://www.trustpilot.com/reviews/69cff61baaad976eef842487",
    "companyName": "Amazon",
    "companyDomain": "www.amazon.com",
    "companyRating": 1.7,
    "companyTotalReviews": 44873
}
```

### Output — company profile (36 fields)

```json
{
    "companyId": "46ad346800006400050092d0",
    "companyName": "Amazon",
    "companyDomain": "www.amazon.com",
    "companyWebsite": "https://www.amazon.com",
    "companyRating": 1.7,
    "companyStars": 1.5,
    "companyTotalReviews": 44873,
    "companyCategories": [{"id": "shoe_store", "name": "Shoe Store"}],
    "companyCountry": "GB",
    "companyCity": "",
    "companyPhone": "",
    "companyEmail": "",
    "companyIsClaimed": true,
    "companyReplyRate": 0,
    "companyAvgReplyDays": null,
    "companyHasSubscription": false,
    "companyIsUsingAIResponses": false,
    "companyClaimedDate": "2015-02-18T19:08:43.000Z",
    "companyVerifiedByGoogle": false,
    "companyTopCategory": "Media & Publishing",
    "companyMidCategory": "Books & Magazines",
    "companySubCategory": "Book Store",
    "companyAiSummary": "Most reviewers were let down by their experience...",
    "companyAiTopics": [{"topic": "delivery_service", "summary": "..."}],
    "companyReviewLanguages": [{"code": "en", "count": 27837}],
    "companyTrustpilotUrl": "https://www.trustpilot.com/review/www.amazon.com"
}
```

### Data fields reference

#### Review fields (35)

| Field | Description |
|-------|-------------|
| `reviewId` | Unique Trustpilot review ID |
| `rating` | Star rating (1-5) |
| `title` | Review headline |
| `text` | Full review text |
| `language` | Review language code (ISO) |
| `reviewerName` | Reviewer display name |
| `reviewerId` | Reviewer unique ID |
| `reviewerCountry` | Reviewer country code |
| `reviewerTotalReviews` | Total reviews by this person |
| `reviewerReviewsOnDomain` | Reviews on same company |
| `reviewerIsVerified` | Verified reviewer account |
| `reviewerHasImage` | Has profile picture |
| `reviewerImageUrl` | Profile picture URL |
| `reviewerProfileUrl` | Link to reviewer's Trustpilot profile |
| `date` | Review publish date |
| `experienceDate` | Date of experience described |
| `updatedDate` | Last update date |
| `isVerified` | Verified purchase review |
| `verificationLevel` | `verified` / `not-verified` |
| `verificationSource` | How it was verified |
| `reviewSourceName` | `Organic` / `Invitation` / etc. |
| `hasReply` | Company replied (boolean) |
| `replyText` | Company reply text |
| `replyDate` | Company reply date |
| `likes` | "Useful" votes count |
| `source` | Review source label |
| `isFiltered` | Flagged by Trustpilot |
| `isPending` | Pending moderation |
| `productReviews` | Product-specific sub-ratings |
| `location` | Business location (if applicable) |
| `reviewUrl` | Direct link to review |
| `companyName` | Company display name |
| `companyDomain` | Company domain |
| `companyRating` | Overall Trustpilot score |
| `companyTotalReviews` | Total review count |

#### Company fields (36)

| Field | Description |
|-------|-------------|
| `companyId` | Trustpilot business ID |
| `companyName` | Display name |
| `companyDomain` | Domain name |
| `companyWebsite` | Official website URL |
| `companyRating` | Trust score (0-5) |
| `companyStars` | Star display (1-5) |
| `companyTotalReviews` | Total reviews |
| `companyCategories` | Business categories |
| `companyCountry` | Registration country |
| `companyCity` | City |
| `companyAddress` | Street address |
| `companyPhone` | Phone number |
| `companyEmail` | Email address |
| `companyZipCode` | Postal code |
| `companyIsClaimed` | Profile claimed by business |
| `companyIsClosed` | Business permanently closed |
| `companyIsTemporarilyClosed` | Temporarily closed |
| `companyProfileImage` | Profile image URL |
| `companyReplyRate` | % of reviews replied to |
| `companyAvgReplyDays` | Average reply time (days) |
| `companyIsAskingForReviews` | Actively soliciting reviews |
| `companyHasSubscription` | Paid Trustpilot subscription |
| `companyIsUsingPaidFeatures` | Using paid features |
| `companyIsUsingAIResponses` | Using AI-generated replies |
| `companyClaimedDate` | When profile was claimed |
| `companyVerifiedByGoogle` | Google-verified business |
| `companyVerifiedPaymentMethod` | Payment method verified |
| `companyVerifiedUserIdentity` | Identity verified |
| `companyTopCategory` | Top-level industry |
| `companyMidCategory` | Mid-level category |
| `companySubCategory` | Specific subcategory |
| `companyAiSummary` | AI-generated review summary |
| `companyAiTopics` | Topic-by-topic AI analysis |
| `companyReviewLanguages` | Reviews by language |
| `companyHasIncentivisedReviews` | Has incentivized reviews |
| `companyTrustpilotUrl` | Trustpilot profile URL |

### How much does it cost to scrape Trustpilot?

This Actor uses lightweight HTTP requests (no browser), making it the **most cost-efficient Trustpilot scraper** on Apify Store. It runs on just **256 MB memory** — 4x less than competitors.

| Scale | Estimated cost | Time |
|-------|---------------|------|
| 100 reviews | ~$0.005 | ~20 sec |
| 1,000 reviews | ~$0.02 | ~2 min |
| 10,000 reviews | ~$0.15 | ~15 min |
| 100 company profiles | ~$0.01 | ~3 min |

Apify provides a **free tier with $5 monthly credit** — enough for tens of thousands of reviews.

### Tips for best results

- **Get more than 1,000 reviews**: Trustpilot limits browsing to 50 pages (1,000 reviews). With `autoBypassLimit: true` (enabled by default), the scraper automatically splits by star rating to extract up to **5,000 reviews per company**. No manual work needed.
- **Use proxies for large runs**: For 1,000+ reviews or many companies, enable Apify Proxy to avoid rate limiting.
- **Schedule recurring scrapes**: Set up daily/weekly schedules to track review trends over time.
- **Company profiles for lead gen**: Use `onlyCompanyInfo: true` to quickly scan hundreds of companies — get ratings, contact info, reply behavior, and AI summaries without downloading individual reviews.
- **Combine with AI**: Feed review data into sentiment analysis, GPT summarization, or topic classification.
- **Filter verified only**: Use `onlyVerified: true` to get only confirmed purchase reviews for higher data quality.
- **Track reviewer behavior**: Use `reviewerProfileUrls` to investigate specific reviewers across all companies they've reviewed.

### FAQ

**Is it legal to scrape Trustpilot?**
Trustpilot reviews are publicly available data. This Actor only accesses publicly visible pages. Always review Trustpilot's Terms of Service and comply with applicable laws in your jurisdiction.

**Can I scrape reviews in specific languages?**
Yes! Use the `language` parameter with an ISO code: `en`, `de`, `fr`, `es`, `nl`, `it`, `pt`, `sv`, `da`, `nb`, `fi`, `pl`, `ja`, `ko`, `zh`, and many more.

**How do I get more than 1,000 reviews?**
With `autoBypassLimit: true` (default), the scraper automatically handles this — it splits by star rating (1-5) and collects up to 5,000 reviews per company in a single run. You can also manually set `filterByStars` and combine results for full control.

**What's the difference between companyRating and companyStars?**
`companyRating` is the precise trust score (e.g. 4.3). `companyStars` is the rounded display value (e.g. 4.5) shown on Trustpilot's UI.

**Can I scrape a reviewer's profile?**
Yes! Provide their Trustpilot profile URL in `reviewerProfileUrls`. You'll get their stats and complete review history across all companies.

**Why am I getting empty results?**
Check that the company domain is correct and has a Trustpilot page. Try the full Trustpilot URL if a plain domain doesn't work.

**Need a custom solution?**
Open an issue in the [Issues tab](https://console.apify.com/actors/HSwLRYOBGvOdrguWf/issues) or contact the developer.

# Actor input Schema

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

Trustpilot company page URLs (e.g. https://www.trustpilot.com/review/amazon.com) or just domain names (e.g. amazon.com). Leave empty if using Reviewer Profile URLs.

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

Maximum number of reviews to scrape per company (or per reviewer profile). Set 0 for unlimited.

## `filterByStars` (type: `integer`):

Only scrape reviews with this star rating (1-5). Set 0 for all ratings.

## `dateFilter` (type: `string`):

Filter reviews by time period.

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

Custom start date in YYYY-MM-DD format (e.g. 2025-01-01). Reviews before this date are excluded. Works with any sort order. Can be combined with Date filter.

## `dateTo` (type: `string`):

Custom end date in YYYY-MM-DD format (e.g. 2025-12-31). Reviews after this date are excluded.

## `onlyVerified` (type: `boolean`):

Only scrape reviews from verified customers.

## `onlyWithReplies` (type: `boolean`):

Only scrape reviews that have a company reply.

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

Add company details (name, domain, rating, total reviews) to each review row. Useful for multi-company scrapes.

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

How to sort reviews.

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

Filter reviews by language code (e.g. 'en', 'de', 'fr', 'es', 'nl'). Leave empty for all languages.

## `autoBypassLimit` (type: `boolean`):

Trustpilot limits browsing to 1000 reviews (50 pages). When enabled, the scraper automatically splits by star rating (1-5) to get up to 5000 reviews per company. Disable if you only need the first 1000.

## `onlyCompanyInfo` (type: `boolean`):

Only scrape company profile data (rating, categories, contact info, reply rate, AI summary, topic insights) without individual reviews. Great for lead generation and competitive intelligence.

## `reviewerProfileUrls` (type: `array`):

Scrape all reviews by specific reviewers. Enter Trustpilot profile URLs (e.g. https://www.trustpilot.com/users/abc123) or user IDs. When set, companyUrls is ignored.

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

Proxy settings. Trustpilot may block requests without proxies on large runs (1000+ reviews).

## Actor input object example

```json
{
  "companyUrls": [
    "amazon.com"
  ],
  "maxReviews": 100,
  "filterByStars": 0,
  "dateFilter": "",
  "dateFrom": "",
  "dateTo": "",
  "onlyVerified": false,
  "onlyWithReplies": false,
  "includeCompanyInfo": true,
  "sortBy": "recency",
  "language": "",
  "autoBypassLimit": true,
  "onlyCompanyInfo": false,
  "reviewerProfileUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `reviews` (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 = {
    "companyUrls": [
        "amazon.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scavenger.agent/trustpilot-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 = { "companyUrls": ["amazon.com"] }

# Run the Actor and wait for it to finish
run = client.actor("scavenger.agent/trustpilot-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 '{
  "companyUrls": [
    "amazon.com"
  ]
}' |
apify call scavenger.agent/trustpilot-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Scraper: Reviews + Company Data + Profiles",
        "description": "The most feature-rich Trustpilot scraper on Apify. 35+ data fields per review, 36 company profile fields, reviewer profile scraping. Filter by stars, date, language, verified. Runs on 256 MB (4x cheaper). Brand monitoring, lead gen, sentiment analysis.",
        "version": "1.0",
        "x-build-id": "XJY6elrQVcfjDctk4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scavenger.agent~trustpilot-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scavenger.agent-trustpilot-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/scavenger.agent~trustpilot-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scavenger.agent-trustpilot-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/scavenger.agent~trustpilot-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scavenger.agent-trustpilot-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": {
                    "companyUrls": {
                        "title": "Company URLs or domains",
                        "type": "array",
                        "description": "Trustpilot company page URLs (e.g. https://www.trustpilot.com/review/amazon.com) or just domain names (e.g. amazon.com). Leave empty if using Reviewer Profile URLs.",
                        "default": [
                            "amazon.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Max reviews per company",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per company (or per reviewer profile). Set 0 for unlimited.",
                        "default": 100
                    },
                    "filterByStars": {
                        "title": "Filter by star rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only scrape reviews with this star rating (1-5). Set 0 for all ratings.",
                        "default": 0
                    },
                    "dateFilter": {
                        "title": "Date filter",
                        "enum": [
                            "",
                            "last7days",
                            "last30days",
                            "last3months",
                            "last6months",
                            "lastyear"
                        ],
                        "type": "string",
                        "description": "Filter reviews by time period.",
                        "default": ""
                    },
                    "dateFrom": {
                        "title": "Date from (custom)",
                        "type": "string",
                        "description": "Custom start date in YYYY-MM-DD format (e.g. 2025-01-01). Reviews before this date are excluded. Works with any sort order. Can be combined with Date filter.",
                        "default": ""
                    },
                    "dateTo": {
                        "title": "Date to (custom)",
                        "type": "string",
                        "description": "Custom end date in YYYY-MM-DD format (e.g. 2025-12-31). Reviews after this date are excluded.",
                        "default": ""
                    },
                    "onlyVerified": {
                        "title": "Only verified reviews",
                        "type": "boolean",
                        "description": "Only scrape reviews from verified customers.",
                        "default": false
                    },
                    "onlyWithReplies": {
                        "title": "Only reviews with replies",
                        "type": "boolean",
                        "description": "Only scrape reviews that have a company reply.",
                        "default": false
                    },
                    "includeCompanyInfo": {
                        "title": "Include company info in each review",
                        "type": "boolean",
                        "description": "Add company details (name, domain, rating, total reviews) to each review row. Useful for multi-company scrapes.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "recency",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "How to sort reviews.",
                        "default": "recency"
                    },
                    "language": {
                        "title": "Review language",
                        "type": "string",
                        "description": "Filter reviews by language code (e.g. 'en', 'de', 'fr', 'es', 'nl'). Leave empty for all languages.",
                        "default": ""
                    },
                    "autoBypassLimit": {
                        "title": "Auto-bypass 1000 review limit",
                        "type": "boolean",
                        "description": "Trustpilot limits browsing to 1000 reviews (50 pages). When enabled, the scraper automatically splits by star rating (1-5) to get up to 5000 reviews per company. Disable if you only need the first 1000.",
                        "default": true
                    },
                    "onlyCompanyInfo": {
                        "title": "Only company info (no reviews)",
                        "type": "boolean",
                        "description": "Only scrape company profile data (rating, categories, contact info, reply rate, AI summary, topic insights) without individual reviews. Great for lead generation and competitive intelligence.",
                        "default": false
                    },
                    "reviewerProfileUrls": {
                        "title": "Reviewer profile URLs",
                        "type": "array",
                        "description": "Scrape all reviews by specific reviewers. Enter Trustpilot profile URLs (e.g. https://www.trustpilot.com/users/abc123) or user IDs. When set, companyUrls is ignored.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Trustpilot may block requests without proxies on large runs (1000+ reviews).",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
