# Clutch Scraper - Companies, Ratings, Reviews & Pricing (`abotapi/clutch-directory-scraper`) Actor

Scrape Clutch company directories and profiles. Get names, ratings, review counts, hourly rate, min project size, employees, location, services, full reviews with reviewer details and per-criterion scores. Search and URL mode, 40+ fields per company.

- **URL**: https://apify.com/abotapi/clutch-directory-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 6 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 company results

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/actors/running/actors-in-store.md#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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Scraper: Companies, Ratings, Reviews & Pricing

Extract structured company data from Clutch in minutes. This scraper covers any Clutch directory, from web developers and SEO firms to marketing agencies and app developers, and returns 40+ fields per company: ratings, review counts, hourly rate, minimum project size, employee range, location, services, and the full review list with reviewer details and per-criterion scores. It supports both filter search and pasted URLs, and runs on every Apify plan with the default settings.

### Why this scraper?

- Any Clutch directory in one actor: pass any directory slug (web-developers, seo-firms, digital-marketing-agencies, app-developers, ecommerce, and more).
- 40+ fields per company, including rating, review count, hourly rate, minimum project size, employee range, location, services breakdown, founding year, and full contact details.
- Deep reviews: each review carries the quote, date, per-criterion scores (Quality, Schedule, Cost, Willing to Refer), the reviewer's role, industry, location and company size, project size and length, and the full background, objective, solution and results write-up.
- Two ways to start: pick filters (directory, location, company size, service line, sort) or paste any Clutch directory URL. Minimum rating and minimum reviews narrow the results either way, since they're applied after fetching.
- Cost-efficient: keeps per-record cost low.
- Results are de-duplicated by company ID, so you never get the same company twice.
- **Walks the whole catalogue by default.** `maxPages` defaults to `0` (unlimited) — the run walks every result page per directory/URL, stopping on its own when the site runs out of results or a page repeats companies already seen this walk. There is no artificial page-number ceiling; the only cap you need is `maxListings`.
- **`maxListings` is the sole cap on volume** (default `20`, so a first run is small and fast; set `0` for unlimited).
- **Resumable runs.** Set `resumeFromRunId` to a previous run or dataset id to collect only the companies that run doesn't already have (a delta) — combine both datasets for the full set. Long unlimited runs also checkpoint their progress to the key-value store, so an Apify platform migration or a Resurrect of a failed run picks up where it left off instead of starting over.
- **Incremental & dedup mode for recurring monitoring.** Turn on `incrementalMode` to schedule this actor daily/weekly against the same search: it remembers the previous run's companies itself and returns only what changed (`changeType`: NEW / UPDATED / UNCHANGED / REAPPEARED / EXPIRED), instead of the full result set every time. Off by default — every run behaves exactly as before.

### Data you get

> Sample shape: values are illustrative placeholders, not from a live company.

| Field | Example |
| --- | --- |
| `id` | `00000` |
| `name` | `Sample Agency LLC` |
| `clutchUrl` | `https://clutch.co/profile/sample-agency` |
| `website` | `https://example.com` |
| `rating` | `4.8` |
| `reviewCount` | `42` |
| `minProjectSize` | `$25,000+` |
| `hourlyRate` | `$100 - $149 / hr` |
| `employeeCount` | `50 - 249` |
| `location` | `New York, NY` |
| `verified` | `true` |
| `services` | `["45% Web Development", "45% Web Design", "10% Branding"]` |
| `description` | `Sample Agency builds websites and digital products for mid-market clients.` |
| `yearFounded` | `2010` |
| `contact.address` | `{ "street": "1 Example St", "city": "New York", "region": "NY", "postal_code": "10000", "country": "US" }` |
| `contactDetails` | `{ "emails": ["hello@example.com"], "phone_numbers": ["1-000-000-0000"], "social_media": ["https://www.linkedin.com/company/example"] }` |
| `detailedRatings` | `{ "Quality": 4.8, "Schedule": 4.7, "Cost": 4.8, "Willing to Refer": 4.9 }` |
| `insights` | `{ "industries": { "industries": ["eCommerce", "Financial services"] }, "service_line_reviews": [ ... ] }` |
| `reviews` | `[{ "quote": "Great team to work with.", "rating": 5.0, "reviewer": { ... }, "projectSize": "$10,000 to $49,999" }]` |
| `sourceUrl` | `https://clutch.co/web-developers` |

### How to use

Basic search (web developers worldwide):

```json
{
  "mode": "search",
  "directory": "web-developers",
  "maxPages": 5,
  "maxListings": 100,
  "proxy": { "useApifyProxy": true }
}
```

SEO firms in a location, with full profile details:

```json
{
  "mode": "search",
  "directory": "seo-firms",
  "location": "united-states",
  "fetchDetails": true,
  "maxPages": 3,
  "proxy": { "useApifyProxy": true }
}
```

Web developers filtered by company size, service line, sort, rating and reviews:

```json
{
  "mode": "search",
  "directory": "web-developers",
  "agencySize": "50_-_249",
  "relatedServices": "field_pp_sl_ecommerce",
  "sortBy": "review_rating",
  "minRating": 4,
  "minReviews": 5,
  "maxListings": 200,
  "proxy": { "useApifyProxy": true }
}
```

URL mode (paste any Clutch directory links). `minRating`/`minReviews` still apply here, since they narrow the fetched results rather than build the URL:

```json
{
  "mode": "url",
  "urls": [
    "https://clutch.co/web-developers",
    "https://clutch.co/digital-marketing-agencies"
  ],
  "minRating": 4,
  "minReviews": 5,
  "maxPages": 5,
  "proxy": { "useApifyProxy": true }
}
```

Walk the whole catalogue for a directory (no page cap, still bounded by `maxListings`):

```json
{
  "mode": "search",
  "directory": "web-developers",
  "maxPages": 0,
  "maxListings": 0,
  "proxy": { "useApifyProxy": true }
}
```

Resume a previous run, collecting only companies it doesn't already have:

```json
{
  "mode": "search",
  "directory": "web-developers",
  "maxListings": 0,
  "resumeFromRunId": "<a previous run id or dataset id from this account>"
}
```

Recurring monitoring — schedule this daily/weekly and get only what changed:

```json
{
  "mode": "search",
  "directory": "web-developers",
  "location": "united-states",
  "maxListings": 0,
  "incrementalMode": true
}
```

### Incremental & dedup mode (recurring monitoring)

Turn on `incrementalMode` to schedule this actor against the SAME search on a recurring basis (Apify Schedules) and get back only what changed since the last run, instead of the full result set every time.

- **How state is tracked.** The actor remembers the companies from its last run in a dedicated key-value store, keyed by a **State key**. By default the state key is derived automatically from your active search filters (`directory`, `location`, `agencySize`, `relatedServices`, `sortBy`, `minRating`, `minReviews`, `urls`, `fetchDetails`) — two different filter setups never share a baseline. Set `stateKey` explicitly to intentionally share state across setups, or to run several separate monitoring campaigns side by side. `maxPages`/`maxListings` are **not** part of the state key — they bound one run's cost, not what search is being tracked.
- **`changeType` on every output row:** `NEW` (first time seen), `UPDATED` (a real field changed — the rank/page position a company happens to appear at does **not** count, see below), `UNCHANGED`, `REAPPEARED` (was gone, is back), or `EXPIRED` (see below). `changedFields`, `firstSeenAt`, and `lastSeenAt` are also added.
- **`emitUnchanged`** (default off): UNCHANGED companies are suppressed by default (not returned, not billed). Turn on to also get an UNCHANGED row every run.
- **`emitExpired`** (default off): a company that was tracked before but is no longer found gets a `changeType: "EXPIRED"` row — but **only on a run that completes a full, uncapped, non-resumed scan** of the tracked search (an interrupted or capped run cannot tell "gone" apart from "not reached yet", so EXPIRED detection is skipped that run and the previous state is kept as-is). Both `emitUnchanged` and `emitExpired` return **and bill** extra rows.
- **Cost:** the detail-enrichment surcharge is only ever charged for a company that is both actually re-fetched **and** actually returned this run — a suppressed UNCHANGED row is never charged, even though its profile page still has to be fetched to compute the comparison.
- **Cap semantics.** `maxListings` bounds how many companies are **scanned** (deduped, filter-passed), not how many are returned. This keeps a mostly-unchanged monitoring run cheap: once the cap is reached the run stops, even if most of what it scanned was suppressed — it never pages deeper trying to "fill up" the cap with fresh rows.
- **What counts as a real change vs. noise:** a company's **rank on the directory page** (and the page URL that rank implies) shifts every time any other company is added, removed, or reordered above it — unrelated to that company's own data — so it is deliberately excluded from change detection. Everything else (name, tagline, description, website, phone, address, rating, review count, and the full review list) triggers `UPDATED` normally.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search` builds a directory URL from filters; `url` uses pasted links. |
| `directory` | string | `web-developers` | Any Clutch directory slug, for example `seo-firms` or `app-developers`. |
| `location` | string | (empty) | Location slug, for example `united-states` or `london`. |
| `agencySize` | string | (empty) | Company-size filter value, for example `50_-_249`. |
| `relatedServices` | string | (empty) | Service-line filter value, for example `field_pp_sl_ecommerce`. |
| `sortBy` | string | `default` | Search mode only: `default`, `review_rating`, `reviews`, or `date`. |
| `urls` | array | (example) | Clutch directory URLs for URL mode. |
| `minRating` | integer | (none) | Both modes: keep companies with at least this overall rating (applied after fetching). |
| `minReviews` | integer | (none) | Both modes: keep companies with at least this many reviews (applied after fetching). |
| `fetchDetails` | boolean | `true` | Open each profile for founding year, languages, full reviews and rating breakdown. |
| `maxPages` | integer | `0` | Optional bound on result pages walked per directory/URL. `0` = walk the whole catalogue: stops on its own when the site runs out of results or a page repeats companies already seen this walk — never an artificial page cap. Does not cap company count; use `maxListings` for that. |
| `maxListings` | integer | `20` | The sole cap on total companies collected. Stop after this many records (0 = unlimited). |
| `resumeFromRunId` | string | (empty) | Optional id of a previous run (or dataset) of this actor. Companies already in that dataset are skipped, so this run returns only new companies (a delta). |
| `incrementalMode` | boolean | `false` | Turn on for recurring/scheduled monitoring: tags every company NEW/UPDATED/UNCHANGED/REAPPEARED/EXPIRED against the previous run's state for the same search. See "Incremental & dedup mode" above. |
| `stateKey` | string | (empty) | Only used when `incrementalMode` is on. Leave empty to auto-derive the tracked scope from your search filters. Set to intentionally share state across setups or run separate monitoring campaigns. |
| `emitUnchanged` | boolean | `false` | Only used when `incrementalMode` is on. Also return (and bill) UNCHANGED companies every run. |
| `emitExpired` | boolean | `false` | Only used when `incrementalMode` is on. Also return (and bill) an EXPIRED row for companies no longer found, on a complete uncapped non-resumed scan. |
| `proxy` | object | Apify proxy | Connection settings. The default works on all plans. |
| `mcpConnectors` | array | (empty) | Optional MCP connectors to pipe a copy of each record into (Notion, Linear, Airtable, Apify). Authorize one under Apify → Settings → Integrations, then pick it here. Leave empty to skip. |
| `notionParentPageUrl` | string | (empty) | Notion only: URL (or id) of the page under which records are created. Required to enable the Notion export; ignored by other connectors. |
| `maxNotifyListings` | integer | `50` | Cap on items written to each connector per run. Does not affect the dataset. |

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape - the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable **summary** of each record - not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip.

### Output example

> Sample shape: values are illustrative placeholders, not from a live company.

```json
{
  "id": "00000",
  "name": "Sample Agency LLC",
  "slug": "sample-agency",
  "clutchUrl": "https://clutch.co/profile/sample-agency",
  "website": "https://example.com/",
  "logo": "https://img.shgstatic.com/clutch-static-prod/image/scale/50x50/logos/00000.jpg",
  "rating": 4.8,
  "reviewCount": 42,
  "minProjectSize": "$25,000+",
  "hourlyRate": "$100 - $149 / hr",
  "employeeCount": "50 - 249",
  "location": "New York, NY",
  "verified": true,
  "services": ["45% Web Development", "45% Web Design", "10% Branding"],
  "description": "Sample Agency builds websites and digital products for mid-market clients.",
  "yearFounded": 2010,
  "contact": {
    "phone": "1-000-000-0000",
    "location": "New York, NY",
    "address": {
      "street": "1 Example St",
      "city": "New York",
      "region": "NY",
      "postal_code": "10000",
      "country": "US"
    }
  },
  "contactDetails": {
    "emails": ["hello@example.com"],
    "phone_numbers": ["1-000-000-0000"],
    "social_media": ["https://www.linkedin.com/company/example"]
  },
  "detailedRatings": { "Quality": 4.8, "Schedule": 4.7, "Cost": 4.8, "Willing to Refer": 4.9 },
  "insights": {
    "industries": { "industries": ["eCommerce", "Financial services"] },
    "service_line_reviews": [
      { "service_line": "Web Development", "reviews_count": 17, "price_range": "0" }
    ]
  },
  "reviews": [
    {
      "quote": "Great team to work with.",
      "date": "Jan 1, 2026",
      "rating": 5.0,
      "summary": "Sample Agency built a new marketing website.",
      "projectSize": "$10,000 to $49,999",
      "projectLength": "Jan. - June 2026",
      "services": ["Web Design", "Web Development"],
      "detailedRatings": { "Quality": 5.0, "Schedule": 5.0, "Cost": 5.0, "Willing to Refer": 5.0 },
      "reviewer": {
        "position": "Director of Marketing, Sample Client Inc",
        "verified": true,
        "industry": "Financial services",
        "location": "Lynchburg, Virginia",
        "clientSize": "11-50 Employees"
      }
    }
  ],
  "sourceUrl": "https://clutch.co/web-developers"
}
```

### Plan requirement

This actor runs on every Apify plan with the default settings, including the **free plan**, with no extra setup. For very large or repeated jobs you can switch the Proxy field to a different option for wider coverage.

#### Connection settings

The connection works out of the box, so you rarely need to touch it:

- **Default works on all plans.** Leave the Proxy field at its default and the actor runs on the free plan with no extra setup.
- **Free-plan safe.** If you select an option your plan does not include, the run automatically continues on a working connection instead of failing.
- **Hands-off reliability.** The actor handles transient connection issues for you and keeps the run going.

### Verification note (2026-08-31)

URL and search modes re-verified against the live site on 2026-08-31 using the actor's own mint-and-replay session: the web-developers directory resolved with its own pagination reaching page 1910, adding the US location narrowed it to page 353 and adding an agency size of 10-49 to page 2, and a pasted profile URL parsed 18 populated fields (rating 4.8, 43 reviews, website, phone). No defect found; version bumped so the Store listing carries a freshly dated, re-verified build.

# Actor input Schema

## `mode` (type: `string`):

How to start the scrape. 'search' builds a directory URL from the filters below. 'url' takes the exact Clutch directory URLs you paste.

## `directory` (type: `string`):

Which Clutch directory to scrape in search mode, for example 'web-developers', 'seo-firms', 'digital-marketing-agencies', 'app-developers', 'ecommerce'. Paste any Clutch directory slug.

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

Optional location slug to narrow results, for example 'united-states', 'london', 'india'. Leave empty for worldwide.

## `agencySize` (type: `string`):

Optional company-size filter value, for example '10\_-*49' or '50*-\_249' employees. Leave empty for any size.

## `relatedServices` (type: `string`):

Optional service-line filter value, for example 'field\_pp\_sl\_ecommerce'. Leave empty for all services.

## `sortBy` (type: `string`):

Result ordering. Search mode only: this reorders the results the site returns, so it has no equivalent in URL mode.

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

Paste one or more Clutch directory URLs (for example https://clutch.co/web-developers). Multi-URL supported. Filter fields above are ignored. If a URL already includes a page number, results continue from that page.

## `minRating` (type: `integer`):

Only keep companies with at least this overall rating (0 to 5). Applied after fetching, so it narrows results in BOTH search mode and URL mode.

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

Only keep companies with at least this many reviews. Applied after fetching, so it narrows results in BOTH search mode and URL mode.

## `fetchDetails` (type: `boolean`):

Open each company profile to add founding year, languages, locations, the full review list (quote, feedback, summary, reviewer details, per-criterion scores, project size and length) and the rating breakdown. Adds one HTTP request per record.

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

How many result pages to read per directory URL. Does NOT cap the run. Leave at 0 to walk the whole catalogue — the run stops on its own at the site's last page or a repeat-page guard, not an artificial page cap. The run is bounded by Max records, which is the cap. Set this only if you want to additionally limit how many pages are read per directory.

## `maxListings` (type: `integer`):

THE cap for the run: stop after this many records (default 20). Set to 0 for unlimited.

## `resumeFromRunId` (type: `string`):

Optional. ID of a previous run of this actor (or a dataset ID). Companies already in that dataset are skipped, so this run returns only NEW companies (a delta). Combine both runs' datasets for the full set. For a recurring monitoring schedule, use Incremental mode below instead.

## `incrementalMode` (type: `boolean`):

When ON, this actor remembers the companies from its last run of the SAME search (see State key) and tags each company NEW / UPDATED / UNCHANGED / REAPPEARED / EXPIRED, so a daily/weekly schedule returns only what changed. Off by default: every run returns the full result set with no change tracking, exactly as before. Combine with resumeFromRunId only to bootstrap a monitoring campaign from one prior run's dataset, not on every scheduled run.

## `stateKey` (type: `string`):

Only used when Incremental mode is ON. Leave empty to auto-derive the tracked scope from your search filters (directory, location, company size, related service, sort, min rating, min reviews, URLs, fetch details) — two different filter setups then never share a baseline. Set an explicit value to intentionally share state across otherwise-different filter setups, or to run multiple separate monitoring campaigns.

## `emitUnchanged` (type: `boolean`):

Only used when Incremental mode is ON. Off by default: companies with no changes since the last run are suppressed (not returned, not billed). Turn ON to also return every UNCHANGED company each run — this returns and BILLS more rows.

## `emitExpired` (type: `boolean`):

Only used when Incremental mode is ON. Off by default. Turn ON to emit a row (changeType EXPIRED) for companies that were in the previous run's tracked set but are no longer found — only on a run that completes a full, uncapped, non-resumed scan of the tracked search. This returns and BILLS extra rows.

## `proxy` (type: `object`):

Network connection. The default works on all plans and is recommended. You can switch to a different proxy option for heavier runs.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON. The complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "directory": "web-developers",
  "sortBy": "default",
  "urls": [
    "https://clutch.co/web-developers"
  ],
  "fetchDetails": true,
  "maxPages": 0,
  "maxListings": 20,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true
  },
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (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 = {
    "mode": "search",
    "directory": "web-developers",
    "location": "",
    "agencySize": "",
    "relatedServices": "",
    "sortBy": "default",
    "urls": [
        "https://clutch.co/web-developers"
    ],
    "fetchDetails": true,
    "maxListings": 20,
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/clutch-directory-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 = {
    "mode": "search",
    "directory": "web-developers",
    "location": "",
    "agencySize": "",
    "relatedServices": "",
    "sortBy": "default",
    "urls": ["https://clutch.co/web-developers"],
    "fetchDetails": True,
    "maxListings": 20,
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/clutch-directory-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "directory": "web-developers",
  "location": "",
  "agencySize": "",
  "relatedServices": "",
  "sortBy": "default",
  "urls": [
    "https://clutch.co/web-developers"
  ],
  "fetchDetails": true,
  "maxListings": 20,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/clutch-directory-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/clutch-directory-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hPwXlesp5tCbf0hzJ/builds/rV3iUAJwXREiwJKLo/openapi.json