# Trustpilot Business Search Scraper (`thescrappa/trustpilot-business-search-scraper`) Actor

Search Trustpilot companies by keyword or browse businesses by category. Extract company names, TrustScores, review counts, claimed status, websites, profile URLs, categories, and location fields.

- **URL**: https://apify.com/thescrappa/trustpilot-business-search-scraper.md
- **Developed by:** [Scrappa](https://apify.com/thescrappa) (community)
- **Categories:** Marketing, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Trustpilot Business Search Scraper

Find companies and category business listings on Trustpilot through Scrappa. Use this Actor to build prospect lists, monitor competitors, discover reviewed businesses in a category, or collect company domains before running the Trustpilot Company Reviews Scraper.

### Features

- Search Trustpilot companies by brand, company name, or domain
- Browse Trustpilot businesses by category slug, country, claimed status, sort order, and minimum TrustScore
- Fetch one or more one-based result pages per run
- Extract company name, domain, website, Trustpilot profile URL, TrustScore, stars, review count, claimed/verified status, categories, country, city, email, and phone fields when available
- Dataset rows optimized for Apify table views
- Full Scrappa page responses saved to the `OUTPUT` key-value-store record

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `search_type` | string | No | `company_search` for keyword/domain discovery or `category` for category browsing. Default `company_search` |
| `query` | string | For company search | Company, brand, or domain query, for example `amazon` |
| `category` | string | For category search | Trustpilot category slug, for example `electronics_technology` or `restaurants_bars` |
| `country` | string | No | ISO-2 country filter, for example `US`, `GB`, or `DE` |
| `page` | integer | No | First one-based result page. Default `1` |
| `max_pages` | integer | No | Number of pages to fetch, 1-10. Default `1` |
| `per_page` | integer | No | Company-search results per page, 1-50. Default `20` |
| `min_rating` | number | No | Minimum TrustScore for company search |
| `min_review_count` | integer | No | Minimum review count for company search |
| `sort` | string | No | Category sort: `reviews_count` or `latest_review` |
| `claimed` | boolean | No | Filter category results to claimed businesses |
| `limit` | integer | No | Category results per page, 1-50. Default `20` |
| `trustscore` | number | No | Minimum TrustScore for category search |

### Example Company Search Input

```json
{
  "search_type": "company_search",
  "query": "amazon",
  "country": "US",
  "min_rating": 3,
  "min_review_count": 100,
  "page": 1,
  "max_pages": 2
}
````

### Example Category Search Input

```json
{
  "search_type": "category",
  "category": "electronics_technology",
  "country": "US",
  "sort": "reviews_count",
  "limit": 20,
  "max_pages": 2
}
```

### Output

Each Trustpilot business is saved as one dataset item:

```json
{
  "business_name": "Amazon",
  "identifying_name": "amazon.com",
  "website_url": "https://www.amazon.com",
  "profile_url": "https://www.trustpilot.com/review/amazon.com",
  "trust_score": 1.4,
  "stars": 1.5,
  "review_count": 38765,
  "is_claimed": true,
  "is_verified": false,
  "country": "United States",
  "country_code": "US",
  "city": "Seattle",
  "category_names": "Marketplace, Electronics",
  "request_search_type": "company_search",
  "request_query": "amazon",
  "request_page": 1,
  "total_results": 42,
  "total_pages": 3
}
```

The `OUTPUT` record includes the request summary, endpoint used, pages fetched, business count, reported Trustpilot totals, and raw Scrappa responses for the fetched pages.

### Pricing

This Actor is designed for paid, usage-aligned runs. Charge per saved `business-result` dataset item so users pay for delivered company records.

### Notes

Trustpilot search returns public company and category listing data. For higher-volume Trustpilot discovery, details, review monitoring, or direct API access, use Scrappa at https://scrappa.co/api/trustpilot/company-search and https://scrappa.co/api/trustpilot/businesses.

# Actor input Schema

## `search_type` (type: `string`):

Use company search for name/domain discovery, or category search for Trustpilot category browsing.

## `query` (type: `string`):

Company, brand, or domain query for Trustpilot company search. Required when Search Type is Company search.

## `category` (type: `string`):

Trustpilot category slug, for example electronics\_technology or restaurants\_bars. Required when Search Type is Category businesses.

## `locale` (type: `string`):

Trustpilot locale for company search.

## `country` (type: `string`):

Optional ISO-2 country filter, for example US, GB, DE, FR, or NL.

## `page` (type: `integer`):

First one-based Trustpilot result page to fetch.

## `max_pages` (type: `integer`):

Number of result pages to fetch, starting from Start Page.

## `per_page` (type: `integer`):

Company-search results per page.

## `min_rating` (type: `number`):

Optional minimum TrustScore for company search.

## `min_review_count` (type: `integer`):

Optional minimum review count for company search.

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

Optional category search sort order.

## `claimed` (type: `boolean`):

Filter category search results to claimed businesses.

## `limit` (type: `integer`):

Maximum category businesses per page.

## `trustscore` (type: `number`):

Optional minimum TrustScore for category search.

## Actor input object example

```json
{
  "search_type": "company_search",
  "query": "amazon",
  "category": "electronics_technology",
  "locale": "en-US",
  "country": "US",
  "page": 1,
  "max_pages": 1,
  "per_page": 20,
  "limit": 20
}
```

# 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 = {
    "query": "amazon",
    "category": "electronics_technology",
    "country": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("thescrappa/trustpilot-business-search-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 = {
    "query": "amazon",
    "category": "electronics_technology",
    "country": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("thescrappa/trustpilot-business-search-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 '{
  "query": "amazon",
  "category": "electronics_technology",
  "country": "US"
}' |
apify call thescrappa/trustpilot-business-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Business Search Scraper",
        "description": "Search Trustpilot companies by keyword or browse businesses by category. Extract company names, TrustScores, review counts, claimed status, websites, profile URLs, categories, and location fields.",
        "version": "1.0",
        "x-build-id": "ScrfclecE2klhh16v"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thescrappa~trustpilot-business-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thescrappa-trustpilot-business-search-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/thescrappa~trustpilot-business-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-thescrappa-trustpilot-business-search-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/thescrappa~trustpilot-business-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-thescrappa-trustpilot-business-search-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": {
                    "search_type": {
                        "title": "Search Type",
                        "enum": [
                            "company_search",
                            "category"
                        ],
                        "type": "string",
                        "description": "Use company search for name/domain discovery, or category search for Trustpilot category browsing.",
                        "default": "company_search"
                    },
                    "query": {
                        "title": "Company Query",
                        "minLength": 2,
                        "maxLength": 200,
                        "type": "string",
                        "description": "Company, brand, or domain query for Trustpilot company search. Required when Search Type is Company search."
                    },
                    "category": {
                        "title": "Category Slug",
                        "minLength": 2,
                        "maxLength": 120,
                        "type": "string",
                        "description": "Trustpilot category slug, for example electronics_technology or restaurants_bars. Required when Search Type is Category businesses."
                    },
                    "locale": {
                        "title": "Locale",
                        "enum": [
                            "da-DK",
                            "de-AT",
                            "de-CH",
                            "de-DE",
                            "en-AU",
                            "en-CA",
                            "en-GB",
                            "en-IE",
                            "en-NZ",
                            "en-US",
                            "es-ES",
                            "fi-FI",
                            "fr-BE",
                            "nl-BE",
                            "fr-FR",
                            "it-IT",
                            "ja-JP",
                            "nb-NO",
                            "nl-NL",
                            "pl-PL",
                            "pt-BR",
                            "pt-PT",
                            "sv-SE"
                        ],
                        "type": "string",
                        "description": "Trustpilot locale for company search.",
                        "default": "en-US"
                    },
                    "country": {
                        "title": "Country",
                        "minLength": 2,
                        "maxLength": 2,
                        "type": "string",
                        "description": "Optional ISO-2 country filter, for example US, GB, DE, FR, or NL."
                    },
                    "page": {
                        "title": "Start Page",
                        "minimum": 1,
                        "maximum": 999,
                        "type": "integer",
                        "description": "First one-based Trustpilot result page to fetch.",
                        "default": 1
                    },
                    "max_pages": {
                        "title": "Maximum Pages",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of result pages to fetch, starting from Start Page.",
                        "default": 1
                    },
                    "per_page": {
                        "title": "Company Results Per Page",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Company-search results per page.",
                        "default": 20
                    },
                    "min_rating": {
                        "title": "Minimum Rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Optional minimum TrustScore for company search."
                    },
                    "min_review_count": {
                        "title": "Minimum Reviews",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional minimum review count for company search."
                    },
                    "sort": {
                        "title": "Category Sort",
                        "enum": [
                            "reviews_count",
                            "latest_review"
                        ],
                        "type": "string",
                        "description": "Optional category search sort order."
                    },
                    "claimed": {
                        "title": "Claimed Only",
                        "type": "boolean",
                        "description": "Filter category search results to claimed businesses."
                    },
                    "limit": {
                        "title": "Category Results Per Page",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum category businesses per page.",
                        "default": 20
                    },
                    "trustscore": {
                        "title": "Category Minimum TrustScore",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Optional minimum TrustScore for category search."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
