# GTM Account Enrichment: Contacts, Tech, Hiring & Fit Score (`capable_cauldron/gtm-account-enrichment`) Actor

Turn a list of company domains into scored target accounts. One row per company with emails, phones, social links, tech stack, open jobs, verified people emails and an ICP fit score. Sends results to Zapier, Make, n8n or Clay.

- **URL**: https://apify.com/capable_cauldron/gtm-account-enrichment.md
- **Developed by:** [Capable Cauldron](https://apify.com/capable_cauldron) (community)
- **Categories:** Lead generation, Business, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 account enricheds

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

GTM Account Enrichment turns a plain list of **company domains** into a **scored target account list**. Each company comes back as one row with its **emails, phones and social profiles**, its **tech stack**, its **open jobs** (hiring signals), optional **verified work emails** for the people you name, and an **ICP fit score** with the reasons behind it. Results can go straight to **Zapier, Make, n8n or Clay** through a webhook.

It is built for **account-based marketing**, outbound sales, RevOps and agencies. A typical setup is: paste 500 domains, set the technologies and job titles that define your ideal customer, schedule it weekly, and let the webhook drop the top accounts into your CRM. No additional accounts or API keys are needed.

Click **Try for free** and press **Start** on the prefilled example. The Apify free plan includes $5 of credit every month, which covers roughly 150 to 250 fully enriched accounts.

See a real run in 47 seconds:

[![GTM Account Enrichment demo video, 47 seconds](https://api.apify.com/v2/key-value-stores/9FGooi7IrKs0P8DcV/records/gtm-account-enrichment-demo-poster.jpg)](https://api.apify.com/v2/key-value-stores/9FGooi7IrKs0P8DcV/records/gtm-account-enrichment-demo.mp4)

▶️ [Watch the 47-second demo](https://api.apify.com/v2/key-value-stores/9FGooi7IrKs0P8DcV/records/gtm-account-enrichment-demo.mp4) (MP4, 19 MB, opens in your browser) · [Transcript](https://api.apify.com/v2/key-value-stores/9FGooi7IrKs0P8DcV/records/gtm-account-enrichment-demo-transcript.srt)

### What can GTM Account Enrichment do?

- 🏢 Builds **one row per company** from five data sources, joined on the domain
- 📧 Finds **company emails, phone numbers and social profiles** on each website, then **validates** the emails and separates personal addresses from shared inboxes
- 🧰 Detects the **tech stack** (CRM, marketing automation, ecommerce, analytics, chat, payments and more) and flags the tools on your ICP list
- 📈 Reads public **job boards** (Greenhouse, Lever, Ashby, Workable, SmartRecruiters) and counts roles matching your **hiring keywords**, the strongest buying signal there is
- 👤 Finds **verified work emails** for named decision makers from a LinkedIn URL or a name plus domain
- 🎯 Calculates a **0 to 100 fit score** with plain-English reasons ("Uses HubSpot", "Hiring 3 roles matching SDR") and sorts accounts best first
- 🔗 Delivers results to a **webhook** in batches of 100, or reads input from another run's dataset (for example a Google Maps export)

| Field | Example |
|---|---|
| `fitScore` | `82` |
| `fitReasons` | `["Uses HubSpot", "Hiring 2 role(s) matching sales, SDR"]` |
| `validEmails`, `riskyEmails` | personal addresses, and shared inboxes such as `sales@` |
| `technologies`, `matchedTechnologies` | everything detected, and the ICP tools among them |
| `openJobs`, `matchedJobs`, `matchedJobTitles` | the hiring signal |
| `people` | name, title and verified email for each person you listed |

### How to enrich a list of target accounts

1. Click **Try for free** and sign up with Google, GitHub or email. No credit card is needed.
2. Paste company domains into **Target companies**, or put a dataset ID from another run (Google Maps Scraper, a directory scrape) into **Or read websites from a dataset**.
3. Under **Ideal customer profile**, list the technologies your best customers use and the job titles that signal a need for your product.
4. Optionally add decision makers under **People to find emails for**.
5. Optionally paste a Zapier, Make, n8n or Clay **webhook URL**, then click **Start**.

#### Connecting it to your CRM

Create a Zapier or Make scenario that starts with a "catch webhook" trigger, paste its URL into `webhookUrl`, and map the fields to HubSpot, Salesforce, Pipedrive or a Google Sheet. Then turn the run into a saved Task and schedule it. Every run posts the new scored accounts automatically.

### How much does it cost to enrich accounts?

You pay a small fee per account delivered, plus the per-result price of each step that runs. Each step runs as its own Actor run in your account, so the cost of every step is visible separately in your Apify Console.

| Event | Price |
|---|---|
| Account enriched (this Actor) | $0.01 |
| Website page crawled for contacts | $0.0015 |
| Website scanned for tech stack | $0.002 |
| Matching job found | $0.001 |
| Email validated | $0.0005 |
| Verified person email found (only if you list people) | $0.04 |

Platform compute is included in those prices.

Worked examples:

- **One account at default settings** (5 pages for contacts, tech scan, hiring signals, about 4 emails validated) costs about **$0.02 to $0.05**, depending on how many matching jobs the company has.
- **500 target accounts** cost roughly **$10 to $25**.
- **Adding two decision makers per account** adds up to $0.08 per account, and only when an email is actually found.
- **The free plan.** $5 of monthly credit covers roughly 150 to 250 accounts.

Each step starts a separate Actor run. **Maximum cost per run on this Actor limits its own account-enrichment fee; it does not set one combined budget for the child runs.** Keep batches small and turn off steps you do not need. Accounts removed by `minFitScore` still incur the child steps' costs because filtering happens after enrichment.

The contact, technology, jobs, validation and email-finding steps use public Actors. Each step has its own published event prices and run limits.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `companies` | array | — | Company domains or websites. Each becomes one account row. |
| `datasetId` | string | — | Dataset from another run to read more websites from. |
| `websiteField` | string | `website` | The dataset field holding the website. |
| `people` | array | `[]` | LinkedIn profile URLs, `"Full Name, domain.com"` lines, or `{"fullName", "domain"}` objects. |
| `targetTechnologies` | array | — | Technologies your ideal customer uses. Matches raise the fit score. |
| `hiringKeywords` | array | — | Job title words that signal intent, matched as whole words. |
| `minFitScore` | integer | 0 | Only output and deliver accounts at or above this score. |
| `findContacts` | boolean | true | Find emails, phones and social profiles on each website. |
| `detectTechStack` | boolean | true | Detect the technologies on each website. |
| `findHiringSignals` | boolean | true | Read each company's public job board. |
| `findEmails` | boolean | true | Find verified emails for the listed people. |
| `validateEmails` | boolean | true | Validate the emails found on websites. |
| `maxPagesPerWebsite` | integer | 5 | Pages read per website in the contacts step. |
| `webhookUrl` | string | — | https URL that receives the accounts as JSON in batches of 100. |

```json
{
    "companies": ["apify.com", "python.org"],
    "targetTechnologies": ["HubSpot", "Salesforce"],
    "hiringKeywords": ["sales", "SDR", "account executive"],
    "maxPagesPerWebsite": 5
}
```

#### How is the fit score calculated?

Three parts add up to 100: tech stack match (40 points), hiring signals (30 points) and how reachable the account is (30 points: valid emails, verified people, phone, LinkedIn page). If you leave out the technology list or turn off hiring signals, that part is left out and the score is rescaled, so a score always means the same thing within a run. Shared inboxes such as `sales@` count half as much as a personal address.

### Output

One row per account, sorted by fit score. This is the real apify.com row from a run of the input above:

```json
{
    "domain": "apify.com",
    "website": "https://apify.com/",
    "companyName": "Apify: Marketplace of ready-to-run tools for AI",
    "fitScore": 40,
    "fitReasons": [
        "Uses HubSpot",
        "13 open role(s), none matching your keywords",
        "2 shared inbox(es) only"
    ],
    "description": "Thousands of tools to automate your business. Get real-time web data, track competitors, generate leads, and integrate your apps and AI agents.",
    "emails": [
        "support@apify.com",
        "hello@apify.com"
    ],
    "validEmails": [],
    "riskyEmails": [
        "support@apify.com",
        "hello@apify.com"
    ],
    "phones": [],
    "linkedin": [
        "https://www.linkedin.com/company/apify"
    ],
    "twitter": [
        "https://x.com/apify"
    ],
    "facebook": [],
    "instagram": [],
    "youtube": [],
    "contactPages": [
        "https://apify.com/contact",
        "https://apify.com/contact-sales"
    ],
    "technologies": [
        "HubSpot",
        "Google Tag Manager",
        "Intercom",
        "OneTrust",
        "React",
        "Next.js",
        "Amazon CloudFront"
    ],
    "techCategories": [
        "Marketing automation",
        "CRM",
        "Tag managers",
        "Live chat",
        "Customer support",
        "Consent management",
        "JavaScript frameworks",
        "CDN"
    ],
    "matchedTechnologies": [
        "HubSpot"
    ],
    "ats": "ashby",
    "openJobs": 13,
    "matchedJobs": 0,
    "matchedJobTitles": [],
    "hiringDepartments": {
        "Engineering": 9,
        "GTM": 3,
        "Product": 1
    },
    "people": [],
    "missingSteps": [],
    "enrichedAt": "2026-11-05T05:16:28.783435+00:00"
}
```

The dataset has three views: **Accounts** (score, reasons, emails, ICP tech, jobs), **Tech and hiring signals**, and **Full detail**. The `OUTPUT` record lists every step's child run, its status and cost, so you can open any step's own results.

### Use cases

Start with one of these six prefilled examples:

- [Research a target account before outreach](https://apify.com/capable_cauldron/gtm-account-enrichment/examples/gae-research-a-target-account-before-outreach)
- [Score accounts by visible technology fit](https://apify.com/capable_cauldron/gtm-account-enrichment/examples/gae-score-accounts-by-technology-fit)
- [Research sales hiring signals for target accounts](https://apify.com/capable_cauldron/gtm-account-enrichment/examples/gae-research-sales-hiring-signals-for-abm)
- [Enrich CRM accounts with public company contacts](https://apify.com/capable_cauldron/gtm-account-enrichment/examples/gae-enrich-crm-with-public-company-contacts)
- [Compare technology and hiring across target accounts](https://apify.com/capable_cauldron/gtm-account-enrichment/examples/gae-compare-technologies-and-hiring-across-accounts)
- [Inspect full account enrichment and missing steps](https://apify.com/capable_cauldron/gtm-account-enrichment/examples/gae-inspect-full-account-enrichment-results)

### API and integrations

The Actor ID is `capable_cauldron/gtm-account-enrichment`.

JavaScript:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('capable_cauldron/gtm-account-enrichment').call({
    companies: ['apify.com', 'python.org'],
    targetTechnologies: ['HubSpot'],
    hiringKeywords: ['sales', 'SDR'],
    minFitScore: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((a) => console.log(a.fitScore, a.domain, a.fitReasons.join('; ')));
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("capable_cauldron/gtm-account-enrichment").call(
    run_input={"companies": ["apify.com"], "people": ["Jane Doe, apify.com"], "hiringKeywords": ["sales"]}
)
for account in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(account["fitScore"], account["domain"], account["validEmails"], account["people"])
```

CLI:

```bash
apify call capable_cauldron/gtm-account-enrichment --input '{"companies":["apify.com"],"hiringKeywords":["sales"]}'
```

Schedule a saved Task to refresh your account list weekly, and use `webhookUrl` or the **Integrations** tab to push results to Zapier, Make, n8n, Clay, HubSpot or Google Sheets.

### FAQ

#### Is it legal to enrich company accounts this way?

This Actor returns company information and verified business contact details. Business contact data is generally fine to process for B2B outreach, but personal data is covered by GDPR, CCPA and similar laws, and email outreach by rules like CAN-SPAM. Make sure you have a lawful basis, honor opt-outs, and ask a lawyer if you are unsure.

#### Where do the decision makers come from?

You name them. Add LinkedIn profile URLs or names with company domains under `people`, and the Actor finds their verified work emails. It does not search LinkedIn for people.

#### What happens if one step fails?

The other steps still run and the accounts are still delivered. The failed step is listed in each row's `missingSteps` and in the run summary, and the run ends as partial success.

#### Can I use only some of the steps?

Yes. Turn off any step under **Steps**. A run with only contacts and tech stack is a fast, cheap way to qualify a long list before spending on people emails.

#### Can I run this from Python or my own backend?

Yes. Use the Python example above or the Apify API from any language. The webhook payload is plain JSON with an `accounts` array.

#### How is this different from running the five Actors myself?

It runs them in parallel, joins their results on the domain, validates the emails it found, scores every account against your ICP, and delivers one clean table instead of five datasets.

### Other Actors by capable_cauldron

| Actor | What it does |
|---|---|
| [App Store Reviews Scraper](https://apify.com/capable_cauldron/app-store-reviews-scraper) | Reviews and ratings for iPhone and iPad apps, grouped by app and country |
| [Company Job Postings Scraper](https://apify.com/capable_cauldron/ats-jobs-scraper) | Open roles and hiring summaries from supported company job boards |
| [Bulk Email Validator](https://apify.com/capable_cauldron/email-validator) | Syntax, mail-routing, disposable-domain and role-inbox checks |
| [Verified Work Email Finder](https://apify.com/capable_cauldron/verified-work-email-finder) | Verified professional emails from LinkedIn URLs or a name and company domain |
| [Investor Database Search](https://apify.com/capable_cauldron/investor-database-search) | Filter investors by stage, industry and geography and export available partner contacts |
| [LinkedIn Comment Scraper](https://apify.com/capable_cauldron/linkedin-comment-scraper) | LinkedIn comments and replies using your own session cookies |
| [LinkedIn Post Comments Scraper](https://apify.com/capable_cauldron/linkedin-post-comments-scraper) | Comments, replies and reactions on public LinkedIn posts without cookies |
| [LinkedIn Profile Posts & Comments Scraper](https://apify.com/capable_cauldron/linkedin-profile-posts-comments-scraper) | Posts from any LinkedIn profile with up to 50 comments and replies per post, no cookies needed |
| [LinkedIn Profile Posts Scraper](https://apify.com/capable_cauldron/linkedin-profile-posts-scraper) | Public profile posts with 56 enriched fields, including engagement and content metadata |
| [Ad Scraper: Meta, Google, LinkedIn & TikTok](https://apify.com/capable_cauldron/multi-channel-ad-intelligence) | Competitor ads from Meta, Google, LinkedIn and TikTok in one dataset |
| [TikTok Shop USA Scraper](https://apify.com/capable_cauldron/tiktok-shop-usa-scraper) | US product, shop, creator and shoppable-video data from TikTok Shop |
| [Website Contact Scraper](https://apify.com/capable_cauldron/website-contact-scraper) | Public emails, phone numbers and social profile links from company websites |
| [Website Tech Stack Detector](https://apify.com/capable_cauldron/website-tech-stack-detector) | Visible website technologies and the evidence supporting each detection |
| [LinkedIn Post Search Scraper](https://apify.com/capable_cauldron/linkedin-post-search-scraper) | Keyword searches for public LinkedIn posts with text, authors and engagement |

### Support

Found a bug or need another step (CRM sync, LinkedIn company data, funding signals)? Open an issue on the Actor's **Issues** tab. Issues are usually answered within 24 hours, and custom pipelines for your own ICP are available on request.

# Actor input Schema

## `companies` (type: `array`):

Company domains or websites, one per line (acme.com, https://www.acme.com). Each becomes one account row.

## `datasetId` (type: `string`):

ID of a dataset from another run, for example a Google Maps or directory scrape. Websites are read from the field below and added to the target companies.

## `websiteField` (type: `string`):

Which field of the dataset holds the website. Google Maps Scraper uses website.

## `people` (type: `array`):

Optional decision makers. Each entry is a LinkedIn profile URL, a "Full Name, domain.com" line, or {"fullName", "domain"}. Their verified work emails are attached to the matching account.

## `targetTechnologies` (type: `array`):

Accounts using any of these score higher, for example HubSpot, Salesforce, Shopify, Stripe, Intercom.

## `hiringKeywords` (type: `array`):

Job title words that mean an account is ready to buy, for example sales, SDR, RevOps, data engineer. Whole words only, so sales does not match Salesforce.

## `minFitScore` (type: `integer`):

Only output and deliver accounts scoring at least this much (0 to 100). Every account is still enriched.

## `findContacts` (type: `boolean`):

Crawl each company website for contact details.

## `detectTechStack` (type: `boolean`):

Identify the CMS, CRM, analytics, chat, payment and other tools on each website.

## `findHiringSignals` (type: `boolean`):

Read each company's public job board on Greenhouse, Lever, Ashby, Workable or SmartRecruiters.

## `findEmails` (type: `boolean`):

Find verified work emails for the people listed above. On automatically when people are listed.

## `validateEmails` (type: `boolean`):

Check the emails found on websites for MX records, disposable domains and shared inboxes, and split them into valid and risky.

## `maxPagesPerWebsite` (type: `integer`):

Pages read on each website to find contact details. Contact and about pages are read first.

## `webhookUrl` (type: `string`):

Optional https URL that receives the finished accounts as JSON, in batches of 100: a Zapier or Make catch hook, an n8n webhook, a Clay table webhook, or your own endpoint.

## Actor input object example

```json
{
  "companies": [
    "apify.com",
    "python.org"
  ],
  "websiteField": "website",
  "people": [],
  "targetTechnologies": [
    "HubSpot",
    "Salesforce"
  ],
  "hiringKeywords": [
    "sales",
    "SDR",
    "account executive"
  ],
  "minFitScore": 0,
  "findContacts": true,
  "detectTechStack": true,
  "findHiringSignals": true,
  "findEmails": true,
  "validateEmails": true,
  "maxPagesPerWebsite": 5
}
```

# Actor output Schema

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

One item per company: fit score and reasons, emails, phones, social links, tech stack, open jobs and verified people.

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

Status, account counts, webhook delivery, and each step's child run id, status and cost.

# 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 = {
    "companies": [
        "apify.com",
        "python.org"
    ],
    "people": [],
    "targetTechnologies": [
        "HubSpot",
        "Salesforce"
    ],
    "hiringKeywords": [
        "sales",
        "SDR",
        "account executive"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("capable_cauldron/gtm-account-enrichment").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 = {
    "companies": [
        "apify.com",
        "python.org",
    ],
    "people": [],
    "targetTechnologies": [
        "HubSpot",
        "Salesforce",
    ],
    "hiringKeywords": [
        "sales",
        "SDR",
        "account executive",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("capable_cauldron/gtm-account-enrichment").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 '{
  "companies": [
    "apify.com",
    "python.org"
  ],
  "people": [],
  "targetTechnologies": [
    "HubSpot",
    "Salesforce"
  ],
  "hiringKeywords": [
    "sales",
    "SDR",
    "account executive"
  ]
}' |
apify call capable_cauldron/gtm-account-enrichment --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,capable_cauldron/gtm-account-enrichment"
        }
    }
}
```

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/okFwA84cXX2wCRaMH/builds/cWIZcjzZ0H18Fg3cb/openapi.json
