Make.com + HubSpot: Automate CRM and Marketing Workflows

Contains affiliate links. Disclosure.

HubSpot's native workflows are powerful — until they aren't. You hit the ceiling when you need cross-app logic: pull enrichment data from a third-party API, run an AI scoring call, sync with a tool HubSpot doesn't natively support, or trigger multi-branch conditional logic that spans five different applications. That's where Make.com changes the equation.

Make connects HubSpot to 2,000+ apps through a visual scenario builder, letting you build automation pipelines that respond to CRM events in real time — without writing a single line of code.

This tutorial walks through four production-grade Make + HubSpot workflows: new contact processing, AI-powered lead scoring, deal stage automation, and multi-channel marketing orchestration. Each section includes a step-by-step implementation guide.

Why Make.com Over HubSpot's Native Automation

HubSpot's built-in Workflows are solid for linear, HubSpot-native sequences. But they have real constraints:

Capability	HubSpot Workflows	Make.com Scenarios
Cross-app logic	HubSpot-only actions	2,000+ app integrations
Conditional branching	Basic if/then	Multi-path routers with filters
AI integration	Limited (HubSpot AI only)	Any LLM via HTTP module
Data transformation	Minimal	Full JSON manipulation
Error handling	None	Retry logic + error routes
Trigger coverage	HubSpot webhook events only	2,000+ app webhook endpoints
Best for	Simple HubSpot-internal sequences	Cross-system orchestration

If your workflow lives entirely inside HubSpot, use native workflows. If it spans multiple tools, Make is the right layer.

Connecting Make.com to HubSpot

Before building any scenario, you need to establish the OAuth connection.

Step 1: Create a Make Account

Sign up for Make — the free plan includes 1,000 operations per month, enough to prototype all workflows in this guide.

Step 2: Add HubSpot as a Connection

1. In your Make dashboard, open any scenario and click Add a module.
2. Search for HubSpot CRM and select any trigger or action.
3. Click Add next to the Connection field.
4. Click Sign in with HubSpot and grant the required scopes.

Make requests the minimum necessary scopes. For CRM automation, you'll need crm.objects.contacts.read, crm.objects.contacts.write, crm.objects.deals.read, crm.objects.deals.write, and automation scope.

Best practice: Create a dedicated HubSpot user (e.g., automation@yourcompany.com) for Make connections. This prevents token invalidation if a team member's account is deactivated.

Step 3: Test the Connection

Use the HubSpot CRM → Get a Contact module with a known contact ID to confirm the connection returns data. If you see the contact object, you're ready.

Scenario 1: Enriching New Contacts on Creation

The use case: Every time a new contact is created in HubSpot, automatically pull enrichment data from external sources and update the contact record.

Architecture Overview

HubSpot (Watch New Contacts) 
  → Router
    → Branch A: Company enrichment via Clearbit/Apollo HTTP API
    → Branch B: LinkedIn profile lookup via Apify
  → HubSpot (Update Contact Properties)

Implementation

Module 1: Trigger

• App: HubSpot CRM
• Event: Watch Contacts
• Watch: New contacts only
• Set the polling interval to match your plan (5 minutes on Core, instant on paid plans)

Module 2: Router

Add a Router module to split the workflow into parallel branches. This runs enrichment steps concurrently instead of sequentially.

Module 3A: Company Domain Enrichment (HTTP)

Using Clearbit's Enrichment API (or any company lookup API):

• App: HTTP → Make a Request
• URL: https://company.clearbit.com/v2/companies/find?domain={{1.properties.company_domain}}
• Method: GET
• Headers: Authorization: Bearer {{your_clearbit_api_key}}

Map the returned name, category.industry, metrics.employees, and geo.country fields to HubSpot custom properties.

Module 3B: Contact Enrichment via Apify

For deeper enrichment using Apify's LinkedIn Profile Scraper:

• App: HTTP → Make a Request
• URL: https://api.apify.com/v2/acts/apimaestro~linkedin-profile-finder/run-sync-get-dataset-items?token=%7B%7Bapify_token%7D%7D&fpr=use-apify
• Method: POST
• Body:

{
  "queries": ["{{1.properties.firstname}} {{1.properties.lastname}} {{1.properties.company}}"],
  "maxResults": 1
}

This returns the contact's LinkedIn URL, job title, and company details, which you can write back to custom HubSpot properties.

Module 4: Update HubSpot Contact

• App: HubSpot CRM
• Action: Update a Contact
• Contact ID: {{1.id}} (from the trigger)
• Map the enriched fields from Modules 3A and 3B to HubSpot contact properties

Result: Every new contact enters HubSpot with enriched company, industry, employee count, and LinkedIn data — without manual research.

Scenario 2: AI-Powered Lead Scoring

The use case: When a lead score changes or a contact fills out a form, use Claude or GPT-4 to analyze the contact profile and assign a fit score, then route to the right sales sequence.

The Scoring Logic

Native HubSpot lead scoring uses rule-based point systems. AI scoring evaluates the full contact profile holistically — job title relevance, company size fit, engagement behavior, and intent signals — then returns a structured assessment.

Implementation

Module 1: Trigger

• App: HubSpot CRM
• Event: Watch Form Submissions (or Watch Contacts filtered by hs_latest_source == 'ORGANIC_SEARCH')

Module 2: Get Full Contact

• App: HubSpot CRM
• Action: Get a Contact
• Contact ID: {{1.submitterVid}}
• Include all relevant properties: jobtitle, company, hs_analytics_num_page_views, hs_email_open_rate, industry, numemployees

Module 3: AI Scoring Call

• App: HTTP → Make a Request
• URL: https://api.anthropic.com/v1/messages
• Method: POST
• Headers: x-api-key: {{claude_key}}, anthropic-version: 2023-06-01
• Body:

{
  "model": "claude-3-5-sonnet-20241022",
  "max_tokens": 500,
  "messages": [{
    "role": "user",
    "content": "Score this B2B lead for a SaaS product targeting VP-level buyers at 50-500 employee companies.\n\nContact:\n- Job title: {{2.properties.jobtitle}}\n- Company: {{2.properties.company}}\n- Industry: {{2.properties.industry}}\n- Employees: {{2.properties.numemployees}}\n- Page views: {{2.properties.hs_analytics_num_page_views}}\n- Email open rate: {{2.properties.hs_email_open_rate}}\n\nReturn JSON only: {\"score\": 0-100, \"tier\": \"hot|warm|cold\", \"reason\": \"one sentence\"}"
  }]
}

Module 4: Parse JSON Response

• App: JSON → Parse JSON
• Input: {{3.content[].text}} (the Claude response text)

Module 5: Router (Score-Based Routing)

Three branches based on {{4.tier}}:

• Hot (score ≥ 75): Create HubSpot Task for immediate sales outreach + add to "High Priority" sequence
• Warm (score 40–74): Enroll in nurture email sequence
• Cold (score < 40): Tag as low-fit and move to long-term nurture

Module 6: Update HubSpot Contact

• Set custom properties:
  • ai_lead_score = {{4.score}}
  • ai_lead_tier = {{4.tier}}
  • ai_score_reason = {{4.reason}}
  • ai_score_date = {{now}}

This gives your sales team an AI-generated score on every qualified contact, with full auditability in HubSpot.

Scenario 3: Automated Deal Pipeline Management

The use case: Move deals through pipeline stages based on external events — email replies, demo completions, proposal opens — without manual updates.

Architecture Overview

Webhook (External Event) 
  → Make Router
    → Demo completed → Move deal to "Demo Done", create follow-up task
    → Proposal opened → Move deal to "Proposal Sent", start 3-day follow-up sequence
    → Contract signed → Close deal, update ARR, trigger finance workflow

Implementation

Module 1: Trigger (Webhook)

For external events (from Calendly, DocuSign, email tools), use Make's webhook trigger:

• App: Webhooks → Custom Webhook
• Copy the webhook URL and configure your external tool to POST to it
• Make will auto-detect the data structure from the first test payload

For HubSpot-native events, use:

• App: HubSpot CRM → Watch Deal Stage Changes

Module 2: Find Associated Deal

If the trigger is a contact event, find the associated deal:

• App: HubSpot CRM → Search for Deals
• Filter: associations.contact = {{1.contactId}}
• Sort by: createdate DESC, Limit: 1

Module 3: Router (Event Type)

Branch based on {{1.eventType}} or the incoming webhook event_name field.

Module 4A: Move Deal Stage (Demo Completed)

• App: HubSpot CRM → Update a Deal
• Deal ID: {{2.results[].id}}
• dealstage: Set to your "Demo Done" stage ID
• hs_deal_stage_probability: Update probability

To find your deal stage IDs, use HubSpot Settings → Objects → Deals → Pipelines.

Module 4B: Create Follow-Up Task

• App: HubSpot CRM → Create a Task
• Subject: "Follow up: Post-demo call with {{1.contactName}}"
• Due date: {{addDays(now, 2)}}
• Associated object: the deal ID
• Owner: the deal's hubspot_owner_id

Module 4C: Trigger Finance Workflow (Contract Signed)

When a deal closes, notify finance via Slack and create a record in your billing system:

• App: Slack → Create a Message
  • Channel: #revenue
  • Message: "Deal closed: {{2.properties.dealname}} — ARR: ${{2.properties.amount}}"
• App: HTTP → Make a Request to your billing API

Handling Stage Validation

Before updating a deal, validate that the transition is valid. Use a Filter module between the Router and the HubSpot Update:

• Condition: {{2.properties.dealstage}} does NOT equal closedwon

This prevents accidentally reopening won deals.

Scenario 4: Multi-Channel Marketing Campaign Orchestration

The use case: Launch coordinated campaigns across HubSpot email, LinkedIn Ads, Google Ads, and Slack — triggered by a single contact segment update in HubSpot.

Architecture Overview

HubSpot (Watch List Membership Changes)
  → Add to LinkedIn Matched Audience
  → Update Google Ads Customer Match
  → Slack notification to marketing team
  → HubSpot (Enroll in Email Sequence)

Implementation

Module 1: Trigger

• App: HubSpot CRM → Watch List Memberships
• List: Your ICP segment list (e.g., "Q2 ABM Targets")
• Watch: New members only

Module 2: Get Full Contact Properties

Fetch email, company domain, and LinkedIn URL for ad platform matching:

• App: HubSpot CRM → Get a Contact
• Include: email, company, linkedin_bio, phone

Module 3: LinkedIn Campaign Manager Integration

LinkedIn doesn't have a native Make module, but you can use the HTTP module against the Marketing API:

• App: HTTP → Make a Request
• Method: POST
• URL: https://api.linkedin.com/v2/dmpSegments/{{your_segment_id}}/users
• Headers: Authorization: Bearer {{linkedin_access_token}}
• Body: {"elements": [{"action": "ADD", "userIds": [{"idType": "SHA256_EMAIL", "idValue": "{{sha256(2.properties.email)}}"}]}]}

Note: LinkedIn requires email addresses hashed with SHA256 for privacy compliance. Make's built-in sha256() function handles this transformation — no external preprocessing needed.

Module 4: Google Ads Customer Match

Use the Google Ads module (available in Make):

• App: Google Ads → Add Member to Customer List
• Customer List ID: Your ICP remarketing list
• Email: {{2.properties.email}}

Module 5: HubSpot Email Sequence Enrollment

• App: HubSpot CRM → Enroll a Contact in a Sequence
• Sequence ID: Your ABM outreach sequence
• Contact ID: {{1.vid}}
• Sender email: Your sales rep's email (map from deal owner)

Module 6: Slack Notification

• App: Slack → Create a Message
• Channel: #marketing-ops
• Message: "🎯 {{2.properties.firstname}} {{2.properties.lastname}} ({{2.properties.company}}) enrolled in ABM campaign. Channels: LinkedIn, Google Ads, HubSpot Sequences."

This creates a coordinated multi-touch campaign in under 5 seconds per contact.

Setting Up Error Handling

All production Make scenarios need error routes. Without them, a failed API call silently drops the record.

Add Error Handling to Every Module

1. Right-click any module and select Add error handler.
2. Choose Rollback (undoes all changes in the current scenario execution) or Ignore (skip and continue) or Break (pause and retry).

For HubSpot write operations, use Break with an error notification:

• Add a Slack → Send Message module on the error route
• Message: "Make scenario failed: {{scenario.name}} — Contact: {{1.properties.email}} — Error: {{error.message}}"

Deduplication Guard

HubSpot's "Watch Contacts" trigger can occasionally re-deliver events. Add a Data Store check before processing:

1. App: Data Store → Check Existence of a Record
   • Key: {{1.id}}_{{1.updatedAt}}
2. Filter: Only proceed if record does NOT exist
3. After processing: Data Store → Add/Replace a Record with the same key

This prevents duplicate contact updates or AI scoring calls.

Make Pricing for HubSpot Automation

Plan	Operations/Month	Minimum Interval	Price
Free	1,000	15 min	$0
Core	10,000	5 min	$9/month
Pro	10,000+	1 min	$16/month
Teams	20,000+	1 min	$29/month

Pricing verified June 2026. Plans change frequently — check the vendor’s official pricing page for current rates.

For HubSpot CRM automation, Core is sufficient for most small teams (< 500 contacts processed per month). Scenarios processing large lists or running hourly enrichment need Pro for the 1-minute trigger interval.

Start with Make's free plan — all scenarios in this guide work on the free tier for testing.

Make vs. Native HubSpot Workflows: When to Use Which

Use HubSpot native workflows when:

• The automation is entirely within HubSpot (email sequences, deal stage notifications, contact property updates)
• You need lifecycle-based triggers like "Contact became a MQL" or "Deal reached X probability"
• Your team manages automation through HubSpot's interface without a dedicated automation engineer

Use Make when:

• You need to call external APIs (enrichment, AI scoring, billing systems)
• The workflow spans 3+ applications
• You need complex data transformation (JSON manipulation, array operations, calculations)
• You want real-time event processing with sub-minute trigger intervals
• You require audit trails and error notifications across all automations

The best setup uses both: HubSpot native workflows for in-CRM logic, Make for everything that crosses application boundaries.

HubSpot + Apify: Enriching Contacts with Fresh Web Data

For teams that need real-time company intelligence beyond static enrichment providers, Apify gives you on-demand scrapers for any data source.

Example scenario: new HubSpot contact → scrape the company's pricing page via Apify → extract product tier signals → update HubSpot with intent data.

HubSpot (Watch New Contacts)
  → Apify (Run Actor: Website Content Crawler on company.com/pricing)
  → Claude (Extract pricing tier indicators)
  → HubSpot (Update Contact: add intent_signal property)

This connects directly to the AI lead scoring workflow covered in Scenario 2. See our guide on Apify + n8n pipelines for more on structuring enrichment workflows.

Frequently Asked Questions

In Make, add any HubSpot CRM module to a scenario. When prompted for a connection, click 'Add' and authenticate via HubSpot OAuth. Make will request the minimum required scopes. The connection supports all HubSpot CRM objects: contacts, deals, companies, tickets, and custom objects.

Yes. Make connects HubSpot to 2,000+ external apps, supports multi-branch routing, real-time webhook triggers, external API calls (including LLMs for AI scoring), and full JSON data transformation — capabilities not available in HubSpot's native workflow builder.

Make supports: Watch New Contacts, Watch Updated Contacts, Watch Deal Stage Changes, Watch Form Submissions, Watch New Companies, Watch List Membership Changes, and custom webhook triggers for HubSpot native webhook events.

Each module execution in a scenario counts as one operation. A scenario with 5 modules processing one contact uses 5 operations. For a 200-contact batch, that's 1,000 operations. The free plan (1,000 ops/month) handles testing; Core plan (10,000 ops) covers most small-team workflows.

For teams needing cross-app orchestration (enrichment APIs, AI scoring, multi-channel campaign sync), yes. Make's Core plan at $9/month handles workflows that would otherwise require custom development or a dedicated integration platform costing hundreds per month.

Use Make's built-in Data Store module as a deduplication layer. Before processing a contact, check if the contact ID + timestamp combination exists in the Data Store. If it does, skip the execution. If not, process and write the key. This prevents re-delivered webhook events from triggering duplicate actions.