# Company Enrichment + ICP Fit Scorer (AI Company Profiler) (`signalforgedata/ai-company-profiler`) Actor

AI company enrichment and lead qualification from any domain list: structured company profiles (industry, products, customers, size, contacts, tech stack, hiring) plus a 0 to 100 ICP fit score with cited reasons and a personalized opener. Pay per company, failed sites free.

- **URL**: https://apify.com/signalforgedata/ai-company-profiler.md
- **Developed by:** [Landon Odom](https://apify.com/signalforgedata) (community)
- **Categories:** Lead generation, AI, Business
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Company Enrichment + ICP Fit Scorer (AI Company Profiler)

AI company enrichment and lead qualification from a plain list of domains. Turn company websites into clean, structured company profiles, then score every company against your ideal customer profile (ICP) with cited reasons, a personalized opening line and talking points. Built for lead qualification, account research, list enrichment, TAM analysis and CRM cleanup. Powered by Claude.

Paste domains in, get rows out. No API keys, no setup, no per-seat subscription: you pay $0.015 per company profiled, $0.010 more for an ICP score, and nothing for sites that fail.

**Typical jobs it replaces:** enriching a scraped lead list before outreach, qualifying inbound signups by company, researching 500 target accounts for a territory plan, checking which companies in a list use HubSpot or Salesforce, building a company research tool for an AI agent.

### What you get for each company

**Company profile**

- Company name, tagline, 2 to 4 sentence description (factual, no marketing fluff)
- Industry, business model (B2B, B2C, marketplace...), company type (software, services, agency, manufacturer...)
- Products and services, target customers, notable customers named on the site
- Headquarters, other locations, estimated employee range, founding year
- Pricing model (tiers, quote-based, free plan), hiring signal from careers pages, recent news on the site
- Key people with titles (executives and founders named on the site)
- Likely buyer roles for this company (labeled as an estimate)
- `inferredFields`: which values are estimates rather than facts stated on the site, so you always know what is sourced and what is judged
- Business emails and phone numbers published on the site (role-based mailboxes only, never personal addresses)
- LinkedIn, X, Facebook, Instagram, YouTube, GitHub and Crunchbase links
- Tech signals detected in the site code (HubSpot, Salesforce, Intercom, Shopify, Webflow, Greenhouse and 40+ more)
- Any extra fields you ask for, in plain English
- Confidence score and the list of pages analyzed, so every claim can be checked

**ICP fit (when you describe your ideal customer)**

- Fit score from 0 to 100
- One-sentence verdict
- Up to three reasons for and three reasons against, each tied to evidence from the site
- Deal breaker flag
- A personalized opening line that references something real about the company
- Up to three talking points grounded in what the site says (a launch, a hiring push, a tool they use) that connect to what you sell

### Why this instead of a generic enrichment API

- **Reads the actual website.** Enrichment databases go stale. This Actor fetches the homepage and the most informative internal pages (about, product, pricing, customers, careers, contact) every time you run it. When a homepage is JavaScript-rendered or has no usable navigation, it falls back to the sitemap and the standard company pages so you still get a full profile.
- **Tells you what is stated and what is estimated.** Every row carries `inferredFields` and a confidence score. Nothing is invented; unknowns come back as `Unknown`, `null` or empty.
- **Scores against your criteria, not a fixed taxonomy.** Describe your ICP in a paragraph. Must-haves, nice-to-haves and deal breakers are applied strictly and every reason cites what was found.
- **Custom fields.** Add a line like `integrations: third-party tools the product integrates with` and it comes back as a column.
- **Honest failures.** Sites that are down, parked, blocked or JavaScript-only are returned with `status: failed` and a reason. You are never charged for them.
- **Works with any language website.** Output is in the language you choose.

### Input

| Field | Description |
|---|---|
| `domains` | One company website per line. Full URLs, bare domains and even email addresses are normalized to the site root. Duplicates are removed. Up to 10,000 per run. |
| `icp` | Optional. Describe who you sell to. When present, every company gets a fit score. |
| `customFields` | Optional. One per line as `fieldName: what to look for`. |
| `maxPagesPerDomain` | Homepage plus the best internal pages. Default 5, max 12. |
| `model` | `fast` (Claude Haiku) for volume, `precise` (Claude Sonnet) for nuanced ICPs or messy sites. |
| `language` | Output language for free-text fields. Default English. |
| `maxConcurrency` | Websites crawled in parallel. Default 10. |
| `proxyConfiguration` | Rarely needed. Turn on Apify Proxy only if some sites block datacenter traffic. |

Example input:

```json
{
    "domains": ["stripe.com", "notion.so", "basecamp.com"],
    "icp": "B2B SaaS companies with 20 to 500 employees in the US or Europe that sell to sales or marketing teams. Good signals: hiring in sales, using HubSpot or Salesforce, public pricing. Deal breakers: agencies, consultancies, no product.",
    "customFields": "integrations: third-party tools the product integrates with\nfreeTrial: whether a free trial or free plan is offered",
    "maxPagesPerDomain": 5,
    "model": "fast"
}
```

### Output

One dataset item per company. Example (shortened):

```json
{
    "domain": "acme-robotics.com",
    "status": "ok",
    "companyName": "Acme Robotics",
    "tagline": "Autonomous forklifts that pay for themselves in 9 months",
    "description": "Acme Robotics builds self-driving forklifts and the fleet software that dispatches them. It sells robots-as-a-service to third-party logistics providers and manufacturers in North America, integrating with Manhattan and SAP warehouse systems.",
    "industry": "Warehouse robotics",
    "businessModel": "B2B",
    "companyType": "Manufacturer",
    "productsServices": ["AutoLift 2 autonomous forklift", "FleetOS dispatch software", "Safety analytics dashboard"],
    "targetCustomers": "Operations leaders at 3PLs and manufacturers running mid-size warehouses",
    "notableCustomers": ["Zippy Logistics", "Norther Foods"],
    "headquarters": "Austin, Texas, United States",
    "employeeRange": "51-200",
    "foundedYear": 2016,
    "pricingModel": "Robots-as-a-service from $2,900 per forklift per month; enterprise quote-based",
    "hiringSignal": "Hiring a mid-market Account Executive, a Field Service Engineer and a Senior Robotics Engineer",
    "keyPeople": [{ "name": "Jane Doe", "role": "CEO" }, { "name": "Raj Patel", "role": "CTO" }],
    "buyerRoles": ["VP Operations", "Director of Warehouse Operations", "CFO"],
    "inferredFields": ["employeeRange", "buyerRoles"],
    "emails": ["sales@acme-robotics.com", "support@acme-robotics.com"],
    "phones": ["+1 (512) 555-0142"],
    "linkedin": "https://www.linkedin.com/company/acme-robotics",
    "techSignals": ["HubSpot", "Intercom", "Webflow"],
    "custom": { "integrations": "Manhattan WMS, SAP EWM", "freeTrial": "No; demo request only" },
    "confidence": 0.86,
    "fitScore": 78,
    "fitSummary": "Strong fit: B2B product company in the target size band, hiring in sales and running HubSpot; outside the stated geography focus on software.",
    "reasonsFor": ["Sells a product, not services, with public pricing", "Hiring an Account Executive now", "HubSpot detected on the site"],
    "reasonsAgainst": ["Hardware-led rather than pure SaaS"],
    "dealBreakerHit": false,
    "openingLine": "Your careers page shows a mid-market AE role opening in Austin alongside the FleetOS launch, which usually means pipeline is outgrowing the team.",
    "talkingPoints": ["The FleetOS launch and the new AE role suggest outbound volume is about to rise", "HubSpot is already in place, so a native integration removes the usual objection", "Robots-as-a-service pricing means they sell on ROI, which matches a payback-period pitch"],
    "sourcePages": ["https://acme-robotics.com/", "https://acme-robotics.com/about", "https://acme-robotics.com/product", "https://acme-robotics.com/pricing", "https://acme-robotics.com/careers"],
    "pagesAnalyzed": 5
}
```

Failed companies look like this and are free:

```json
{ "domain": "example-parked.com", "status": "failed", "error": "Site returned no readable text (blocked, parked, or requires JavaScript)" }
```

Export to CSV, Excel, JSON or feed the dataset into Clay, HubSpot, Salesforce, Google Sheets, Airtable or n8n with the Apify integrations.

### Pricing

Pay per event. You only pay for companies that produced a usable profile.

| Event | Price |
|---|---|
| Company profile | $0.015 per company |
| ICP fit score (only when an ICP is provided) | $0.010 per company |
| Failed or unreachable site | Free |

1,000 companies profiled and scored costs $25. Set a maximum charge on the run to cap spend; the Actor stops cleanly when it is reached and tells you how many companies were left.

### How it compares

| | Database enrichment APIs | Keyword-based website scorers | This Actor |
|---|---|---|---|
| Data source | Stored records, refreshed on the vendor's schedule | Live page text | Live pages, up to 12 per company, with sitemap and page-probing fallbacks |
| Company description, products, customers | Sometimes | No | Yes, written from the site itself |
| ICP scoring | Fixed firmographic filters | Keyword matches | Plain-English ICP with must-haves and deal breakers, strict scoring, cited reasons |
| Personalization | No | No | Opening line and talking points grounded in the site |
| Custom fields | No | No | Yes, in plain English |
| Stated vs estimated labeling | No | No | `inferredFields` plus confidence on every row |
| Failed lookups | Often billed | Varies | Free |
| Typical price per company | $0.02 to $0.20 | under $0.01 | $0.015, plus $0.01 with ICP scoring |

### Use cases

- **Qualify scraped lead lists** from Google Maps, LinkedIn, directories or trade-show exports before anyone touches them.
- **Enrich a CRM** with industry, size, location, contacts and tech stack straight from each company's own site.
- **Account research at scale** for outbound teams: one personalized opener per account, grounded in what the company actually says.
- **Territory and TAM analysis**: score a whole market segment against an ICP and sort by fit.
- **Competitor and partner mapping**: ask for custom fields like `partners`, `integrations` or `certifications`.
- **AI agent tool**: expose this Actor through Apify's MCP server so your agent can look up any company on demand.

### Use from code or an AI agent

Run it from the Apify API, the JavaScript or Python client, or as an MCP tool:

```bash
curl -X POST "https://api.apify.com/v2/acts/<username>~ai-company-profiler/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{ "domains": ["stripe.com"], "icp": "Fintech companies with public APIs" }'
```

**As an MCP tool in Claude Desktop, Cursor, Windsurf or any MCP client.** Apify's MCP server exposes this Actor as a tool. Add this to your client's MCP config (get a token at console.apify.com/settings/integrations):

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=signalforgedata/ai-company-profiler",
      "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }
    }
  }
}
```

Then ask your agent: "Profile acme.com and tell me whether it fits an ICP of mid-market logistics companies in Texas." The agent gets back the full structured profile and fit assessment.

**From n8n, Make or Zapier.** Use the Apify node or module, pick this Actor, pass `domains` as an array, and map the dataset items to Google Sheets, HubSpot, Salesforce, Airtable or Clay.

### Limits and notes

- Only public pages are read, and `robots.txt` is respected. Sites that require JavaScript to render text may come back as failed; try `precise` mode or enable Apify Proxy if a site blocks datacenter traffic.
- Employee range and founding year are estimates from site evidence; `Unknown` or `null` means the site gave no evidence. Nothing is invented.
- Contact details are business contacts published on the site (sales@, support@, main phone). The Actor does not look up individuals or scrape social networks.
- Typical speed: 100 companies in about 2 to 4 minutes at default settings.

### FAQ

**Does it work for non-software companies?** Yes. Contractors, clinics, manufacturers, agencies, nonprofits and local businesses all produce profiles; the company type and industry fields adapt.

**Can I bring my own Anthropic key?** Yes, set `anthropicApiKey` in the input. Pricing per company stays the same.

**How accurate is the ICP score?** It is strict by design: unmet must-haves cap the score at 40 and deal breakers at 20, and every reason cites evidence. Write your ICP the way you would brief a new SDR, with explicit must-haves and deal breakers, for the best results.

**What if a site is in another language?** Source pages can be in any language. Set `language` to control the output.

**How does it compare with company enrichment APIs like Clearbit, Apollo or ZoomInfo?** Those return records from a database that may be months old and charge per credit whether or not the record is useful. This Actor reads each company's live website at run time, writes the profile from what it finds, labels estimates, and never charges for a site it could not read. It is a complement, not a replacement, when you need verified emails for individuals.

Questions or feature requests: open an issue on this Actor's page. Fields people ask for get added.

If it saved you time, a short review on this page helps other sales and RevOps teams find it. Honest feedback, good or bad, shapes what gets built next.

# Actor input Schema

## `domains` (type: `array`):

One company website per line, for example `stripe.com` or `https://www.notion.so`. Up to 10,000 per run. Duplicates and subpaths are normalized to the site root.

## `icp` (type: `string`):

Describe who you sell to in plain English: industry, company size, geography, tech used, buying triggers, deal breakers. When filled in, every company gets a 0 to 100 fit score, three reasons, risks and a personalized opening line. Leave empty to only build profiles (cheaper).

## `customFields` (type: `string`):

One per line, as `fieldName: what to look for`. Example: `integrations: third-party tools the product integrates with`. These appear under `custom` in each result.

## `maxPagesPerDomain` (type: `integer`):

The homepage plus the most informative internal pages (about, product, pricing, customers, careers, contact). More pages means richer profiles and slightly slower runs. 1 to 12.

## `model` (type: `string`):

Fast is tuned for volume and price. Precise reads more carefully and is better for nuanced ICPs or messy websites.

## `language` (type: `string`):

Language for the description, reasons and opening line. Source pages can be in any language.

## `maxConcurrency` (type: `integer`):

How many websites to crawl in parallel.

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

Proxies are rarely needed for company websites. Enable Apify Proxy if some sites block datacenter traffic.

## `anthropicApiKey` (type: `string`):

If set, AI calls run on your key instead of ours. Pricing per domain stays the same.

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "notion.so",
    "basecamp.com"
  ],
  "icp": "B2B SaaS companies with 20 to 500 employees in the US or Europe that sell to sales or marketing teams. Good signals: they are hiring in sales, use HubSpot or Salesforce, publish pricing. Deal breakers: agencies, consultancies, companies with no product.",
  "maxPagesPerDomain": 5,
  "model": "fast",
  "language": "English",
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All profiled companies as JSON items (append ?format=csv for a spreadsheet). Each item has status, profile fields, contacts, techSignals, inferredFields, confidence, sourcePages and, with an ICP, fitScore, fitSummary, reasonsFor, reasonsAgainst, dealBreakerHit, openingLine, talkingPoints.

## `summary` (type: `string`):

Counts of profiled, scored and failed companies plus model usage for this run.

# 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 = {
    "domains": [
        "stripe.com",
        "notion.so",
        "basecamp.com"
    ],
    "icp": "B2B SaaS companies with 20 to 500 employees in the US or Europe that sell to sales or marketing teams. Good signals: they are hiring in sales, use HubSpot or Salesforce, publish pricing. Deal breakers: agencies, consultancies, companies with no product."
};

// Run the Actor and wait for it to finish
const run = await client.actor("signalforgedata/ai-company-profiler").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 = {
    "domains": [
        "stripe.com",
        "notion.so",
        "basecamp.com",
    ],
    "icp": "B2B SaaS companies with 20 to 500 employees in the US or Europe that sell to sales or marketing teams. Good signals: they are hiring in sales, use HubSpot or Salesforce, publish pricing. Deal breakers: agencies, consultancies, companies with no product.",
}

# Run the Actor and wait for it to finish
run = client.actor("signalforgedata/ai-company-profiler").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 '{
  "domains": [
    "stripe.com",
    "notion.so",
    "basecamp.com"
  ],
  "icp": "B2B SaaS companies with 20 to 500 employees in the US or Europe that sell to sales or marketing teams. Good signals: they are hiring in sales, use HubSpot or Salesforce, publish pricing. Deal breakers: agencies, consultancies, companies with no product."
}' |
apify call signalforgedata/ai-company-profiler --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,signalforgedata/ai-company-profiler"
        }
    }
}
```

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/3XJ5zLjUCKIFn8Jwj/builds/cBsqddWNIqyHwHm1h/openapi.json
