# ⭐️ Trustpilot Reviews Scraper (`taroyamada/trustpilot-enterprise-review-aggregator`) Actor

Extract full review text, star ratings, and company reply data from Trustpilot profiles to track customer sentiment and SLAs.

- **URL**: https://apify.com/taroyamada/trustpilot-enterprise-review-aggregator.md
- **Developed by:** [太郎 山田](https://apify.com/taroyamada) (community)
- **Categories:** Marketing, E-commerce, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 API | Ratings, Samples & Reply Signals

Audit your customer service efficiency by automatically extracting review data and reply signals from Trustpilot profiles. For customer experience teams, missing a negative review can cause severe damage to brand trust. This scraper eliminates the need to manually refresh web pages in a browser, allowing you to track exactly which reviews have been answered and which are still pending a company response. Just provide the target URLs and the tool will scrape the complete timeline of interactions.

Many teams use this monitor to enforce service level agreements (SLAs) and measure their reply rates against industry standards. By configuring the scraper to run on a daily or weekly schedule, you can catch low-star ratings the moment they are posted. This continuous monitoring workflow ensures that support agents are alerted to critical feedback immediately, closing the loop on customer complaints before they escalate into larger PR issues.

The API extracts specific, actionable details from every interaction. Your results will contain the full review text, star ratings, reviewer contact signals, and precise timestamps for both the original post and the company reply. Tracking these specific reply signals helps management evaluate support team performance objectively. With perfectly structured scraped data at your fingertips, you can seamlessly power internal compliance dashboards, ensuring every verified customer feels heard and valued across the web.

### Store Quickstart

- Start with 3–10 company review URLs or raw domains and keep `reviewLimit` around 25–50.
- Use dataset delivery on early runs so blocked or partial cases are easy to inspect.
- Keep `dryRun: true` for validation-only checks before a scheduled or webhook handoff.
- After the first useful run, move to the recurring watchlist template, then use the webhook handoff template for negative-review or reply-gap alerts.

### What it does

- Accepts multiple Trustpilot company review URLs or raw company domains.
- Fetches company metadata, recent review samples, rating distribution, review language mix, and company reply signals.
- Flags blocked, missing, invalid, or partially collected sources with structured warnings.
- Produces a clean `companies` array for downstream analytics or enrichment pipelines.

### Use Cases

| Who | Why |
|---|---|
| **Brand teams** | Monitor rating drift and company reply rates across brands or competitors |
| **CX teams** | Pull recent review samples for QA, escalation, or coaching workflows |
| **Agencies** | Benchmark multiple clients or competitors in one normalized dataset |
| **Revenue / partnerships teams** | Enrich company lists with public reputation signals before outreach |

### Input

- `companyUrls`: Trustpilot review URLs like `https://www.trustpilot.com/review/www.shopify.com` or domains like `shopify.com`
- `reviewLimit`: max recent reviews to collect per company
- `delivery`: `dataset` or `webhook`
- `webhookUrl`: optional when `delivery=webhook`
- `dryRun`: skip dataset writes and only create `output/result.json`

### Output shape

Each company row includes:

- `status`: `ok`, `partial`, `blocked`, `missing`, or `invalid`
- `company`: normalized Trustpilot company metadata
- `ratingDistribution`: star breakdown when Trustpilot exposes it
- `reviewLanguageDistribution`: counts by language when available
- `reviewSample`: normalized recent review samples
- `reviewSampleSummary`: counts, page coverage, verified review count, and reply flags
- `warnings`: structured warnings for blocked, missing, or partial collection scenarios

#### Output Example

```json
{
  "status": "ok",
  "company": {
    "displayName": "Example Co",
    "trustScore": 4.2,
    "numberOfReviews": 6,
    "contactInfo": { "city": "Austin", "country": "US" }
  },
  "ratingDistribution": {
    "total": 6,
    "breakdown": [{ "rating": 5, "count": 4 }]
  },
  "reviewSampleSummary": {
    "collected": 3,
    "verifiedReviewCount": 2,
    "companyReplyCount": 1
  },
  "reviewSample": [
    { "rating": 5, "title": "Fast onboarding", "language": "en", "hasCompanyReply": true }
  ],
  "warnings": []
}
````

### Local run

```bash
npm start
```

Use `input.json` for local runs and `npm test` to run the unit tests.

### Related Actors

Pair this actor with other flagship intelligence APIs in the same portfolio:

- [Google Maps Review Intelligence API](https://apify.com/taroyamada/google-maps-review-intelligence) — compare location-level ratings and snippets with brand-level Trustpilot signals.
- [G2 & Capterra Review Intelligence API](https://apify.com/taroyamada/g2-capterra-review-intelligence) — extend the same workflow into B2B software review surfaces.
- [Shopify Store Intelligence API](https://apify.com/taroyamada/shopify-store-intelligence) — pair Trustpilot reputation data with public storefront and catalog intelligence.
- [YouTube Channel Analytics API](https://apify.com/taroyamada/youtube-channel-analytics) — connect review sentiment with creator and content visibility signals.

### Pricing & Cost Control

Apify Store pricing is usage-based, so total cost mainly follows how many `companyUrls` you process and how many review samples you request. Check the Store pricing card for the current per-event rates.

- Start with a small `companyUrls` batch and `reviewLimit` of 25–50.
- Use dataset delivery first so you can inspect blocked or partial cases.
- Keep scheduled runs focused on shortlists rather than large dumps when possible.
- Use `dryRun: true` before webhook handoffs.

### ⭐ Was this helpful?

If this actor saved you time, please [**leave a ★ rating**](https://apify.com/taroyamada/trustpilot-enterprise-review-aggregator/reviews) on Apify Store. It takes 10 seconds, helps other developers discover it, and keeps updates free.

Bug report or feature request? Open an issue on the [Issues tab](https://apify.com/taroyamada/trustpilot-enterprise-review-aggregator/issues) of this actor.

# Actor input Schema

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

One or more Trustpilot company review URLs or company domains.

## `reviewLimit` (type: `integer`):

Maximum number of recent review samples to collect for each company.

## `delivery` (type: `string`):

Where to send results: dataset or webhook.

## `webhookUrl` (type: `string`):

Webhook URL to POST the full normalized payload to when delivery=webhook.

## `dryRun` (type: `boolean`):

Run collection without pushing company rows to the dataset.

## Actor input object example

```json
{
  "companyUrls": [
    "https://www.trustpilot.com/review/www.shopify.com",
    "https://www.trustpilot.com/review/www.zendesk.com"
  ],
  "reviewLimit": 50,
  "delivery": "dataset",
  "dryRun": false
}
```

# 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": [
        "https://www.trustpilot.com/review/www.shopify.com",
        "https://www.trustpilot.com/review/www.zendesk.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("taroyamada/trustpilot-enterprise-review-aggregator").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": [
        "https://www.trustpilot.com/review/www.shopify.com",
        "https://www.trustpilot.com/review/www.zendesk.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("taroyamada/trustpilot-enterprise-review-aggregator").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": [
    "https://www.trustpilot.com/review/www.shopify.com",
    "https://www.trustpilot.com/review/www.zendesk.com"
  ]
}' |
apify call taroyamada/trustpilot-enterprise-review-aggregator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "⭐️ Trustpilot Reviews Scraper",
        "description": "Extract full review text, star ratings, and company reply data from Trustpilot profiles to track customer sentiment and SLAs.",
        "version": "0.1",
        "x-build-id": "9qSEfmrrbL6tzBhCC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/taroyamada~trustpilot-enterprise-review-aggregator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-taroyamada-trustpilot-enterprise-review-aggregator",
                "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/taroyamada~trustpilot-enterprise-review-aggregator/runs": {
            "post": {
                "operationId": "runs-sync-taroyamada-trustpilot-enterprise-review-aggregator",
                "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/taroyamada~trustpilot-enterprise-review-aggregator/run-sync": {
            "post": {
                "operationId": "run-sync-taroyamada-trustpilot-enterprise-review-aggregator",
                "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",
                "required": [
                    "companyUrls"
                ],
                "properties": {
                    "companyUrls": {
                        "title": "Company review URLs",
                        "type": "array",
                        "description": "One or more Trustpilot company review URLs or company domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "reviewLimit": {
                        "title": "Review sample limit per company",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of recent review samples to collect for each company.",
                        "default": 50
                    },
                    "delivery": {
                        "title": "Delivery",
                        "enum": [
                            "dataset",
                            "webhook"
                        ],
                        "type": "string",
                        "description": "Where to send results: dataset or webhook.",
                        "default": "dataset"
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "Webhook URL to POST the full normalized payload to when delivery=webhook."
                    },
                    "dryRun": {
                        "title": "Dry run",
                        "type": "boolean",
                        "description": "Run collection without pushing company rows to the dataset.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
