# Clutch Agencies Scraper — Ratings, Services & Pricing (`khadinakbar/clutch-listings-scraper`) Actor

Scrape public Clutch.co agency directories for B2B leads and vendor research. Get validated agency names, profiles, websites, ratings, review counts, services, locations, pricing, team sizes, verification, sponsorship, and rank. Listing cards only; no full review text. $0.004/agency + usage.

- **URL**: https://apify.com/khadinakbar/clutch-listings-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, MCP servers, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 agency scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Clutch Agencies Scraper — Ratings, Services & Pricing

**Clutch Agencies Scraper** turns public [Clutch.co](https://clutch.co) category, service, and location directories into structured agency data. Give it one or more listing URLs and receive one validated row per agency with the company name, Clutch profile, external website, rating, review count, services, location, price bands, team size, verification state, sponsorship state, and displayed rank. It needs no Clutch login or cookies and works through the Apify Console, API, schedules, integrations, and MCP clients.

Use this Clutch agencies scraper for B2B lead generation, agency market research, procurement, and vendor shortlisting. It is intentionally focused on directory cards: it does not open every company profile or collect full review text. For review bodies and reviewer details, use the linked Clutch Reviews Scraper instead.

### When to use Clutch Agencies Scraper

- Build targeted lists of web development, SEO, digital marketing, design, or IT agencies.
- Compare visible ratings, review counts, project minimums, hourly rates, and team-size bands.
- Shortlist verified providers or remove sponsored placements from market research.
- Collect several Clutch niches in one run while deduplicating repeated profile URLs.
- Feed clean agency rows into enrichment, CRM, procurement, or AI-agent workflows.

### What data can I extract?

| Field | Type | Meaning |
|---|---|---|
| `company_name` | string | Agency name shown on the listing card |
| `profile_url` | string | Canonical public Clutch profile URL |
| `website` | string or null | Resolved external agency website |
| `tagline` | string or null | Short positioning statement |
| `star_rating` | number or null | Visible rating from 0 to 5 |
| `review_count` | integer or null | Visible number of Clutch reviews |
| `min_project_size` | string or null | Displayed minimum project budget |
| `hourly_rate` | string or null | Displayed hourly price band |
| `employees` | string or null | Displayed team-size band |
| `location` | string or null | Primary location on the card |
| `services` | string[] | Deduplicated visible services |
| `is_verified` | boolean | Whether a verified badge was detected |
| `is_sponsored` | boolean | Whether the card is sponsored or featured |
| `result_position` | integer | Position among returned rows |
| `page_number` | integer | Source pagination number |
| `source_url` | string | Exact directory page scraped |
| `scraped_at` | ISO string | UTC extraction timestamp |

Each dataset row is normalized and schema-validated before it is stored. Malformed cards are skipped and reported in `OUTPUT` and `RUN_SUMMARY`; they are never replaced with fabricated placeholder rows.

### How much does scraping Clutch cost?

This actor uses **Pay per event + platform usage**. Both parts are mandatory for every run.

| Event | Price |
|---|---:|
| Actor start | $0.00005 per GB of allocated memory (minimum one) |
| Complete agency row written | $0.004 |

A run returning 50 agencies has $0.20 in agency events. At the default 4 GB, its start event is $0.00020, and Apify platform compute and proxy usage is charged separately. A 250-agency run has $1.00 in agency events plus start and platform usage. `maxResults` caps the number of billable agency rows, and Apify's run-level charge limit can impose a lower cap. Rows rejected by your filters or by output validation are not charged as scraped agencies.

### How to use Clutch Agencies Scraper

1. Open the actor input in Apify Console.
2. Paste one or more public Clutch directory URLs into `searchUrls`, or use `categoryUrl` for one URL.
3. Set `maxResults`; optionally add rating, review, service, location, verified, or sponsored filters.
4. Run the actor and export the default dataset as JSON, CSV, Excel, XML, or through the API.

`searchUrls` takes precedence over `categoryUrl`. Full URLs and paths such as `/it-services` are accepted. If neither field is supplied, the actor uses the digital-marketing agencies directory. Individual `/profile/` pages are outside this actor's scope.

The `location` field adds Clutch's server-side `geolocation` parameter. The other filters are applied to extracted cards and combine with AND logic. `maxPages` limits pagination per starting URL, while `maxResults` limits the total validated agencies across all starting URLs.

#### Example input

```json
{
  "searchUrls": [
    "https://clutch.co/web-developers",
    "https://clutch.co/seo-firms"
  ],
  "maxResults": 50,
  "maxPages": 10,
  "minRating": 4.5,
  "minReviews": 10,
  "excludeSponsored": true
}
````

#### Example output

```json
{
  "company_name": "Example Agency",
  "profile_url": "https://clutch.co/profile/example-agency",
  "website": "https://example.com/",
  "tagline": "Digital products built for growth.",
  "star_rating": 4.8,
  "review_count": 42,
  "min_project_size": "$10,000+",
  "hourly_rate": "$100 - $149 / hr",
  "employees": "50 - 249",
  "location": "New York, NY",
  "services": ["Web Development", "Mobile App Development"],
  "is_verified": true,
  "is_sponsored": false,
  "result_position": 1,
  "page_number": 1,
  "source_url": "https://clutch.co/web-developers",
  "scraped_at": "2026-07-15T00:00:00.000Z"
}
```

### Run with the Apify API

JavaScript:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/clutch-listings-scraper').call({
  searchUrls: ['https://clutch.co/web-developers'],
  maxResults: 30,
  minRating: 4.5,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems({ clean: true });
console.log(items);
```

Python:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("khadinakbar/clutch-listings-scraper").call(run_input={
    "searchUrls": ["https://clutch.co/it-services"],
    "maxResults": 25,
    "verifiedOnly": True,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["company_name"], item["star_rating"])
```

For automation, inspect the `OUTPUT` key for the stable outcome (`COMPLETE`, `PARTIAL`, `VALID_EMPTY`, `INVALID_INPUT`, `UPSTREAM_FAILED`, or `CONFIG_ERROR`). `RUN_SUMMARY` adds page counts, errors, warnings, charge counts, storage IDs, and the stop reason.

### Other dedicated scrapers

- [Clutch Scraper](https://apify.com/khadinakbar/clutch-scraper) — a broader Clutch data workflow.
- [Clutch Reviews Scraper](https://apify.com/khadinakbar/clutch-reviews-scraper) — collect full public review data from profile pages.
- [B2B Lead Finder + Enrichment](https://apify.com/khadinakbar/b2b-lead-finder-enrichment) — enrich company research with contact data.
- [Bulk Website Contact Extractor](https://apify.com/khadinakbar/bulk-website-contact-extractor) — find public emails, phones, and social links from returned websites.
- [Google Maps Leads Scraper](https://apify.com/khadinakbar/google-maps-leads-scraper) — build local-business lead lists with contacts.
- [Google Maps Email Extractor](https://apify.com/khadinakbar/google-maps-email-extractor) — discover public email addresses for map listings.
- [B2B Lead Finder](https://apify.com/khadinakbar/universal-lead-finder) — search for companies, emails, phones, and contacts.
- [LinkedIn Company Search Scraper](https://apify.com/khadinakbar/linkedin-company-search-scraper) — find companies through public LinkedIn search results.
- [Dun & Bradstreet Companies Scraper](https://apify.com/khadinakbar/dnb-companies-scraper) — collect public business-directory company data.
- [SEO Domain & Keyword Scraper](https://apify.com/khadinakbar/seo-domain-keyword-scraper) — add domain and search-market intelligence.

### FAQ

#### How many results can I scrape with Clutch Agencies Scraper?

You can request from 1 to 5,000 agencies per run. Actual availability depends on the supplied directories, filters, `maxPages`, the run timeout, Clutch availability, and any lower Apify charge limit. Start with 20–50 rows when testing a new category.

#### Can I integrate Clutch Agencies Scraper with other apps?

Yes. Use Apify integrations, webhooks, schedules, Zapier, Make, or your own code. The default dataset is available in common export formats, and the explicit output records make downstream branching straightforward.

#### Can I use Clutch Agencies Scraper with the Apify API?

Yes. Call `khadinakbar/clutch-listings-scraper` with the JavaScript or Python client, REST API, or CLI. The examples above show the actor call and dataset retrieval flow.

#### Can I use Clutch Agencies Scraper through an MCP Server?

Yes. The input and output surfaces are MCP-ready, so an MCP client can find the actor, submit a bounded run, retrieve agency rows, and inspect the run outcome. Use `maxResults` to keep agent-initiated calls predictable.

#### Do I need proxies to scrape Clutch?

No proxy input is required. The actor automatically rotates managed residential proxy sessions because Clutch currently blocks datacenter egress; proxy traffic is included in the separately billed platform usage. Browser-grade HTTP/TLS fingerprints and bounded retries handle transient challenges, and the actor reports an upstream failure if every route fails.

#### Is it legal to scrape Clutch data?

This actor collects publicly available business listing information and does not access login-gated or private data. You are responsible for following Clutch's terms, applicable laws, data-protection rules, and outreach requirements. Collect only what you need, use it for a legitimate purpose, and honor deletion or opt-out obligations that apply to your workflow.

### Your feedback

If a Clutch layout, category, or edge case produces incomplete rows, open an issue from the actor page with the run ID and a non-sensitive example URL. That evidence helps keep selectors, schemas, and troubleshooting guidance current.

# Actor input Schema

## `searchUrls` (type: `array`):

Use this when you want to scrape one or several Clutch category, service, or location directory pages in the same run. Supply public listing pages rather than individual /profile/ pages. This list takes precedence over One agency directory URL. Leave the list empty to use that single-URL field or the built-in digital-marketing fallback.

## `categoryUrl` (type: `string`):

Use this when you have one Clutch listing page and prefer a simple URL field. A full URL or path such as /it-services works. It is ignored whenever Agency directory URLs contains at least one entry. Omit both URL fields to use the built-in digital-marketing agencies directory.

## `location` (type: `string`):

Use this when Clutch should narrow every supplied directory URL server-side. The value is added through Clutch's geolocation query parameter. Values such as United States or London are useful starting points. Leave it empty for the directory's default geography.

## `maxResults` (type: `integer`):

Use this to cap both returned agencies and scraped-listing event charges. The crawler stops after this many validated rows. A lower Apify run charge limit always takes precedence. Start with 20 to 50 agencies when testing a new directory.

## `maxPages` (type: `integer`):

Use this to put a hard pagination boundary on each supplied directory URL. The limit applies independently to every starting URL. Lower it for quick samples. Raise it when a narrow client-side filter needs more source pages.

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

Use this when you only want agencies whose listing card has at least this Clutch star rating. Values from zero through five are accepted. Agencies without a visible rating are excluded when this filter is set. Leave the field unset to keep rated and unrated agencies.

## `minReviews` (type: `integer`):

Use this when an agency must have at least a specific number of visible Clutch reviews. Zero and positive integers are accepted. Agencies without a visible review count are excluded when this filter is set. Leave the field unset to keep agencies regardless of review count.

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

Use this when your shortlist should contain only listing cards where a Clutch verification badge is visible. Verification is detected from the directory card rather than inferred from other fields. Keep it off to include verified and unverified agencies. Combine it with other filters to make a stricter shortlist.

## `excludeSponsored` (type: `boolean`):

Use this when you want an organic agency shortlist without sponsored or featured listing cards. Sponsored status is detected from the card and its tracked links. Keep it off when paid placements should remain in their displayed order. The output always includes is\_sponsored for independent auditing.

## `serviceKeyword` (type: `string`):

Use this when at least one service shown on the listing card must contain a phrase such as mobile app or SEO. Matching is case-insensitive and uses substring logic. This filters collected cards; it is not a Clutch search query. Leave it empty to accept every visible service mix.

## `locationKeyword` (type: `string`):

Use this when the location displayed on each agency card must contain a phrase such as New York or India. Matching is case-insensitive and uses substring logic. This filter runs after the cards are collected. For Clutch's server-side geography, use Clutch geolocation instead.

## `maxConcurrency` (type: `integer`):

Use this advanced control to set how many Clutch directory requests run in parallel. Two is the reliability-oriented default. Higher values may finish faster but can trigger stricter rate limiting. Keep the default unless runtime matters more than conservative request pacing.

## Actor input object example

```json
{
  "searchUrls": [
    "https://clutch.co/web-developers",
    "https://clutch.co/agencies/seo"
  ],
  "categoryUrl": "https://clutch.co/agencies/digital-marketing",
  "location": "United States",
  "maxResults": 50,
  "maxPages": 10,
  "minRating": 4.5,
  "minReviews": 10,
  "verifiedOnly": true,
  "excludeSponsored": true,
  "serviceKeyword": "mobile app",
  "locationKeyword": "New York",
  "maxConcurrency": 2
}
```

# Actor output Schema

## `results` (type: `string`):

One validated dataset row per collected agency listing card.

## `output` (type: `string`):

Stable outcome and count record for automations and MCP clients.

## `runSummary` (type: `string`):

Page-level diagnostics, timestamps, stop reason, warnings, and errors.

# 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 = {
    "searchUrls": [
        "https://clutch.co/agencies/digital-marketing"
    ],
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/clutch-listings-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 = {
    "searchUrls": ["https://clutch.co/agencies/digital-marketing"],
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/clutch-listings-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 '{
  "searchUrls": [
    "https://clutch.co/agencies/digital-marketing"
  ],
  "maxResults": 50
}' |
apify call khadinakbar/clutch-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Clutch Agencies Scraper — Ratings, Services & Pricing",
        "description": "Scrape public Clutch.co agency directories for B2B leads and vendor research. Get validated agency names, profiles, websites, ratings, review counts, services, locations, pricing, team sizes, verification, sponsorship, and rank. Listing cards only; no full review text. $0.004/agency + usage.",
        "version": "1.0",
        "x-build-id": "OM3t1SFvby5GaFx2w"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~clutch-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-clutch-listings-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/khadinakbar~clutch-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-clutch-listings-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/khadinakbar~clutch-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-clutch-listings-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": {
                    "searchUrls": {
                        "title": "Agency directory URLs",
                        "type": "array",
                        "description": "Use this when you want to scrape one or several Clutch category, service, or location directory pages in the same run. Supply public listing pages rather than individual /profile/ pages. This list takes precedence over One agency directory URL. Leave the list empty to use that single-URL field or the built-in digital-marketing fallback.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "categoryUrl": {
                        "title": "One agency directory URL",
                        "type": "string",
                        "description": "Use this when you have one Clutch listing page and prefer a simple URL field. A full URL or path such as /it-services works. It is ignored whenever Agency directory URLs contains at least one entry. Omit both URL fields to use the built-in digital-marketing agencies directory."
                    },
                    "location": {
                        "title": "Clutch geolocation",
                        "type": "string",
                        "description": "Use this when Clutch should narrow every supplied directory URL server-side. The value is added through Clutch's geolocation query parameter. Values such as United States or London are useful starting points. Leave it empty for the directory's default geography.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Maximum agencies",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Use this to cap both returned agencies and scraped-listing event charges. The crawler stops after this many validated rows. A lower Apify run charge limit always takes precedence. Start with 20 to 50 agencies when testing a new directory.",
                        "default": 50
                    },
                    "maxPages": {
                        "title": "Maximum pages per URL",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Use this to put a hard pagination boundary on each supplied directory URL. The limit applies independently to every starting URL. Lower it for quick samples. Raise it when a narrow client-side filter needs more source pages.",
                        "default": 20
                    },
                    "minRating": {
                        "title": "Minimum agency rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Use this when you only want agencies whose listing card has at least this Clutch star rating. Values from zero through five are accepted. Agencies without a visible rating are excluded when this filter is set. Leave the field unset to keep rated and unrated agencies."
                    },
                    "minReviews": {
                        "title": "Minimum agency reviews",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Use this when an agency must have at least a specific number of visible Clutch reviews. Zero and positive integers are accepted. Agencies without a visible review count are excluded when this filter is set. Leave the field unset to keep agencies regardless of review count."
                    },
                    "verifiedOnly": {
                        "title": "Require verified badge",
                        "type": "boolean",
                        "description": "Use this when your shortlist should contain only listing cards where a Clutch verification badge is visible. Verification is detected from the directory card rather than inferred from other fields. Keep it off to include verified and unverified agencies. Combine it with other filters to make a stricter shortlist.",
                        "default": false
                    },
                    "excludeSponsored": {
                        "title": "Remove sponsored agencies",
                        "type": "boolean",
                        "description": "Use this when you want an organic agency shortlist without sponsored or featured listing cards. Sponsored status is detected from the card and its tracked links. Keep it off when paid placements should remain in their displayed order. The output always includes is_sponsored for independent auditing.",
                        "default": false
                    },
                    "serviceKeyword": {
                        "title": "Required service keyword",
                        "type": "string",
                        "description": "Use this when at least one service shown on the listing card must contain a phrase such as mobile app or SEO. Matching is case-insensitive and uses substring logic. This filters collected cards; it is not a Clutch search query. Leave it empty to accept every visible service mix.",
                        "default": ""
                    },
                    "locationKeyword": {
                        "title": "Required location keyword",
                        "type": "string",
                        "description": "Use this when the location displayed on each agency card must contain a phrase such as New York or India. Matching is case-insensitive and uses substring logic. This filter runs after the cards are collected. For Clutch's server-side geography, use Clutch geolocation instead.",
                        "default": ""
                    },
                    "maxConcurrency": {
                        "title": "Parallel directory requests",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Use this advanced control to set how many Clutch directory requests run in parallel. Two is the reliability-oriented default. Higher values may finish faster but can trigger stricter rate limiting. Keep the default unless runtime matters more than conservative request pacing.",
                        "default": 2
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
