HubSpot CRM Company Enrichment & Fuzzy Matcher for Clay

Fuzzy match and enrich companies against your HubSpot CRM using multi-signal matching (domain, company name, phone, location). Returns HubSpot ID, lifecycle stage, deal status & confidence scores. Perfect for Clay workflows, lead deduplication, and outbound enrichment.

Clay Compatible: This actor works seamlessly with Clay's Apify integration. See Clay Integration below for setup instructions.

Features

• Multi-Signal Matching: Uses domain (40%), company name (35%), phone (15%), and location (10%) for accurate matching
• Fuzzy Matching: Levenshtein distance algorithm for catching typos and variations
• Intelligent Indexing: Pre-indexes HubSpot companies for fast lookups
• Confidence Scores: Returns 0-100 confidence score with match type details
• CRM Enrichment: Returns HubSpot ID, lifecycle stage, and deal stage for matched companies
• Demo Mode: Test the actor without API calls or charges

Quick Start

{
  "hubspotApiKey": "pat-na1-xxxxxxxx",
  "companies": [
    {
      "name": "Acme Photography LLC",
      "domain": "acmephoto.com",
      "phone": "555-123-4567",
      "city": "Austin",
      "state": "TX"
    }
  ],
  "matchThreshold": 70,
  "includeDeals": true,
  "maxHubspotCompanies": 10000
}

Demo Mode

Run the actor in demo mode to see sample output without making HubSpot API calls or incurring charges:

{
  "demoMode": true
}

This returns 3 sample results demonstrating exact domain match, name match, and no match scenarios.

Input Schema

Parameter	Type	Required	Default	Description
hubspotApiKey	string	Yes	-	Your HubSpot private app API key with CRM access
companies	array	Yes	-	Array of companies to match against HubSpot
matchThreshold	integer	No	70	Minimum confidence score (0-100) to consider a match
includeDeals	boolean	No	true	Include deal stage info for matched companies
maxHubspotCompanies	integer	No	10000	Max companies to load from HubSpot
demoMode	boolean	No	false	Return sample data without API calls

Company Object Fields

Each company in the companies array can include:

Field	Type	Description
name	string	Company name (e.g., "Acme Corp")
domain	string	Website domain (e.g., "acme.com")
phone	string	Phone number (any format)
email	string	Email address (domain will be extracted)
city	string	City name
state	string	State/province
address	string	Street address

Output Schema

Each result in the dataset contains:

{
  // Input company info
  inputCompany: string;        // Original company name
  inputDomain: string | null;  // Input domain
  inputPhone: string | null;   // Input phone

  // Match results
  matchedCompany: string | null;   // HubSpot company name
  matchedDomain: string | null;    // HubSpot domain
  hubspotId: string | null;        // HubSpot company ID
  confidenceScore: number;         // 0-100 match confidence
  matchType: string;               // exact_domain, similar_domain, name_match, phone_match, no_match

  // Match breakdown
  matchDetails: {
    domainMatch: number;     // Domain similarity (0-100)
    nameMatch: number;       // Name similarity (0-100)
    phoneMatch: number;      // Phone match (0 or 100)
    locationMatch: number;   // Location match (0-100)
  };

  // HubSpot data
  dealStage: string | null;        // Latest deal stage
  lifecycleStage: string | null;   // Lifecycle stage
  isMatch: boolean;                // True if above threshold
}

Match Algorithm

The matching algorithm uses weighted signals:

Signal	Weight	Description
Domain	40%	Exact or similar domain match
Name	35%	Fuzzy company name matching
Phone	15%	Phone number match (normalized)
Location	10%	City + State match

Match Types

• exact_domain: Exact domain match (highest confidence)
• similar_domain: Domain similarity >= 80%
• name_match: Company name similarity >= 85%
• phone_match: Phone number match
• no_match: No match above threshold

Pricing (Pay-Per-Event)

This actor uses Apify's pay-per-event pricing:

Event	Price	Description
company_matched	$0.01	Per successful company match
hubspot_loaded	$0.02	Per 1,000 HubSpot companies loaded

Demo mode runs are free (no charges).

Example Cost

• Matching 100 companies against 5,000 HubSpot companies
• 5,000 companies = 5 load charges = $0.10
• 70 matches found = $0.70
• Total: $0.80

Clay Integration

This actor integrates seamlessly with Clay through their native Apify integration.

Setup in Clay

1. Connect Apify to Clay:

   • Go to Settings > Connections in Clay
   • Add Connection > Select "Apify"
   • Enter your Apify API token (found at Apify Settings > Integrations)

2. Use the Actor in a Clay Table:

   • Add a new enrichment column
   • Select "Apify" as the data source
   • Search for "HubSpot CRM Company Enrichment" or use the actor ID
   • Configure the input JSON mapping your Clay columns:

{
  "hubspotApiKey": "{{your_hubspot_api_key}}",
  "companies": [
    {
      "name": {{Company Name}},
      "domain": {{Domain}},
      "phone": {{Phone}},
      "city": {{City}},
      "state": {{State}}
    }
  ],
  "matchThreshold": 70,
  "includeDeals": true
}

3. Map Output Columns:
   • hubspotId → HubSpot Company ID
   • confidenceScore → Match Confidence
   • matchType → How matched (exact_domain, name_match, etc.)
   • lifecycleStage → Customer lifecycle stage
   • dealStage → Current deal status
   • isMatch → Boolean for filtering

Clay Use Cases

Lead Deduplication: Before outreach, check if leads already exist in your CRM Lead Scoring: Use lifecycle stage and deal status to prioritize leads Data Enrichment: Add HubSpot IDs to sync data between Clay and HubSpot Customer Filtering: Filter out existing customers from prospecting lists

Note: This actor works with Clay's native Apify integration, NOT with OpenMart. OpenMart (acquired by Clay in 2024) is a separate Clay integration focused on SMB/local business intelligence data (restaurants, salons, retailers, etc.). If you're looking to enrich local business leads, check out OpenMart. For matching companies against your own HubSpot CRM, use this actor via the Apify integration.

Use Cases

Outbound Lead Qualification

Before reaching out to leads:

1. Batch match your lead list against HubSpot
2. Filter out existing customers (lifecycle = customer)
3. Prioritize leads already in pipeline (has deal stage)
4. Skip companies with no match (new prospects)

Data Deduplication

Identify potential duplicates in your CRM:

1. Export HubSpot companies
2. Match against themselves with lower threshold (50%)
3. Review similar_domain and name_match results
4. Merge or clean duplicate records

HubSpot API Setup

1. Go to HubSpot Settings > Integrations > Private Apps
2. Create a new private app
3. Grant these scopes:
   • crm.objects.companies.read
   • crm.objects.deals.read (if using includeDeals)
4. Copy the access token

Performance Tips

• Set maxHubspotCompanies based on your CRM size
• Use higher matchThreshold (80+) for strict matching
• Use lower matchThreshold (50-60) for deduplication
• Provide domain whenever possible (most reliable signal)

Example Output

{
  "inputCompany": "Acme Photography LLC",
  "inputDomain": "acmephoto.com",
  "inputPhone": "555-123-4567",
  "matchedCompany": "Acme Photography Inc",
  "matchedDomain": "acmephoto.com",
  "hubspotId": "12345678",
  "confidenceScore": 95,
  "matchType": "exact_domain",
  "matchDetails": {
    "domainMatch": 100,
    "nameMatch": 90,
    "phoneMatch": 100,
    "locationMatch": 50
  },
  "dealStage": "qualified",
  "lifecycleStage": "opportunity",
  "isMatch": true
}

Support

For issues or feature requests, please open a GitHub issue or contact support.