# Clutch.co Company Scraper (`datascrapers/clutch-scraper`) Actor

Scrape Clutch.co company listings, profiles, and reviews by directory URL or service + location search. Optional company details and paginated reviews with pay-per-event charging.

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

## Pricing

from $1.70 / 1,000 company records

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **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.co Company Scraper** creates a structured dataset of B2B service companies and their client reviews, collected from [Clutch.co](https://clutch.co), the B2B services directory. Each dataset item represents one company and can include reputation scores, hourly rates, employee size, contact data, and an optional paginated review history. Query the source by pasting Clutch directory or profile URLs, or by service category plus location with filters for size, rate, budget, and review count. Control the result limit with `maxItems`, and retrieve records through the Apify Dataset API or export them as JSON, CSV, Excel, or other supported formats.

### Dataset at a glance

| Property | Value |
|---|---|
| Source | clutch.co (public B2B services directory) |
| Record unit | One company, with nested profile fields and optional nested reviews |
| Input methods | Clutch URL list (`startUrls`) or service + location search (`searchQuery`, `location`) |
| Main identifiers | `companyId`, company profile URL |
| Delivery | Apify Dataset and API |
| Export formats | JSON, CSV, Excel, XML, HTML (Apify dataset exports) |
| Update model | Fresh records per Actor run |
| Pricing | $1.50 per 1,000 companies; +$2.00 per 1,000 for company details; +$2.00 per 1,000 for company reviews |

### Coverage and available records

The Actor collects companies from public Clutch.co pages using one of two entry points:

- **URL-based**: Pass Clutch directory URLs (for example `https://clutch.co/app-developers/nyc`) or individual company profile URLs in `startUrls`. The Actor scrapes exactly those pages. When `startUrls` is set, search fields are ignored.
- **Search-based**: Set `searchQuery` to a Clutch service (for example `Mobile App Development`) with an optional `location`. Directory sort order and filters (verified-only, employee size, hourly rate, client budget, minimum reviews) are applied automatically during pagination.

Record types and limits:

- **Listing-level records** are always collected: name, profile URL, rating, review count, hourly rate, employee size, location, services, and verification status.
- **Company detail fields** are conditional: website, phone, tagline, full description, year founded, languages, timezones, address, office locations, and social links are returned only when `scrapeCompanyDetails` is enabled, which visits each company profile.
- **Review records** are conditional: a paginated `reviews` array per company is returned only when `scrapeReviews` is enabled.
- **Result cap**: `maxItems` limits the number of companies collected (`0` means unlimited, the default).

Known exclusions: content Clutch only shows behind login is not collected; each run captures page state at run time (no historical snapshots); the Actor does not follow outbound links to a company's own website.

### Data dictionary

Field names below match dataset record JSON properties exactly. Fields marked *conditional* appear only when the corresponding input toggle is enabled.

#### Company-level fields

| Field | Type | Nullable | Description | Example |
|---|---:|---|---|---|
| `companyId` | string | No | Clutch company identifier; best stable deduplication key | `68874` |
| `name` | string | No | Company name | `Utility` |
| `url` | string | No | Clutch profile URL | `https://clutch.co/profile/utility` |
| `logoUrl` | string | Yes | Logo image URL | `https://img.shgstatic.com/.../50x50/...jpg` |
| `rating` | number | Yes | Average review rating on Clutch (0–5 scale) | `4.8` |
| `reviewCount` | number | Yes | Number of Clutch reviews | `26` |
| `minProjectSize` | string | Yes | Minimum typical project size | `$50,000+` |
| `hourlyRate` | string | Yes | Average hourly rate range | `$100 - $149 / hr` |
| `employees` | string | Yes | Employee size bucket | `50 - 249` |
| `location` | string | Yes | Primary location as shown in the listing | `New York, NY` |
| `verification` | string | Yes | Verification status text | `Verified` |
| `isVerified` | boolean | No | Whether Clutch marks the company verified | `true` |
| `isSponsored` | boolean | No | Whether the company is a sponsored listing | `true` |
| `listingType` | string | Yes | Listing slot observed (`sponsored` or unset) | `sponsored` |
| `position` | number | Yes | Position of the company within the directory results | `1` |
| `serviceLines` | string\[] | Yes | Main service lines shown in the listing | `["Mobile App Development", ...]` |
| `services` | object\[] | Yes | Services with percentage share: `{name, percent}` | `[{"name": "Mobile App Development", "percent": 50}]` |

#### Company detail fields (conditional — `scrapeCompanyDetails`)

| Field | Type | Nullable | Description | Example |
|---|---:|---|---|---|
| `website` | string | Yes | Company website URL from the profile | `https://utility.agency` |
| `phone` | string | Yes | Phone number from the profile | `(212) 328-1167` |
| `tagline` | string | Yes | Short profile tagline | `Utility is a product-focused agency.` |
| `description` | string | Yes | Company summary text from the profile | Long-form summary |
| `fullDescription` | string | Yes | Full profile description | Long-form profile copy |
| `yearFounded` | number | Yes | Founding year | `2013` |
| `timezones` | string | Yes | Timezone coverage as shown on Clutch | `2 Timezones` |
| `languages` | string | Yes | Language coverage as shown on Clutch | `English, Spanish` |
| `address` | object | Yes | Postal address: `{street, city, region, postalCode, country}` | See example record |
| `locations` | array | Yes | Additional office locations when listed | See example record |
| `socialLinks` | object | Yes | `{linkedin, facebook, instagram}` profile URLs | See example record |

#### Review fields (conditional — `scrapeReviews`)

Each company record may include a `reviews` array. One review object:

| Field | Type | Nullable | Description |
|---|---:|---|---|
| `reviewId` | string | No | Clutch review identifier |
| `title` | string | Yes | Review title |
| `rating` | number | No | Review score (0–5 scale) |
| `date` | string | Yes | Review date as rendered on Clutch (e.g. `Apr 17, 2020`) |
| `quote` | string | Yes | Short client quote |
| `summary` | string | Yes | Longer review summary |
| `projectSize` | string | Yes | Project budget bucket (e.g. `$10,000 to $49,999`, `Confidential`) |
| `projectLength` | string | Yes | Project duration (e.g. `July - Dec. 2018`) |
| `services` | string\[] | Yes | Services mentioned in the review |
| `focusAreas` | string\[] | Yes | Focus areas mentioned in the review |
| `quality` | number | Yes | Clutch quality score (0–5) |
| `schedule` | number | Yes | Clutch schedule score (0–5) |
| `cost` | number | Yes | Clutch cost score (0–5) |
| `willingToRefer` | number | Yes | Willingness-to-refer score (0–5) |
| `reviewerName` | string | Yes | Reviewer name (may be `Anonymous`) |
| `reviewerPosition` | string | Yes | Reviewer role at time of review |
| `reviewerIndustry` | string | Yes | Reviewer industry |
| `reviewerLocation` | string | Yes | Reviewer location |
| `reviewType` | string | Yes | Collection type (`Online Review`, `Phone Interview`) |
| `isVerified` | boolean | No | Whether Clutch verified the review |
| `isFeatured` | boolean | No | Whether the review is featured on the profile |

### Example dataset record

Real record produced with the test input below (`startUrls` for the New York mobile app developers directory, `maxItems: 3`, company details and reviews enabled). The `reviews` array is truncated to one item for readability.

```json
{
  "companyId": "68874",
  "name": "Utility",
  "url": "https://clutch.co/profile/utility",
  "logoUrl": "https://img.shgstatic.com/clutch-static-prod/image/scale/50x50/s3fs-public/logos/f9ce0e705d09825f677bdf52037d4c29_83948758567eaeb99c94c2.jpg",
  "rating": 4.8,
  "reviewCount": 26,
  "minProjectSize": "$50,000+",
  "hourlyRate": "$100 - $149 / hr",
  "employees": "50 - 249",
  "location": "New York, NY",
  "description": "Utility is a prominent mobile app development company specializing in mobile application development for iOS and Android platforms.",
  "services": [
    { "name": "Mobile App Development", "percent": 50 },
    { "name": "AI Development", "percent": 10 }
  ],
  "verification": "Verified",
  "isVerified": true,
  "isSponsored": true,
  "listingType": "sponsored",
  "position": 1,
  "website": "https://utility.agency",
  "phone": "(212) 328-1167",
  "yearFounded": 2013,
  "timezones": "2 Timezones",
  "address": {
    "street": "135 Madison Avenue",
    "city": "New York, United States",
    "region": "NY",
    "postalCode": "10016",
    "country": "US"
  },
  "socialLinks": {
    "linkedin": "https://www.linkedin.com/company/utility-nyc/",
    "facebook": "https://www.facebook.com/utilitynyc/",
    "instagram": "https://www.instagram.com/utilitynyc/"
  },
  "serviceLines": [
    "Mobile App Development",
    "AI Development",
    "Custom Software Development",
    "UX/UI Design",
    "Web Design",
    "Web Development"
  ],
  "reviews": [
    {
      "reviewId": "63429",
      "title": "Mobile App Dev for Sports Content Site",
      "rating": 5.0,
      "date": "Apr 17, 2020",
      "quote": "\"What was most impressive was probably their speed and skills.\"",
      "summary": "Utility was successful in building the brand. They launched the app on schedule and were very easy to work with.",
      "projectSize": "$10,000 to $49,999",
      "projectLength": "July - Dec. 2018",
      "services": ["Mobile App Development"],
      "quality": 5.0,
      "schedule": 5.0,
      "cost": 5.0,
      "willingToRefer": 5.0,
      "reviewerPosition": "Director of Creative Strategy, Sports Content Company",
      "reviewerIndustry": "Other industries",
      "reviewType": "Online Review",
      "isVerified": true,
      "isFeatured": true
    }
  ]
}
```

The record above was produced with this input:

```json
{
  "startUrls": [{ "url": "https://clutch.co/app-developers/nyc" }],
  "maxItems": 3,
  "scrapeCompanyDetails": true,
  "scrapeReviews": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Query and input reference

| Input | Type | Required | Default | Accepted values | Description |
|---|---|---|---|---|---|
| `startUrls` | array (requestListSources) | No\* | — | Clutch directory or profile URLs | URL-based entry point. When set, search and filter fields are ignored |
| `searchQuery` | string | No\* | — | Free text (e.g. `Mobile App Development`) | Clutch service/category search. Required when no URLs are provided |
| `location` | string | No | — | Free text (e.g. `New York`); leave empty for any location | Geographic filter for search mode |
| `maxItems` | integer | No | `0` | `0` or any positive integer | Maximum companies to collect; `0` = unlimited |
| `scrapeCompanyDetails` | boolean | No | `false` | `true` / `false` | Visit each profile and collect detail fields (charged as company details) |
| `scrapeReviews` | boolean | No | `false` | `true` / `false` | Collect the full paginated review history per company (charged as company reviews) |
| `sortBy` | string | No | `""` | `Sponsorship`, `Verification`, `ClutchRank`, `NumberOfReviews`, `ReviewRating`, `CompanyName` | Directory sort order (search mode only) |
| `agencySize` | array | No | — | `Freelancer`, `2 - 9`, `10 - 49`, `50 - 249`, `250 - 999`, `1,000 - 9,999`, `10,000+` | Employee size filter (search mode only) |
| `hourlyRate` | array | No | — | `< $25`, `$25 - $49`, `$50 - $99`, `$100 - $149`, `$150 - $199`, `$200 - $300`, `$300+` | Hourly rate filter (search mode only) |
| `clientBudget` | string | No | `""` | `Under $5,000` … `Under $250,000` | Maximum typical project budget (search mode only) |
| `minReviews` | string | No | `""` | `1+` … `20+`, `All companies` | Minimum review count (search mode only) |
| `verifiedOnly` | boolean | No | `false` | `true` / `false` | Only Clutch-verified companies (search mode only) |
| `proxyConfiguration` | object | No | Apify proxy, `RESIDENTIAL` group | Apify proxy groups or custom proxies | Residential proxies are recommended; datacenter IPs are frequently rate-limited |

\* Provide either `startUrls` or `searchQuery` — at least one source is required.

Minimal request:

```json
{ "searchQuery": "Mobile App Development", "location": "New York" }
```

Advanced request (URL entry point with enrichment):

```json
{
  "startUrls": [{ "url": "https://clutch.co/app-developers/nyc" }],
  "maxItems": 5000,
  "scrapeCompanyDetails": true,
  "scrapeReviews": true,
  "verifiedOnly": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

### Retrieve the data through the API

The Actor runs on the Apify platform, so there is no server to host and no crawling infrastructure to maintain.

1. Start the Actor with a JSON input (console or API).
2. Wait for the run to finish, or use a synchronous endpoint if you want the response inline.
3. Retrieve items from the run's default dataset.
4. Paginate or export the dataset.

Python example:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR-APIFY-TOKEN")

run_input = {
    "startUrls": [{"url": "https://clutch.co/app-developers/nyc"}],
    "maxItems": 10,
    "scrapeCompanyDetails": True,
}

run = client.actor("datascrapers/clutch-scraper").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["companyId"], item["name"], item["rating"])
```

Apify generates ready-to-run Python, JavaScript, and cURL examples on the Actor's API tab. Do not put a real API token in shared code or URLs.

### Data quality and record handling

- **Conditional fields**: detail and review fields are present only when their input toggle is enabled. Listings alone return a leaner record.
- **Source changes**: Clutch page structure and values can change; unreadable fields are returned as null rather than fabricated.
- **Deduplication**: each run appends fresh records; the Actor does not deduplicate companies across runs. Use `companyId` as the stable key and filter repeated runs against previously stored IDs.
- **Rate limits**: Clutch aggressively rate-limits automated traffic. Runs use retry logic; residential proxies are strongly recommended for consistent coverage.
- **Charges**: the Actor stops gracefully when a spending limit is reached (see run log). Values such as rating, rates, and scores are read from Clutch and normalized to the field types in the data dictionary.

### Export and pipeline examples

| Destination | Recommended method | Typical use |
|---|---|---|
| PostgreSQL / Supabase | Dataset API poll or webhook consumer | Store agency leads alongside CRM records |
| Google Sheets | Apify Google Sheets integration | Share shortlists with sales teams |
| CRM (HubSpot, Salesforce) | Webhook on run completion | Push new companies into outreach pipelines |
| S3 / cloud storage | Scheduled export via Apify scheduler + integration | Archival of market snapshots |

### Pricing and cost examples

The Actor uses pay-per-event pricing with three chargeable events, all billed per 1,000 companies:

| Event | Trigger | Rate (per 1,000 companies) |
|---|---|---|
| Company result | Every company record pushed to the dataset | $1.50 |
| Company details | `scrapeCompanyDetails` enabled, profile visited | $2.00 |
| Company reviews | `scrapeReviews` enabled, paginated reviews fetched | $2.00 |

Example costs:

| Records | Configuration | Estimated base cost |
|---:|---|---:|
| 1,000 | Listing only | $1.50 |
| 10,000 | Listing only | $15.00 |
| 1,000 | Listing + company details | $3.50 |
| 1,000 | Listing + details + reviews | $5.50 |
| 10,000 | Listing + details + reviews | $55.00 |

Apify paid plans reduce the per-1,000 rate (for example $1.20 per 1,000 companies at the Gold tier). Compute units consumed by the run are billed by your Apify plan. Estimates depend on the verified pricing model and the options selected for the run.

### Limitations and responsible data use

- The Actor collects publicly accessible data from Clutch.co pages only.
- Field availability depends on what Clutch renders at run time; some values can be null or missing, and site changes can alter fields.
- The Actor does not provide historical snapshots unless you store them yourself.
- Large runs require residential proxies; without them, coverage may degrade due to rate limiting.
- You are responsible for compliance with Clutch's terms of service, applicable privacy law, and any contractual obligations before using the data.

### Dataset questions

#### What does one dataset item represent?

One company from Clutch.co. Review records are nested inside the company record as a `reviews` array, so a company with 50 reviews still produces a single dataset item.

#### Which field should I use as a unique identifier?

`companyId` is the stable Clutch identifier and is the recommended deduplication key. The `url` (profile URL) is a reasonable secondary key.

#### Are fields nullable or conditional?

Yes. Detail fields (website, phone, address, social links, description) exist only when `scrapeCompanyDetails` is enabled; the `reviews` array exists only when `scrapeReviews` is enabled. Within available records, fields that Clutch does not render for a company are returned as null.

#### Can I retrieve the records as CSV or JSON?

Yes. The dataset can be exported as JSON, CSV, Excel, XML, or HTML from the Apify Console, and queried through the Dataset API.

#### Does the Actor return historical data?

No. Each run captures the state of the pages at run time. To track changes over time, schedule repeated runs and store the outputs yourself.

#### What counts as a billable result?

Three pay-per-event charges apply: a company result for every company record ($1.50 per 1,000), a company-details charge for each enriched profile ($2.00 per 1,000), and a company-reviews charge for each company whose reviews are fetched ($2.00 per 1,000). A listing-only run incurs only the company-result charge.

#### How do I search by service and location?

Set `searchQuery` to the Clutch service and `location` to a city, region, or country. Directory filters (`sortBy`, `agencySize`, `hourlyRate`, `clientBudget`, `minReviews`, `verifiedOnly`) apply in search mode automatically during pagination.

### Related datasets from Data Scrapers

- **[LinkedIn Company Scraper](https://apify.com/datascrapers/linkedin-company-scraper)** — Company profiles that can be joined with Clutch companies by name or website for B2B lead enrichment.
- **[Instagram Post Scraper](https://apify.com/datascrapers/instagram-post-scraper)** — Public Instagram posts of the same companies, useful for brand presence research alongside reputation data.
- **[Redfin Scraper](https://apify.com/datascrapers/redfin-scraper)** — Property listings and market signals for agency research in the real estate services vertical.

### Data Scrapers support

Need an additional field, record type, or export workflow? Contact Data Scrapers at stardustspotlight@rigelbytes.com. Include a sample source URL, required fields, expected record volume, and preferred delivery format.

# Actor input Schema

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

Directory or company profile URLs copied from clutch.co (e.g. https://clutch.co/app-developers/nyc or https://clutch.co/profile/designli). When provided, URLs are used and search fields below are ignored.

## `searchQuery` (type: `string`):

Clutch service to search (e.g. Mobile App Development). Ignored when Clutch URLs are provided.

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

City, region, or country (e.g. New York). Leave empty for any location. Ignored when Clutch URLs are provided.

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

Maximum number of companies to scrape (0 = unlimited)

## `scrapeCompanyDetails` (type: `boolean`):

Visit each company profile and extract website, phone, description, locations, and other profile fields. Charged as company-details.

## `scrapeReviews` (type: `boolean`):

Fetch all paginated reviews for each company. Charged as company-reviews.

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

Directory sort order. Applied only when using Service / category search (not URLs).

## `agencySize` (type: `array`):

Filter by number of employees. Applied only when using Service / category search.

## `hourlyRate` (type: `array`):

Filter by average hourly rate. Applied only when using Service / category search.

## `clientBudget` (type: `string`):

Maximum typical project budget. Applied only when using Service / category search.

## `minReviews` (type: `string`):

Only include companies with at least this many reviews. Applied only when using Service / category search.

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

Only include Clutch-verified companies. Applied only when using Service / category search.

## `proxyConfiguration` (type: `object`):

Apify proxy settings. Residential proxies are recommended.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://clutch.co/app-developers/nyc"
    }
  ],
  "searchQuery": "Mobile App Development",
  "location": "New York",
  "maxItems": 10,
  "scrapeCompanyDetails": false,
  "scrapeReviews": false,
  "sortBy": "",
  "clientBudget": "",
  "minReviews": "",
  "verifiedOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset of scraped Clutch companies

## `runStats` (type: `string`):

Record counts and run timestamps

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://clutch.co/app-developers/nyc"
        }
    ],
    "searchQuery": "Mobile App Development",
    "location": "New York",
    "maxItems": 10,
    "scrapeCompanyDetails": false,
    "scrapeReviews": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascrapers/clutch-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://clutch.co/app-developers/nyc" }],
    "searchQuery": "Mobile App Development",
    "location": "New York",
    "maxItems": 10,
    "scrapeCompanyDetails": False,
    "scrapeReviews": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("datascrapers/clutch-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 '{
  "startUrls": [
    {
      "url": "https://clutch.co/app-developers/nyc"
    }
  ],
  "searchQuery": "Mobile App Development",
  "location": "New York",
  "maxItems": 10,
  "scrapeCompanyDetails": false,
  "scrapeReviews": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call datascrapers/clutch-scraper --silent --output-dataset

```

## MCP server setup

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