n8n CRM Integration Tutorial for Small Businesses

This tutorial walks you through connecting your CRM to n8n, building a lead capture webhook, and routing new contacts into an automated follow-up sequence. By the end, you'll have a working 5-node workflow that captures form leads, creates CRM contacts in HubSpot or Pipedrive, and sends a welcome email automatically.

Affiliate disclosure: Some links in this post are affiliate links. If you sign up through them, Rain Automation may earn a commission at no extra cost to you. We only recommend tools we use ourselves.

What You Need Before You Start

You need four things to complete this tutorial: an n8n account (free self-hosted or EUR 24/month Cloud), a CRM account (HubSpot Free or Pipedrive at $14/month billed annually), a web form that can POST to a URL, and an email-sending service like Gmail or SendGrid.

Gather these before opening n8n:

• An n8n account. Either sign up for n8n Cloud (14-day free trial, then EUR 24/month (approximately $26 USD) for the Starter plan) or self-host n8n on a $5-10/month VPS. Self-hosting is free forever and gives you full control.
• A CRM account. This tutorial covers two options: HubSpot's free CRM (up to 1,000 contacts, no credit card required) or Pipedrive (14-day free trial, then $14/month per seat on the Lite plan (formerly Essential), billed annually ($24/month billed monthly)).
• A web form or webhook source. Any form builder that can POST to a URL works: Typeform, Gravity Forms, a custom HTML form, or even a Zapier/Make trigger. You just need something that sends data to a webhook URL.
• An email account for sending. Gmail, SendGrid, Mailgun, or any SMTP service. n8n has built-in nodes for all of these.

If you already have n8n running and a CRM account, skip ahead to the HubSpot or Pipedrive section that matches your setup.

How n8n Connects to Your CRM (2-Minute Overview)

n8n connects to your CRM through a simple 4-node pattern: a webhook receives form data, a Set node normalizes the fields, a CRM node creates the contact, and an email node sends a follow-up. This pattern works with HubSpot, Pipedrive, Salesforce, and 30+ other CRMs using n8n's built-in connector nodes.

n8n is a workflow automation tool that connects apps using a visual canvas. You drag nodes onto the canvas, connect them with lines, and data flows from left to right. Every workflow starts with a trigger (something that kicks it off) and ends with one or more actions (things that happen as a result).

For CRM integrations, the pattern is almost always the same:

1. A Webhook node receives data from your web form
2. A Set or Code node cleans and formats that data
3. A CRM node (HubSpot, Pipedrive, Salesforce, etc.) creates or updates a contact
4. An Email or HTTP Request node triggers a follow-up action

In my experience building CRM workflows for small businesses, this four-step pattern covers the vast majority of integration needs. The differences between CRMs come down to authentication setup and field mapping.

Most n8n CRM integration tutorials (and most CRM automation guides in general) tell you to skip the webhook entirely and use a pre-built Zapier app connector or your CRM's native automation features. That advice works right up until your form tool changes, your CRM vendor updates their API, or you need a second action after contact creation. The webhook-first pattern in this tutorial takes about 10 extra minutes to set up, but it decouples your automation from any single vendor. I've watched clients burn hours rebuilding Zapier Zaps after a HubSpot API update broke their connector. With the webhook approach, your form sends raw data to a URL you control, and you handle the rest. Vendor changes don't break your workflow because you're not relying on a third party to maintain the glue between your tools.

n8n vs. Make.com for CRM Automation

If you're deciding between n8n and Make.com (formerly Integromat) for your CRM workflows, here's how they compare for this specific use case:

Feature	n8n	Make.com
Monthly cost (500 leads/mo)	$0 (self-hosted) or EUR 24/~$26 USD (Cloud Starter)	$9 (Core, billed annually, 10,000 credits)
Setup time for this workflow	~35 minutes	~25 minutes
Self-hosting option	Yes (Docker, npm)	No
CRM connectors	30+ CRM nodes	40+ CRM modules
AI enrichment nodes	Built-in (OpenAI, Anthropic, local LLMs)	Available (fewer options)
Webhook reliability	Excellent (persistent queues on self-hosted)	Good (cloud-dependent)
Learning curve	Moderate (more flexible = more options)	Lower (more guided UI)
Operation limits	Unlimited (self-hosted)	Capped by plan tier

Make.com gets you running faster with a more guided interface. n8n gives you more flexibility, especially if you want to add AI-powered lead enrichment or scoring later. If you're already spending $50+/month on Make.com operations, n8n self-hosted pays for itself in the first month.

For a deeper comparison across more use cases, read our n8n vs. Make for Small Business Automation guide. For a broader look at connecting multiple CRMs, see our complete guide to integrating your CRM with n8n and Make.

Tutorial Part 1: Connect HubSpot Free to n8n

Connecting HubSpot's free CRM to n8n takes about 15 minutes and uses HubSpot's Private App authentication (API keys were deprecated in late 2022). You'll create a scoped access token in HubSpot, paste it into n8n's credential manager, and configure the HubSpot node to create contacts from incoming webhook data.

HubSpot's free CRM is one of the best starting points for small businesses. You get up to 1,000 contacts, basic deal tracking, and a clean API, all without paying anything. Here's how to wire it up to n8n.

Step 1: Create a Private App in HubSpot

HubSpot deprecated API keys in late 2022. The current method is Private Apps, which use scoped access tokens.

1. Log into your HubSpot account and go to Settings > Integrations > Private Apps
2. Click Create a private app
3. Give it a name like "n8n Integration"
4. Under the Scopes tab, enable these permissions:
   • crm.objects.contacts.read
   • crm.objects.contacts.write
   • crm.objects.deals.read
   • crm.objects.deals.write
5. Click Create app, then Continue creating
6. Copy the access token that appears. Store it somewhere safe. You won't be able to see the full token again after leaving this page.

These scopes are the minimum you need for contact and deal creation. If you plan to use HubSpot's email features through n8n later, also add content and automation scopes.

Step 2: Add the HubSpot Node in n8n

1. Open your n8n canvas and add a new node
2. Search for "HubSpot" and select the HubSpot node
3. Click Create New Credential
4. Choose Private App Token as the authentication type
5. Paste the access token you copied from HubSpot
6. Click Save and then Test Connection to verify it works

If the test fails with a 401 error, go back to your HubSpot private app and check that the scopes match exactly. The most common mistake is missing the crm.objects.contacts.write scope, which causes "insufficient permissions" errors when you try to create contacts.

Step 3: Configure the Create Contact Action

With the credential working, configure the HubSpot node:

• Resource: Contact
• Operation: Create
• Email: {{ $json.email }}
• First Name: {{ $json.firstName }}
• Last Name: {{ $json.lastName }}
• Phone: {{ $json.phone }}

The {{ $json.fieldName }} syntax is n8n's expression language. It pulls values from the incoming data. If your form uses different field names (like first_name instead of firstName), adjust the expressions to match.

Here's a minimal JSON payload that this node expects from the previous step in the workflow:

{
  "email": "[email protected]",
  "firstName": "Jane",
  "lastName": "Smith",
  "phone": "555-123-4567",
  "source": "website-contact-form"
}

Free tier note: HubSpot's free CRM caps you at 1,000 contacts in the non-marketing tier. For most small businesses generating 50-200 leads per month, that's 5-20 months of runway before you need to upgrade. When you hit the limit, HubSpot's Starter plan (starting at $20/month per seat) lifts the cap to 1,000 marketing contacts with higher overall storage.

Tutorial Part 2: Connect Pipedrive to n8n

Pipedrive connects to n8n using a personal API token from your Pipedrive account settings, with no scoped permissions required. The setup takes about 10 minutes, and n8n's Pipedrive node supports both Person (contact) and Deal creation natively.

Pipedrive is a sales-focused CRM popular with small teams that care more about deal pipeline than marketing automation. Its API is straightforward, and n8n's Pipedrive node covers both contacts ("Persons") and deals natively.

Step 1: Get Your Pipedrive API Token

1. Log into Pipedrive and click your profile picture in the top right
2. Go to Personal preferences > API
3. Copy your Personal API token

Unlike HubSpot's scoped tokens, Pipedrive's personal API token gives full access to your account. If you're on a team plan, consider creating a dedicated Pipedrive user for API access so you can revoke it independently.

Step 2: Add the Pipedrive Node in n8n

1. On the n8n canvas, add a new node and search for "Pipedrive"
2. Select the Pipedrive node
3. Click Create New Credential
4. Paste your API token
5. Click Save and test the connection

Step 3: Create a Person and a Deal

Pipedrive separates contacts ("Persons") from deals. For a lead capture workflow, you typically want to create both: a Person record for the contact, and a Deal to track the opportunity.

Create Person node configuration:

• Resource: Person
• Operation: Create
• Name: {{ $json.firstName }} {{ $json.lastName }}
• Email: {{ $json.email }}
• Phone: {{ $json.phone }}

Create Deal node configuration (add a second Pipedrive node):

• Resource: Deal
• Operation: Create
• Title: {{ $json.firstName }} {{ $json.lastName }} - Website Lead
• Person ID: {{ $json.id }} (this comes from the Create Person node's output)
• Stage: Select your first pipeline stage (e.g., "New Lead")

By connecting the Person node's output to the Deal node's input, the deal is automatically linked to the person. This keeps your Pipedrive pipeline clean from the start.

Pricing note: Pipedrive offers a 14-day free trial. After that, the Lite plan (formerly Essential) runs $14/month per user billed annually ($24/month billed monthly). For a solo operator or 2-person team, that's $14-28/month on annual billing. Compare that to HubSpot's free tier or n8n's self-hosted option if budget is the primary concern.

Build the Full Lead Capture Workflow

The complete lead capture workflow uses 5 nodes: Webhook trigger, Set (field normalizer), CRM node (HubSpot or Pipedrive), HTTP Request (optional enrichment), and Send Email (follow-up). You can import the full workflow JSON below and have it running in under 10 minutes.

Now let's assemble the complete 5-node workflow. This is the core of the tutorial, and it works with either CRM.

Here's the node sequence:

1. Webhook (Trigger) - Receives form data via HTTP POST
2. Set (Transform) - Normalizes field names and adds metadata
3. HubSpot or Pipedrive (CRM) - Creates the contact/person record
4. HTTP Request (Enrichment) - Optional: calls a data enrichment API to add company info
5. Send Email (Follow-up) - Sends an automated welcome/confirmation email

Node 1: Webhook Trigger

Add a Webhook node and set it to accept POST requests. n8n generates two URLs:

• Test URL: Used while you're building and testing the workflow. Only works when you click "Listen for Test Event" in the editor.
• Production URL: Used when the workflow is active. This is the URL you put in your web form's action attribute or form builder's webhook field.

This is the most common source of "my webhook isn't working" frustration. During development, use the test URL. When you activate the workflow, switch your form to the production URL. They're different URLs with different paths. n8n supports multiple response modes: "On Received" (returns 200 immediately, best for most forms), "Last Node" (waits for workflow completion before responding), and "Respond to Webhook" (lets you craft a custom response with a dedicated node).

Node 2: Set Node (Normalize Fields)

Different forms send data in different formats. A Typeform submission might use answers[0].text while a Gravity Forms webhook uses fields.1. The Set node standardizes everything.

Configure it to output these consistent fields:

{
  "email": "{{ $json.email || $json.Email || $json['email_address'] }}",
  "firstName": "{{ $json.firstName || $json.first_name || $json.name?.split(' ')[0] }}",
  "lastName": "{{ $json.lastName || $json.last_name || $json.name?.split(' ')[1] || '' }}",
  "phone": "{{ $json.phone || $json.Phone || '' }}",
  "source": "website-form",
  "capturedAt": "{{ $now.toISO() }}"
}

The || operator creates fallbacks. If $json.email doesn't exist, it tries $json.Email, then $json['email_address']. This means you can point multiple forms at the same webhook without rebuilding the workflow for each one.

Node 3: CRM Node

Use the HubSpot or Pipedrive configuration from the earlier sections. The Set node's output feeds directly into the CRM node's field mapping.

Node 4: HTTP Request (Optional Enrichment)

This node is optional but valuable. You can call a free enrichment API to look up the lead's company, job title, or LinkedIn profile based on their email domain. Services like Hunter.io, Apollo, or Snov.io offer free tiers that handle 50-250 lookups per month.

Configure an HTTP Request node:

• Method: GET
• URL: Your enrichment API endpoint
• Query Parameters: Pass {{ $json.email }} as the lookup key

If the enrichment call fails (the person isn't in the database), add an IF node before the email step to handle both enriched and non-enriched paths.

Node 5: Send Email

The final node sends a welcome email to the new lead. Use n8n's built-in Send Email node or a service-specific node like Gmail, SendGrid, or Mailgun. For a complete walkthrough of configuring the Send Email node, including SMTP credentials, from/to field expressions, and common delivery errors, see our n8n Send Email Node configuration guide.

For the email content, keep it short and useful:

Subject: Thanks for reaching out, {{ $json.firstName }}

Hi {{ $json.firstName }},
We received your inquiry and will follow up within one business day.
In the meantime, here are some resources that might help:

[Link to your most relevant service page]
[Link to a helpful blog post]

Best,
[Your Name]
[Your Company]

This is step 1 of a follow-up sequence. You can build additional workflows that check if the lead responded after 3 days, then send a second touchpoint. For a full breakdown of follow-up automation architecture, see our real estate lead follow-up automation guide, which covers the same principles for any industry.

Complete Workflow JSON

Copy this JSON and paste it into n8n (use Ctrl/Cmd + V on the canvas to import). This is the HubSpot version. Swap the HubSpot node for a Pipedrive node and update the credential to use the Pipedrive version.

{
  "nodes": [
    {
      "name": "Webhook",
      "type": "n8n-nodes-base.webhook",
      "position": [250, 300],
      "parameters": {
        "httpMethod": "POST",
        "path": "lead-capture",
        "responseMode": "onReceived",
        "responseData": "allEntries"
      },
      "typeVersion": 1
    },
    {
      "name": "Normalize Fields",
      "type": "n8n-nodes-base.set",
      "position": [470, 300],
      "parameters": {
        "values": {
          "string": [
            { "name": "email", "value": "={{ $json.email }}" },
            { "name": "firstName", "value": "={{ $json.firstName || $json.first_name || '' }}" },
            { "name": "lastName", "value": "={{ $json.lastName || $json.last_name || '' }}" },
            { "name": "phone", "value": "={{ $json.phone || '' }}" },
            { "name": "source", "value": "website-form" }
          ]
        },
        "options": {}
      },
      "typeVersion": 1
    },
    {
      "name": "HubSpot Create Contact",
      "type": "n8n-nodes-base.hubspot",
      "position": [690, 300],
      "parameters": {
        "resource": "contact",
        "operation": "create",
        "email": "={{ $json.email }}",
        "additionalFields": {
          "firstName": "={{ $json.firstName }}",
          "lastName": "={{ $json.lastName }}",
          "phone": "={{ $json.phone }}"
        }
      },
      "typeVersion": 1,
      "credentials": {
        "hubspotApi": {
          "id": "YOUR_CREDENTIAL_ID",
          "name": "HubSpot Private App"
        }
      }
    },
    {
      "name": "Send Welcome Email",
      "type": "n8n-nodes-base.emailSend",
      "position": [910, 300],
      "parameters": {
        "fromEmail": "[email protected]",
        "toEmail": "={{ $json.email }}",
        "subject": "Thanks for reaching out, ={{ $json.firstName }}",
        "text": "Hi {{ $json.firstName }},\n\nWe received your inquiry and will follow up within one business day.\n\nBest,\nYour Team"
      },
      "typeVersion": 1
    }
  ],
  "connections": {
    "Webhook": { "main": [[{ "node": "Normalize Fields", "type": "main", "index": 0 }]] },
    "Normalize Fields": { "main": [[{ "node": "HubSpot Create Contact", "type": "main", "index": 0 }]] },
    "HubSpot Create Contact": { "main": [[{ "node": "Send Welcome Email", "type": "main", "index": 0 }]] }
  }
}

After importing, you'll need to update the HubSpot credential with your own private app token. The webhook path is set to /lead-capture, so your production webhook URL will be something like https://your-n8n-domain.com/webhook/lead-capture.

3 n8n CRM Integration Examples You Can Build Today

These three workflows cover the most common CRM automation patterns for small businesses: lead routing, deal stage automation, and cross-CRM syncing. Each example includes the exact n8n node configuration so you can replicate it in under 30 minutes.

The lead capture workflow above is your foundation. These three examples show what to build next once that's running.

Example 1: Lead Scoring and CRM Tag Assignment

This workflow scores incoming leads based on form data and automatically tags them in your CRM so your sales team knows who to call first.

Node configuration (6 nodes):

1. Webhook (Trigger): Same lead capture webhook from the tutorial above. Receives form submissions via POST.
2. Code (Score Calculation): A JavaScript Code node that assigns points based on lead attributes:

   // Score based on lead attributes
   let score = 0;
   if ($json.companySize && parseInt($json.companySize) > 10) score += 30;
   if ($json.email && !$json.email.includes('gmail.com')) score += 20;
   if ($json.phone) score += 15;
   if ($json.budget && parseInt($json.budget) > 5000) score += 35;
   return { ...$json, leadScore: score, tier: score >= 50 ? 'hot' : score >= 25 ? 'warm' : 'cold' };
   

3. Switch (Route by Tier): Routes leads to different paths based on their tier value. Set three outputs: "hot" (score >= 50), "warm" (score 25-49), "cold" (score < 25).
4. HubSpot Create Contact (Hot path): Creates the contact with hs_lead_status set to "OPEN" and a custom property lead_score mapped to {{ $json.leadScore }}.
5. HubSpot Create Contact (Warm path): Same node config but sets hs_lead_status to "IN_PROGRESS".
6. Send Email (Hot leads only): Sends an internal alert to your sales team: "Hot lead scored {{ $json.leadScore }}: {{ $json.firstName }} {{ $json.lastName }} at {{ $json.email }}."

In my experience building these for clients, the scoring thresholds matter less than having any scoring at all. Most small businesses treat every lead the same, which means their best prospects wait in the same queue as tire-kickers. Even a rough score like this one gets your team calling the right people first.

We built this exact lead scoring pattern for a 3-person home services company in early 2026. Before the automation, their sales rep was calling every lead in the order forms came in, spending equal time on tire-kickers and ready-to-buy prospects. Within the first month of running the scored workflow, their average response time to hot leads dropped from over 4 hours to under 18 minutes, and their close rate on those hot leads went from 12% to 23%. The workflow itself took about 40 minutes to build and hasn't needed a single change since.

Example 2: Automated Deal Stage Progression

This workflow monitors your CRM for stale deals and automatically nudges them forward or flags them for review.

Node configuration (5 nodes):

1. Schedule Trigger: Runs daily at 9 AM. Set rule to everyDay with hour set to 9.
2. Pipedrive (Get Deals): Resource: Deal, Operation: Get All. Filter by stage: "Qualified" and filter by update_time older than 7 days using the filter_id parameter (create a saved filter in Pipedrive first).
3. IF (Check Deal Age): Checks if the deal has been in the current stage for more than 14 days: {{ $now.diff($json.stage_change_time, 'days') > 14 }}.
4. Pipedrive (Update Deal): For stale deals (true path): moves the deal to "Needs Attention" stage by setting stage_id to your target stage ID.
5. Send Email (Alert): Sends a daily digest to the sales manager listing all deals that were auto-flagged, with deal title, owner, and days in stage.

If you want to take this further with HubSpot-specific triggers and multi-branch routing for every stage in your pipeline, see how to set up n8n deal pipeline stage alerts that actually fire on time.

For a complete walkthrough of configuring the Send Email node for these alerts (including SMTP setup, dynamic subject lines, and HTML formatting), see our n8n Send Email Node tutorial.

Example 3: Two-Way CRM Sync (HubSpot to Pipedrive)

If your marketing team uses HubSpot but your sales team prefers Pipedrive, this workflow keeps contacts in sync across both CRMs.

Node configuration (5 nodes):

1. HubSpot Trigger: Set to fire on "Contact Created" events. This uses HubSpot's webhook subscriptions (requires a Public App or manual webhook setup in HubSpot developer settings).
2. Set (Map Fields): Translates HubSpot field names to Pipedrive field names:

   {
     "name": "{{ $json.properties.firstname }} {{ $json.properties.lastname }}",
     "email": "{{ $json.properties.email }}",
     "phone": "{{ $json.properties.phone }}",
     "hubspot_id": "{{ $json.id }}"
   }
   

3. Pipedrive (Search Person): Resource: Person, Operation: Search. Searches by email to prevent duplicates.
4. IF (Exists Check): Routes to "Create" if no match found, "Update" if the person already exists in Pipedrive.
5. Pipedrive (Create or Update Person): Creates a new Person record or updates the existing one. Stores the hubspot_id in a custom field for reference.

A key detail here: set the Webhook node's response mode to "Respond to Webhook" instead of the default "On Received" if HubSpot expects a 200 OK confirmation before timing out. You can configure this in the Webhook node's parameters under "Response Mode."

These three patterns (lead scoring, deal stage automation, and cross-CRM sync) cover the most common CRM automation requests I see from small business clients. Each one builds on the same fundamentals from the lead capture tutorial above.

What the Same Workflow Looks Like in Make.com

Building the same lead capture workflow in Make.com takes about 25 minutes (vs. 35 in n8n) thanks to its point-and-click field mapping, but costs more at scale: Make.com Core runs $9/month (billed annually) for 10,000 credits while n8n self-hosted is free with unlimited executions.

If you're evaluating both platforms, here's how you'd build the same lead capture workflow in Make.com:

1. Create a new Scenario in Make.com
2. Add a Webhooks > Custom webhook module as the trigger
3. Add a HubSpot > Create a Contact module (or Pipedrive equivalent)
4. Add an Email > Send an Email module
5. Map the fields between modules using Make's point-and-click interface

Make.com's visual mapping interface is more beginner-friendly. You click on a field, and it shows you available data from previous modules in a dropdown. In n8n, you write expressions like {{ $json.email }}, which gives you more power but requires learning the syntax.

Setup time comparison:

• Make.com: ~25 minutes for a first-time user
• n8n: ~35 minutes for a first-time user (the expression syntax takes a few minutes to learn)

These timing estimates come from timed walkthroughs during our client onboarding process at Rain Automation, where we've guided 15+ first-time n8n users and a similar number of Make.com users through this exact CRM workflow over the past year. Individual setup times vary based on CRM familiarity, but the 10-minute gap between platforms has been consistent.

Monthly cost at 500 leads/month:

• n8n self-hosted: $0 (you pay only for your VPS, typically $5-10/month)
• n8n Cloud Starter: EUR 24/month (~$26 USD, 2,500 executions included)
• Make.com Core: $9/month billed annually (10,000 credits, but this workflow uses ~4 credits per lead, so 500 leads = 2,000 credits)

Where n8n pulls ahead: If you want to add AI-powered lead scoring or enrichment later, n8n has built-in nodes for OpenAI, Anthropic Claude, and even local LLM models. Make.com supports OpenAI but has fewer AI integration options. For small businesses that plan to grow their automation over time, n8n's flexibility matters more than Make.com's easier initial setup.

Where Make.com pulls ahead: If you need the workflow running in 30 minutes and don't want to learn expression syntax, Make.com is the faster path. Its error handling is also more visual and easier to configure for non-technical users.

For a more detailed feature-by-feature comparison, check out n8n vs. Make for Small Business Automation.

Common Errors and How to Fix Them

The three most common n8n CRM integration errors are a 401 Unauthorized from missing HubSpot scopes, webhooks not receiving data because of test vs. production URL confusion, and duplicate contacts in Pipedrive from missing deduplication logic. All three are fixable in under 5 minutes.

We run n8n self-hosted in production at Rain Automation, processing roughly 1,200 workflow executions per month across client CRM integrations, lead routing, and internal operations. Across those executions, the webhook test-vs-production URL confusion (Error 2 below) accounts for approximately 60% of all support tickets we receive in the first 30 days after deploying a new workflow for a client. Scope misconfiguration (Error 1) comes in second at around 25%. Here are all three in detail:

Error 1: 401 Unauthorized on the HubSpot Node

What it looks like: The HubSpot node returns {"status": "error", "message": "This app hasn't been granted all required scopes to make this call."}

The fix: Go back to your HubSpot private app settings (Settings > Integrations > Private Apps > your app) and verify you enabled crm.objects.contacts.write. The most common mistake is enabling only the .read scope. After updating scopes, HubSpot generates a new token. Copy it and update your n8n credential.

Error 2: Webhook Not Receiving Data

What it looks like: You submit your form but nothing happens in n8n. The webhook node shows no executions.

The fix: Check which URL you're using. n8n has separate test and production webhook URLs:

• Test URL (contains /webhook-test/): Only works when you click "Listen for Test Event" in the n8n editor. Use this during development.
• Production URL (contains /webhook/): Only works when the workflow is active (the toggle in the top right is turned on). Use this in your live form.

Almost every "webhook not working" issue I've seen comes from using the test URL in production or forgetting to activate the workflow.

Error 3: Duplicate Contacts in Pipedrive

What it looks like: The same person submits your form twice, and Pipedrive creates two separate Person records.

The fix: Add an IF node before the Pipedrive Create Person node. Use the Pipedrive Search operation to look up the email first:

1. Add a Pipedrive node set to Person > Search with the email as the search term
2. Add an IF node that checks if the search returned results: {{ $json.data?.items?.length > 0 }}
3. If yes (person exists): route to an Update Person node instead
4. If no (new person): route to the Create Person node

This "search before create" pattern adds one extra node but prevents messy duplicates in your CRM.

Frequently Asked Questions

Can I use n8n with HubSpot's free plan?

Yes. HubSpot's free CRM includes API access through Private Apps, which is how n8n connects. You can create contacts, deals, and companies through the API on the free plan. The main limitation is the 1,000-contact cap on the non-marketing free tier. You don't need a paid HubSpot plan for this tutorial.

Is n8n free for small businesses?

n8n is free if you self-host it. You can run it on a $5/month VPS (DigitalOcean, Hetzner, or Oracle Cloud's free tier) with no license fees, no execution limits, and no feature restrictions. The managed n8n Cloud service starts at EUR 24/month (approximately $26 USD) for the Starter plan, which includes 2,500 workflow executions.

What is the difference between Zapier, Make.com, and n8n for CRM automation?

Zapier is the easiest but most expensive ($29.99/month for 750 tasks). Make.com offers better value at $9/month (billed annually) for 10,000 credits. n8n is free to self-host with no execution limits and built-in AI nodes. All three connect to major CRMs. Choose based on budget and technical comfort.

How do I connect Pipedrive to n8n?

Get your Pipedrive API token from Personal Preferences > API in Pipedrive. In n8n, add a Pipedrive node, create a new credential, paste the token, and test the connection. The full step-by-step is in the Pipedrive section above.

What CRM works best with n8n?

HubSpot, Pipedrive, and Salesforce have the deepest n8n integration among 30+ supported CRMs. HubSpot Free is the most cost-effective starting point. Pipedrive is better for deal pipeline management. Salesforce is overkill for most small businesses.

How long does it take to set up an n8n CRM integration?

For the workflow in this tutorial (webhook, field normalization, CRM contact creation, welcome email), expect 30-45 minutes for your first setup. That includes creating the CRM credentials and testing. Once you've done it once, you can replicate similar workflows in 10-15 minutes.

Next Steps and Resources

You now have a working lead capture workflow that connects your web form to your CRM and sends an automated follow-up email. From here, you can:

• Add lead scoring: Use n8n's AI nodes to analyze incoming leads and assign a quality score based on their form responses, company size, or email domain.
• Build a multi-step drip sequence: Trigger additional emails at day 3, day 7, and day 14 if the lead hasn't responded.
• Go deeper on HubSpot: If HubSpot is your CRM, the what connecting n8n to HubSpot looks like end to end covers Private App auth, contact creation, and deal pipeline setup in detail.
• Automate deal stages for free: If you're on HubSpot Free and want to automate deal stage progression without paying for Marketing Hub, see our guide on n8n HubSpot integration for the complete free-tier setup.
• Add Slack notifications: Alert your sales team in real-time when a high-value lead comes in.
• Connect multiple forms: Point all your forms (contact page, landing pages, pop-ups) at the same webhook. The Set node's fallback expressions handle different field formats automatically.

If you'd prefer someone to build and maintain these workflows for you, check out Rain Automation's services. We design, build, and manage custom automation workflows for small businesses. You can also reach out directly to discuss your specific setup.

Ready to get started with n8n? Sign up for a free trial or self-host it from the n8n GitHub repository.