--- title: "Leadpipe + n8n: Open-Source Visitor Data Automation" description: "Use n8n to automate visitor identification workflows without vendor lock-in. Webhook triggers, conditional routing, and multi-step automations." canonical_url: "https://www.leadpipe.com/blog/leadpipe-n8n-automation/" source_url: "https://www.leadpipe.com/blog/leadpipe-n8n-automation/" md_url: "https://www.leadpipe.com/blog/leadpipe-n8n-automation.md" content_type: "article" pubDate: "2026-01-16T00:00:00.000Z" last_updated: "2026-01-16T00:00:00.000Z" --- # Leadpipe + n8n: Open-Source Visitor Data Automation In this guide Use n8n to automate visitor identification workflows without vendor lock-in. Webhook triggers, conditional routing, and multi-step automations. Zapier charges you per task. Make charges you per operation. And both of them lock your automation logic into a platform you don’t control. If you’re a developer - or a team with a developer - there’s a better option. [n8n](https://docs.n8n.io/) is an open-source workflow automation tool that you can self-host, customize without limits, and run without per-execution pricing. When you combine it with Leadpipe’s [real-time webhooks](/blog/webhook-payload-reference-every-visitor-data-field/), you get a visitor identification automation layer that’s as flexible as code but as visual as a no-code tool. This guide covers everything: n8n setup, webhook configuration, conditional routing, multi-step enrichment workflows, code node examples for custom logic, and production-ready workflow templates. --- ## Why Developers Prefer n8n If your team is already using [Zapier](/blog/leadpipe-zapier-automation-recipes/) and it’s working fine, you don’t need to switch. But if any of these apply, n8n is worth considering: | Concern | Zapier | n8n | | --- | --- | --- | | **Cost at scale** | $0.01-0.03 per task, adds up fast | Free (self-hosted) or $24/mo (cloud) | | **Vendor lock-in** | Your logic lives in Zapier’s platform | Self-host, export workflows as JSON | | **Custom code** | Limited code steps, sandboxed | Full JavaScript/Python in Code nodes | | **Error handling** | Basic retry logic | Advanced error workflows, custom retry | | **Data privacy** | Data passes through Zapier servers | Self-hosted = data stays on your infra | | **API flexibility** | Pre-built connectors only | HTTP Request node for any API | | **Branching logic** | Zapier Paths (limited) | Unlimited IF/ELSE, Switch, Merge nodes | For high-volume Leadpipe users processing 1,000+ identified visitors per month, n8n’s self-hosted option saves significant money. At 1,000 visitors/month with 5 actions per visitor, you’d pay $150-300/month in Zapier tasks. n8n self-hosted costs $0 in execution fees. For a comparison of Zapier-based approaches, see our [Zapier automation recipes](/blog/leadpipe-zapier-automation-recipes/). --- ## What You’ll Need - **Leadpipe account** - [Start free with 500 leads](https://dashboard.leadpipe.com/auth/signup) - **n8n instance** - self-hosted (Docker, npm) or n8n Cloud - **Target systems** - CRM, Slack, email platform, enrichment APIs - **Basic comfort with JSON** - n8n is visual, but you’ll work with webhook payloads ### Quick n8n Setup (Docker) If you don’t have n8n running yet: ``` As described in n8n's Docker installation guide: docker run -it --rm \ --name n8n \ -p 5678:5678 \ -v n8n_data:/home/node/.n8n \ n8nio/n8n ``` Open `http://localhost:5678` and you’re ready. --- ## Workflow 1: Basic Webhook to CRM The foundational workflow. Every identified visitor becomes a CRM lead. ### Step 1: Webhook Trigger Node 1. In n8n, create a new workflow 2. Add a **Webhook** node (trigger) 3. Set HTTP method to **POST** 4. Copy the webhook URL 5. Add this URL to Leadpipe: **Settings > Integrations > Webhooks** 6. Select **First Match** trigger type in Leadpipe 7. Send a test event The webhook node receives the full Leadpipe payload: ``` { "email": "sarah.chen@acmecorp.com", "first_name": "Sarah", "last_name": "Chen", "company_name": "Acme Corp", "job_title": "VP of Marketing", "linkedin_url": "https://linkedin.com/in/sarahchen", "page_url": "/pricing", "visit_duration": 187 } ``` ### Step 2: Filter Node (ICP Check) Add an **IF** node to filter for business emails: ``` Condition: {{$json.email}} does not contain "gmail.com" AND: {{$json.email}} does not contain "yahoo.com" AND: {{$json.email}} does not contain "hotmail.com" ``` True path continues to CRM. False path stops (or routes to a separate tracking workflow). ### Step 3: CRM Node Add a CRM node based on your system: **HubSpot:** - Node: HubSpot > Create/Update Contact - Map: email, firstName, lastName, company, jobtitle **Salesforce:** - Node: Salesforce > Create Lead - Map: Email, FirstName, LastName, Company, Title **Pipedrive:** - Node: Pipedrive > Create Person - Map: name, email, org_id (lookup by company_name first) **Any CRM via API:** - Node: HTTP Request > POST to your CRM’s API endpoint - Body: mapped Leadpipe fields For CRM-specific details, see the [Salesforce](/blog/leadpipe-salesforce-integration/), [Pipedrive](/blog/leadpipe-pipedrive-integration/), or [HubSpot](/blog/leadpipe-clay-hubspot-integration/) integration guides. --- ## Workflow 2: Intent-Based Routing Route visitors to different actions based on which pages they viewed. This is where n8n’s flexibility shines - unlimited branching without per-path charges. ### Switch Node Setup Add a **Switch** node after the filter: ``` Rules: 1. page_url contains "pricing" OR "demo" → Output 1 (Hot) 2. page_url contains "features" OR "product" OR "case-studies" → Output 2 (Warm) 3. page_url contains "blog" → Output 3 (Nurture) 4. Default → Output 4 (Track only) ``` ### Hot Path (Output 1) ``` Switch → Slack Alert → CRM Lead (Rating: Hot) → Email Sequence Enrollment ``` 1. **Slack** node: Send message to #sales-hot-leads with visitor details 2. **CRM** node: Create lead with hot rating 3. **HTTP Request** node: Enroll in [Outreach](/blog/leadpipe-outreach-integration/) or [Salesloft](/blog/leadpipe-salesloft-integration/) sequence via API ### Warm Path (Output 2) ``` Switch → CRM Lead (Rating: Warm) → Nurture Email → Task Creation ``` 1. **CRM** node: Create lead with warm rating 2. **Email** node: Send a resource relevant to the page they viewed 3. **CRM** node: Create follow-up task for rep (48-hour deadline) ### Nurture Path (Output 3) ``` Switch → CRM Lead (Rating: Cold) → Newsletter Subscription ``` 1. **CRM** node: Create lead with cold rating 2. **HTTP Request** node: Add to email marketing list (Mailchimp, ActiveCampaign, etc.) ### Track Only Path (Output 4) ``` Switch → Google Sheets Row ``` Log to a tracking spreadsheet for pattern analysis without cluttering your CRM. --- ## Workflow 3: Enrichment Pipeline (Identify → Enrich → Qualify → Route) This is n8n’s killer workflow. Chain multiple API calls together to enrich visitor data before routing to your CRM. ### The Flow ``` Leadpipe Webhook → Filter (business email) → Clay API (company enrichment) → Code Node (ICP scoring) → Switch (score-based routing) → CRM + Slack + Sequence ``` ### Step 1: Clay Enrichment Use the HTTP Request node to call Clay’s API for company enrichment: ``` // HTTP Request Node Method: POST URL: https://api.clay.com/v3/people/enrich Headers: { "Authorization": "Bearer YOUR_CLAY_API_KEY", "Content-Type": "application/json" } Body: { "email": "{{$json.email}}" } ``` Clay returns company revenue, employee count, industry, tech stack, and more. See the [Clay + HubSpot integration](/blog/leadpipe-clay-hubspot-integration/) for details on Clay enrichment. ### Step 2: ICP Scoring (Code Node) Add a **Code** node to calculate an ICP score based on Leadpipe + Clay data: ``` const visitor = $input.first().json; let score = 0; // Page intent scoring if (visitor.page_url?.includes('pricing')) score += 30; else if (visitor.page_url?.includes('demo')) score += 30; else if (visitor.page_url?.includes('features')) score += 20; else if (visitor.page_url?.includes('case-studies')) score += 15; else if (visitor.page_url?.includes('blog')) score += 5; // Visit duration scoring if (visitor.visit_duration > 300) score += 20; else if (visitor.visit_duration > 120) score += 10; else if (visitor.visit_duration > 60) score += 5; // Job title scoring const title = (visitor.job_title || '').toLowerCase(); if (/\b(ceo|cto|cfo|cmo|coo|founder|president)\b/.test(title)) score += 25; else if (/\b(vp|vice president|director|head of)\b/.test(title)) score += 20; else if (/\b(manager|lead|senior)\b/.test(title)) score += 10; // Company size scoring (from Clay enrichment) const employees = visitor.company_employee_count || 0; if (employees >= 500) score += 20; else if (employees >= 100) score += 15; else if (employees >= 20) score += 10; // Revenue scoring (from Clay enrichment) const revenue = visitor.company_revenue || 0; if (revenue >= 50000000) score += 20; else if (revenue >= 10000000) score += 15; else if (revenue >= 1000000) score += 10; return [{ json: { ...visitor, icp_score: score, icp_tier: score >= 60 ? 'A' : score >= 40 ? 'B' : score >= 20 ? 'C' : 'D' } }]; ``` ### Step 3: Score-Based Routing (Switch Node) Route by ICP tier: | Tier | Score | Action | | --- | --- | --- | | **A** (60+) | High-intent ICP match | Slack alert + CRM lead (hot) + sequence enrollment + task for AE | | **B** (40-59) | Good fit, moderate intent | CRM lead (warm) + nurture sequence | | **C** (20-39) | Possible fit, low intent | CRM lead (cold) + marketing list | | **D** (0-19) | Poor fit | Log to spreadsheet, no CRM entry | This workflow ensures your CRM only contains leads worth working. Your reps never waste time on poor-fit visitors, and your highest-value prospects get immediate attention. --- ## Workflow 4: Multi-Channel Alert System Send identified visitor notifications to different channels based on context: ``` Leadpipe Webhook → IF pricing page → Slack #sales-hot-leads + Email to AE + SMS (optional) → IF target account → Slack #abm-alerts + CRM note → IF competitor page → Slack #competitive-intel → Default → Slack #website-visitors ``` ### Slack Message Template (Code Node) ``` const v = $input.first().json; const duration = Math.floor(v.visit_duration / 60); const seconds = v.visit_duration % 60; const message = [ `*${v.first_name} ${v.last_name}* - ${v.job_title}`, `Company: ${v.company_name}`, `Email: ${v.email}`, `LinkedIn: ${v.linkedin_url}`, `Page: ${v.page_url}`, `Time on page: ${duration}m ${seconds}s`, ].join('\n'); return [{ json: { message, channel: '#sales-hot-leads' } }]; ``` For more Slack alert patterns, see [Leadpipe + Slack Visitor Alerts](/blog/visitor-identification-slack-alerts/). --- ## Workflow 5: Deduplication and Return Visitor Tracking n8n gives you full control over deduplication logic - something that’s limited in Zapier: ### Deduplication with Database Lookup ``` Leadpipe Webhook → PostgreSQL Query: SELECT * FROM leads WHERE email = '{{email}}' → IF exists: → Update record (add new page view to activity log) → IF page_url = '/pricing' AND previous visits didn't include pricing: → Upgrade lead status to "Hot" → Send Slack alert: "Return visitor now on pricing page!" → IF not exists: → Create new lead in DB + CRM → Start sequence ``` ### Code Node for Dedup Logic ``` const visitor = $input.first().json; const existingLead = $('PostgreSQL').first()?.json; if (existingLead) { // Return visitor - update and potentially escalate const isNewHighIntent = visitor.page_url?.includes('pricing') && !existingLead.pages_viewed?.includes('pricing'); return [{ json: { action: isNewHighIntent ? 'escalate' : 'update', visitor, existingLead } }]; } else { // New visitor - create lead return [{ json: { action: 'create', visitor } }]; } ``` This level of custom deduplication and escalation logic would require multiple Zapier steps and workarounds. In n8n, it’s a single Code node. --- ## Workflow 6: Target Account Matching For [ABM programs](/blog/abm-with-visitor-identification/), match identified visitors against your target account list: ``` Leadpipe Webhook → Google Sheets Lookup: Check company_name against target account list → IF match found: → Slack #abm-alerts with account details → CRM: Link visitor to target account → Update account engagement score → IF no match: → Standard routing (Workflow 2) ``` ### Code Node for Fuzzy Company Matching Company names don’t always match exactly. “Acme Corporation” vs “Acme Corp” vs “ACME” requires fuzzy matching: ``` const visitor = $input.first().json; const targetAccounts = $('Google Sheets').all().map(item => item.json); const normalize = (name) => (name || '').toLowerCase() .replace(/\b(inc|llc|ltd|corp|corporation|company|co)\b\.?/g, '') .replace(/[^a-z0-9]/g, '') .trim(); const visitorCompany = normalize(visitor.company_name); const match = targetAccounts.find(account => { const targetCompany = normalize(account.company_name); return visitorCompany === targetCompany || visitorCompany.includes(targetCompany) || targetCompany.includes(visitorCompany); }); return [{ json: { ...visitor, is_target_account: !!match, matched_account: match || null } }]; ``` --- ## Error Handling and Monitoring n8n’s error handling is significantly more capable than Zapier’s: ### Error Workflow Create a dedicated error workflow: ``` Error Trigger → Slack #n8n-errors: "Leadpipe workflow failed: {{error.message}}" → Log to error tracking (Sentry, Datadog, or a database) → IF critical: Send email to ops team ``` ### Retry Logic Configure retry behavior on individual nodes: - **CRM nodes:** Retry 3 times with 30-second delay (handles rate limits) - **Enrichment API nodes:** Retry 2 times with 60-second delay - **Slack nodes:** Retry 2 times with 10-second delay ### Monitoring Dashboard n8n’s execution log shows every workflow run with input/output data. Set up a monitoring routine: - Check failed executions daily - Monitor webhook response times - Track CRM creation success rates - Alert on consecutive failures --- ## Workflow 7: Time-Based Follow-Up Scheduling n8n’s Wait node enables time-based automation that’s difficult to replicate in Zapier: ``` Leadpipe Webhook → CRM Lead Created → Wait 24 hours → Check: Did the lead respond? → IF no response: → Send follow-up email via SendGrid/Mailgun → Wait 72 hours → Check again → IF still no response: → Create LinkedIn outreach task in CRM ``` ### Wait Node Configuration ``` Node: Wait Settings: - Resume: After time interval - Amount: 24 - Unit: Hours ``` The Wait node pauses the workflow for a specified duration, then continues execution. This lets you build multi-step, time-delayed sequences entirely within n8n - no separate email sequence tool needed for simple follow-ups. This approach works best for teams that want to keep their automation logic centralized in n8n rather than spreading it across multiple platforms. --- ## Production Checklist Before going live with your n8n + Leadpipe workflows: - **Webhook URL is stable.** If self-hosting, ensure your n8n instance has a static URL (use a reverse proxy with SSL). - **Error workflow is active.** Don’t run production workflows without error notifications. - **Deduplication is tested.** Send the same test visitor twice and verify it doesn’t create duplicates. - **Rate limits are respected.** If calling external APIs (Clay, CRM, Slack), add delays between requests for batch processing. - **Data backup.** If self-hosting, ensure n8n’s data directory is backed up. - **Credentials are secure.** Store API keys in n8n’s credential manager, not in workflow nodes. - **Filtering is working.** Verify that personal emails and non-ICP visitors are filtered correctly. --- ## Performance at Scale n8n handles Leadpipe’s webhook volume comfortably: | Monthly Identified Visitors | Webhook Frequency | n8n Resource Needs | | --- | --- | --- | | 500-1,000 | 20-30/day | Minimal (1 CPU, 512MB RAM) | | 1,000-5,000 | 30-150/day | Light (1 CPU, 1GB RAM) | | 5,000-20,000 | 150-650/day | Moderate (2 CPU, 2GB RAM) | | 20,000+ | 650+/day | Scale with queue workers | For most Leadpipe customers, a basic n8n instance on a $5/month VPS handles the volume with room to spare. [Try Leadpipe free with 500 leads ->](https://dashboard.leadpipe.com/auth/signup) --- ## Getting Started 1. **Set up n8n** (5-10 minutes). Docker, npm, or n8n Cloud. 2. **Create a Webhook node** and add the URL to Leadpipe. 3. **Build Workflow 1** (basic webhook to CRM). Test with a real visitor. 4. **Add intent routing** (Workflow 2). Route by page viewed. 5. **Add enrichment** (Workflow 3). Layer Clay or similar enrichment API. 6. **Set up error handling.** Don’t skip this. **[Start your free trial - 500 leads, no credit card required ->](https://dashboard.leadpipe.com/auth/signup)** --- ## FAQ ### How long does it take to build a Leadpipe + n8n workflow? The basic webhook-to-CRM workflow takes 15-30 minutes once n8n is running. Installing n8n via Docker adds another 5-10 minutes. Building the intent-routing workflow with filters and CRM actions takes 30-60 minutes. The enrichment pipeline with Clay API calls and ICP scoring Code nodes takes 1-2 hours. Production-ready workflows with error handling and deduplication typically take a developer half a day to build and test. ### Do I need a developer to use n8n with Leadpipe? For simple workflows (webhook to CRM, Slack alerts), no - n8n’s visual node editor is accessible to ops people comfortable with JSON. For the advanced workflows (custom scoring logic, fuzzy company matching, deduplication against a database), yes - those require writing JavaScript in Code nodes. The good news is you only need one Code node for most use cases, and the examples in this guide are copy-paste ready. ### What does n8n cost compared to Zapier? n8n self-hosted is free for execution. You pay only for the server - a $5/mo VPS handles most Leadpipe volumes comfortably. n8n Cloud starts at $24/mo. Zapier charges per task at roughly $0.01-$0.03 each, which adds up fast at volume. A team processing 1,000 identified visitors per month with 5 actions per visitor would pay $150-$300/mo in Zapier tasks versus $5-$24/mo in n8n. ### Can n8n handle high webhook volumes from Leadpipe? Yes. A basic n8n instance (1 CPU, 1GB RAM) comfortably handles 500-5,000 identified visitors per month. For 20,000+ visitors per month, scale to 2 CPU / 2GB RAM or add queue workers. n8n’s architecture supports horizontal scaling for enterprise volumes. If you are processing 50K+ webhooks per month, consider n8n’s queue mode with Redis for reliable delivery at scale. ### How does n8n compare to Zapier for CRM integration? Zapier has more pre-built connectors (thousands vs hundreds) and a simpler learning curve for non-technical users. n8n gives you unlimited branching, full JavaScript in Code nodes, self-hosted data privacy, and no per-task pricing. For a straightforward [Zapier setup](/blog/leadpipe-zapier-automation-recipes/), Zapier is faster. For complex conditional logic, high volume, or data-residency requirements, n8n is the better choice. ## Related Articles - [Leadpipe + Zapier: 10 Automation Recipes](/blog/leadpipe-zapier-automation-recipes/) - [Webhook Payload Reference: Every Visitor Data Field](/blog/webhook-payload-reference-every-visitor-data-field/) - [Leadpipe API in 5 Minutes](/blog/leadpipe-api-in-5-minutes-identity-data-made-simple/) - [Build a Custom AI SDR with Leadpipe and OpenAI](/blog/build-custom-ai-sdr-with-leadpipe-and-openai/) - [Leadpipe + Clay + HubSpot Integration Guide](/blog/leadpipe-clay-hubspot-integration/) - [Visitor Identification API: Complete Developer Guide](/blog/visitor-identification-api-complete-developer-guide/) - [How to Feed Visitor Data into an AI Agent](/blog/how-to-feed-visitor-data-into-ai-agent/)