# Clutch.co Companies & Reviews Scraper — Agency Leads & Pricing (`zapticx/clutch-companies-scraper`) Actor

Scrape Clutch.co companies and agencies: ratings, reviews, hourly rates, project sizes, services, locations and full company profiles for lead generation, competitor research and automation. Filter by rating, size, price and service. Export agency leads to CSV, Excel, JSON or API.

- **URL**: https://apify.com/zapticx/clutch-companies-scraper.md
- **Developed by:** [Zapticx](https://apify.com/zapticx) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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.

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 Companies & Reviews Scraper — Agency Leads, Pricing & Services

**Clutch.co scraper for B2B lead generation, competitor research and agency sourcing.** Point it at any Clutch directory — web development companies in Austin, SEO and marketing agencies in London, software development agencies across the US — and get a clean list of Clutch companies: rating, review count, verification badge, hourly rate, minimum project size, team size, services, location, website and Clutch profile link, plus whether each listing is **sponsored or organic** and where it ranks.

Two optional extras: **profile enrichment** adds full company profiles (description, founding year, offices, social profiles, industries, client focus, focus areas), and **reviews** collects agency reviews written by real clients (ratings breakdown, project details, reviewer role, interview Q\&A) into a separate reviews dataset.

**Pricing:** $2.00 per 1,000 companies, $4.00 per 1,000 enriched profiles, $0.50 per 1,000 reviews ([details](#pricing)). *Reviews require profile enrichment, so companies processed for reviews also incur the profile-enrichment charge.*

Export to **CSV, Excel or JSON**, use the **Apify API**, schedule runs, or connect **Make, Zapier, n8n**, CRMs and AI workflows.

Data source: [Clutch.co](https://clutch.co/)

### What can you do with this Actor?

- 🎯 **Build agency and company lead lists** — every company in a Clutch category, country or city, with website, phone and Clutch profile.
- 🥊 **Compare competitors** — ratings, review counts, pricing bands, team size and service mix side by side.
- 💲 **Research agency pricing** — hourly-rate bands and minimum project sizes, normalized to numbers you can sort and chart.
- ⭐ **Find highly rated firms** — filter by rating, number of reviews and verification badge.
- 🤝 **Source vendors** — shortlist agencies that match your budget, team-size and service requirements.
- 💬 **Analyze client reviews** — what clients say, project sizes, durations and industries, with per-category ratings.
- 🧩 **Compare service focus** — the share of work each company puts into each service, plus industries and client focus.
- 🗺️ **Find companies by geography** — any Clutch city or country directory, plus country, city and state filters.
- 📇 **Populate CRMs** — export to CSV/Excel or push rows into your CRM through the API or an automation tool.
- 🤖 **Feed AI and BI workflows** — structured JSON ready for dashboards, enrichment pipelines and LLM analysis.

### How to use this Actor

- 👉 **Register for a free Apify account**: no credit card required.
- 🎉 Just click [**Sign up free on Apify →**](https://console.apify.com/sign-up?fpr=1h3gvi) and complete a quick signup.
- 💰 Apify's free plan includes $5 of usage every month, enough to try this Actor.
- 🔗 Open the Actor and add one or more **Clutch URLs**: a directory (`https://clutch.co/web-developers/austin`) and/or company profiles (`https://clutch.co/profile/...`).
- ⚙️ Choose the **mode**: directory data only (default, cheapest), **profile enrichment**, and optionally **client reviews**.
- 🔍 Add **filters** if you want (rating, reviews, team size, hourly rate, project size, location, services, verification, organic/sponsored).
- 📏 Set **limits**: maximum companies, pages per URL and requests per run.
- ▶️ Click **Start**. The default run (15 companies, directory data only) finishes in well under a minute.
- 📥 **Export** to CSV, Excel or JSON (tip: export the **Companies** view for a clean spreadsheet), or use the API and integrations.

### Features

- **Clutch directory scraping** — service categories, country and city directories, followed page by page until your limits.
- **Direct company profile URLs** — scrape specific companies by their Clutch profile link.
- **Profile enrichment** — description, tagline, founding year, every office, languages, timezones, social profiles and Clutch Certified services.
- **Client reviews** — title, date, overall and Quality / Schedule / Cost / Willing to Refer ratings, quote, project size and length, services, reviewer role, industry, location and company size, verification and the interview Q\&A.
- **Sponsored vs organic detection** — paid "Sponsor" placements are flagged; ad-only blocks are not mixed into the ranking.
- **Stable ranking** — overall rank, organic rank and page position computed by the Actor.
- **Service percentages** — each company's service mix with the share of work per service.
- **Industry, client-size and focus data** — industries, client focus, technologies, frameworks, platforms and other focus areas (with enrichment).
- **Multiple offices** — every office with address, phone and size, plus the headquarters (with enrichment).
- **Pricing and team-size normalization** — "$50 - $99 / hr" → `hourlyRateMin` 50, `hourlyRateMax` 99; "$10,000+" → 10000; "50 - 249" → 50 and 249.
- **Filters before enrichment** — filtered-out companies are never enriched, reviewed or charged.
- **Deduplication** — a company that appears in several of your URLs is returned once.
- **Resume and checkpointing** — if a run is migrated or aborted and resurrected, it continues where it stopped without repeating results.
- **Request-budget protection** — a hard cap on requests per run.
- **Spending-limit protection** — the run stops cleanly before a result your maximum cost per run cannot pay for.
- **API, scheduling and webhooks** — everything the Apify platform offers.
- **Separate reviews dataset** — companies and reviews never mix in one table.

### Data fields

Company rows always contain the same set of fields; fields Clutch does not publish for a company are `null` (or an empty list).

| Group | Main fields |
|---|---|
| Company identity | `companyName`, `companyId`, `companySlug`, `clutchProfileUrl`, `website`, `websiteDomain`, `logoUrl`, `phone` |
| Ratings & verification | `rating`, `reviewCount`, `verificationStatus`, `isVerified`, `isPremierVerified`, `clutchSummary` |
| Pricing | `hourlyRateText`, `hourlyRateMin`, `hourlyRateMax`, `minProjectSizeText`, `minProjectSizeAmount` |
| Company size | `employeeCountText`, `employeeMin`, `employeeMax` |
| Location | `locationText` (location shown on the listing); `streetAddress`, `city`, `region`, `postalCode`, `countryCode` (company address, often the headquarters) |
| Services | `primaryService`, `services` (name, percentage of work, Clutch Certified) |
| Profile enrichment | `tagline`, `description`, `foundedYear`, `headquarters`, `offices`, `officeCount`, `languages`, `timezones`, `linkedinUrl`, `facebookUrl`, `twitterUrl`, `instagramUrl`, `socialProfiles`, `clutchCertifiedServices` |
| Focus areas | `industries`, `clientFocus`, `focusAreas`, `frameworks`, `programmingLanguages`, `cmsPlatforms`, `ecommercePlatforms`, `applicationPlatforms`, `mobilePlatforms` |
| Ranking | `sponsored`, `featuredListing`, `overallRank`, `organicRank`, `pagePosition`, `pageNumber`, `rankContinuity` |
| Source metadata | `directoryTitle`, `directoryTotalCompanies`, `sourceUrl`, `sourcePageUrl`, `recordSource`, `profileStatus`, `profileError`, `scrapedAt`, `profileScrapedAt` |

**Reviews** (separate dataset): `companyId`, `companyName`, `reviewId`, `reviewUrl`, `reviewTitle`, `reviewDate`, `overallRating`, `qualityRating`, `scheduleRating`, `costRating`, `willingToReferRating`, `quote`, `projectSummary`, `feedbackSummary`, `servicesProvided`, `projectSize`, `projectLength`, `reviewerPosition`, `reviewerCompany`, `reviewerIndustry`, `reviewerLocation`, `reviewerCompanySize`, `reviewType`, `reviewVerified`, `reviewQA` and more.

The datasets include ready-made table views: **Companies**, **Ranking & sponsorship**, **Pricing & size (numeric)**, **Enriched profiles**, **Services & focus** and **Reviews**.

### Input

| Field | What it does |
|---|---|
| `startUrls` | Clutch directory URLs and/or company profile URLs. |
| `enableProfileEnrichment` | Add full company profiles (default off). |
| `includeReviews` | Collect client reviews into the `reviews` dataset (default off; also counts each company as an enriched profile). |
| `maxReviewsPerCompany` | Reviews per company (default 10, max 1000). |
| `minRating` / `maxRating`, `minReviews` / `maxReviews` | Rating and review-count filters. |
| `minEmployees` / `maxEmployees`, `minHourlyRate` / `maxHourlyRate` | Team-size and hourly-rate filters (band overlap). |
| `minProjectSize` / `maxProjectSize` | Minimum-project-size filters (USD). |
| `countryCodes`, `cities`, `regions`, `services` | Location and service filters. |
| `verificationStatus` | `any`, `verified`, `premierVerified`, `unverified`. |
| `listingType` | `all`, `organic`, `sponsored`. |
| `maxItems` | Maximum unique companies in total (default 100; 0 = no limit). |
| `maxPagesPerUrl` | Directory pages per URL (0 = follow every page). |
| `maxRequestsPerRun` | Safety cap on requests (default 2,000). |
| `failRunIfUnhealthyPercentAbove` | Optionally fail the run if too many pages fail. |
| `deduplicate` | Return each company once across all URLs (default on). |

#### Example A — listing only (fast, cheapest)

15 web development companies in Austin, directory data only. Cost: 15 company results = **$0.03**.

```json
{
  "startUrls": [{ "url": "https://clutch.co/web-developers/austin" }],
  "maxItems": 15
}
```

#### Example B — companies with full profiles

100 SEO agencies in London with profile enrichment. Cost: up to 100 × ($0.002 + $0.004) = **up to $0.60**.

```json
{
  "startUrls": [{ "url": "https://clutch.co/seo-firms/uk/england/london" }],
  "enableProfileEnrichment": true,
  "maxItems": 100
}
```

#### Example C — companies, profiles and reviews

50 app developers in Seattle with up to 10 reviews each. Reviews require visiting each profile, so every company is also an enriched profile. Cost: up to 50 × ($0.002 + $0.004) + 500 × $0.0005 = **up to $0.55**.

```json
{
  "startUrls": [{ "url": "https://clutch.co/app-developers/seattle" }],
  "enableProfileEnrichment": true,
  "includeReviews": true,
  "maxReviewsPerCompany": 10,
  "maxItems": 50
}
```

#### Example D — market research with filters

Organic (non-sponsored) US web development companies rated 4.5+, with at least 10 reviews, 10–249 people, charging up to $99/hr. Filters run before any profile is opened, so only matching companies are enriched and charged.

```json
{
  "startUrls": [{ "url": "https://clutch.co/us/web-developers" }],
  "enableProfileEnrichment": true,
  "minRating": 4.5,
  "minReviews": 10,
  "minEmployees": 10,
  "maxEmployees": 249,
  "maxHourlyRate": 99,
  "services": ["Web Development"],
  "listingType": "organic",
  "maxItems": 200,
  "maxPagesPerUrl": 20
}
```

### Output

Real output, shortened for readability; the full rows contain all fields listed above.

#### Company (directory data only)

```json
{
  "resultType": "company",
  "companyId": "54510",
  "companyName": "Coalition Technologies",
  "clutchProfileUrl": "https://clutch.co/profile/coalition-technologies",
  "website": "https://coalitiontechnologies.com/contact/",
  "rating": 4.8,
  "reviewCount": 167,
  "verificationStatus": "Premier Verified",
  "minProjectSizeText": "$1,000+",
  "minProjectSizeAmount": 1000,
  "hourlyRateText": "$50 - $99 / hr",
  "hourlyRateMin": 50,
  "hourlyRateMax": 99,
  "employeeCountText": "50 - 249",
  "employeeMin": 50,
  "employeeMax": 249,
  "locationText": "Austin, TX",
  "city": "Los Angeles",
  "region": "CA",
  "countryCode": "US",
  "primaryService": "Search Engine Optimization",
  "services": [
    { "name": "Search Engine Optimization", "percentage": 70, "clutchCertified": true },
    { "name": "Web Development", "percentage": 10, "clutchCertified": true }
  ],
  "sponsored": false,
  "pagePosition": 4,
  "overallRank": 4,
  "organicRank": 2,
  "directoryTitle": "Top Web Development Companies in Austin",
  "profileStatus": "notRequested"
}
```

`locationText` is the location shown on the Clutch listing (in a city directory, the office in that city). `city`, `region` and `countryCode` come from the company address Clutch publishes, which is often the headquarters — that is why this Austin listing has `city: "Los Angeles"`. The default **Companies** table shows `locationText`.

#### Enriched company (profile enrichment on)

```json
{
  "companyName": "Imaginovation",
  "tagline": "Trusted Partner in Software, AI, & App Development",
  "foundedYear": 2011,
  "website": "https://imaginovation.net/",
  "linkedinUrl": "https://www.linkedin.com/company/imaginovation-llc/",
  "officeCount": 1,
  "headquarters": {
    "city": "Raleigh", "region": "NC", "countryCode": "US",
    "phone": "919-568-1256", "employeeCountText": "16 - 20"
  },
  "languages": ["English"],
  "timezones": ["Eastern Standard Time (EST)"],
  "clientFocus": [
    { "name": "Midmarket ($10M - $1B)", "percentage": 40 },
    { "name": "Small Business (<$10M)", "percentage": 35 },
    { "name": "Enterprise (>$1B)", "percentage": 25 }
  ],
  "focusAreas": [
    { "group": "AI Expertise", "name": "Machine Learning", "percentage": 20 },
    { "group": "CMS Focus", "name": "WordPress CMS", "percentage": 100 }
  ],
  "recordSource": "profile",
  "profileStatus": "enriched"
}
```

#### Review (reviews dataset)

```json
{
  "resultType": "review",
  "companyId": "87062",
  "companyName": "Imaginovation",
  "reviewId": "306912",
  "reviewTitle": "Custom Software Development for Healthcare Company",
  "reviewDate": "2024-08-12",
  "overallRating": 5.0,
  "qualityRating": 5.0,
  "scheduleRating": 5.0,
  "costRating": 5.0,
  "willingToReferRating": 5.0,
  "quote": "Imaginovation aligns with our company culture, and there's a lot of mutual respect amongst their team members.",
  "servicesProvided": ["Custom Software Development"],
  "projectSize": "Confidential",
  "projectLength": "Jan. 2023 - Ongoing",
  "reviewerPosition": "COO & Product Manager, Everflex Health",
  "reviewerIndustry": "Other industries",
  "reviewerCompanySize": "201-500 Employees",
  "reviewType": "Phone Interview",
  "reviewVerified": true,
  "reviewQA": [
    { "section": "BACKGROUND", "question": "Introduce your business and what you do there.", "answer": "…" }
  ]
}
```

#### Where are the reviews?

Company records are stored in the run's **default dataset**. When review extraction is enabled, review records are stored in a **separate run-scoped `reviews` dataset** that belongs to that run (it is not a shared, globally named dataset). You find it:

- in the run's **Output** tab, under **Reviews**;
- in the run's **Storage** tab, among the run's datasets;
- through the API: the run object lists it as `storageIds.datasets.reviews` (it is also in the run's `RUN_SUMMARY` record as `reviews.datasetId`).

Join reviews to companies with `companyId`. When reviews are off, the run's `reviews` dataset still exists but stays empty.

#### Exporting

For a clean spreadsheet with the most useful columns, export the **Companies** view. The full dataset export includes all available fields (useful for the API and advanced analysis).

### Pricing

This Actor uses pay-per-event pricing. You pay for successfully delivered results.

- **Company result:** `$0.002` each — $2.00 / 1,000
- **Profile enrichment:** `$0.004` per successfully enriched company — $4.00 / 1,000
- **Review result:** `$0.0005` each — $0.50 / 1,000

> **Reviews include profile enrichment:** when reviews are enabled, each processed company is also charged one profile-enrichment event because its Clutch profile must be visited to collect the reviews. Example: 3 companies with 5 reviews each = 3 × $0.002 + 3 × $0.004 + 15 × $0.0005 = **$0.0255**.

| Example | Price |
|---|---|
| 1,000 listing companies | $2.00 |
| 1,000 enriched companies | $2 + $4 enrichment = **$6.00** |
| 1,000 companies with 10 reviews each | $2 + $4 enrichment + $5 reviews = **$11.00** |
| 100 companies with up to 10 reviews each | up to **$1.10** |

Actual charges depend on the results actually delivered. Filtered-out companies, duplicates, failed profiles and repeated reviews are never charged; a profile that could not be read leaves the company as a directory-only row with no enrichment charge. Apify also charges a tiny standard Actor-start fee per run.

**Maximum cost per run.** You can set a maximum cost for each run in Apify. Before delivering each paid result, the Actor checks that the remaining limit can pay for the complete result (for example, both the company and its enrichment). If it cannot, the run stops cleanly with the stop reason `maxTotalChargeReached`. Everything already delivered stays in your datasets, and a company is never delivered half-priced.

### Filtering

Filters are checked on directory results **before** any profile or review is requested, so rejected companies cost nothing.

- **Filters combine with AND.** A company must match every filter you set (e.g. rating + reviews + employees + service).
- **Values within one list combine with OR.** `"services": ["Web Development", "Web Design"]` keeps companies offering either.
- **Unknown values fail an active filter.** A company with an undisclosed hourly rate is excluded while an hourly-rate filter is set.
- **"Not yet reviewed"** companies have `rating` = unknown (they fail any rating filter) and `reviewCount` = 0.
- **Employee and hourly-rate bands use overlap.** Clutch publishes bands, so a company matches when its band overlaps your range: `10 - 49` employees matches `minEmployees: 20`; `$50 - $99 / hr` matches `maxHourlyRate: 75`.
- **Minimum project size** compares Clutch's single threshold (`$10,000+` = 10000) with `minProjectSize` / `maxProjectSize`.
- **Services** use Clutch's service names exactly, case-insensitive, with no fuzzy matching (e.g. `Web Development`, `Search Engine Optimization`).
- **Cities** ignore case and accents (`Poznan` = `Poznań`). **Countries** use two-letter ISO codes (`US`, `GB`, `CA`; `UK` is accepted for `GB`). **Regions** use the codes Clutch shows (`CA`, `NY`, `ON`).
- **Location filters** use the address Clutch publishes in its structured data (often the headquarters). In a city directory this can differ from the office shown in `locationText`.
- **Listing type:** `all` (default), `organic` (skip paid placements) or `sponsored` (only paid placements). Profile URLs have no listing position, so this filter does not apply to them.

With filters on and `maxPagesPerUrl` 0, each directory is limited to 20 pages (1,000 companies examined); set a higher value to search deeper.

### Sponsored vs organic ranking

Clutch shows paid **Sponsor** listings at the top of a directory's first page. Every directory row has `sponsored` (true/false). Separate ad blocks (featured carousels, Leaders Matrix) are not returned as ranked rows; a ranked company that also appears in a featured block gets `featuredListing: true`.

The Actor computes its own ranks because Clutch's position numbering is not reliable across pages: `overallRank` (all rows, 1, 2, 3…), `organicRank` (non-sponsored rows only) and `pagePosition` (position on its page). If a directory page cannot be loaded at all, ranks after the gap are left `null` (and `rankContinuity` is false) instead of guessing.

### Reviews behaviour

- The first page of reviews (usually about 10) comes with the company profile, so no extra request is needed for it.
- More reviews require review pagination; `maxReviewsPerCompany` sets how many you get per company (up to 1,000).
- Reviews come in Clutch's default order; the Actor does not offer sorting options Clutch does not provide.
- Each review is returned once, identified by its Clutch review ID (a pinned/featured review that appears again on a later page is not duplicated).
- The interview Q\&A (`reviewQA`) and the four rating categories are included where Clutch publishes them.
- Companies with no reviews return no review rows.

### API — Clutch data through the Apify API

Run the Actor and get the companies in one call (replace `YOUR_APIFY_TOKEN`):

```bash
curl -X POST "https://api.apify.com/v2/acts/zapticx~clutch-companies-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://clutch.co/web-developers/austin"}],"maxItems":15}'
```

#### Python

```python
## pip install apify-client  (version 3.x)
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("zapticx/clutch-companies-scraper").call(run_input={
    "startUrls": [{"url": "https://clutch.co/web-developers/austin"}],
    "enableProfileEnrichment": True,
    "includeReviews": True,
    "maxReviewsPerCompany": 10,
    "maxItems": 20,
})

for company in client.dataset(run.default_dataset_id).iterate_items():
    print(company["companyName"], company["rating"], company["hourlyRateText"])

## Reviews live in the run's separate "reviews" dataset.
for review in client.dataset(run.storage_ids.datasets.reviews).iterate_items():
    print(review["companyName"], review["overallRating"], review["reviewTitle"])
```

#### JavaScript

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('zapticx/clutch-companies-scraper').call({
    startUrls: [{ url: 'https://clutch.co/web-developers/austin' }],
    enableProfileEnrichment: true,
    includeReviews: true,
    maxReviewsPerCompany: 10,
    maxItems: 20,
});

const { items: companies } = await client.dataset(run.defaultDatasetId).listItems();
console.log(companies.map((c) => `${c.companyName} ${c.rating}`));

// Reviews are in the run's separate "reviews" dataset.
const { items: reviews } = await client.dataset(run.storageIds.datasets.reviews).listItems();
console.log(`${reviews.length} reviews`);
```

### Make, Zapier, n8n and automation

Connect Actor runs and datasets to other tools through Apify's integrations, webhooks and API:

- **Make / Zapier / n8n** — trigger a run on a schedule or event, then read the dataset and send new companies to Google Sheets, HubSpot, Airtable or Slack.
- **Webhooks** — call your endpoint when a run finishes and import the dataset automatically.
- **AI workflows** — pass companies and reviews to an LLM to summarize client feedback, score vendors or draft outreach.

### Scheduling

Use Apify **Schedules** to run the Actor automatically:

- **Weekly competitor monitoring** — track ratings, review counts and pricing bands of the agencies you compete with.
- **Monthly agency discovery** — refresh a city or category directory to catch new companies.
- **Periodic review research** — collect new client reviews for a shortlist of companies.
- **Recurring lead-list refreshes** — keep your CRM's agency data current.

### Limitations

- The fields available vary by company: Clutch does not publish every value for every firm.
- Some directory listings show no website; profile enrichment fills it from the company profile when available.
- No email extraction: this Actor does not collect email addresses.
- Results depend on Clutch pages remaining publicly accessible; temporary access problems can slow or stop a run, and the run keeps everything collected.
- Clutch can change its site; the Actor is maintained to follow such changes.
- Companies with no reviews return no review rows.
- Coverage (which companies and locations exist) is whatever Clutch lists.

### FAQ

**Can I scrape Clutch reviews?** Yes. Turn on **Include client reviews** and set **Maximum reviews per company**. Reviews go to the run's separate `reviews` dataset.

**Can I scrape multiple Clutch URLs?** Yes. Add as many directory and profile URLs as you like; `maxItems` is the total across all of them, and duplicates are removed.

**Can I scrape direct company profiles?** Yes. Add `https://clutch.co/profile/...` URLs; they are always returned with full profile details.

**Can I filter by rating?** Yes, with `minRating` / `maxRating` (and `minReviews` / `maxReviews` for review counts).

**Can I filter by hourly rate?** Yes, with `minHourlyRate` / `maxHourlyRate` in USD (band overlap).

**Can I filter by company size?** Yes, with `minEmployees` / `maxEmployees` (band overlap).

**Are sponsored listings identified?** Yes. Every directory row has `sponsored` (true/false), and `organicRank` ranks only non-sponsored rows (company profile URLs have no listing position, so these fields are empty for them). Use `listingType: "organic"` to skip paid placements.

**Where are reviews stored?** In the run's separate `reviews` dataset (Output tab → Reviews), linked to companies by `companyId`.

**Does enabling reviews cost profile enrichment?** Yes. Reviews require visiting company profile pages, so companies processed for reviews are returned as enriched profiles and incur the profile-enrichment charge in addition to review-result charges.

**Can I export CSV or Excel?** Yes, from the run's Output/Storage tab, or through the API.

**Can I use the API?** Yes. See the [API](#api--clutch-data-through-the-apify-api) section for curl, Python and JavaScript.

**Can I schedule runs?** Yes, with Apify Schedules (daily, weekly, monthly or a custom cron).

**Why are some fields null?** Clutch does not publish every value for every company, and profile-only fields stay empty unless profile enrichment is on (`profileStatus` tells you whether a profile was read).

**Does this scrape email addresses?** No, this Actor does not extract email addresses. You get websites, phone numbers and social profiles where Clutch lists them.

**What happens if my spending limit is reached?** The run stops cleanly before any result it cannot fully charge. Everything already delivered stays available, and the run summary shows `maxTotalChargeReached`.

### Troubleshooting

- **No companies found** — check that the URL is a Clutch directory or profile that opens in your browser, and that your filters are not excluding everything (see `RUN_SUMMARY` → `filters.rejectionsByReason`).
- **Unsupported Clutch URL** — Clutch search pages are not supported; use a category, country or city directory, or profile URLs.
- **Missing optional fields** — turn on profile enrichment; some values are simply not published by Clutch.
- **Spending limit reached** — raise the maximum cost per run, or lower `maxItems` / reviews per company.
- **Request budget reached** — raise **Maximum requests per run**; the run kept everything collected so far.
- **Source temporarily unavailable** — the run stops early and keeps its data; try again later.
- **Can't find the reviews** — open the run's Output tab → **Reviews**, or use the run's `storageIds.datasets.reviews` through the API. It is empty unless **Include client reviews** is on.
- **Filter too restrictive** — check `RUN_SUMMARY` → `filters` for how many companies each filter rejected.

### About Zapticx

Built and maintained by [Zapticx](https://www.zapticx.com/). Need another field or a custom dataset? Open an issue on the Actor's Issues tab.

**Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Clutch.co or its operator, Clutch Co LLC.

# Actor input Schema

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

Add Clutch.co directory pages, company profile pages, or both. A directory can be a service category (https://clutch.co/web-developers), a country (https://clutch.co/us/web-developers) or a city (https://clutch.co/web-developers/austin, https://clutch.co/seo-firms/uk/england/london); pages are followed until your limits are reached. A company profile looks like https://clutch.co/profile/cleveroad and is always returned with full profile details (charged as an enriched profile). Clutch search pages are not supported.

## `enableProfileEnrichment` (type: `boolean`):

Also open each company's Clutch profile and add its tagline, full description, founding year, website, social links, every office, languages, timezones, industries, client-size focus, technology and other focus areas, and Clutch Certified services. Uses one extra request per company and makes runs slower. Each company delivered with its profile successfully read (profileStatus "enriched") is charged as profile enrichment; failed profiles are not charged. Company profile URLs in the list above are always returned with full profile details.

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

Extract reviews for each company. Review extraction requires visiting the company profile, so each processed company is also delivered as an enriched profile and incurs the profile-enrichment charge in addition to review-result charges. Reviews are saved in Output → Reviews.

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

Stop after this many reviews for each company, in Clutch's default order. The first page of reviews (usually about 10) comes with the profile page at no extra request; each further page needs one more request. To collect every review of a typical company, set a high number such as 500 (maximum 1000).

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

Keep companies rated at least this (0-5), e.g. 4.5. Companies not yet reviewed have no rating and are excluded while this filter is set.

## `maxRating` (type: `number`):

Keep companies rated at most this (0-5).

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

Keep companies with at least this many Clutch reviews (companies not yet reviewed count as 0).

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

Keep companies with at most this many Clutch reviews.

## `minEmployees` (type: `integer`):

Clutch shows team size as a band (e.g. 10 - 49). A company is kept when its band overlaps your range: 10 - 49 matches a minimum of 20. Companies with an undisclosed size are excluded while a size filter is set.

## `maxEmployees` (type: `integer`):

Upper end of the team-size range (band overlap, see Minimum employees).

## `minHourlyRate` (type: `integer`):

Clutch shows hourly rates as bands (e.g. $50 - $99 / hr). A company is kept when its band overlaps your range. Undisclosed rates are excluded while a rate filter is set.

## `maxHourlyRate` (type: `integer`):

Upper end of the hourly-rate range (band overlap): $50 - $99 / hr matches a maximum of 75.

## `minProjectSize` (type: `integer`):

Keep companies whose minimum project size is at least this amount, e.g. 25000 for agencies that take only larger projects.

## `maxProjectSize` (type: `integer`):

Keep companies whose minimum project size is at most this amount, e.g. 10000 for agencies that accept projects of $10,000 or less. Undisclosed values are excluded while this filter is set.

## `countryCodes` (type: `array`):

Keep companies located in these countries, as two-letter ISO codes: US, GB (UK also accepted), CA, IN, PL, DE... Location filters use the company address Clutch publishes in its structured data (often the headquarters), which can differ from the office location shown in a city directory.

## `cities` (type: `array`):

Keep companies in these cities (matching ignores upper/lower case and accents, e.g. Poznan = Poznań). Location filters use the company address Clutch publishes in its structured data (often the headquarters), which can differ from the office location shown in a city directory.

## `regions` (type: `array`):

Keep companies in these states or regions as Clutch shows them, e.g. CA, NY, TX for US states or ON, BC for Canadian provinces. Location filters use the company address Clutch publishes in its structured data (often the headquarters), which can differ from the office location shown in a city directory.

## `services` (type: `array`):

Keep companies that offer at least one of these services, using Clutch's service names exactly (case-insensitive, no fuzzy matching), e.g. Web Development, Search Engine Optimization, Mobile App Development.

## `verificationStatus` (type: `string`):

Keep only companies with this Clutch verification status.

## `listingType` (type: `string`):

Clutch places paid "Sponsor" listings at the top of the first page. Choose organic to skip them. Not applied to company profile URLs, which have no listing position.

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

Stop after this many unique companies in total, across all URLs. Each directory page holds up to 50 companies. Set 0 for no limit (a large category can contain tens of thousands of companies).

## `maxPagesPerUrl` (type: `integer`):

Stop each directory after this many pages (50 companies per page). Set 0 to follow every page until the end of the directory or the company limit.

## `maxRequestsPerRun` (type: `integer`):

Safety limit: the run stops after this many requests to Clutch and keeps everything collected so far. Every attempt counts, including automatic retries. As a guide, 2,000 requests covers well over a thousand directory pages, or a few hundred companies with profile details and reviews. Raise it for large jobs.

## `failRunIfUnhealthyPercentAbove` (type: `number`):

Optional. Marks the run as failed (all collected data is still saved) when, at the end, more than this percentage of pages failed permanently. A page is a directory page, a company profile or a review page; it fails permanently only if every retry was blocked or errored. Formula: failed pages / (loaded + failed pages) x 100. Pages that loaded after retries count as healthy. Leave empty to never fail the run for this reason.

## `deduplicate` (type: `boolean`):

When the same company appears in more than one of your URLs, keep only its first appearance (matched by Clutch company ID). Turn off to get one record per URL in which the company appears.

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

Managed automatically (Apify Proxy UNBLOCKER group, which this Actor is tested with). Not shown in the form.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://clutch.co/web-developers/austin"
    }
  ],
  "enableProfileEnrichment": false,
  "includeReviews": false,
  "maxReviewsPerCompany": 10,
  "verificationStatus": "any",
  "listingType": "all",
  "maxItems": 15,
  "maxPagesPerUrl": 0,
  "maxRequestsPerRun": 2000,
  "deduplicate": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "UNBLOCKER"
    ]
  }
}
```

# Actor output Schema

## `companies` (type: `string`):

One row per unique Clutch company (default dataset).

## `reviews` (type: `string`):

Client reviews in this run's separate "reviews" dataset (only when "Include client reviews" is on), linked to companies by companyId.

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

Counts, stop reasons, request usage, billing (delivered and charged results) and failures.

# 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/web-developers/austin"
        }
    ],
    "maxItems": 15,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "UNBLOCKER"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("zapticx/clutch-companies-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/web-developers/austin" }],
    "maxItems": 15,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["UNBLOCKER"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("zapticx/clutch-companies-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/web-developers/austin"
    }
  ],
  "maxItems": 15,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "UNBLOCKER"
    ]
  }
}' |
apify call zapticx/clutch-companies-scraper --silent --output-dataset

```

## MCP server setup

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