# Clutch Reviews Scraper (`automation-lab/clutch-reviews-scraper`) Actor

Extract individual Clutch.co reviews with ratings, client context, project details, summaries, and full interview answers. Export to JSON, CSV, Excel, or API.

- **URL**: https://apify.com/automation-lab/clutch-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Marketing, Lead generation
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## Clutch Reviews Scraper

Extract **individual Clutch.co reviews** from public provider profiles.

Turn detailed client interviews into structured rows for procurement, competitor research, reputation monitoring, and voice-of-customer analysis.

Each result includes ratings, project context, reviewer details, summaries, and the full background, challenge, solution, and results sections.

No Clutch login or API key is required.

- ✅ One row per client review
- ✅ Multiple provider profiles per run
- ✅ Automatic review pagination
- ✅ Verified-review and rating filters
- ✅ JSON, CSV, Excel, XML, API, and webhook delivery

### What does Clutch Reviews Scraper do?

Clutch Reviews Scraper visits public [Clutch provider profiles](https://clutch.co/) and extracts the individual reviews shown in the Reviews section.

It captures more than a testimonial quote.

You receive the project scope, budget, timeline, reviewer context, detailed rating dimensions, project summary, results summary, and complete interview answers when Clutch publishes them.

Use it when provider-level fields are not enough and the **review itself** is the record you need.

For company listing discovery, use [Clutch Scraper](https://apify.com/automation-lab/clutch-scraper) instead.

### Who is Clutch Reviews Scraper for?

**Procurement and vendor-management teams**

- Compare verified client evidence before creating a shortlist.
- Inspect recurring strengths, risks, budgets, and delivery patterns.
- Preserve review evidence in an auditable spreadsheet or warehouse.

**Agencies and competitive-intelligence teams**

- Monitor competitors for newly published client reviews.
- Analyze which services, industries, and project sizes competitors win.
- Find themes in client praise and areas for improvement.

**Reputation and customer-success teams**

- Track a provider's public feedback over time.
- Send new review records to Slack, email, or a CRM.
- Build dashboards for rating dimensions and review volume.

**Voice-of-customer and market researchers**

- Collect detailed buyer language from project interviews.
- Compare outcomes across industries and provider categories.
- Prepare text for qualitative coding or AI-assisted analysis.

### Why use this Clutch review extractor?

- 🎯 **Review-level output** — one clean dataset row per individual review.
- 🧾 **Detailed evidence** — project summaries and interview sections are included.
- ⭐ **Typed ratings** — overall, quality, schedule, cost, and referral scores are numbers.
- 🏢 **Provider context** — provider name, profile URL, aggregate rating, and review count travel with every row.
- 🔎 **Useful filters** — select verified reviews or a minimum overall rating.
- 🔁 **Automatic pagination** — collect more than the first page.
- 🧩 **Flat exports** — analysis-friendly columns work in CSV and Excel.
- 🛡️ **Explicit failures** — blocked or empty pages do not silently produce misleading success.
- ⏰ **Scheduling** — rerun profiles daily, weekly, or monthly.
- 🔌 **Integrations** — connect through API, webhooks, Make, Zapier, Google Sheets, or MCP.

### What Clutch review data can you extract?

| Category | Fields |
|---|---|
| Provider | Name, profile URL, aggregate rating, aggregate review count |
| Review identity | Review ID, permalink, title, featured flag, publication date |
| Project | Services, budget, timeline, project summary, results summary |
| Ratings | Overall, quality, schedule, cost, willingness to refer |
| Reviewer | Name, role, company, original position, verification status |
| Client context | Industry, location, company size, review type |
| Interview | Background, challenge, solution, results and feedback |
| Metadata | Extraction timestamp |

Clutch does not publish every optional field on every review.

Missing source values are returned as `null`, while services are returned as an array.

### How much does it cost to scrape Clutch reviews?

The Actor uses pay-per-event pricing.

You pay a small run-start fee plus a fee for each review saved.

| Event | Price |
|---|---:|
| Run started | $0.005 per run |
| Review extracted | $0.0028026–$0.011511 per review, depending on Apify plan |

Examples at the current FREE-tier rate:

- 10 reviews: about **$0.24**
- 50 reviews: about **$1.16**
- 100 reviews: about **$2.31**

Apify's Free plan includes monthly platform credits, so you can test a small profile before scheduling a larger workflow.

Actual total usage can vary with target protection and retries.

### How to scrape reviews from Clutch.co

1. Open **Clutch Reviews Scraper** on Apify.
2. Click **Try for free**.
3. Add one or more public provider profile URLs.
4. Set the maximum number of reviews.
5. Optionally enable verified-only results or a minimum rating.
6. Click **Start**.
7. Preview the dataset while the Actor runs.
8. Export results as JSON, CSV, Excel, or XML.
9. Save the task and add a schedule if you want ongoing monitoring.

A valid profile URL looks like:

```text
https://clutch.co/profile/smartsites
````

Directory URLs and non-Clutch URLs are rejected.

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---:|---|
| `startUrls` | array | required | Public Clutch provider profile URLs |
| `maxReviews` | integer | `20` | Global maximum number of matching reviews |
| `verifiedOnly` | boolean | `false` | Include only reviews with Clutch's verified badge |
| `minRating` | number | `0` | Minimum overall rating; `0` disables this filter |
| `maxPagesPerProfile` | integer | `20` | Pagination safety limit for each profile |

**Small monitoring run**

```json
{
  "startUrls": [{ "url": "https://clutch.co/profile/smartsites" }],
  "maxReviews": 10,
  "verifiedOnly": false,
  "minRating": 0,
  "maxPagesPerProfile": 2
}
```

**Verified-review research**

```json
{
  "startUrls": [
    { "url": "https://clutch.co/profile/smartsites" },
    { "url": "https://clutch.co/profile/req" }
  ],
  "maxReviews": 100,
  "verifiedOnly": true,
  "minRating": 4,
  "maxPagesPerProfile": 10
}
```

### Output example

Each dataset item is one review:

```json
{
  "providerName": "SmartSites",
  "providerUrl": "https://clutch.co/profile/smartsites",
  "providerOverallRating": 4.9,
  "providerReviewCount": 362,
  "reviewId": "320820",
  "reviewUrl": "https://clutch.co/go-to-review/.../320820",
  "title": "SEO & Web Dev for Hospitality & Architectural Design Firm",
  "isFeatured": true,
  "services": ["Advertising", "Content Marketing", "Search Engine Optimization"],
  "projectBudget": "$10,000 to $49,999",
  "projectTimeline": "June 2024 - Ongoing",
  "overallRating": 5,
  "qualityRating": 5,
  "scheduleRating": 5,
  "costRating": 5,
  "willingnessToReferRating": 5,
  "quote": "They're extremely knowledgeable in what they do.",
  "reviewDate": "Oct 8, 2024",
  "reviewerName": "Anonymous",
  "reviewerRole": "Manager",
  "reviewerCompany": "Nunzio Marc DeSantis Architects",
  "reviewerVerified": true,
  "reviewerIndustry": "Other industries",
  "reviewerLocation": "Dallas, Texas",
  "reviewerCompanySize": "11-50 Employees",
  "reviewType": "Online Review",
  "projectSummary": "SmartSites provides SEO and web development services...",
  "resultsSummary": "SmartSites swiftly delivers monthly reports...",
  "background": "Please describe your company and position...",
  "challenge": "What specific goals or objectives...",
  "solution": "How did you find SmartSites...",
  "resultsAndFeedback": "What were the measurable outcomes...",
  "scrapedAt": "2026-07-21T00:00:00.000Z"
}
```

Rating values are numbers from 0 to 5.

Dates and project timelines remain in Clutch's displayed text format.

### Tips for reliable Clutch review extraction

- Start with 10 reviews to validate your profile URL and output.
- Use `verifiedOnly` when evidence quality matters more than volume.
- Keep `minRating` at 0 for unbiased reputation analysis.
- Use a rating threshold only for a clearly defined shortlist workflow.
- Increase `maxPagesPerProfile` when collecting deep review history.
- Schedule smaller incremental runs for monitoring instead of repeatedly downloading all history.
- Deduplicate downstream records with `providerUrl + reviewId`.
- Treat optional nulls as missing source data, not scraper errors.
- Retry later if Clutch temporarily challenges every available proxy session.

### Monitor new Clutch reviews on a schedule

Create an Apify task with the provider URLs you want to follow.

Run it daily or weekly with an Apify schedule.

Use `reviewId` as your stable key in a database, sheet, or automation.

A downstream workflow can compare the latest dataset with stored IDs and alert only on unseen reviews.

This pattern supports agency reputation monitoring, competitor launches, procurement refreshes, and client-sentiment dashboards.

### Integrations for procurement and reputation workflows

**Clutch Reviews Scraper → Google Sheets**

Append verified client reviews to a sourcing workbook and filter by service, industry, budget, or rating.

**Clutch Reviews Scraper → Slack or Discord**

Send an alert when a monitored competitor receives a new review or a rating below a chosen threshold.

**Clutch Reviews Scraper → Make or Zapier**

Trigger sentiment classification, CRM enrichment, or vendor-risk review whenever a new dataset item appears.

**Clutch Reviews Scraper → Airtable or a data warehouse**

Maintain a longitudinal review table keyed by provider URL and review ID.

**Clutch Reviews Scraper → AI analysis**

Summarize challenge, solution, and result language across providers without manually copying review pages.

### Use the Apify API

The Actor ID is `automation-lab/clutch-reviews-scraper`.

**Node.js**

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/clutch-reviews-scraper').call({
  startUrls: [{ url: 'https://clutch.co/profile/smartsites' }],
  maxReviews: 10,
  verifiedOnly: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/clutch-reviews-scraper").call(run_input={
    "startUrls": [{"url": "https://clutch.co/profile/smartsites"}],
    "maxReviews": 10,
    "verifiedOnly": True,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

**cURL**

```bash
curl "https://api.apify.com/v2/acts/automation-lab~clutch-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://clutch.co/profile/smartsites"}],
    "maxReviews": 10,
    "verifiedOnly": true
  }'
```

### Use Clutch Reviews Scraper with AI agents via MCP

Connect Claude Code, Claude Desktop, Cursor, or VS Code through Apify's hosted [Model Context Protocol](https://docs.apify.com/platform/integrations/mcp) server.

**Claude Code**

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/clutch-reviews-scraper"
```

**Claude Desktop, Cursor, or VS Code**

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/clutch-reviews-scraper"
    }
  }
}
```

Authenticate with your Apify account when prompted.

Example prompts:

- "Use automation-lab/clutch-reviews-scraper to collect the latest 20 verified SmartSites reviews."
- "Extract Clutch reviews for these three agencies and compare quality, schedule, and cost ratings."
- "Monitor these Clutch provider profiles and summarize recurring client challenges and outcomes."

### Is it legal to scrape Clutch reviews?

Public web data can generally be collected for legitimate purposes, but laws and contractual restrictions vary by jurisdiction and use case.

Only collect public information you are authorized to process.

Do not use the Actor to access private accounts, bypass access controls, harass reviewers, or build discriminatory profiles.

Review Clutch's terms and applicable privacy, copyright, database, and data-protection rules.

If personal data is not necessary for your purpose, minimize, aggregate, or delete it.

This documentation is not legal advice.

### Limitations

- Clutch can change its HTML structure or anti-bot controls.
- Residential proxy sessions may occasionally be challenged and retried.
- A run fails when no usable review page can be extracted; it does not return challenge HTML as data.
- Some reviews omit reviewer names, budgets, locations, or interview sections.
- `reviewerRole` and `reviewerCompany` are split from the displayed position when a comma is present.
- The Actor accepts provider profile URLs, not directory, search, blog, or review-submission URLs.
- The source controls ordering, featured reviews, and displayed text.
- Pagination stops at your result or page limit.

### Troubleshooting

**Why did the run reject my URL?**

Use a public URL in the form `https://clutch.co/profile/provider-slug`.

Directory and non-Clutch URLs are outside this Actor's review-level scope.

**Why did the run fail after proxy retries?**

Clutch may temporarily challenge all browser sessions.

Retry later with the same small input; do not interpret an empty dataset as proof that the provider has no reviews.

**Why are some fields null?**

Clutch does not publish every optional field for every review.

The Actor preserves missing values rather than inventing data.

**Why did a rating filter return no rows?**

The filter fails closed: reviews with missing ratings do not pass an active minimum-rating threshold.

Lower `minRating` or use 0 to include all ratings.

### Frequently asked questions

**How fast is the Clutch reviews scraper?**

A single review page usually completes in seconds after a working residential session is established, but Cloudflare retries can add time.

**Can it scrape every review on a profile?**

Yes, within your `maxReviews` and `maxPagesPerProfile` limits and while the public pages remain available.

**Does it need my Clutch login?**

No. It extracts only anonymously visible public provider reviews.

**Does it return verified reviews only?**

It can. Enable `verifiedOnly`, or leave it disabled to collect all public review cards.

**How is this different from Clutch Scraper?**

Clutch Reviews Scraper emits individual review rows. [Clutch Scraper](https://apify.com/automation-lab/clutch-scraper) emits provider/company listing rows.

**Can I use the output for sentiment analysis?**

Yes. The quote, summaries, and interview sections provide useful text, subject to your legal basis and data-minimization obligations.

**Can I export to Excel?**

Yes. Open the default dataset and choose Excel, CSV, JSON, or XML.

**Can I run it automatically?**

Yes. Save the input as a task, attach an Apify schedule, and send results through integrations or webhooks.

### Related B2B and review scrapers

- [Clutch Scraper](https://apify.com/automation-lab/clutch-scraper) — collect provider listings and aggregate company fields.
- [G2 Reviews Scraper](https://apify.com/automation-lab/g2-reviews-scraper) — extract individual software-product reviews.
- [G2 Products Scraper](https://apify.com/automation-lab/g2-products-scraper) — discover software products and aggregate rating context.
- [Trustpilot Scraper](https://apify.com/automation-lab/trustpilot-scraper) — collect public business reviews.
- [Google Maps Reviews Scraper](https://apify.com/automation-lab/google-maps-reviews-scraper) — gather local-business reviews.
- [GoodFirms Scraper](https://apify.com/automation-lab/goodfirms-scraper) — research B2B service providers.

Use review actors for record-level feedback and provider actors for discovery or lead lists.

### Data freshness and responsible monitoring

Every output row includes `scrapedAt` so you can track when the source was observed.

Clutch controls publication dates, edits, removals, featured placement, and profile-level aggregates.

For recurring monitoring, store prior review IDs and compare them with each new run.

Avoid unnecessary high-frequency schedules.

Daily or weekly collection is usually more useful and cost-efficient than repeatedly downloading the same history.

# Actor input Schema

## `startUrls` (type: `array`):

Add one or more public Clutch provider profile URLs, for example https://clutch.co/profile/smartsites.

## `maxReviews` (type: `integer`):

Stop after saving this many matching reviews across all provider profiles.

## `verifiedOnly` (type: `boolean`):

When enabled, save only reviews that display Clutch's verified reviewer badge.

## `minRating` (type: `number`):

Save only reviews at or above this rating. Use 0 to include every rating.

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

Safety limit for pagination on each provider profile. Each Clutch page normally contains about 10 reviews.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://clutch.co/profile/smartsites"
    }
  ],
  "maxReviews": 10,
  "verifiedOnly": false,
  "minRating": 0,
  "maxPagesPerProfile": 2
}
```

# Actor output Schema

## `reviews` (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 = {
    "startUrls": [
        {
            "url": "https://clutch.co/profile/smartsites"
        }
    ],
    "maxReviews": 10,
    "verifiedOnly": false,
    "minRating": 0,
    "maxPagesPerProfile": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/clutch-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 = {
    "startUrls": [{ "url": "https://clutch.co/profile/smartsites" }],
    "maxReviews": 10,
    "verifiedOnly": False,
    "minRating": 0,
    "maxPagesPerProfile": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/clutch-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 '{
  "startUrls": [
    {
      "url": "https://clutch.co/profile/smartsites"
    }
  ],
  "maxReviews": 10,
  "verifiedOnly": false,
  "minRating": 0,
  "maxPagesPerProfile": 2
}' |
apify call automation-lab/clutch-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Clutch Reviews Scraper",
        "description": "Extract individual Clutch.co reviews with ratings, client context, project details, summaries, and full interview answers. Export to JSON, CSV, Excel, or API.",
        "version": "0.1",
        "x-build-id": "g9DICobTqv7ccpCA1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~clutch-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-clutch-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/automation-lab~clutch-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-clutch-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/automation-lab~clutch-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-clutch-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🏢 Clutch provider profile URLs",
                        "type": "array",
                        "description": "Add one or more public Clutch provider profile URLs, for example https://clutch.co/profile/smartsites.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxReviews": {
                        "title": "Maximum reviews",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many matching reviews across all provider profiles.",
                        "default": 20
                    },
                    "verifiedOnly": {
                        "title": "Verified reviews only",
                        "type": "boolean",
                        "description": "When enabled, save only reviews that display Clutch's verified reviewer badge.",
                        "default": false
                    },
                    "minRating": {
                        "title": "Minimum overall rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Save only reviews at or above this rating. Use 0 to include every rating.",
                        "default": 0
                    },
                    "maxPagesPerProfile": {
                        "title": "Maximum pages per profile",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety limit for pagination on each provider profile. Each Clutch page normally contains about 10 reviews.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```