# TrustMate Reviews Scraper - Company Feedback (`benthepythondev/trustmate-reviews-scraper`) Actor

Scrape paginated TrustMate company reviews with rating, text, original language, translation, author, verified status, company reply, helpful counts and company context.

- **URL**: https://apify.com/benthepythondev/trustmate-reviews-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** E-commerce, Marketing, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## TrustMate Reviews Scraper - Company Feedback

Scrape public company reviews from TrustMate into a structured dataset. The Actor follows TrustMate's public first-party review API, paginates beyond the initially rendered profile page, and exports review text, rating, author, verified status, original language, translations, company replies, helpful counts, timestamps, and company-level rating context.

Use it for customer-experience research, reputation monitoring, ecommerce analysis, competitor benchmarking, sentiment pipelines, and recurring review alerts. No TrustMate account or API key is required because the Actor reads the same public company information and reviews displayed to visitors.

### What makes the output useful

A review body alone lacks context. TrustMate distinguishes verified and unverified feedback, can translate reviews, stores the original text, exposes company responses, and publishes aggregate company statistics. This Actor preserves those fields so downstream analysis can separate translated text from the source, compare ratings over time, identify answered reviews, and filter by credibility signals.

Common workflows include:

- collecting the newest reviews for reputation monitoring;
- comparing average grades and review volume across companies;
- feeding review bodies into sentiment or topic analysis;
- detecting low-grade feedback that needs attention;
- measuring whether a company responds to customers;
- exporting verified-purchase reviews for quality research;
- archiving review history for trend analysis;
- building dashboards in Sheets, Airtable, a warehouse, or BI software.

### Input

Paste one or more public TrustMate company review URLs. English profiles commonly use `/en/reviews/<slug>` and Polish profiles use `/opinie/<slug>`.

```json
{
  "profileUrls": [
    "https://trustmate.io/en/reviews/trustmate-io-en"
  ],
  "minGrade": 1,
  "maxGrade": 5,
  "order": "newest",
  "includeReviewsWithoutContent": false,
  "maxReviewsPerProfile": 50,
  "maxPagesPerProfile": 20
}
````

#### Input fields

| Field | Description |
|---|---|
| `profileUrls` | Public TrustMate company review pages. |
| `minGrade` | Lowest grade to request, from 1 to 5. |
| `maxGrade` | Highest grade to request, from 1 to 5. |
| `order` | Newest or oldest reviews first. |
| `includeReviewsWithoutContent` | Include grade-only reviews without a written body. |
| `maxReviewsPerProfile` | Maximum stored reviews for each company. |
| `maxPagesPerProfile` | Hard pagination limit; the API currently returns 25 records per page. |

The default run collects 50 recent written reviews. Limits are enforced independently per company so a multi-profile run stays predictable.

### Review output

Each dataset row represents one unique public review and may include:

- stable public and numeric review IDs;
- `grade`, translated `body`, and displayed language;
- `original_body` and `original_language`;
- available translation records;
- author display name;
- verified/not-verified and purchase-weight signals;
- publication status, enabled/imported/shared/pinned flags;
- company reply text and reply date;
- helpful and unhelpful counts;
- review creation and update timestamps;
- company ID, UUID, name, website, email, and profile URL;
- company verified status, average grade, total review count, grade distribution, and recommendation percentage;
- scrape timestamp and result rank.

Example result:

```json
{
  "grade": 5,
  "body": "Easy to use system.",
  "original_body": "Latwy w obsludze system.",
  "original_language": "pl",
  "language": "en",
  "author_name": "swiatpierogow.pl",
  "verified": true,
  "created_at": "2026-07-10T06:46:34+00:00",
  "company_name": "TRUSTMATE SPOLKA AKCYJNA",
  "company_average_grade": 4.89,
  "profile_url": "https://trustmate.io/en/reviews/trustmate-io-en"
}
```

### Pagination and filters

TrustMate's profile page initially embeds a limited review set. The public “Show more” control calls a JSON endpoint with an account ID, offset, language, grade filters, and ordering. The Actor resolves the public company slug to that account ID and advances the offset in 25-review steps until it reaches your limit, the source ends, or the page safety limit is reached.

Grade filtering happens at the source. Written-content filtering happens before storage so grade-only entries do not consume result events unless you explicitly request them.

### Monitoring workflow

For ongoing reputation monitoring:

1. save a TrustMate profile list as an Apify Task;
2. schedule it daily or weekly with newest-first ordering;
3. use the public review identifier as the stable deduplication key;
4. send only unseen reviews to your database or alert channel;
5. route low-grade rows or unanswered feedback for manual review.

This design keeps notifications focused while preserving a dataset history for reporting. Webhooks can deliver completed run metadata to Make, Zapier, n8n, Slack, or a custom service.

### Sentiment and research considerations

Translations are useful for cross-market analysis, but they are not the original customer wording. Keep `original_body` and `original_language` when evaluating nuance. Verified status and review weight are source-published signals, not an independent audit by this Actor. Reviews can also be imported from other systems, which is why the output retains import metadata.

Do not use review data to harass authors, infer sensitive traits, or make automated high-impact decisions. Follow applicable privacy, consumer-protection, and platform rules.

### Pricing

This Actor uses pay-per-event pricing: one small start event and `$0.002` per unique written review stored in the default dataset. The price matches the closest proven Store implementation while preserving more company and translation context in a flat export. Duplicate review identifiers within a run are not stored twice.

### Reliability and scope

The Actor uses TrustMate's credential-free public web API with bounded retries and pagination limits. It does not sign in, access merchant dashboards, submit reviews, or call private integration APIs. A default run is small enough for routine scheduling and Apify's automated reliability tests.

Public reviews and company statistics can change. Deleted, mediated, disabled, newly translated, or newly answered reviews may differ between runs. Treat the dataset as a timestamped observation and keep the source profile URL for verification.

### FAQ

#### Do I need a TrustMate API key?

No. The Actor reads public company profiles and the public review endpoint used by the profile page.

#### Does it collect more than the first page?

Yes. It advances through 25-review offsets up to your review and page limits.

#### Can I collect only one-star reviews?

Yes. Set both `minGrade` and `maxGrade` to 1.

#### Are translations separated from original text?

Yes. The displayed body/language and original body/language have separate fields.

#### Are company replies included?

Yes when TrustMate exposes a reply for that review.

#### Can I include ratings without comments?

Yes. Enable `includeReviewsWithoutContent`.

#### Can I export CSV or Excel?

Yes. Apify datasets support JSON, CSV, Excel, XML, RSS, and API access.

#### How do I report an issue?

Open an Actor issue with the profile URL and run ID. If the Actor saved you time, please leave a Store review; reviews help other users compare tools and help prioritize maintenance.

### You might also like

- [Review Scrapers](https://apify.com/store?search=reviews%20scraper)
- [Ecommerce Research Actors](https://apify.com/store?search=ecommerce%20research)
- [Sentiment Analysis Workflows](https://apify.com/store?search=sentiment%20analysis)

**Keywords:** TrustMate scraper, TrustMate reviews API, company reviews scraper, customer feedback export, ecommerce reputation monitoring, verified reviews, review translations, company response tracker, sentiment dataset, review pagination

# Actor input Schema

## `profileUrls` (type: `array`):

Public TrustMate company profile URLs in English or Polish.

## `minGrade` (type: `integer`):

Lowest review grade to include.

## `maxGrade` (type: `integer`):

Highest review grade to include.

## `order` (type: `string`):

Return newest or oldest reviews first.

## `includeReviewsWithoutContent` (type: `boolean`):

Include reviews that have a grade but no written body.

## `maxReviewsPerProfile` (type: `integer`):

Maximum reviews saved for each TrustMate company.

## `maxPagesPerProfile` (type: `integer`):

Pagination safety limit. TrustMate currently returns 25 reviews per API page.

## Actor input object example

```json
{
  "profileUrls": [
    "https://trustmate.io/en/reviews/trustmate-io-en"
  ],
  "minGrade": 1,
  "maxGrade": 5,
  "order": "newest",
  "includeReviewsWithoutContent": false,
  "maxReviewsPerProfile": 50,
  "maxPagesPerProfile": 20
}
```

# Actor output Schema

## `results` (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 = {
    "profileUrls": [
        "https://trustmate.io/en/reviews/trustmate-io-en"
    ],
    "minGrade": 1,
    "maxGrade": 5,
    "order": "newest",
    "includeReviewsWithoutContent": false,
    "maxReviewsPerProfile": 50,
    "maxPagesPerProfile": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/trustmate-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 = {
    "profileUrls": ["https://trustmate.io/en/reviews/trustmate-io-en"],
    "minGrade": 1,
    "maxGrade": 5,
    "order": "newest",
    "includeReviewsWithoutContent": False,
    "maxReviewsPerProfile": 50,
    "maxPagesPerProfile": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/trustmate-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 '{
  "profileUrls": [
    "https://trustmate.io/en/reviews/trustmate-io-en"
  ],
  "minGrade": 1,
  "maxGrade": 5,
  "order": "newest",
  "includeReviewsWithoutContent": false,
  "maxReviewsPerProfile": 50,
  "maxPagesPerProfile": 20
}' |
apify call benthepythondev/trustmate-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TrustMate Reviews Scraper - Company Feedback",
        "description": "Scrape paginated TrustMate company reviews with rating, text, original language, translation, author, verified status, company reply, helpful counts and company context.",
        "version": "1.0",
        "x-build-id": "IYewGIELXSiXEY5wb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~trustmate-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-trustmate-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/benthepythondev~trustmate-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-trustmate-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/benthepythondev~trustmate-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-trustmate-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",
                "required": [
                    "profileUrls"
                ],
                "properties": {
                    "profileUrls": {
                        "title": "TrustMate company review URLs",
                        "type": "array",
                        "description": "Public TrustMate company profile URLs in English or Polish.",
                        "default": [
                            "https://trustmate.io/en/reviews/trustmate-io-en"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "minGrade": {
                        "title": "Minimum grade",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Lowest review grade to include.",
                        "default": 1
                    },
                    "maxGrade": {
                        "title": "Maximum grade",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Highest review grade to include.",
                        "default": 5
                    },
                    "order": {
                        "title": "Review order",
                        "enum": [
                            "newest",
                            "oldest"
                        ],
                        "type": "string",
                        "description": "Return newest or oldest reviews first.",
                        "default": "newest"
                    },
                    "includeReviewsWithoutContent": {
                        "title": "Include ratings without text",
                        "type": "boolean",
                        "description": "Include reviews that have a grade but no written body.",
                        "default": false
                    },
                    "maxReviewsPerProfile": {
                        "title": "Maximum reviews per profile",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum reviews saved for each TrustMate company.",
                        "default": 50
                    },
                    "maxPagesPerProfile": {
                        "title": "Maximum pages per profile",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Pagination safety limit. TrustMate currently returns 25 reviews per API page.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
