# Clutch.co Scraper - Company Search, Reviews & Portfolio Data (`epctex/clutchco-scraper`) Actor

$2 per 1,000 Clutch.co , The Leading Marketplace for Finding Business Services  search results, or $0.002 each, with 8 fields per company. Fits agency sourcing, procurement and competitive intelligence teams. Scrapes profiles, reviews and portfolios by keyword or profile URL.

- **URL**: https://apify.com/epctex/clutchco-scraper.md
- **Developed by:** [epctex](https://apify.com/epctex) (community)
- **Categories:** Jobs
- **Features:** Limited permissions
- **Stats:** 2,684 total users, 43 monthly users, 97.7% runs succeeded, 50 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.00 / 1,000 companies

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Clutch.co Scraper

Clutch.co Scraper is an Apify actor that extracts Clutch.co company search results, profiles, reviews and portfolio items from a search keyword or a company profile URL. Company profile lookups cost $0.002 each, or $2.00 per 1,000 lookups, billed per event with no subscription.

The Clutch.co Scraper runs 4 query types, accepts 13 input fields, returns up to 8 structured fields per company record, and bills through 5 charge events. Every price below is a per-event charge with no subscription and no monthly minimum.

### What Does the Clutch.co Scraper Extract?

The Clutch.co Scraper extracts 4 query types: a keyword search and 3 opt-in extras layered onto a company profile lookup.

| Query Type | Description |
| --- | --- |
| Company Search | Searches Clutch.co by keyword and returns matching companies, paginating through all result pages. |
| Company Details | Returns full profile information for a specific company, either from a given profile URL or for each company found by a search when details are enabled. |
| Company Reviews | Client reviews left for a company. Fetched as an opt-in extra alongside company details. |
| Company Portfolio | Portfolio and case-study items published by a company. Fetched as an opt-in extra alongside company details. |

### Which Identifiers Does the Clutch.co Scraper Accept?

The Clutch.co Scraper accepts 2 input identifiers: `search` and `startUrls`. A keyword search targets Clutch.co's company directory, while a start URL targets one Clutch.co company profile directly.

- **`search`** takes a keyword string, such as `"web developers"`, and returns matching companies from Clutch.co's search results, paginated from the page number in `page`.
- **`startUrls`** takes an array of Clutch.co company profile URLs, such as `https://clutch.co/profile/smartsites`, and returns the Company Detail record for each profile directly, without running a search.

### Who Uses the Clutch.co Scraper?

Listed below are the 5 roles that run the Clutch.co Scraper against Clutch.co company data.

- **Business development and agency-sourcing teams** run keyword searches and read `name`, `rating`, `reviewsCount` and `location` from each Company Search Result to shortlist agencies.
- **Vendor due-diligence and procurement teams** fetch Company Detail records and read `summary.hourlyRate`, `summary.minProjectSize`, `summary.employees` and `verification.status` to qualify a vendor.
- **Competitive intelligence teams** read the `focus` field on a Company Detail record to see how a listed company splits its work across services.
- **Reputation and marketing teams** enable `includeReviews` and read each review's `reviewer`, `rating` and `text` field for social-proof research.
- **Case-study and portfolio researchers** enable `includePortfolio` and read each portfolio item's `title` and `description` field.

### What Does the Clutch.co Scraper Cost?

The Clutch.co Scraper charges 5 event types. The cheapest are `company-detail` and `dataset-item`, both at **$0.002**, and the priciest is `get-reviews` at **$0.01**.

| Query Type | Charge Event | Price |
| --- | --- | --- |
| Company Search | `company-search` | $0.008 |
| Company Detail | `company-detail` | $0.002 |
| Company Reviews | `get-reviews` | $0.01 |
| Company Portfolio | `get-portfolio` | $0.006 |
| Every dataset item | `dataset-item` | $0.002 |

`dataset-item` is waived for paying users on items returned from the first page of a plain company search, when `getDetails` is off.

#### Clutch.co Scraper Cost Examples

The table below prices 4 scenarios against the rate card above.

| Scenario | Charge Events | Calculation | Total Cost |
| --- | --- | --- | --- |
| Single company profile via `startUrls`, no reviews or portfolio | 1 `company-detail` + 1 `dataset-item` | $0.002 + $0.002 | $0.004 |
| Company profile requested but not found on Clutch.co | 1 `company-detail`, no dataset item pushed | $0.002 | $0.002 |
| Company profile with `includeReviews` and `includePortfolio` (15-review cap) | 1 `company-detail` + up to 2 `get-reviews` + up to 10 `get-portfolio` + 1 `dataset-item` | $0.002 + (2 x $0.01) + (10 x $0.006) + $0.002 | up to $0.084 |
| Keyword search, 3 result pages, `getDetails` off | 1 `company-search`, `dataset-item` waived on page 1 for paying users, charged on pages 2 and 3 | $0.008 + (paying: 2 x dataset-item, non-paying: 3 x dataset-item) | from $0.008 |

#### Clutch.co Scraper Unit Economics

The 4 figures below are derived from the rate card above, using the company-detail lookup as the base unit since it is charged once per requested profile regardless of page size.

| Metric | Value |
| --- | --- |
| Cost per company profile lookup, including its dataset item | $0.004 |
| Company profile lookups per $1 | 250 |
| Cost per 1,000 company profile lookups, including their dataset items | $4.00 |
| Ratio between cheapest and most expensive charge event | 5x (`get-reviews` vs `company-detail`/`dataset-item`) |

### How Is the Clutch.co Scraper Configured?

The Clutch.co Scraper exposes 13 input fields covering identifiers, detail-depth toggles, limits, output transformation and delivery to other services.

| Name | Type | Description |
| --- | --- | --- |
| search | string | Keyword to search for companies on Clutch.co, such as "agency" or "web developers". |
| startUrls | array | Clutch.co company profile URLs to retrieve. For example: https://clutch.co/profile/smartsites. Only company profile URLs are supported. |
| page | integer | The page number from which to start retrieving search results. |
| getDetails | boolean | When enabled, retrieves detailed information for each company found in the search results. When disabled, only basic company information is returned. |
| includeReviews | boolean | When enabled, includes reviews for each company in the output. |
| maxReviewsPerCompany | integer | Maximum number of reviews to retrieve for each company. Leave empty to retrieve all available reviews. |
| includePortfolio | boolean | When enabled, includes portfolio information for each company in the output. |
| maxItems | integer | Maximum number of companies to retrieve. Leave empty to retrieve all available results. |
| customMapFunction | string | Optional JavaScript function to transform each company. Ignored with a warning if it is not a usable function. |
| outputConnector | string | MCP connector to deliver the results to — pick one (see [How Do You Send Clutch.co Scraper Results to Notion, Todoist and More?](#how-do-you-send-clutchco-scraper-results-to-notion-todoist-and-more)). |
| deliverTarget | string | Where the connector writes — paste the URL or ID (Notion example: `https://www.notion.so/My-Posts-24f8a1b2c3d44e5f8a9b0c1d2e3f4a5b`); some services need none. |
| deliverMode | string | `perPost` (one record per item) or `summary` (one roll-up per run). |
| deliverMaxItems | integer | Optional cap on how many records `perPost` delivers (ignored in `summary`). |

### Which Input Rules Does the Clutch.co Scraper Enforce?

The Clutch.co Scraper enforces 6 usage constraints covering identifier requirements, URL validation, tier-based limits and custom-function safety.

| Rule | Why |
| --- | --- |
| Either `search` or `startUrls` must be provided | The run fails immediately at startup if both are empty. |
| `startUrls` must be `http`/`https` URLs on a hostname containing "clutch" | Non-Clutch URLs are rejected during input validation and skipped with a warning. |
| Only Clutch.co company profile URLs (path containing `/profile/<slug>`) are supported | Any other Clutch.co URL is skipped with an "Unsupported URL" warning. |
| `start_urls` is accepted as an alias for `startUrls` | Used only when `startUrls` itself is empty, so a snake_case input still resolves. |
| `maxItems` only lowers the item cap on paid-tier runs | On free-tier runs the actor uses the configured per-run item limit and ignores `maxItems`. |
| `customMapFunction` must be a synchronous function returning a non-null object | A function that throws, returns a non-object (including `null`), returns a Promise, is `async`/generator, or takes longer than about 1 second on one item is rejected; the run continues pushing the original, unmodified items instead. It runs in an isolated sandbox with plain JavaScript only (no network requests, `require` or `console`). The returned value is only checked for being a non-null object, so arrays and other non-plain objects pass through without further validation. |

### How Do You Search Clutch.co Companies With the Clutch.co Scraper?

A keyword search returns paginated Company Search Results starting from the page number in `page`. Set `getDetails` to fetch a full Company Detail record for every match instead of the basic search fields.

```json
{
  "search": "web development",
  "page": 1,
  "maxItems": 5
}
```

### How Do You Retrieve a Clutch.co Company Profile With the Clutch.co Scraper?

The Clutch.co Scraper resolves each URL in `startUrls` directly to its Company Detail record, without running a search.

```json
{
  "startUrls": ["https://clutch.co/profile/smartsites"]
}
```

### How Do You Include Reviews and Portfolio With the Clutch.co Scraper?

The Clutch.co Scraper fetches reviews and portfolio items as opt-in extras layered onto a Company Detail lookup. `maxReviewsPerCompany` caps the review count; leaving it empty retrieves every review Clutch.co returns.

```json
{
  "startUrls": ["https://clutch.co/profile/smartsites"],
  "includeReviews": true,
  "maxReviewsPerCompany": 15,
  "includePortfolio": true
}
```

### How Do You Transform Output With the Clutch.co Scraper's Custom Map Function?

The Clutch.co Scraper compiles `customMapFunction` once at the start of the run and applies it to every item before it reaches the dataset. The function runs in an isolated sandbox with plain JavaScript only (no network requests, `require` or `console`), must run synchronously, finish within about 1 second per item and return a non-null object; arrays and other non-plain objects are accepted without further validation, but a function that throws, returns a Promise or runs too long is rejected once, and the run continues pushing the original, unmodified items. The run log explains the rejection in a warning that starts with `Your "customMapFunction" input was rejected:`.

```json
{
  "startUrls": ["https://clutch.co/profile/smartsites"],
  "customMapFunction": "(object) => { return { url: object.url, websiteUrl: object.websiteUrl, inputSource: object.inputSource } }"
}
```

### How Do You Send Clutch.co Scraper Results to Notion, Todoist and More?

Skip the manual exports — the Clutch.co Scraper can deliver its results directly into the tools you already work in, through [Apify MCP Connectors](https://apify.com/store/collections/mcp-connectors):

1. Authorize a connector (Notion, Todoist, or any service whose MCP server offers non-destructive write tools) once in [Console → Settings → API & Integrations → MCP connectors](https://console.apify.com/settings/integrations).
2. Pick it from the **Send results to Notion, Todoist, …** dropdown.
3. Fill in where and how to write:
   - **Destination target** — paste the URL or ID (Notion example: `https://www.notion.so/My-Posts-24f8a1b2c3d44e5f8a9b0c1d2e3f4a5b`); share it with your connector first via Notion's **•••  → Connections** menu. For structured columns use a **page** URL (the Actor builds the database for you) or a database that **already has columns** — an empty database only receives titles. (Some services need no target.)
   - **Write mode** — `perPost` writes one record per company; `summary` writes a single roll-up for the run.
   - **Max records to deliver** *(optional)* — cap on how many records `perPost` delivers.

**Notion, structured like a spreadsheet:** for a table of typed columns, point the target at a Notion **page** — the Actor auto-creates a database from the data, one matching, correctly-typed column per field (URL, number, date, text). Pointing at an **existing database** fills the columns it already has (matched by name); an **empty database** receives only the title, and the rest of each record goes to the row body — the connector can't add columns to an existing database without destructive access it never requests. Nested fields are flattened into columns too — an `inputSource` object becomes `inputSource.searchQuery`, `inputSource.pageNumber`, … — so everything is sortable and filterable in the grid. Fields that don't fit a column go to the row's page body, so nothing is lost.

Your credentials stay yours: the Actor talks to your services exclusively through your own authorized connector and only ever uses non-destructive write tools — it cannot delete or overwrite anything you already have. Delivery is best-effort and runs after the scrape: if a connector is misconfigured or a delivery fails, your run still finishes normally with all results intact — the failure is reported in the run log, never by failing the run. If the run is about to hit its timeout, delivery stops early so the run still succeeds, and the log tells you how many records were delivered.

### Which Fields Does the Clutch.co Scraper Output?

The Clutch.co Scraper outputs 8 fields per Company Detail record and 7 fields per Company Search Result, covering identification, business summary, service focus, verification, reviews and portfolio.

#### Clutch.co Scraper Company Detail Fields

| Field | Type |
| --- | --- |
| inputSource | object |
| url | string |
| websiteUrl | string |
| summary | object |
| focus | object |
| verification | object |
| reviews | array |
| portfolio | array |

#### Clutch.co Scraper Company Search Result Fields

| Field | Type |
| --- | --- |
| slug | string |
| name | string |
| website | string |
| location | string |
| rating | number |
| reviewsCount | number |
| inputSource | object |

#### Clutch.co Scraper Company Detail Example

```json
{
  "inputSource": {
    "sourceUrl": "https://clutch.co/profile/example-agency"
  },
  "url": "https://clutch.co/profile/example-agency",
  "websiteUrl": "https://example-agency.com",
  "summary": {
    "tagline": "Full-service digital agency",
    "founded": 2015,
    "employees": "50 - 249",
    "minProjectSize": "$10,000+",
    "hourlyRate": "$100 - $149 / hr",
    "verificationStatus": "verified"
  },
  "focus": {
    "service": [
      { "name": "Web Development", "percentage": 40 },
      { "name": "Digital Strategy", "percentage": 25 }
    ]
  },
  "verification": {
    "status": "verified"
  },
  "reviews": [
    {
      "reviewer": "VP of Marketing, Financial Services Company",
      "rating": 5,
      "text": "Placeholder review text."
    }
  ],
  "portfolio": [
    {
      "title": "Placeholder case study",
      "description": "Placeholder portfolio description."
    }
  ]
}
```

#### Clutch.co Scraper Company Search Result Example

```json
{
  "name": "Example Agency",
  "slug": "example-agency",
  "website": "https://example-agency.com",
  "location": "New York, NY",
  "rating": 4.8,
  "reviewsCount": 32,
  "inputSource": {
    "searchQuery": "agency",
    "pageNumber": 1
  }
}
```

### Which Errors Does the Clutch.co Scraper Report?

The Clutch.co Scraper reports 11 error codes. 8 of the 11 codes are non-terminal, logging the failure and continuing the run past the affected item. 3 codes terminate the run: `C098`, `C099` and `C100`.

The 8 non-terminal codes split into 3 recovery behaviors:

- 3 codes (`C001`, `C002`, `C003`) skip the current company or search query and continue the queue.
- 4 codes (`C004`, `C005`, `C006`, `C007`) stop only the reviews or portfolio sub-fetch for the current company, keeping its other fields.
- 1 code (`C019`) logs the failure, pushes an error item to the dataset, and retries.

| Code | Trigger | Behavior |
| --- | --- | --- |
| C001 | Company detail or search request failed to complete | Logs the error and skips the current slug or query; the run continues. |
| C002 | Company detail or search request returned no data | Logs the error and skips the current slug or query; the run continues. |
| C003 | Requested company profile was not found on Clutch.co | Logs the error and skips the profile; `company-detail` is still charged, since the request had already been made. |
| C004 | Reviews request failed for a company | Logs the error and stops fetching further review pages for that company. |
| C005 | Reviews request returned no data | Logs the error and stops fetching further review pages for that company. |
| C006 | Portfolio request failed for a company | Logs the error and stops fetching further portfolio pages for that company. |
| C007 | Portfolio request returned no data | Logs the error and stops fetching further portfolio pages for that company. |
| C019 | A request came back throttled | Logs the error, pushes an error item to the dataset, waits, and retries. |
| C098 | An unhandled rejection occurred anywhere in the run | Logs the error and exits the run. |
| C099 | An uncaught exception occurred anywhere in the run | Logs the error and exits the run. |
| C100 | The run failed to initialize | Logs the error and exits the run before any query starts. |

### Which Clutch.co Scraper Questions Come Up Most Often?

#### Does the Clutch.co Scraper charge for a company profile that Clutch.co does not find?

Yes. `company-detail` is charged once the request for a profile is made, whether or not Clutch.co returns a match, since the charge is billed against the request rather than the result.

#### Does the Clutch.co Scraper charge for an invalid or non-Clutch.co URL?

No. A URL that is not `http`/`https`, not on a hostname containing "clutch", or not a `/profile/<slug>` path is skipped during input validation before any request or charge happens.

#### Does the Clutch.co Scraper charge extra for paginating through search results?

No. `company-search` is charged once per search query, not once per result page. Only `dataset-item` charges scale with the number of result pages returned, and page 1 is waived for paying users when `getDetails` is off.

#### Can the Clutch.co Scraper search and retrieve a specific profile in the same run?

Yes. The Clutch.co Scraper accepts `search` and `startUrls` together in one run, combining Company Search Results with Company Detail records from the listed profile URLs.

#### Does the Clutch.co Scraper support `start_urls` as an alias for `startUrls`?

Yes. The Clutch.co Scraper reads `start_urls` as `startUrls` when the standard field is left empty, so a snake_case input still resolves.

#### How many reviews does the Clutch.co Scraper retrieve per company?

The Clutch.co Scraper retrieves every review Clutch.co returns unless `maxReviewsPerCompany` sets a cap, in which case it stops once that count is reached.

#### Is the `dataset-item` charge always applied by the Clutch.co Scraper?

No. The Clutch.co Scraper waives `dataset-item` for paying users on items returned from the first page of a plain company search, when `getDetails` is off.

#### What happens when a Clutch.co Scraper custom map function throws an error?

The Clutch.co Scraper rejects the function once, logs a warning naming the error, and continues the run pushing the original, unmodified items to the dataset for every later item.

#### Can the Clutch.co Scraper's custom map function run asynchronously?

No. The Clutch.co Scraper rejects `async` functions, generator functions and any function that returns a Promise, and falls back to the original item.

#### Does the Clutch.co Scraper require either `search` or `startUrls`?

Yes. The Clutch.co Scraper fails the run at startup if both `search` and `startUrls` are empty.

#### Can the Clutch.co Scraper extract a company's service focus breakdown?

Yes. The Clutch.co Scraper returns a `focus` field on every Company Detail record, listing each service and its percentage of the company's work.

#### Does the Clutch.co Scraper retrieve portfolio items by default?

No. The Clutch.co Scraper fetches portfolio items only when `includePortfolio` is set to true, as an opt-in extra alongside a Company Detail lookup.

#### What happens when a Clutch.co Scraper run reaches its configured cost limit?

The Clutch.co Scraper stops queuing further charged queries once their combined cost would exceed the run's maximum cost per run, and exits the run.

### Where Do You Get Clutch.co Scraper Support?

The Clutch.co Scraper is published by epctex, reachable at [epctex.com](https://epctex.com) for all available products, through the chat box on epctex.com for custom integrations, or at business@epctex.com for support.

# Actor input Schema

## `search` (type: `string`):

Keyword to search for companies on Clutch.co, such as "agency" or "web developers".

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

Clutch.co company profile URLs to retrieve. For example: https://clutch.co/profile/smartsites. Only company profile URLs are supported.

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

The page number from which to start retrieving search results.

## `getDetails` (type: `boolean`):

When enabled, retrieves detailed information for each company found in the search results. When disabled, only basic company information is returned.

## `includeReviews` (type: `boolean`):

When enabled, includes reviews for each company in the output.

## `maxReviewsPerCompany` (type: `integer`):

Maximum number of reviews to retrieve for each company. Leave empty to retrieve all available reviews.

## `includePortfolio` (type: `boolean`):

When enabled, includes portfolio information for each company in the output.

## `maxItems` (type: `integer`):

Maximum number of companies to retrieve. Leave empty to retrieve all available results.

## `customMapFunction` (type: `string`):

JavaScript function to transform each output company. Use to add computed fields, modify values, or remove unnecessary data. NOT intended for filtering - filtering may result in automatic bans. Must be a single synchronous function, e.g. (object) => { return {...object} }. It runs in a sandbox with plain JavaScript only (no network or require) and about 1 second per item. Leave empty if you do not need to transform the output - an unusable function is ignored and the original items are saved instead.

## `outputConnector` (type: `string`):

Pick an MCP connector you authorized in Console → Settings → API & Integrations → MCP connectors (e.g. Notion, Todoist — any service whose MCP server offers non-destructive write tools works best-effort). The scraped results are written through your own connector — the Actor never sees your third-party credentials. Only non-destructive write tools are used; it can never delete or overwrite your existing data.

## `deliverTarget` (type: `string`):

Where to write into the connector — paste the URL or ID. Notion example: https://www.notion.so/My-Posts-24f8a1b2c3d44e5f8a9b0c1d2e3f4a5b. Leave empty for services that need no target (e.g. Todoist Inbox, Slack). For Notion, share the page or database with your connector first (Notion's ••• → Connections menu), and point at a PAGE for structured columns (the Actor builds the database for you) — an empty database receives only the title (the rest of each record goes to the row's body).

## `deliverMode` (type: `string`):

perPost writes one record per scraped item; summary writes a single roll-up for the run.

## `deliverMaxItems` (type: `integer`):

Cap on how many records perPost mode writes to the connector; ignored in summary mode. Leave empty to deliver everything scraped.

## Actor input object example

```json
{
  "search": "agency",
  "startUrls": [
    "https://clutch.co/profile/smartsites"
  ],
  "page": 1,
  "getDetails": false,
  "includeReviews": false,
  "includePortfolio": false,
  "customMapFunction": "(object) => { return {...object} }",
  "deliverMode": "perPost"
}
```

# 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 = {
    "search": "agency",
    "startUrls": [
        "https://clutch.co/profile/smartsites"
    ],
    "page": 1,
    "customMapFunction": (object) => { return {...object} }
};

// Run the Actor and wait for it to finish
const run = await client.actor("epctex/clutchco-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 = {
    "search": "agency",
    "startUrls": ["https://clutch.co/profile/smartsites"],
    "page": 1,
    "customMapFunction": "(object) => { return {...object} }",
}

# Run the Actor and wait for it to finish
run = client.actor("epctex/clutchco-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 '{
  "search": "agency",
  "startUrls": [
    "https://clutch.co/profile/smartsites"
  ],
  "page": 1,
  "customMapFunction": "(object) => { return {...object} }"
}' |
apify call epctex/clutchco-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,epctex/clutchco-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/XBE8BJUuJZgMf2sms/builds/IrB2hStcbTmNhUhWi/openapi.json