# Trustpilot Reviews Scraper — Ratings, Replies & Sentiment (`khadinakbar/trustpilot-reviews-scraper`) Actor

Extract Trustpilot reviews in bulk — rating, text, reviewer, date, verified status, company reply, trust score, and sentiment label MCP-ready. $2.50/1K.

- **URL**: https://apify.com/khadinakbar/trustpilot-reviews-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, Agents, MCP servers
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 review scrapeds

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

### What does Trustpilot Reviews Scraper do?

**Trustpilot Reviews Scraper** extracts structured review data from any company's Trustpilot page — review text, star ratings, reviewer metadata, company replies, trust scores, and 25+ additional fields — without requiring a browser, proxy, or login. Simply provide a company domain, Trustpilot URL, or company name, and the actor returns clean, analysis-ready JSON records within seconds.

### Why use Trustpilot Reviews Scraper?

- **Fastest + cheapest** — pure HTTP scraping via Trustpilot's server-rendered JSON (no browser, no proxy costs). Delivers 100 reviews in under 10 seconds.
- **Most complete output** — 28 fields per review including reviewer country, verification level, company reply text, computed sentiment label, and company trust score. The richest output of any Trustpilot actor on the Store.
- **3 input modes** — paste a domain (`apple.com`), a full Trustpilot URL, or just the company name. The actor resolves all three automatically — no lookup needed.

### What data can Trustpilot Reviews Scraper extract?

| Field | Type | Example |
|-------|------|---------|
| `reviewId` | string | `"64a2f1c3e4b0..."` |
| `reviewUrl` | string | `"https://www.trustpilot.com/reviews/..."` |
| `title` | string | `"Excellent service!"` |
| `text` | string | `"The team resolved my issue in 2 hours."` |
| `rating` | integer (1–5) | `5` |
| `publishedAt` | ISO 8601 | `"2025-11-14T09:21:00Z"` |
| `experienceDate` | ISO 8601 | `"2025-11-10T00:00:00Z"` |
| `language` | string | `"en"` |
| `isVerified` | boolean | `true` |
| `verificationLevel` | string | `"VERIFIED_ORDER"` |
| `reviewSource` | string | `"InvitationLink"` |
| `usefulVotes` | integer | `3` |
| `reviewerDisplayName` | string | `"Sarah M."` |
| `reviewerCountry` | ISO code | `"US"` |
| `reviewerTotalReviews` | integer | `12` |
| `reviewerAvatarUrl` | string | `"https://..."` |
| `reviewerId` | string | `"5e4b2a1c..."` |
| `hasCompanyReply` | boolean | `true` |
| `companyReplyText` | string | `"Thank you for your feedback..."` |
| `companyReplyDate` | ISO 8601 | `"2025-11-15T10:00:00Z"` |
| `companyName` | string | `"Postmark"` |
| `companyDomain` | string | `"postmarkapp.com"` |
| `companyTrustScore` | number | `4.6` |
| `companyTotalReviews` | integer | `2847` |
| `companyCategories` | string[] | `["Software Company"]` |
| `companyUrl` | string | `"https://www.trustpilot.com/review/..."` |
| `sentimentLabel` | string | `"positive"` / `"neutral"` / `"negative"` |
| `scraped_at` | ISO 8601 | `"2026-04-13T10:00:00Z"` |
| `source_url` | string | `"https://www.trustpilot.com/review/..."` |

Export scraped data in JSON, CSV, or Excel. Run via API, schedule automated monitoring, or integrate directly with AI pipelines and CRMs.

---

### Tutorial — How to Scrape Trustpilot Reviews

#### Step 1 — Enter companies

In the **Companies to Scrape** field, enter one identifier per line. Any of these formats work:

````

postmarkapp.com
apple.com
https://www.trustpilot.com/review/netflix.com
Spotify

````

The actor resolves domains, Trustpilot URLs, and company names automatically.

#### Step 2 — Set filters (optional)

Use the filter fields to narrow your results:

- **Max Reviews Per Company** — default 100; set to `0` for unlimited
- **Filter by Star Rating** — select 1–5 stars (leave blank for all)
- **Filter by Language** — enter `en`, `de`, `fr`, `es`, etc.
- **Filter by Date Range** — last 30 days, 3 months, 6 months, or 12 months
- **Sort Reviews By** — most recent or most relevant
- **Verified Reviews Only** — only verified purchase/invitation reviews
- **Reviews With Company Reply Only** — useful for competitor analysis

#### Step 3 — Run and export

Click **Start** and the actor runs immediately. When complete, download results from the **Output** tab in JSON, CSV, or Excel format — or pull via the Apify API.

---

### 💡 Use Cases

**Brand reputation monitoring** — Continuously track your own trust score and review sentiment. Set up a scheduled run to alert you when negative reviews spike.

**Competitor benchmarking** — Scrape multiple competitors at once, compare trust scores, sentiment distribution, and most common complaints.

**Customer sentiment analysis** — Feed the `text` and `sentimentLabel` fields into any LLM or NLP pipeline for deeper analysis.

**Sales prospecting** — Mine low-rated competitor reviews to identify dissatisfied customers ready to switch.

**Review embedding on websites** — Collect and display verified Trustpilot reviews directly on your website or product pages.

**AI training data** — Build labeled sentiment datasets from the `rating` and `text` fields for fine-tuning classification models.

**Lead generation for agencies** — Identify businesses with poor reputation scores and offer reputation management services.

---

### 💰 Pricing

This actor uses **Pay Per Event** pricing — you only pay for reviews you actually get.

| Apify Plan | Price Per Review | 1,000 reviews | 10,000 reviews |
|------------|-----------------|---------------|----------------|
| Free | $0.0004 | $0.40 | $4.00 |
| Bronze | $0.00033 | $0.33 | $3.30 |
| Silver | $0.00028 | $0.28 | $2.80 |
| Gold | $0.00022 | $0.22 | $2.20 |
| Platinum | $0.00018 | $0.18 | $1.80 |
| Diamond | $0.00013 | $0.13 | $1.30 |

A one-time **Actor Start** fee of $0.0005 is charged per run regardless of results.

**Example:** Scraping 500 reviews from 5 competitors (100 each) on the Free plan costs $0.20 + $0.0005 ≈ **$0.20 total**.

Compare to alternatives charging $0.003/review — that's the same 500 reviews at **$1.50**. We're 7× cheaper.

---

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `companyIdentifiers` | string[] | `["postmarkapp.com"]` | Domains, Trustpilot URLs, or company names |
| `maxReviewsPerCompany` | integer | `100` | Max reviews per company (0 = unlimited) |
| `filterStars` | string[] | `[]` | Filter by star rating (1–5) |
| `filterLanguage` | string | `""` | Filter by language code (`en`, `de`, `fr`…) |
| `filterDateRange` | string | `""` | `last30days`, `last3months`, `last6months`, `last12months` |
| `sortBy` | string | `"recency"` | `recency` or `relevance` |
| `onlyVerified` | boolean | `false` | Only verified reviews |
| `onlyWithReplies` | boolean | `false` | Only reviews with a company reply |
| `includeCompanyInfo` | boolean | `true` | Include company metadata in each record |

---

### API Usage Example

Run via the Apify API to integrate with your own application:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_API_TOKEN' });

const run = await client.actor('USERNAME/trustpilot-reviews-scraper').call({
    companyIdentifiers: ['postmarkapp.com', 'mailchimp.com'],
    maxReviewsPerCompany: 200,
    filterStars: ['1', '2'],  // negative reviews only
    sortBy: 'recency',
});

const dataset = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Scraped ${dataset.items.length} reviews`);
console.log(dataset.items[0]);
````

**Python example:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_API_TOKEN")

run = client.actor("USERNAME/trustpilot-reviews-scraper").call(run_input={
    "companyIdentifiers": ["apple.com"],
    "maxReviewsPerCompany": 500,
    "filterLanguage": "en",
    "onlyVerified": True,
})

dataset = client.dataset(run["defaultDatasetId"]).list_items()
print(f"Scraped {len(dataset.items)} reviews")
```

***

### Sample Output

```json
{
    "reviewId": "64a2f1c3e4b09d001a7b3e12",
    "reviewUrl": "https://www.trustpilot.com/reviews/64a2f1c3e4b09d001a7b3e12",
    "title": "Excellent customer service",
    "text": "Had an issue with my order and support resolved it within 2 hours. Very impressed with the speed and professionalism.",
    "rating": 5,
    "publishedAt": "2025-11-14T09:21:00.000Z",
    "updatedAt": null,
    "experienceDate": "2025-11-10T00:00:00.000Z",
    "language": "en",
    "isVerified": true,
    "verificationLevel": "VERIFIED_ORDER",
    "reviewSource": "InvitationLink",
    "usefulVotes": 3,
    "reviewerDisplayName": "Sarah M.",
    "reviewerCountry": "US",
    "reviewerTotalReviews": 12,
    "reviewerAvatarUrl": "https://user-images.trustpilot.com/abc/73x73.png",
    "reviewerId": "5e4b2a1c3d001a7b3e12",
    "hasCompanyReply": true,
    "companyReplyText": "Thank you for your kind words, Sarah! We're delighted to hear our team exceeded expectations.",
    "companyReplyDate": "2025-11-15T10:00:00.000Z",
    "companyName": "Postmark",
    "companyDomain": "postmarkapp.com",
    "companyTrustScore": 4.6,
    "companyTotalReviews": 2847,
    "companyCategories": ["Email Service Provider", "Software Company"],
    "companyUrl": "https://www.trustpilot.com/review/postmarkapp.com",
    "sentimentLabel": "positive",
    "scraped_at": "2026-04-13T10:00:00.000Z",
    "source_url": "https://www.trustpilot.com/review/postmarkapp.com?page=1"
}
```

***

### FAQ

**Q: Does this actor require a proxy or login?**
A: No. Trustpilot review pages are publicly accessible. The actor uses fast HTTP scraping with no proxy overhead, keeping your costs low.

**Q: How many reviews can I scrape?**
A: Unlimited. Set `maxReviewsPerCompany` to `0` to scrape all reviews for a company. Trustpilot shows approximately 20 reviews per page; the actor automatically paginates.

**Q: Can I scrape multiple companies at once?**
A: Yes. Add as many domains or company names as you need to the `companyIdentifiers` list. They are processed in parallel.

**Q: What's the `sentimentLabel` field?**
A: A computed field derived from the star rating: `positive` (4–5 stars), `neutral` (3 stars), `negative` (1–2 stars). Useful for quick sentiment filtering without NLP.

**Q: What happens if a company isn't found?**
A: The actor logs a warning and continues with the remaining companies. No error is thrown.

**Q: Can I schedule this to run automatically?**
A: Yes. Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run the actor on a daily or weekly cron to monitor reviews continuously.

**Q: The actor returned fewer reviews than expected — why?**
A: Trustpilot may paginate differently depending on applied filters. Try setting `filterStars` and `filterLanguage` to empty values, or increase `maxReviewsPerCompany`.

**Q: Is this actor MCP-compatible?**
A: Yes. The actor is fully MCP-optimized with rich dataset schema and output schema metadata, making it discoverable and usable by Claude and other AI agents via the Apify MCP server.

***

### Works Great With

- **[Apify Scheduler](https://docs.apify.com/platform/schedules)** — Set up automated weekly review monitoring
- **[Apify Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — Trigger downstream workflows when new reviews are scraped
- **Make / Zapier** — Push review data automatically into Google Sheets, Airtable, HubSpot, or Slack

***

### Legal Disclaimer

This actor extracts publicly available data from Trustpilot for legitimate research, monitoring, and analysis purposes. Users are responsible for ensuring their use complies with applicable laws, Trustpilot's Terms of Service, and data protection regulations including GDPR and CCPA. Do not use scraped data to misrepresent, harass, or harm individuals or businesses.

# Actor input Schema

## `companyIdentifiers` (type: `array`):

Use this field when the user provides domains (e.g. 'apple.com'), Trustpilot review URLs (e.g. 'https://www.trustpilot.com/review/apple.com'), or company names (e.g. 'Apple'). Enter one per line. Accepts all three formats — the actor resolves each to the correct Trustpilot page automatically.

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

Maximum number of reviews to scrape per company. Set to 0 for unlimited (scrapes all available reviews). Default is 100.

## `filterStars` (type: `array`):

Only scrape reviews with these star ratings. Leave empty to scrape all ratings. Use when the user wants only positive reviews (4-5 stars) or only negative reviews (1-2 stars).

## `filterLanguage` (type: `string`):

Only scrape reviews written in this language. Use ISO 639-1 codes: 'en' for English, 'de' for German, 'fr' for French, 'es' for Spanish, 'nl' for Dutch. Leave empty for all languages.

## `filterDateRange` (type: `string`):

Only scrape reviews published within this date range. Leave empty to scrape all dates.

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

Sort order for reviews. 'recency' returns newest first. 'relevance' returns most helpful first (Trustpilot default).

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

When enabled, only scrape reviews from verified purchases or verified invitations. Reduces quantity but improves data quality for market research.

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

When enabled, only scrape reviews that have received a reply from the company. Useful for analyzing how companies handle customer feedback.

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

When enabled, each review record includes company metadata: trust score, total review count, categories, and domain. Disable to reduce output size when only review content is needed.

## Actor input object example

```json
{
  "companyIdentifiers": [
    "postmarkapp.com"
  ],
  "maxReviewsPerCompany": 100,
  "filterStars": [],
  "filterLanguage": "",
  "filterDateRange": "",
  "sortBy": "recency",
  "onlyVerified": false,
  "onlyWithReplies": false,
  "includeCompanyInfo": true
}
```

# Actor output Schema

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

All extracted Trustpilot review records as structured JSON

# 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 = {
    "companyIdentifiers": [
        "postmarkapp.com"
    ],
    "maxReviewsPerCompany": 100,
    "filterLanguage": "",
    "sortBy": "recency"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/trustpilot-reviews-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "companyIdentifiers": ["postmarkapp.com"],
    "maxReviewsPerCompany": 100,
    "filterLanguage": "",
    "sortBy": "recency",
}

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

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

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

```

## CLI example

```bash
echo '{
  "companyIdentifiers": [
    "postmarkapp.com"
  ],
  "maxReviewsPerCompany": 100,
  "filterLanguage": "",
  "sortBy": "recency"
}' |
apify call khadinakbar/trustpilot-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Reviews Scraper — Ratings, Replies & Sentiment",
        "description": "Extract Trustpilot reviews in bulk — rating, text, reviewer, date, verified status, company reply, trust score, and sentiment label MCP-ready. $2.50/1K.",
        "version": "1.0",
        "x-build-id": "ADnZEoYlP0dwEZzDL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~trustpilot-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-trustpilot-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/khadinakbar~trustpilot-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-trustpilot-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/khadinakbar~trustpilot-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-trustpilot-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "companyIdentifiers": {
                        "title": "Companies to Scrape",
                        "type": "array",
                        "description": "Use this field when the user provides domains (e.g. 'apple.com'), Trustpilot review URLs (e.g. 'https://www.trustpilot.com/review/apple.com'), or company names (e.g. 'Apple'). Enter one per line. Accepts all three formats — the actor resolves each to the correct Trustpilot page automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerCompany": {
                        "title": "Max Reviews Per Company",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per company. Set to 0 for unlimited (scrapes all available reviews). Default is 100.",
                        "default": 100
                    },
                    "filterStars": {
                        "title": "Filter by Star Rating",
                        "type": "array",
                        "description": "Only scrape reviews with these star ratings. Leave empty to scrape all ratings. Use when the user wants only positive reviews (4-5 stars) or only negative reviews (1-2 stars).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "1 Star (Terrible)",
                                "2 Stars (Poor)",
                                "3 Stars (Average)",
                                "4 Stars (Great)",
                                "5 Stars (Excellent)"
                            ]
                        },
                        "default": []
                    },
                    "filterLanguage": {
                        "title": "Filter by Language",
                        "type": "string",
                        "description": "Only scrape reviews written in this language. Use ISO 639-1 codes: 'en' for English, 'de' for German, 'fr' for French, 'es' for Spanish, 'nl' for Dutch. Leave empty for all languages.",
                        "default": ""
                    },
                    "filterDateRange": {
                        "title": "Filter by Date Range",
                        "enum": [
                            "",
                            "last30days",
                            "last3months",
                            "last6months",
                            "last12months"
                        ],
                        "type": "string",
                        "description": "Only scrape reviews published within this date range. Leave empty to scrape all dates.",
                        "default": ""
                    },
                    "sortBy": {
                        "title": "Sort Reviews By",
                        "enum": [
                            "recency",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Sort order for reviews. 'recency' returns newest first. 'relevance' returns most helpful first (Trustpilot default).",
                        "default": "recency"
                    },
                    "onlyVerified": {
                        "title": "Verified Reviews Only",
                        "type": "boolean",
                        "description": "When enabled, only scrape reviews from verified purchases or verified invitations. Reduces quantity but improves data quality for market research.",
                        "default": false
                    },
                    "onlyWithReplies": {
                        "title": "Reviews With Company Reply Only",
                        "type": "boolean",
                        "description": "When enabled, only scrape reviews that have received a reply from the company. Useful for analyzing how companies handle customer feedback.",
                        "default": false
                    },
                    "includeCompanyInfo": {
                        "title": "Include Company Profile Data",
                        "type": "boolean",
                        "description": "When enabled, each review record includes company metadata: trust score, total review count, categories, and domain. Disable to reduce output size when only review content is needed.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
