Clutch Scraper | Companies, Reviews & Buyer Leads

Scrape Clutch.co company profiles, project reviews and buyer-company details. Export agency data for vendor research and lead qualification. Requested reviews and deterministic insights share one company-bundle fee.

Useful for: Compare agencies; read project budgets and client feedback; organize buyer-company evidence for vendor research.

Why choose this Actor: One delivered company bundle includes requested public reviews, buyer leads and deterministic review insights without separate developer review fees. Optional AI uses your chosen provider.

Try a small sample

1. Click Try for free, then open Input and switch to JSON.
2. Paste the example below and click Start. It uses a small result limit.
3. Open the dataset to inspect results, then export JSON, CSV or Excel. Source restrictions can still cause partial or failed runs.

{
  "startUrls": [
    {
      "url": "https://clutch.co/profile/ddnyc-0"
    }
  ],
  "includeCompanyReviews": true,
  "extractBuyerLeads": true,
  "maxItems": 1,
  "maxPages": 1,
  "maxReviewsPerCompany": 5
}

Cost at a glance

Primary billing unit: Delivered company bundle. Rates below are per 1,000 primary events.

Free plan	Starter / Bronze	Scale / Silver	Business / Gold and higher
$1.4	$1.4	$1.26	$1.12

Platform compute, proxy, transfer and storage are additional. Optional AI provider usage is billed separately. Other event types, where enabled, are listed in the Pricing tab. “Try for free” uses available account credits; it does not make usage unlimited or unmetered.

Coverage to know: Directory/profile access and review depth depend on Clutch responses. Missing fields remain unknown. AI provider charges and access requirements are separate.

Guides and full reference

Collect public company profiles, project reviews and buyer-company details from Clutch. Independently developed; not affiliated with Clutch.

Implemented: directory pagination, company identity checks, JSON-LD company details, public reviews and rating dimensions, buyer-company/project records, review deduplication, bounded collection, optional proxies, transient retries, and explicit partial results when a profile or later review page fails.

Optional reviewInsights: true requires includeCompanyReviews: true. It adds rating-based sentiment counts, negative-review keyword themes with evidence links, and request snippets; it is not AI analysis.

A further cloud check on September 9, 2026 covered three non-US profiles: Bob's Your Uncle (Canada, 24 reviews over 3 pages), Human Digital (Australia, 21 over 3), and Creativos RD (Mexico, 18 over 2). All 63 review IDs were unique within their company, review totals matched the source, buyer records matched review counts, and no coverage warnings were emitted. Three company events were charged, with no separate review, buyer or insight event. These are three source snapshots, not universal country coverage.

Coverage depends on the target and selected provider; universal competitor parity is not claimed. Source-derived legal fields, compatibility mode and cloud PPE mechanics are implemented and have bounded evidence; missing source values remain unknown.

Invalid option combinations fail explicitly rather than being silently ignored. Pay-per-event pricing applies to delivered company bundles. No guarantee of complete review history: check pagination diagnostics, source counts and warnings.

enrichEmails fetches up to three public company website pages and returns published emails with provenance. qualifyByPayment requires enrichment and identifies payment integration URLs, not actual revenue. No visible integration is unknown, not proof a business does not take payments. Neither feature uses personal logins.

Budget handling: maxCostUsd caps company-bundle event fees across all inputs using the effective Apify price. Zero means no extra event cap. Platform usage is separate. The platform maximum-total-charge setting also limits event charges; it does not impose an all-inclusive resource or AI spending ceiling. Company-bundle event rates are $1.40 per 1,000 for Free/Bronze, $1.26 for Silver, and $1.12 for Gold and higher tiers. These are company fees only: compute, proxy, storage and any AI provider usage are additional. There is no custom review, buyer-lead, deterministic-insight or start fee. Listing-only fallback and error rows have no company event charge. Private cloud billing checks passed for normal delivery, a platform budget limit, a sub-result custom budget and a failed source. These verify event accounting, not customer revenue.

AI analysis (painPointAnalysis: true) requires reviews. The default aiProvider: "apify" uses the official Apify OpenRouter service with the running account's runtime token and requires that account's service entitlement. Alternatively, set aiProvider: "openrouter" and supply your own openrouterApiKey in the encrypted input field to use the direct OpenRouter API. Direct calls charge your OpenRouter account and do not require access to the Apify OpenRouter Actor. There is no automatic provider fallback and no embedded developer credential. Direct-provider contract tests passed locally; live provider availability depends on the selected model and your account. AI calls are separately billed by the selected provider, outside this Actor's company-event budget; parent-run usage alone is not total AI cost. Up to 200 reviews are analyzed, with the first 1,500 characters of each; affected review IDs are reported. Model findings are interpretations linked to review IDs, not verified facts. Provider errors preserve the collected reviews and emit an analysis failure warning.

Company serviceLines now include published percentage slices; serviceLineNames preserves plain names. chartPie retains source service/focus/industry/client breakdowns. Missing source charts remain null rather than invented zeroes.

Pricing and total usage cost

This Actor uses pay-per-event pricing for each delivered structured company bundle. Platform compute, proxy traffic, data transfer and storage are additional. Pricing is not an all-inclusive quote.

Apify discount tier	Company fee per 1,000
Free / Bronze	$1.40
Silver	$1.26
Gold / Platinum / Diamond	$1.12

Requested reviews, buyer leads and deterministic review insights have no additional developer event fee. Listing-only fallbacks and error rows have no company fee, although attempted requests can still incur platform usage. There is no developer start fee. External AI-provider charges are separate, and availability depends on your selected provider and credentials.

A measured two-page, 100-company sample used approximately $0.0596 in platform resources at public Starter/Bronze rates. Adding $0.14 in company fees gives approximately $0.1996 in marginal run charges for that sample. This excludes the monthly plan commitment, taxes, post-run exports and time-based retention. It is a workload estimate, not a guarantee: retries, memory, target responses and optional enrichment change usage.

See Apify customer pricing for resource tariffs. Both company fees and metered resources consume the usage credit in the customer's plan. Use maxCostUsd to bound company events; it does not cap resource or external AI charges. Review the platform usage limits, run timeout and input limits as well.

Migrating default configuration

Set compatibilityMode to competitor to use the current competitor default configuration when fields are omitted: maxConcurrency:100, minConcurrency:1, maxRequestRetries:100, and Apify RESIDENTIAL proxy. The default balanced mode retains max5/min1/retries2/no proxy. Explicit parameters override either mode; when changing modes in Console, clear previously filled override fields if you want the mode defaults. OUTPUT.effectiveOptions records applied numeric settings without proxy credentials.

minConcurrency is the initial and minimum target for profile workers. Successful profiles increase the target toward maxConcurrency; partial/error profiles reduce it. Already-running requests are allowed to finish. Output order follows source order. This is our bounded scheduler, not a claim to replicate the competitor's internal autoscaler. Permanent403 responses still fail directly rather than repeating identical denied requests; retries cover transient failures. Residential proxy traffic and prolonged retries can increase platform costs, and maxCostUsd only caps configured company-result events. AI-provider entitlement and full output parity remain separate acceptance gaps.

Delivery accounting uses the SDK's accepted charged count for priced company events. Zero-priced events may save rows without a billed event; error and listing-only fallback rows have no company-bundle fee. A positive default dataset-item fee alongside company-bundle pricing is rejected to prevent duplicate charges. Collection saves completed profiles in source order, including within a directory page. Later requests may still be in flight when an earlier profile is saved; an unfinished earlier profile can delay later results to preserve ordering. The SDK remaining result budget bounds profile requests before each batch; a company profile and its requested reviews still finish together. Remaining in-flight requests finish normally if a delivery budget stop occurs; no new requests are submitted. Confirmed writes are recorded in DELIVERY_PROGRESS. Uncertain writes fail without automatic replay. Additional full-review and directory active-price cloud cases are tracked separately; the basic four-case cloud billing matrix passed. Local SDK budget tests are not evidence of customer payment.

OUTPUT reports structuredCompanyRows, partialCompanyRows, listingOnlyRows, and errorRows for observed results. Partial profiles can have structured identity but incomplete optional details; listing-only rows have no retrieved profile identity. A nonempty run with no structured company profiles fails explicitly after retaining available diagnostics and listing fallbacks. These counters describe observed rows; use delivery.rowsSaved for acknowledged dataset delivery, especially after a budget stop or uncertain write.

Viewing and exporting results

The default dataset keeps one row per company, preserving nested reviews and buyer leads for API compatibility. Console provides four views: Companies, Contacts and locations, Review coverage, and Diagnostics. Changing a view does not remove fields from the stored records. Use JSON export to preserve nested arrays; CSV consumers should choose and flatten the fields they need.

The Output tab provides the company dataset and a native Run reports and saved progress record list. Open OUTPUT for coverage/budget status or DELIVERY_PROGRESS for confirmed writes. The underlying JSON API record paths remain available to clients. A zero-result run might not create a progress record. A failed or interrupted run can have saved data without a final OUTPUT; inspect run status and confirmed progress together.

Coverage is bounded by your inputs: maxItems limits companies per start URL, maxPages bounds directory and review pagination, and maxReviewsPerCompany bounds review count. Overlapping company URLs are deduplicated across inputs. reviewsFetched is the returned count; compare it with reviewCount and inspect warnings. A successful run is not proof of exhaustive source coverage.

Python API example

This standard-library client can start a run or resume observing an existing run. Set APIFY_TOKEN in your environment using your own Apify token; never place it in the input JSON. Use your own Apify account and token to run this public Actor.

Save this input as input.json:

{
  "startUrls": [
    "https://clutch.co/profile/ddnyc-0"
  ],
  "includeCompanyReviews": true,
  "extractBuyerLeads": true,
  "reviewInsights": true,
  "maxReviewsPerCompany": 500,
  "maxPages": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}

Save the following script as export_companies.py, then run:

python3 export_companies.py --input input.json --out-dir clutch-export --max-charge 0.03

--max-charge limits Actor event charges. Platform resources and external AI usage are additional; it is not an all-inclusive spending limit. Use reasonable input limits and the platform run timeout as well.

The script saves run-id.txt immediately after a confirmed submission. After a connection interruption, use the saved ID:

python3 export_companies.py --run-id YOUR_RUN_ID --out-dir clutch-export

Resume reads the same run; it does not repeat the crawl. If the original submission itself lost its response before returning an ID, inspect Console before submitting again. JSON output retains all nested reviews and buyer leads. Exit code 2 means the run failed or coverage is partial/limited (including an intentional directory limit); available records are still exported. Exporting a failed run does not imply successful source collection.

#!/usr/bin/env python3
"""Standard-library API client; explicit resume and partial-result reporting."""
import argparse,json,os,time,sys
from pathlib import Path
from urllib.request import Request,urlopen
from urllib.error import HTTPError
from urllib.parse import urlencode,quote

BASE='https://api.apify.com/v2/'
TERMINAL={'SUCCEEDED','FAILED','ABORTED','TIMED-OUT'}

def request(path,token,body=None,missing_ok=False):
    data=json.dumps(body).encode() if body is not None else None
    req=Request(BASE+path,data=data,headers={'Authorization':'Bearer '+token,'Content-Type':'application/json'})
    try:
        with urlopen(req,timeout=60) as response:return json.load(response)
    except HTTPError as exc:
        if missing_ok and exc.code==404:return None
        raise RuntimeError(f'Apify HTTP {exc.code}; inspect account access and run status') from None
    except (OSError,ValueError):
        detail='Run submission outcome is uncertain; inspect Console before submitting again.' if body is not None else 'Read failed; resume with the saved run ID.'
        raise RuntimeError(detail) from None

def download_dataset(dataset_id,token,call=request):
    rows=[]
    while True:
        batch=call('datasets/'+quote(dataset_id,safe='')+'/items?'+urlencode({'format':'json','clean':'true','limit':1000,'offset':len(rows)}),token)
        if not isinstance(batch,list):raise RuntimeError('Expected dataset array')
        rows.extend(batch)
        if len(batch)<1000:return rows

def is_incomplete(status,rows,report):
    return (status!='SUCCEEDED' or report is None
            or report.get('delivery',{}).get('platformChargeLimitReached',False)
            or any(not x.get('complete',False) for x in report.get('sourceDiagnostics',[]))
            or any(x.get('type')=='error' or x.get('coverage')=='partial' or x.get('warnings') for x in rows))

def main(argv=None):
    parser=argparse.ArgumentParser(description=__doc__)
    source=parser.add_mutually_exclusive_group(required=True)
    source.add_argument('--input',type=Path,help='Actor input JSON file')
    source.add_argument('--run-id',help='Resume observing an existing run; does not create another run')
    parser.add_argument('--out-dir',type=Path,default=Path('clutch-export'))
    parser.add_argument('--max-charge',type=float,default=.05,help='Per-run event spending cap in USD')
    args=parser.parse_args(argv)
    token=os.environ.get('APIFY_TOKEN')
    if not token:parser.error('Set APIFY_TOKEN in your environment; do not put it in the input JSON')
    import math
    if not math.isfinite(args.max_charge) or args.max_charge<=0:parser.error('--max-charge must be positive')
    args.out_dir.mkdir(parents=True,exist_ok=True);handle=args.out_dir/'run-id.txt'
    if args.input:
        if handle.exists():parser.error('This output directory already has a run ID. Resume with --run-id or choose another directory.')
        body=json.loads(args.input.read_text())
        result=request('acts/peerless_columbine~clutch-companies-reviews-scraper/runs?'+urlencode({'maxTotalChargeUsd':args.max_charge}),token,body)
        run_id=result['data']['id'];handle.write_text(run_id+'\n')
    else:
        run_id=args.run_id
        if handle.exists() and handle.read_text().strip()!=run_id:parser.error('Output directory belongs to a different run')
        handle.write_text(run_id+'\n')
    print('Run ID:',run_id,flush=True)
    while True:
        run=request('actor-runs/'+quote(run_id,safe=''),token)['data']
        if run['status'] in TERMINAL:break
        time.sleep(5)
    rows=download_dataset(run['defaultDatasetId'],token)
    report=request('key-value-stores/'+quote(run['defaultKeyValueStoreId'],safe='')+'/records/OUTPUT',token,missing_ok=True)
    incomplete=is_incomplete(run['status'],rows,report)
    (args.out_dir/'companies-and-diagnostics.json').write_text(json.dumps(rows,ensure_ascii=False,indent=2))
    (args.out_dir/'report.json').write_text(json.dumps({'runId':run_id,'status':run['status'],'incomplete':incomplete,'recordCount':len(rows),'report':report},indent=2))
    print(f"{run['status']}: {len(rows)} records saved; incomplete={incomplete}")
    return 2 if incomplete else 0

if __name__=='__main__':
    try:sys.exit(main())
    except RuntimeError as exc:print(str(exc),file=sys.stderr);sys.exit(1)

API compatibility and run defaults

The run response exposes output.results as the canonical dataset URL, matching the competitor's documented output schema. output.companies remains an alias for earlier private-build integrations. Both refer to the same stored records; they do not represent additional results or charges. The report list is an additional output.

The Actor's default timeout is 3,600 seconds with 512 MB allocated memory. These are run settings rather than input fields; an explicit Console or API override takes precedence. A timeout is not a guarantee of full-source coverage: check the final run status and coverage diagnostics. The measured 100-company/two-page sample took approximately 426 seconds on an earlier runtime, so a 300-second default would be insufficient for that workload.

Optional free AI model

Set aiProvider to openrouter and aiModel to nex-agi/nex-n2.5-mini:free, and enter your OpenRouter key in the encrypted input. The model listing had zero input/output token prices when checked on September 10, 2026. Free models still require authentication and have provider rate limits; this Actor never falls back to a paid model. Ordinary Apify scraping charges remain. Direct OpenRouter free inference passed a three-review cloud sample on September 10, 2026; this does not establish general model quality or continuous provider availability. AI analysis remains optional and defaults off.