# Clutch.co Agency API: B2B Company Data, Directory & Reviews (`johnvc/clutch-agency-api`) Actor

Company data API for Clutch.co, the B2B directory of agencies and service providers. Build a marketing agency database with ratings, pricing, service mix, team size, locations and every verified client review, returned as JSON plus LLM-ready markdown. Pay per row, MCP-ready for Claude and AI agents.

- **URL**: https://apify.com/johnvc/clutch-agency-api.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:**
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 company profile scrapeds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

## Clutch.co Agency API: B2B Company Data, Directory & Reviews

A company data API for Clutch.co, the B2B directory of agencies and service
providers. Walk any category directory, pull full company profiles, and
paginate every verified client review, returned as JSON **and** as
publish-ready markdown for RAG pipelines and AI agents.

Use it to build a marketing agency database, shortlist B2B service providers, or
feed verified provider data straight into a CRM or a vector store.

### What this actor returns

Three row types, chosen by `mode`:

- **`listing`**: one row per company on a directory or category page, with
  name, rating, review count, verification badges, minimum project size, hourly rate,
  team size, location, and the profile URL.
- **`profile`**: the full company record, everything above plus description,
  founding year, every office location, languages, timezones, service-line mix
  with percentages, technology focus areas, industry mix, client-size split,
  cost rating, typical project size per service, and published packages.
- **`review`**: one row per verified client review, with title, rating, the
  quality / schedule / cost / willing-to-refer breakdown, project services,
  budget band, duration, reviewer role and industry, and Clutch's own project
  and feedback summaries.

Every profile row can also carry **`markdown`**, Clutch's own LLM-ready
rendering of the page, at no extra cost. Add `html` for the raw page source.

### Use cases

- **Build a marketing agency database**: a filtered list of digital marketing
  agencies by service, location, budget band, and rating, each with its real website.
- **Competitive intelligence**: track how rivals price, which services they
  lead with, and what clients actually say about them.
- **Shortlist B2B service providers**: compare verified providers on cost
  rating, typical project size, and industry experience before an RFP.
- **CRM enrichment and AI agents**: integrate company data into a CRM using the
  API, or feed the markdown straight into a vector store without converting HTML
  to text first.
- **Market research**: measure service-mix and pricing trends across a whole
  category or country, or export a list of software development companies for
  an entire region.

### Input parameters

| Field | Type | Notes |
|---|---|---|
| `mode` | string | `directory` (default), `profiles`, or `search`. |
| `directoryUrls` | array | Any Clutch category or location page, e.g. `https://clutch.co/web-developers`. |
| `maxPagesPerDirectory` | integer | Result pages per directory URL. Each page carries 70-90 companies. |
| `profileUrls` | array | Company profiles, e.g. `https://clutch.co/profile/ignite-visibility`. A bare slug works too. |
| `searchQueries` | array | Free-text queries, e.g. `shopify development`. |
| `includeReviews` | boolean | Return every verified review as its own row. Default `true`. |
| `maxReviewsPerProfile` | integer | Cap on reviews per company. |
| `outputFormats` | array | `json`, `markdown` (default), and optionally `html`. |
| `maxItems` | integer | Hard ceiling on rows for the run. Use it as a spend cap. |

### Example output

```json
{
  "result_type": "profile",
  "name": "Ignite Visibility",
  "slug": "ignite-visibility",
  "profile_url": "https://clutch.co/profile/ignite-visibility",
  "website": "https://ignitevisibility.com",
  "rating": 4.8,
  "review_count": 175,
  "is_verified": true,
  "verification": ["Premier Verified"],
  "min_project_size": "$1,000+",
  "hourly_rate": "$100 - $149",
  "employees": "250 - 999",
  "founded_year": 2013,
  "headquarters": "San Diego, CA",
  "cost_rating": 4.7,
  "most_common_project_size": "$50,000 to $199,999",
  "service_lines": [{ "name": "Search Engine Optimization", "percent": 30 }],
  "clients": [{ "name": "Midmarket ($10M - $1B)", "percent": 50 }],
  "review_ratings": { "quality": 4.8, "schedule": 4.9, "cost": 4.7, "willing_to_refer": 4.8 },
  "markdown": "# Ignite Visibility\n## Company Information\n..."
}
```

#### Output fields

Every row carries `result_type` (`listing`, `profile`, `review`, or `error`) and
`fetched_at`. Two ready-made dataset views are included: **Companies Overview**
and **Client Reviews**. Full field descriptions are in the Output tab.

### Pricing

Pay per row, with no start fee:

| Event | What it covers |
|---|---|
| `listing-scraped` | One company row from a directory page. |
| `profile-scraped` | One full company profile. |
| `review-scraped` | One verified client review. |

You are only charged for rows actually delivered. Failed pages produce an error
row and are not billed as results. `maxItems` is a hard ceiling on the run.

A company that appears on more than one directory page (sponsored and featured
cards repeat) is de-duplicated and billed **once**.

### How to get started

1. Pick a `mode`. To browse a category, leave it on `directory` and paste a
   Clutch URL such as `https://clutch.co/web-developers`.
2. Set `maxItems` as your spend ceiling.
3. Run it, then export from the dataset as JSON, CSV, or Excel.

Call it from the API:

```bash
curl -X POST "https://api.apify.com/v2/acts/johnvc~clutch-agency-api/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"directory","directoryUrls":["https://clutch.co/web-developers"],"maxItems":50}'
```

### 🔌 Use this API from Claude (MCP)

This Actor is MCP-compatible, so Claude and other AI agents can call it directly.
Add it to Claude Code:

```bash
claude mcp add clutch --transport http "https://mcp.apify.com/?actors=johnvc/clutch-agency-api"
```

New to Claude? [Start a free trial](https://claude.ai/referral/uIlpa7nPLg).

### 💸 Pay per run with crypto (x402)

This Actor supports x402, so an agent can pay per run in USDC without an Apify
subscription. Useful when an autonomous agent needs Clutch data on demand.

### Speed and reliability

Pages are fetched with a browser-grade TLS fingerprint, which is what Clutch's
protection actually checks. Measured across 150 consecutive profile fetches:
**zero blocks** and a 0.12s median response. Requests inside a chunk run in
parallel, and rows are written as each chunk completes, so a long run streams
results rather than holding them to the end.

### 🔌 Integrations

Works with everything on the Apify platform: scheduled runs and saved tasks,
n8n, Make, Zapier, webhooks, and direct REST access. Push results into Supabase,
Google Sheets, or a vector store, or let an agent call it over MCP.

### 🔗 Related tools

- **Google Maps Places API**: local business data with contact details.
- **LinkedIn Company API**: company firmographics and headcount.
- **Crunchbase Company API**: funding and investor data.
- **G2 Reviews API**: software reviews, the B2B software counterpart to Clutch.

More at [Alpha OSINT](https://www.alphaosint.com).

### ❓ FAQ

**Do I need a Clutch account or API key?**
No. There is nothing to configure. Just give it a URL.

**Can I get every review for a company?**
Yes. Set `includeReviews` to true and raise `maxReviewsPerProfile`. Reviews are
paginated until the company's declared total is reached.

**What is the markdown for?**
It is Clutch's own AI-oriented rendering of the page. Because it comes from the
same request as the structured data, it costs nothing extra, and it is a better
RAG input than HTML converted to text.

**Why does a directory page return more than 50 companies?**
Clutch mixes sponsored and featured cards into the organic list. All of them are
returned, de-duplicated across pages so you are never billed twice.

**Do I get the company's real website?**
Yes. Clutch's outbound links carry referral tracking; those parameters are
stripped so you get the clean homepage URL.

**Why do some profiles have so few fields?**
Many Clutch profiles are genuinely thin. A large share have no reviews and
little published detail. Those rows return what exists rather than guessing.

**Can I filter by rating or location?**
Use a Clutch directory URL that already encodes the filter (Clutch has pages for
most service and location combinations), then filter the dataset afterwards.

**How do I integrate this company data into a CRM using an API?**
Run the Actor over the API or a webhook, then map `name`, `website`, `location`,
`employees`, and `min_project_size` onto your CRM fields. Every row is flat JSON,
so most CRMs will take it without a transformation layer in between.

**How does a company data enrichment API work here?**
You give it a profile URL, or let directory mode find the companies for you.
Each row comes back with firmographics, service mix, pricing bands, and review
history already parsed into fields, so there is nothing left to extract.

**Which B2B data platform is better for lead generation?**
It depends on what you are qualifying on. General firmographic providers know
company size and industry. Clutch knows what a buyer weighs when picking a
vendor: verified client reviews, published rates, minimum project size, and
service mix. This Actor gives you that second layer.

**How do B2B lead generation tools compare to agencies?**
A tool gives you the raw list and the filters; an agency gives you outreach. This
Actor covers the first half, and the data it returns is what most agencies would
be sourcing manually anyway.

**Is scraping Clutch.co legal?**
This Actor collects only publicly available pages. You are responsible for how
you use the data, including under GDPR and CCPA where applicable.

### 🌐 About Alpha OSINT

Built and maintained by [Alpha OSINT](https://www.alphaosint.com), a portfolio
of open-source-intelligence and market-data APIs on Apify.

# Actor input Schema

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

Directory mode walks a Clutch category or location page and returns one row per listed company. Profiles mode collects specific companies in full, with their client reviews. Search mode runs a keyword query and then collects the companies it finds.

## `directoryUrls` (type: `array`):

Clutch category, location, or industry pages. Any Clutch directory path works, for example https://clutch.co/web-developers or https://clutch.co/us/agencies/digital-marketing/chicago. Each company row is charged once. Need larger batches? Contact us and we can raise this limit for your account.

## `maxPagesPerDirectory` (type: `integer`):

How many result pages to read per directory URL. Each page carries about 50 companies. Pages are fetched only up to this limit, so raising it is what increases both results and cost.

## `profileUrls` (type: `array`):

Clutch company profiles to collect in full, for example https://clutch.co/profile/ignite-visibility. A bare slug such as ignite-visibility also works. Need larger batches? Contact us and we can raise this limit for your account.

## `searchQueries` (type: `array`):

Free-text queries run against Clutch search, for example "shopify development" or "healthcare branding". Matching companies are then collected as full profiles.

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

Return every verified client review for each company as its own row, with project size, project length, sub-ratings, reviewer role, and summaries. Applies to profile and search modes.

## `maxReviewsPerProfile` (type: `integer`):

Upper bound on reviews collected per company. The first page of a profile already carries about 40 reviews at no extra cost; higher values page deeper and cost more.

## `outputFormats` (type: `array`):

JSON gives structured fields. Markdown adds Clutch's own LLM-ready markdown for the page, which costs nothing extra and is ideal for RAG and AI agents. HTML adds the raw page source and costs one additional request per company.

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

Overall cap on rows returned by this run, across listings, profiles, and reviews. Use it as a hard spend ceiling.

## Actor input object example

```json
{
  "mode": "directory",
  "directoryUrls": [
    "https://clutch.co/web-developers"
  ],
  "maxPagesPerDirectory": 1,
  "profileUrls": [
    "https://clutch.co/profile/ignite-visibility"
  ],
  "searchQueries": [
    "shopify development"
  ],
  "includeReviews": true,
  "maxReviewsPerProfile": 100,
  "outputFormats": [
    "json",
    "markdown"
  ],
  "maxItems": 1000
}
```

# Actor output Schema

## `allResults` (type: `string`):

Every dataset item from this run: listings, profiles, reviews, and any error rows.

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

Tabular overview: name, rating, review count, minimum project size, hourly rate, employees, location, and website.

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

Every client review with its project details, ratings, reviewer, and summaries.

# 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 = {
    "directoryUrls": [
        "https://clutch.co/web-developers"
    ],
    "profileUrls": [
        "https://clutch.co/profile/ignite-visibility"
    ],
    "searchQueries": [
        "shopify development"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/clutch-agency-api").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 = {
    "directoryUrls": ["https://clutch.co/web-developers"],
    "profileUrls": ["https://clutch.co/profile/ignite-visibility"],
    "searchQueries": ["shopify development"],
}

# Run the Actor and wait for it to finish
run = client.actor("johnvc/clutch-agency-api").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 '{
  "directoryUrls": [
    "https://clutch.co/web-developers"
  ],
  "profileUrls": [
    "https://clutch.co/profile/ignite-visibility"
  ],
  "searchQueries": [
    "shopify development"
  ]
}' |
apify call johnvc/clutch-agency-api --silent --output-dataset

```

## MCP server setup

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

```

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/JYnIiqxn4hMnWZiKQ/builds/eA3ovyqTOaM4qZtI3/openapi.json