n8n per CRM: automatizza vendite con HubSpot e Pipedrive

Quanto lavoro manuale c'è nel processo di vendita?

Se usi un CRM come HubSpot, Pipedrive o Salesforce, sai che lo strumento da solo non basta. Il vero problema non è registrare i contatti, ma tutto quello che succede intorno: qualificare i lead, assegnarli alla persona giusta, aggiornare gli stage, inviare follow-up al momento giusto, generare report. Queste attività manuali consumano fino al 30% del tempo del team commerciale, tempo che dovrebbe essere speso a parlare con i clienti.

n8n permette di automatizzare l'intero ciclo di vendita, dal primo contatto alla chiusura del deal, mantenendo il CRM come fonte unica di verità.

Come si integra n8n con il CRM?

Il concetto è semplice: il CRM resta l'interfaccia per il team commerciale, n8n lavora dietro le quinte per automatizzare tutto il lavoro ripetitivo.

Lead entra (form, ads, email)
  -> n8n qualifica e arricchisce
  -> CRM riceve il lead qualificato
  -> n8n gestisce i follow-up automatici
  -> Commerciale interviene quando serve
  -> n8n aggiorna stage e notifica
  -> Deal chiuso -> n8n attiva onboarding

Come catturare lead automaticamente da fonti multiple?

Il problema

I lead arrivano da 5-10 canali diversi: form del sito, Meta Ads, Google Ads, LinkedIn, email, telefonate, fiere. Inserirli manualmente nel CRM è lento e spesso si perdono contatti.

Il workflow n8n

Fonti multiple (webhook/polling):
  -> Form sito web (Webhook)
  -> Meta Lead Ads (polling ogni 5 min)
  -> Google Ads conversioni (Webhook)
  -> LinkedIn Lead Gen (polling ogni 15 min)
  -> Email parsed (IMAP trigger)

Per ogni lead:
  -> Normalizza dati (nome, email, telefono, fonte)
  -> Verifica duplicati nel CRM
  -> IF nuovo:
     -> Crea contatto nel CRM
     -> Assegna punteggio iniziale
     -> Trigger workflow di qualificazione
  -> IF esistente:
     -> Aggiorna attività nel CRM
     -> Notifica owner del contatto

Normalizzazione dati

// Nodo Code: standardizza i dati del lead
const raw = $json;

const normalized = {
  first_name: (raw.nome || raw.first_name || raw.firstName || '')
    .trim()
    .replace(/^\w/, c => c.toUpperCase()),
  last_name: (raw.cognome || raw.last_name || raw.lastName || '')
    .trim()
    .replace(/^\w/, c => c.toUpperCase()),
  email: (raw.email || raw.mail || raw.e_mail || '')
    .trim()
    .toLowerCase(),
  phone: (raw.telefono || raw.phone || raw.tel || '')
    .replace(/[^+\d]/g, ''),
  company: raw.azienda || raw.company || raw.organization || '',
  source: raw._source || 'website',
  utm_source: raw.utm_source || '',
  utm_medium: raw.utm_medium || '',
  utm_campaign: raw.utm_campaign || '',
  created_at: new Date().toISOString()
};

// Validazione base
if (!normalized.email || !normalized.email.includes('@')) {
  throw new Error(`Email non valida: ${normalized.email}`);
}

return [{ json: normalized }];

Deduplicazione

// Cerca nel CRM se il contatto esiste già
// Nodo HubSpot/Pipedrive: Search Contacts by email
// Poi nel nodo IF:
$json.results.length === 0  // true = nuovo lead

Come funziona il lead routing intelligente?

Il problema

Assegnare i lead alla persona giusta del team è critico. Un lead assegnato male ha il 50% in meno di probabilità di conversione.

Regole di routing

Ecco le regole più comuni per le PMI italiane:

1. Per zona geografica: lead del Nord Italia a Marco, Centro a Laura, Sud a Giuseppe
2. Per dimensione azienda: enterprise (50+ dipendenti) al senior, PMI al junior
3. Per fonte: lead da partner al referente partner, lead organici al team standard
4. Per prodotto/servizio: a seconda dell'interesse espresso
5. Round robin: distribuzione equa quando non ci sono criteri specifici

Implementazione in n8n

// Nodo Code: logica di routing
const lead = $json;

// Mappa regioni -> commerciali
const geoRouting = {
  'Lombardia': '[email protected]',
  'Piemonte': '[email protected]',
  'Veneto': '[email protected]',
  'Emilia-Romagna': '[email protected]',
  'Toscana': '[email protected]',
  'Lazio': '[email protected]',
  'Umbria': '[email protected]',
  'Campania': '[email protected]',
  'Sicilia': '[email protected]',
  'Puglia': '[email protected]'
};

// Determina regione dal CAP o dalla provincia
const region = lead.region || detectRegion(lead.postal_code);
let assignee = geoRouting[region];

// Override: lead enterprise al senior
if (lead.company_size && lead.company_size > 50) {
  assignee = '[email protected]';
}

// Override: lead da partner
if (lead.source === 'partner_referral') {
  assignee = '[email protected]';
}

// Fallback: round robin
if (!assignee) {
  const team = ['[email protected]', '[email protected]', '[email protected]'];
  const index = Date.now() % team.length;
  assignee = team[index];
}

return [{ json: { ...lead, assignee } }];

Notifica immediata

Quando un lead viene assegnato, il commerciale deve saperlo subito:

Canale Slack #vendite:

Nuovo lead assegnato a @marco

Nome: {{ firstName }} {{ lastName }}
Azienda: {{ company }}
Fonte: {{ source }}
Score: {{ score }}/100

Azioni rapide:
- Profilo CRM: {{ crmUrl }}
- Chiama: {{ phone }}
- Email: {{ email }}

Come implementare il lead scoring basato sul comportamento?

Il problema

Non tutti i lead hanno lo stesso valore. Un visitatore che ha scaricato 3 guide, visitato la pagina prezzi e aperto 5 email ha un potenziale molto diverso da chi ha solo compilato un form.

Il modello di scoring

// Nodo Code: calcola lead score
const lead = $json;
let score = 0;

// Dati demografici (max 40 punti)
if (lead.company) score += 10;
if (lead.job_title && lead.job_title.match(/CEO|CTO|Direttore|Manager/i)) score += 15;
if (lead.company_size > 10) score += 10;
if (lead.company_size > 50) score += 5;

// Comportamento (max 60 punti)
if (lead.pages_visited > 5) score += 10;
if (lead.pricing_page_visited) score += 15;
if (lead.demo_requested) score += 20;
if (lead.downloads > 0) score += 5 * Math.min(lead.downloads, 3);
if (lead.email_opens > 3) score += 5;
if (lead.email_clicks > 1) score += 10;

// Penalità
if (lead.email && lead.email.match(/@(gmail|yahoo|hotmail)\./)) score -= 5;
if (lead.unsubscribed) score -= 20;

// Classificazione
let category;
if (score >= 70) category = 'hot';
else if (score >= 40) category = 'warm';
else if (score >= 20) category = 'cool';
else category = 'cold';

return [{
  json: {
    ...lead,
    score,
    category,
    scored_at: new Date().toISOString()
  }
}];

Azioni basate sullo score

Score	Categoria	Azione
70-100	Hot	Notifica immediata al commerciale, chiamata entro 1 ora
40-69	Warm	Email di nurturing personalizzata, follow-up in 2 giorni
20-39	Cool	Inserimento in sequenza email educativa
0-19	Cold	Nurturing automatico a lungo termine

Come creare follow-up automatici basati sullo stage del deal?

Il problema

Il 44% dei commerciali rinuncia dopo il primo follow-up, ma l'80% delle vendite richiede almeno 5 contatti. Le sequenze automatiche risolvono questo problema.

Sequenza per lead warm (score 40-69)

Giorno 0: Email di benvenuto personalizzata
  -> Attendi 2 giorni
  -> Verifica: ha aperto l'email?
  -> IF si:
     Giorno 2: Email con case study del suo settore
     -> Attendi 3 giorni
     Giorno 5: Email con invito a demo
     -> Attendi 2 giorni
     Giorno 7: Follow-up telefonico (task al commerciale)
  -> IF no:
     Giorno 3: Re-invio con oggetto diverso
     -> Attendi 4 giorni
     Giorno 7: Ultimo tentativo via LinkedIn

Template email per ogni stage

Stage: "Primo contatto"

Oggetto: {{ company }} + {{ yourCompany }}: una possibilità

Ciao {{ firstName }},

ho notato che hai visitato la nostra pagina {{ lastPage }}.
{{ if industry }}Lavoriamo con diverse aziende nel settore {{ industry }}
e potrei condividere come {{ casestudy_company }} ha ottenuto
{{ casestudy_result }}.{{ endif }}

Hai 15 minuti questa settimana per una breve call?

{{ signature }}

Stage: "Demo richiesta"

Oggetto: La tua demo di {{ product }} è pronta

Ciao {{ firstName }},

grazie per l'interesse in {{ product }}.
Ho preparato una demo personalizzata basata su {{ company }}.

Scegli lo slot che preferisci: {{ calendarLink }}

Nel frattempo, ecco un case study che potrebbe interessarti:
{{ caseStudyLink }}

{{ signature }}

Stage: "Proposta inviata"

Oggetto: La proposta per {{ company }} - prossimi passi

Ciao {{ firstName }},

ti scrivo per verificare se hai avuto modo di leggere la proposta
che ti ho inviato {{ daysAgo }} giorni fa.

Ci sono domande o punti che vorresti approfondire?

Possiamo organizzare una call di 15 minuti per rispondere
a qualsiasi dubbio: {{ calendarLink }}

{{ signature }}

Come aggiornare automaticamente lo stage dei deal?

Il problema

I commerciali dimenticano di aggiornare lo stage nel CRM. Questo rende i report inaffidabili e il forecast delle vendite impreciso.

Il workflow

Trigger: eventi multipli
  -> Email risposta ricevuta -> Sposta a "In conversazione"
  -> Demo completata (calendario) -> Sposta a "Demo effettuata"
  -> Proposta aperta (tracking link) -> Sposta a "Proposta in valutazione"
  -> Contratto firmato (DocuSign webhook) -> Sposta a "Chiuso - Vinto"
  -> Nessuna attività per 14 giorni -> Sposta a "Stallo"
  -> Lead ha scritto "non interessato" -> Sposta a "Chiuso - Perso"

Implementazione: rilevamento stallo

// Schedule trigger: ogni giorno alle 8:00
// Cerca deal senza attività negli ultimi 14 giorni

const fourteenDaysAgo = new Date();
fourteenDaysAgo.setDate(fourteenDaysAgo.getDate() - 14);

// Query al CRM: deal aperti con ultima attività prima di 14 giorni fa
// Poi per ogni deal in stallo:

return deals.filter(deal => {
  const lastActivity = new Date(deal.last_activity_date);
  return lastActivity < fourteenDaysAgo
    && deal.stage !== 'closed_won'
    && deal.stage !== 'closed_lost';
}).map(deal => ({
  json: {
    deal_id: deal.id,
    deal_name: deal.title,
    owner: deal.owner_email,
    days_stale: Math.floor(
      (Date.now() - new Date(deal.last_activity_date)) / 86400000
    ),
    value: deal.value
  }
}));

Report stallo settimanale

Ogni lunedi mattina, il direttore commerciale riceve:

Report deal in stallo - Settimana {{ weekNumber }}

Deal senza attività da 14+ giorni:

1. {{ dealName }} - {{ value }} EUR ({{ daysStale }} giorni)
   Owner: {{ owner }}
   Ultimo contatto: {{ lastActivity }}

2. ...

Valore totale a rischio: {{ totalValue }} EUR
Azione consigliata: review con il team entro venerdì

Come automatizzare il reporting delle vendite?

Dashboard settimanale

Schedule Trigger (lunedi alle 8:00)
  -> Query CRM: metriche della settimana
  -> Calcola KPI
  -> Genera report
  -> Invia su Slack + email al management

KPI calcolati automaticamente

// Nodo Code: calcola metriche vendite
const deals = $json.deals;
const period = $json.period; // 'week'

const metrics = {
  // Pipeline
  new_leads: deals.filter(d => d.created_this_period).length,
  qualified_leads: deals.filter(d => d.score >= 40).length,
  demos_booked: deals.filter(d => d.stage === 'demo_scheduled').length,
  proposals_sent: deals.filter(d => d.stage === 'proposal_sent').length,

  // Conversioni
  deals_won: deals.filter(d => d.stage === 'closed_won').length,
  deals_lost: deals.filter(d => d.stage === 'closed_lost').length,
  revenue_won: deals
    .filter(d => d.stage === 'closed_won')
    .reduce((sum, d) => sum + d.value, 0),

  // Velocità
  avg_days_to_close: calculateAvgDaysToClose(deals),
  conversion_rate: (
    deals.filter(d => d.stage === 'closed_won').length /
    Math.max(deals.filter(d => d.created_this_period).length, 1) * 100
  ).toFixed(1),

  // Per commerciale
  by_rep: groupByRep(deals)
};

return [{ json: metrics }];

Come configurare l'integrazione con HubSpot?

HubSpot è il CRM più diffuso tra le PMI italiane. Ecco come configurare l'integrazione con n8n:

1. Credenziali: usa l'OAuth di HubSpot (più sicuro delle API key)
2. Nodi disponibili: Contact, Company, Deal, Ticket, Engagement
3. Webhook HubSpot: configura i workflow HubSpot per inviare webhook a n8n quando cambiano proprietà specifiche

HubSpot Trigger (contact.propertyChange)
  -> n8n riceve evento
  -> Esegue logica di business
  -> Aggiorna HubSpot via API

Come configurare l'integrazione con Pipedrive?

Pipedrive è popolare per la sua semplicità. L'integrazione n8n è nativa:

1. Credenziali: API token dal profilo Pipedrive
2. Nodi: Deal, Person, Organization, Activity, Note
3. Webhook: Pipedrive invia webhook per ogni cambio di stato

Quali risultati aspettarsi dall'automazione vendite?

Con il processo di vendita automatizzato:

• 30% di tempo in più per il team commerciale da dedicare alle conversazioni
• 2x velocità di risposta ai nuovi lead (da ore a minuti)
• 15-20% in più di conversioni grazie a follow-up tempestivi
• Zero lead persi nella transizione tra canali
• Forecast affidabile grazie ad aggiornamenti automatici degli stage
• Visibilità completa su pipeline e performance individuali

Errori comuni da evitare quando automatizzi le vendite

1. Automatizzare prima di aver definito gli stage del CRM: senza una pipeline chiara, ogni workflow finisce per spostare deal nel posto sbagliato. Mettere ordine nel CRM PRIMA di scrivere il primo nodo.
2. Lead scoring troppo aggressivo all'inizio: partire con punteggi semplici (5-6 segnali max), poi tarare sui dati reali dopo 30-60 giorni. Un modello complesso senza dati produce solo rumore.
3. Sequenze di follow-up senza opt-out automatico: la PMI italiana finisce su GDPR e reputazione. Ogni sequenza n8n deve contenere il check "lead ha risposto/disiscritto" prima del nodo email.
4. Non testare la deduplicazione: un lead che entra da 3 canali in 5 minuti viene creato 3 volte se la finestra di dedup è troppo stretta. Verificare con dataset reale prima di andare live.
5. Trigger di stage automatici senza override umano: il commerciale deve poter dire "no, questo deal non è in stallo, sto aspettando il CDA del cliente". Predisporre sempre un tag manuale che blocca le automazioni.

Come gestire la sincronizzazione bidirezionale CRM e n8n

Il rischio più frequente in produzione è il loop infinito: n8n aggiorna il CRM, il webhook del CRM richiama n8n, n8n riaggiorna il CRM, e così via. Tre regole per evitarlo:

• Set timestamp di ultima modifica n8n: ogni workflow scrive un campo custom last_n8n_sync con timestamp. Il webhook in entrata ignora eventi più recenti di X secondi rispetto a quel timestamp.
• Filtro source: HubSpot, Pipedrive e Salesforce permettono di filtrare i webhook per source !== "n8n_integration". Configurare a livello di CRM, non di workflow.
• Idempotency key: ogni esecuzione n8n include un hash (deal_id, action, day). Se l'hash è già stato processato nelle ultime 24 ore, skip.

// Nodo Code: idempotency check
import crypto from 'crypto';

const key = crypto
  .createHash('sha256')
  .update(`${$json.deal_id}:${$json.action}:${new Date().toISOString().slice(0,10)}`)
  .digest('hex');

// Cerca in tabella idempotency (Postgres, Redis, n8n staticData)
const exists = await $execution.customData.get(key);
if (exists) {
  return [{ json: { skipped: true, reason: 'duplicate', key } }];
}
await $execution.customData.set(key, Date.now(), { ttl: 86400 });

return [{ json: $json }];

Come iniziare: il piano in 14 giorni

Se parti da zero, evita la trappola "automatizziamo tutto subito". Sequenza realistica:

• Giorni 1-3: inventario sorgenti lead, mappatura stage CRM esistenti, scelta CRM target se non già presente
• Giorni 4-7: primo workflow live (cattura lead + dedup + notifica Slack), nessun routing complesso ancora
• Giorni 8-10: aggiungi lead scoring base (5 segnali), notifica differenziata hot/warm/cold
• Giorni 11-14: prima sequenza email automatica per i warm, stage update su risposta

A 14 giorni hai già un sistema che salva il 30% del tempo del team. Le ottimizzazioni successive (multi-canale, AI scoring, predictive forecast) entrano dal mese 2.

Approfondimenti correlati

• Vedi il confronto pratico n8n vs Zapier per PMI italiane se stai valutando la migrazione del CRM workflow
• Guida tecnica AI Agent con n8n per aggiungere qualificazione automatica AI al lead scoring
• Template pronti per arricchimento contatti CRM automatico e sincronizzazione HubSpot - Google Sheets

---

In sintesi

Automatizzare il CRM con n8n non significa sostituire il commerciale, ma togliergli il 30% di lavoro ripetitivo che lo distoglie dalle conversazioni che chiudono i deal. La differenza tra un'implementazione che funziona e una che esplode in 3 mesi sta tutta nei dettagli operativi: deduplica, idempotency, opt-out, override umano.

Vuoi accelerare l'implementazione?

• Scarica il Production Playbook n8n gratuito: 27 controlli operativi e bundle nginx/docker/backup pronti per la produzione (PDF in italiano)
• Parla con Marco, il nostro assistente AI tecnico, usando il widget chat in basso a destra. Risponde in italiano su scope, stack, volumi
• Hai un progetto CRM concreto da valutare? Richiedi una valutazione - risposta tecnica via email entro 24 ore lavorative