# Trustpilot Bussiness Search Scraper (`alexist/trustpilot-bussiness-search-scraper`) Actor

Scrape business listings from Trustpilot.com search results to extract trust scores, review counts, company profiles, and category data. Perfect for competitive analysis, market research, reputation monitoring, and consumer sentiment analysis across industries.

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

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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.com Business Search Scraper: Extract Consumer Review Intelligence

### Understanding Trustpilot and Its Value for Business Intelligence

Trustpilot operates as one of the world's largest consumer review platforms, hosting over 230 million reviews for businesses across virtually every industry. Unlike niche review sites, Trustpilot provides standardized trust metrics—star ratings, trust scores, and review volumes—that enable direct comparison across competitors, markets, and sectors.

The platform's search functionality aggregates businesses by keywords, locations, and categories, making it a goldmine for market researchers analyzing competitive landscapes, businesses monitoring reputation benchmarks, and investors evaluating customer satisfaction across portfolio companies. Each search result page displays core business metrics: trust scores reflecting overall satisfaction, review counts indicating engagement levels, category classifications showing market positioning, and location data for geographic analysis.

Manually collecting this data across hundreds of businesses means endless clicking, copying, and organizing fragmented information. The Trustpilot Business Search Scraper automates this workflow, converting search pages into structured datasets ready for competitive benchmarking, market entry analysis, or reputation monitoring.

### What This Scraper Extracts and Who Benefits

The Trustpilot Business Search Scraper processes search result pages—the listings displayed after searching for businesses on Trustpilot. Unlike detail page scrapers requiring individual company URLs, this tool efficiently captures multiple businesses from search queries.

**Core Data Fields:**

**Business Unit ID:** Trustpilot's unique identifier for each company. Essential for tracking businesses over time, linking to detailed reviews, and building relational databases.

**Stars:** Visual rating (1-5 stars) representing overall customer satisfaction. The primary metric for quick quality assessment.

**Identifying Name:** Internal business identifier, typically the domain name (e.g., "bankofamerica.com"). Useful for matching with other datasets and verifying company identity.

**Display Name:** Public-facing company name as shown on Trustpilot (e.g., "Bank of America"). Used for reporting, filtering, and customer-facing applications.

**Logo URL:** Direct link to company logo image. Provides branding assets for dashboards, reports, and competitive analysis presentations.

**Number of Reviews:** Total review count indicating engagement level and data reliability. High review counts signal established presence; low counts may indicate new businesses or limited customer feedback.

**Trust Score:** Numerical score (1.0-5.0) calculated from review ratings. More precise than star ratings, enabling statistical analysis and trend tracking.

**Location:** Geographic information (country, region, or city). Critical for local market analysis, regional benchmarking, and understanding geographic reputation variations.

**Recommended in Categories:** Industry classifications assigned by Trustpilot. Shows how businesses position themselves and enables cross-category competitive analysis.

**Contact:** Available contact information (email, phone, website). Facilitates direct outreach for partnerships, sales, or verification.

**Categories:** Primary business categories defining industry classification. Enables filtering, segmentation, and industry-specific trend analysis.

**Target Users:**

**Market Researchers** analyze competitive landscapes across industries using standardized trust metrics. **Businesses** benchmark their reputation against competitors and track market positioning. **Investors** evaluate customer satisfaction across potential investments or portfolio companies. **Marketing Agencies** monitor client reputation and identify improvement opportunities. **Sales Teams** prioritize leads based on reputation gaps or market positioning. **Product Managers** identify pain points through trust score patterns across competitor sets.

### Input Configuration: Building Effective Search Queries

The scraper processes Trustpilot search result URLs—pages displaying business listings after performing searches. Understanding URL structure and parameters ensures targeted data collection.

**Example Input Configuration:**

```json
{
  "proxy": {
    "useApifyProxy": false
  },
  "max_items_per_url": 20,
  "ignore_url_failures": true,
  "urls": [
    "https://www.trustpilot.com/search?query=Bank%20in%20United%20States&experiment=semantic_search_enabled"
  ]
}
````

#### Example Screenshot:

![](https://i.ibb.co/cKRshshc/Screenshot-from-2025-12-09-23-49-30.png)

**Parameter Explanation:**

**proxy configuration:** Set to `false` for standard scraping. Enable (`useApifyProxy: true` with residential proxies) if experiencing blocks or needing to appear as specific geographic users. Trustpilot generally allows scraping without aggressive proxy rotation.

**max\_items\_per\_url:** Controls extraction limit per search page. Set to 20 for standard page results. Increase to 50-100 if search returns more results or you want to capture extended listings. Each Trustpilot search page typically shows 20-24 businesses.

**ignore\_url\_failures:** When `true`, continues processing remaining URLs even if some fail. Essential when scraping multiple searches—one broken URL won't halt the entire run. Set `false` only when every URL must succeed.

**urls array:** Contains Trustpilot search result page URLs. Build these by performing searches on Trustpilot and copying the resulting URLs.

**Building Effective URL Lists:**

1. **Industry Surveys:** Create searches for each industry segment: "Hotels London," "SaaS companies," "Insurance providers UK"
2. **Competitive Sets:** Search specific competitors by name or category to build comparison databases
3. **Geographic Analysis:** Vary location parameters across searches to compare regional markets
4. **Quality Segmentation:** Use star filters to identify high-performers vs. struggling businesses

**Pro Tips:**

- Test searches manually on Trustpilot before scraping to verify relevant results
- For comprehensive industry data, create multiple searches with varied keywords rather than one broad query
- Save successful search URLs in a spreadsheet for reproducible data collection

### Complete Output Structure: Field-by-Field Analysis

The scraper returns JSON data with each business as an object containing multiple fields. Understanding field meanings enables effective analysis.

**Business Unit ID:**

- Format: Alphanumeric string (e.g., "5baa4e2e0000ff00057c46e2")
- Purpose: Unique identifier for tracking businesses across time, building relational databases, constructing detail page URLs (https://www.trustpilot.com/review/\[domain])
- Use cases: Deduplication, longitudinal tracking, linking search data to review details

**Stars:**

- Format: Numeric (1-5, may include decimals like 4.2)
- Purpose: Quick quality indicator, filtering, visual dashboards
- Analysis: Distribution analysis reveals market quality standards, outlier identification

**Identifying Name:**

- Format: Domain name or slug (e.g., "chase.com", "wells-fargo")
- Purpose: Technical identifier, cross-referencing with web analytics, matching with internal databases
- Use cases: Automated lookups, data enrichment from other sources

**Display Name:**

- Format: Human-readable company name (e.g., "Wells Fargo", "Chase Bank")
- Purpose: Reporting, customer-facing displays, presentation materials
- Analysis: Brand name variations across markets, subsidiary identification

**Logo URL:**

- Format: Direct image link (https://cdn.trustpilot.net/brand-assets/\[id]/logo.png)
- Purpose: Visual assets for dashboards, reports, competitor comparison matrices
- Use cases: Automated report generation, brand recognition analysis

**Number of Reviews:**

- Format: Integer (e.g., 15420)
- Purpose: Reliability indicator, engagement metric, market presence signal
- Analysis: Review volume vs. trust score correlation, market saturation assessment, identifying underrepresented businesses

**Trust Score:**

- Format: Decimal (1.0-5.0, e.g., 4.3)
- Purpose: Precise quality metric for statistical analysis, trend tracking, benchmarking
- Analysis: Calculate averages by category/location, identify improvement/decline trends, competitive positioning

**Location:**

- Format: Country, region, or city (e.g., "United States", "London, UK")
- Purpose: Geographic segmentation, regional benchmarking, market entry analysis
- Analysis: Regional reputation differences, location-based competitive landscapes

**Recommended in Categories:**

- Format: Array of category names (e.g., \["Banking", "Financial Services"])
- Purpose: Understanding business positioning, cross-category analysis, market classification
- Analysis: Multi-category businesses (diversified players), category-specific trust patterns

**Contact:**

- Format: Object with email, phone, website fields
- Purpose: Direct outreach, verification, partnership development
- Use cases: Lead generation, fact-checking business information

**Categories:**

- Format: Array of primary categories (e.g., \["Banks", "Credit Unions"])
- Purpose: Industry classification, filtering, competitive set definition
- Analysis: Category-level benchmarking, identifying category leaders/laggards

**Sample Output:**

```json
[
  {
  "business_unit_id": "603936ef6ab2220001c9aae4",
  "stars": 5,
  "identifying_name": "texasbaycu.org",
  "display_name": "Texas Bay Credit Union",
  "logo_url": "//s3-eu-west-1.amazonaws.com/tpd/logos/603936ef6ab2220001c9aae4/0x0.png",
  "number_of_reviews": 2494,
  "trust_score": 4.9,
  "location": {
    "address": "12611 Fuqua Street",
    "city": "Houston",
    "zip_code": "77034",
    "country": "United States"
  },
  "is_recommended_in_categories": false,
  "contact": {
    "website": "https://texasbaycu.org",
    "email": "marketing@tbacu.org",
    "phone": "713.852.6700"
  },
  "categories": [
    {
      "category_id": "credit_union",
      "display_name": "Credit Union",
      "is_predicted": false
    },
    {
      "category_id": "financial_institution",
      "display_name": "Financial Institution",
      "is_predicted": false
    },
    {
      "category_id": "bank",
      "display_name": "Bank",
      "is_predicted": false
    },
    {
      "category_id": "insurance_agency",
      "display_name": "Insurance Agency",
      "is_predicted": false
    },
    {
      "category_id": "mortgage_lender",
      "display_name": "Mortgage Lender",
      "is_predicted": false
    }
  ],
  "from_url": "https://www.trustpilot.com/search?query=Bank%20in%20United%20States&experiment=semantic_search_enabled"
}
]
```

### Step-by-Step Implementation Guide

**1. Define Research Objectives:** Identify what you need—competitive benchmarking (specific competitors), market overview (industry-wide), geographic analysis (location-specific), or quality segmentation (high vs. low performers).

**2. Build Search URLs:** Perform searches on Trustpilot matching your objectives. Copy URLs from browser address bar. Create multiple URLs for comprehensive coverage—vary keywords, locations, and filters.

**3. Configure Input JSON:** Add URLs to configuration. Set `max_items_per_url` based on needs (20 for standard pages, 50+ for extended extraction). Enable `ignore_url_failures` for robustness.

**4. Execute Scraping Run:** Launch through Apify console. Monitor progress. Processing 5-10 search URLs typically completes in 2-4 minutes, depending on result volumes.

**5. Review Data Quality:** Check dataset preview. Verify trust scores, review counts, and categories populate correctly. Identify any missing fields or systematic issues.

**6. Export and Analyze:** Export in preferred format—JSON for databases, CSV for Excel analysis. Filter by trust score, review count, or location for targeted analysis.

**7. Handle Pagination:** Trustpilot search results span multiple pages. To capture beyond first page, modify URLs with `&page=2`, `&page=3`, etc., or increase `max_items_per_url` beyond page limits to trigger automatic pagination.

**Error Troubleshooting:** If URLs fail, verify they're search result pages (contain `/search?query=`). Ensure proper URL encoding. Check that searches return results on Trustpilot directly.

### Strategic Applications for Competitive Intelligence

**Competitive Benchmarking:** Compare your trust score and review volume against direct competitors. Identify performance gaps and market positioning. Track competitor reputation changes over time through periodic scraping.

**Market Entry Analysis:** Before entering new markets, scrape businesses in target categories/locations. Understand average trust scores, review engagement levels, and competitive density. Identify underserved segments with low average scores or few players.

**Investment Due Diligence:** Investors evaluating companies can assess customer satisfaction through trust scores and review analysis. Compare portfolio companies against industry benchmarks. Identify reputation risks before acquisition.

**Category Leadership Identification:** Scrape entire industries to identify category leaders—businesses with high trust scores AND high review counts. Study their positioning, categories, and customer feedback patterns.

**Geographic Reputation Mapping:** Compare location-based trust scores to identify regional reputation variations. Businesses strong in one region but weak in others reveal operational inconsistencies or market-specific challenges.

**Review Volume Analysis:** Low review counts despite market presence indicate limited customer engagement or difficulty generating feedback. High volumes with low scores signal systematic issues. Optimal businesses balance high volume with high scores.

**Multi-Category Strategy Assessment:** Businesses appearing in multiple "recommended categories" demonstrate successful diversification. Analyze whether category expansion correlates with maintained trust scores.

**Sentiment Trend Forecasting:** Scrape same searches monthly/quarterly. Track trust score movements across competitive sets. Declining scores signal emerging issues; improving scores indicate successful turnaround strategies.

### Maximizing Data Value: Advanced Techniques

**Time-Series Analysis:** Schedule weekly/monthly scraping of identical searches. Build historical databases tracking trust score evolution, review volume growth, and competitive position changes.

**Correlation Studies:** Combine Trustpilot data with financial metrics, stock performance, or website traffic. Identify relationships between customer satisfaction and business outcomes.

**Outlier Investigation:** Flag businesses with unusual patterns—high reviews + low scores (systematic problems), low reviews + high scores (new/niche players), significant score changes (investigate causes).

**Category Cross-Analysis:** Compare trust scores across categories. Example: "E-commerce platforms" vs. "E-commerce clothing stores" reveals whether specialization drives higher satisfaction.

**Contact Data Enrichment:** Use extracted contact information to enrich CRM systems, validate business databases, or build outreach lists for partnerships/sales.

**Logo Asset Collection:** Build branded competitor databases using logo URLs for presentations, monitoring dashboards, and competitive intelligence reports.

**Market Saturation Metrics:** Calculate businesses per capita in geographic markets. High saturation with low average scores indicates commoditized markets with differentiation challenges.

**Review Volume Benchmarking:** Establish industry-specific "review volume standards." Businesses below standards despite market maturity may have customer engagement problems or poor review generation strategies.

### Data Governance and Best Practices

**Scraping Frequency:** Balance freshness needs against resource consumption. Weekly scraping for active competitive monitoring, monthly for market trend analysis. Trustpilot data changes gradually—trust scores shift over weeks/months.

**Data Validation:** Implement checks for missing critical fields (business\_unit\_id, trust\_score). Flag unrealistic values (scores outside 1-5 range). Verify location data consistency.

**Privacy Compliance:** Contact information is business data, generally not subject to personal data regulations. However, maintain ethical usage—don't spam businesses extracted from scraping.

**Attribution Practices:** Store source URLs and scrape timestamps. Enables verification, troubleshooting, and understanding data freshness for analysis.

**Duplicate Management:** Same businesses may appear in multiple searches. Use business\_unit\_id for deduplication. Track which searches returned each business for search effectiveness analysis.

**Error Logging:** Monitor failed URLs. Common issues: searches returning no results, URL encoding problems, temporary Trustpilot outages. Retry failed URLs separately.

**Data Refresh Strategy:** Archive historical data when re-scraping. Comparing current vs. historical snapshots reveals reputation trends impossible to detect from single extractions.

### Conclusion

The Trustpilot Business Search Scraper transforms consumer review intelligence into actionable competitive insights. From benchmarking reputation against competitors to identifying market entry opportunities and tracking satisfaction trends, this tool delivers standardized metrics across any industry. Whether conducting market research, monitoring brand reputation, or evaluating investment opportunities, Trustpilot data provides the customer satisfaction intelligence driving strategic decisions. Start extracting review intelligence today.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the bussiness list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.trustpilot.com/search?query=Bank%20in%20United%20States&experiment=semantic_search_enabled"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 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 = {
    "urls": [
        "https://www.trustpilot.com/search?query=Bank%20in%20United%20States&experiment=semantic_search_enabled"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexist/trustpilot-bussiness-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 = {
    "urls": ["https://www.trustpilot.com/search?query=Bank%20in%20United%20States&experiment=semantic_search_enabled"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("alexist/trustpilot-bussiness-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 '{
  "urls": [
    "https://www.trustpilot.com/search?query=Bank%20in%20United%20States&experiment=semantic_search_enabled"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call alexist/trustpilot-bussiness-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Bussiness Search Scraper",
        "description": "Scrape business listings from Trustpilot.com search results to extract trust scores, review counts, company profiles, and category data. Perfect for competitive analysis, market research, reputation monitoring, and consumer sentiment analysis across industries.",
        "version": "0.0",
        "x-build-id": "SIi3sZujs5rAWU34L"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/alexist~trustpilot-bussiness-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-alexist-trustpilot-bussiness-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/alexist~trustpilot-bussiness-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-alexist-trustpilot-bussiness-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/alexist~trustpilot-bussiness-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-alexist-trustpilot-bussiness-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": {
                    "urls": {
                        "title": "URLs of the bussiness list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the bussiness list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```