n8n e CRM: la guida completa per automazione vendite e lead management

Perché n8n per l'automazione CRM

La gestione delle relazioni con i clienti (CRM) è il cuore operativo di qualsiasi azienda che vende B2B o B2C con un ciclo di vendita strutturato. Strumenti come HubSpot, Pipedrive e Salesforce offrono funzionalità native di automazione, ma spesso le aziende hanno bisogno di collegare il CRM a decine di altri sistemi: email, e-commerce, fatturazione, supporto clienti, analytics.

È qui che entra in gioco n8n. Mentre Zapier è il tool più noto per le integrazioni, n8n offre vantaggi significativi per la gestione CRM, specialmente per aziende italiane con esigenze specifiche e budget definiti.

n8n vs Zapier per il CRM: confronto dettagliato

Costi

Il confronto sui costi è spesso il fattore determinante per le PMI italiane:

Piano	Zapier	n8n Cloud	n8n Self-Hosted
Free	100 task/mese	250 esecuzioni/mese	Illimitate
Entry	25 USD/mese (750 task)	24 EUR/mese (5.000 esecuzioni)	~15-30 EUR/mese (VPS)
Business	69 USD/mese (2.000 task)	56 EUR/mese (20.000 esecuzioni)	~15-30 EUR/mese (VPS)
Unlimited	Non disponibile	112 EUR/mese	~15-30 EUR/mese (VPS)

Nota: il self-hosting di n8n richiede competenze tecniche per la manutenzione, ma il costo mensile di una VPS adeguata è significativamente inferiore a qualsiasi piano a consumo. Per volumi elevati di automazione, la differenza di costo è dell'ordine di 5-10x.

Funzionalità CRM

Funzionalità	Zapier	n8n
Nodi nativi CRM	15+ CRM	10+ CRM
Logica condizionale complessa	Filtri multi-step	IF/Switch + Code
Trasformazione dati	Formatter (limitato)	Code (JavaScript completo)
Gestione errori	Auto-retry base	Error Trigger + retry custom
Branching parallelo	Paths (max 3)	Illimitato
Sub-workflow	Transfer	Execute Workflow
Rate limiting	Gestito da Zapier	Da configurare manualmente
Debugging	Log base	Console + execution log dettagliato

Quando n8n è superiore a Zapier

1. Logica complessa: se la tua automazione CRM richiede elaborazioni dati, calcoli personalizzati o logica multi-step, n8n offre la flessibilità del codice JavaScript
2. Volumi alti: con il self-hosting, non paghi per ogni esecuzione
3. Integrazioni custom: se usi API proprietarie o sistemi legacy, n8n permette chiamate HTTP completamente configurabili
4. Dati sensibili: con il self-hosting, i dati dei clienti rimangono sui tuoi server, in Italia, conformemente al GDPR
5. Controllo totale: puoi modificare ogni singolo nodo, aggiungere logica personalizzata e creare workflow che Zapier non supporta nativamente

Workflow 1: sincronizzazione bidirezionale con HubSpot

La sincronizzazione bidirezionale tra il CRM e altri sistemi è uno dei casi d'uso più frequenti. Questo workflow mantiene allineati i contatti tra HubSpot e un database interno.

Da HubSpot al database interno

Schedule Trigger (ogni 15 minuti)
  -> HTTP Request (GET contatti recenti da HubSpot)
  -> Loop Over Items
    -> PostgreSQL (UPSERT contatto nel DB interno)
    -> IF (contatto modificato?)
      -> true: Slack (notifica aggiornamento)

Query HubSpot per contatti recenti

{
  "parameters": {
    "method": "GET",
    "url": "https://api.hubapi.com/crm/v3/objects/contacts",
    "authentication": "genericCredentialType",
    "genericAuthType": "httpHeaderAuth",
    "sendHeaders": true,
    "headerParameters": {
      "parameters": [
        {
          "name": "Authorization",
          "value": "Bearer <HUBSPOT_ACCESS_TOKEN>"
        }
      ]
    },
    "sendQuery": true,
    "queryParameters": {
      "parameters": [
        {
          "name": "limit",
          "value": "100"
        },
        {
          "name": "properties",
          "value": "email,firstname,lastname,phone,company,jobtitle,lead_status,lastmodifieddate"
        },
        {
          "name": "sort",
          "value": "lastmodifieddate"
        },
        {
          "name": "after",
          "value": "={{ $json.last_timestamp || '' }}"
        }
      ]
    }
  },
  "type": "n8n-nodes-base.httpRequest",
  "name": "Leggi Contatti HubSpot"
}

UPSERT nel database interno

{
  "parameters": {
    "operation": "executeQuery",
    "query": "INSERT INTO contacts (hubspot_id, email, first_name, last_name, phone, company, job_title, lead_status, last_sync) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, NOW()) ON CONFLICT (hubspot_id) DO UPDATE SET email = EXCLUDED.email, first_name = EXCLUDED.first_name, last_name = EXCLUDED.last_name, phone = EXCLUDED.phone, company = EXCLUDED.company, job_title = EXCLUDED.job_title, lead_status = EXCLUDED.lead_status, last_sync = NOW()",
    "queryParameters": {
      "parameters": [
        { "name": "hubspot_id", "type": "string", "value": "={{ $json.id }}" },
        { "name": "email", "type": "string", "value": "={{ $json.properties.email }}" },
        { "name": "first_name", "type": "string", "value": "={{ $json.properties.firstname || '' }}" },
        { "name": "last_name", "type": "string", "value": "={{ $json.properties.lastname || '' }}" },
        { "name": "phone", "type": "string", "value": "={{ $json.properties.phone || '' }}" },
        { "name": "company", "type": "string", "value": "={{ $json.properties.company || '' }}" },
        { "name": "job_title", "type": "string", "value": "={{ $json.properties.jobtitle || '' }}" },
        { "name": "lead_status", "type": "string", "value": "={{ $json.properties.lead_status || 'new' }}" }
      ]
    }
  },
  "type": "n8n-nodes-base.postgres",
  "name": "Aggiorna Contatto DB"
}

Workflow 2: lead scoring automatico

Il lead scoring assegna un punteggio a ogni contatto in base al suo comportamento e alle sue caratteristiche, permettendo al team vendite di concentrarsi sui contatti più promettenti.

Modello di scoring personalizzato

// Nodo Code - Lead Scoring
const item = $input.first().json;
const c = item.json;

let score = 0;
let reasons = [];

// Dati demografici (max 30 punti)
if (c.company) {
  score += 10;
  reasons.push('Azienda compilata (+10)');
}
if (c.job_title) {
  const ruoliDecisionali = ['CEO', 'CTO', 'Direttore', 'Manager', 'Head', 'VP', 'Responsabile'];
  const match = ruoliDecisionali.some(r => c.job_title.toLowerCase().includes(r.toLowerCase()));
  if (match) {
    score += 15;
    reasons.push('Ruolo decisionale (+15)');
  } else {
    score += 5;
    reasons.push('Ruolo compilato (+5)');
  }
}
if (c.phone) {
  score += 5;
  reasons.push('Telefono compilato (+5)');
}

// Comportamento email (max 40 punti)
const emailOpens = parseInt(c.email_opens_30d || 0);
if (emailOpens >= 10) {
  score += 20;
  reasons.push(`${emailOpens} aperture email (+20)`);
} else if (emailOpens >= 5) {
  score += 15;
  reasons.push(`${emailOpens} aperture email (+15)`);
} else if (emailOpens >= 2) {
  score += 8;
  reasons.push(`${emailOpens} aperture email (+8)`);
}

const emailClicks = parseInt(c.email_clicks_30d || 0);
if (emailClicks >= 5) {
  score += 20;
  reasons.push(`${emailClicks} click email (+20)`);
} else if (emailClicks >= 2) {
  score += 12;
  reasons.push(`${emailClicks} click email (+12)`);
}

// Comportamento sito (max 20 punti)
const pageViews = parseInt(c.page_views_30d || 0);
const visitsPricing = parseInt(c.pricing_page_visits || 0);

if (visitsPricing >= 3) {
  score += 15;
  reasons.push(`${visitsPricing} visite pagina prezzi (+15)`);
} else if (visitsPricing >= 1) {
  score += 8;
  reasons.push(`${visitsPricing} visite pagina prezzi (+8)`);
}

if (pageViews >= 20) {
  score += 5;
  reasons.push(`${pageViews} pagine visitate (+5)`);
}

// Interazioni (max 10 punti)
if (c.form_submissions && parseInt(c.form_submissions) >= 2) {
  score += 10;
  reasons.push('Più form compilati (+10)');
} else if (c.form_submissions && parseInt(c.form_submissions) >= 1) {
  score += 5;
  reasons.push('Form compilato (+5)');
}

// Dimensione azienda (max 10 punti)
if (c.company_size) {
  const size = parseInt(c.company_size);
  if (size >= 50 && size <= 500) {
    score += 10; // target ideale
    reasons.push('Dimensione azienda target (+10)');
  } else if (size >= 10 && size <= 1000) {
    score += 5;
    reasons.push('Dimensione azienda accettabile (+5)');
  }
}

// Classificazione
let grade = 'D';
if (score >= 70) grade = 'A';
else if (score >= 50) grade = 'B';
else if (score >= 30) grade = 'C';

return [{
  json: {
    contact_id: c.id,
    email: c.email,
    nome: `${c.first_name || ''} ${c.last_name || ''}`.trim(),
    punteggio: score,
    grado: grade,
    motivazioni: reasons.join('; '),
    email_opens: emailOpens,
    email_clicks: emailClicks,
    pricing_visits: visitsPricing,
    last_updated: new Date().toISOString()
  }
}];

Aggiornamento del CRM con il punteggio

Schedule Trigger (ogni giorno alle 6:00)
  -> PostgreSQL (leggi attività recenti per ogni contatto)
  -> Code (calcola punteggio lead scoring)
  -> IF (punteggio cambiato significativamente?)
    -> true: HTTP Request (aggiorna HubSpot)
    -> IF (nuovo grado A?)
      -> true: Slack (alert lead caldo al team vendite)
      -> Email (invia notifica al commerciale assegnato)

Workflow 3: follow-up automatici intelligente

I follow-up tempestivi aumentano drasticamente le probabilità di conversione. Secondo le statistiche, rispondere entro 5 minuti a una richiesta aumenta le probabilità di contatto di 900% rispetto a una risposta dopo 30 minuti.

Sequenza di follow-up per nuovi lead

Webhook (nuovo lead da modulo sito)
  -> PostgreSQL (salva lead)
  -> Email immediata (benvenuto + informazioni richieste)
  -> Assegna al commerciale (rotazione round-robin)
  -> Slack (notifica al commerciale: nuovo lead da contattare entro 5 minuti)
  -> Wait (1 ora)
  -> IF (commerciale ha contato il lead?)
    -> true: Stop (gestione manuale)
    -> false: Slack (reminder al commerciale)
  -> Wait (1 giorno)
  -> IF (lead risposto?)
    -> true: Stop
    -> false: Email follow-up (ulteriori informazioni)
  -> Wait (3 giorni)
  -> IF (lead risposto?)
    -> true: Stop
    -> false: Email follow-up (caso studio pertinente)
  -> Wait (7 giorni)
  -> IF (lead risposto?)
    -> true: Stop
    -> false: Email finale (offerta speciale + invito a chiamare)
  -> Aggiorna stato lead a "nurturing"

Assegnazione commerciale round-robin

// Nodo Code - Round Robin Assignment
const items = $input.all();
const lead = items[0].json;

// Leggi le assegnazioni recenti dal database
// (in produzione, questo sarebbe una query al DB)
const commerciali = [
  { id: 1, nome: 'Marco Bianchi', email: '[email protected]' },
  { id: 2, nome: 'Laura Verdi', email: '[email protected]' },
  { id: 3, nome: 'Andrea Russo', email: '[email protected]' }
];

// Per semplicità, assegna in base al giorno della settimana
const dayOfWeek = new Date().getDay();
const commerciale = commerciali[dayOfWeek % commerciali.length];

return [{
  json: {
    ...lead,
    assegnato_a: commerciale.nome,
    assegnato_a_email: commerciale.email,
    assegnato_a_id: commerciale.id,
    data_assegnazione: new Date().toISOString()
  }
}];

Workflow 4: report vendite automatico

I manager commerciali hanno bisogno di visibility sulle performance del team. Questo workflow genera un report giornaliero automatico.

Query vendite del giorno

-- Vendite per commerciale (giorno corrente)
SELECT
  u.nome AS commerciale,
  COUNT(DISTINCT d.id) AS trattative_attive,
  COUNT(DISTINCT CASE WHEN d.stage = 'won' THEN d.id END) AS deal_chiusi,
  ROUND(COALESCE(SUM(CASE WHEN d.stage = 'won' THEN d.value ELSE 0 END), 0), 2) AS fatturato_giorno,
  ROUND(COALESCE(AVG(CASE WHEN d.stage = 'won' THEN d.value ELSE NULL END), 0), 2) AS deal_medio,
  COUNT(DISTINCT CASE WHEN d.stage = 'lost' THEN d.id END) AS deal_persi
FROM deals d
JOIN users u ON u.id = d.assigned_to
WHERE d.updated_at >= CURRENT_DATE
GROUP BY u.nome
ORDER BY fatturato_giorno DESC;

Pipeline forecast settimanale

-- Pipeline con probabilità ponderata
SELECT
  u.nome AS commerciale,
  d.stage,
  COUNT(*) AS num_deal,
  ROUND(SUM(d.value), 2) AS valore_totale,
  ROUND(SUM(d.value * d.probability / 100), 2) AS valore_ponderato
FROM deals d
JOIN users u ON u.id = d.assigned_to
WHERE d.stage NOT IN ('won', 'lost')
  AND d.expected_close_date <= CURRENT_DATE + INTERVAL '30 days'
GROUP BY u.nome, d.stage
ORDER BY u.nome, valore_ponderato DESC;

Formattazione e invio report

// Nodo Code - Formatta Report Vendite
const vendite = $input.all();
const oggi = new Date().toLocaleDateString('it-IT', {
  weekday: 'long',
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});

const totaleFatturato = vendite
  .reduce((sum, v) => sum + parseFloat(v.json.fatturato_giorno || 0), 0);

const totaliDeal = vendite
  .reduce((sum, v) => sum + parseInt(v.json.deal_chiusi || 0), 0);

const report = `# Report Vendite - ${oggi}

## Riepilogo Giornaliero
- **Deal chiusi**: ${totaliDeal}
- **Fatturato totale**: ${totaleFatturato.toFixed(2)} EUR

## Performance per Commerciale

${vendite.map(v => `
### ${v.json.commerciale}
- Trattative attive: ${v.json.trattative_attive}
- Deal chiusi: ${v.json.deal_chiusi}
- Fatturato: ${parseFloat(v.json.fatturato_giorno || 0).toFixed(2)} EUR
- Deal medio: ${parseFloat(v.json.deal_medio || 0).toFixed(2)} EUR
- Deal persi: ${v.json.deal_persi}
`).join('')}
`;

return [{
  json: {
    report_markdown: report,
    report_subject: `Report Vendite ${new Date().toLocaleDateString('it-IT')}`
  }
}];

Integrazione con Pipedrive

Pipedrive è un CRM molto popolare tra le PMI italiane per la sua semplicità e il focus sulla pipeline visuale. Ecco come collegarlo a n8n.

Webhook Pipedrive per nuovi deal

{
  "parameters": {
    "httpMethod": "POST",
    "path": "pipedrive-new-deal",
    "responseMode": "onReceived"
  },
  "type": "n8n-nodes-base.webhook",
  "name": "Pipedrive New Deal"
}

Configura in Pipedrive: Settings > Webhooks > Add Webhook, puntando all'URL del tuo n8n con evento deal.added.

Creazione attività di follow-up

Quando un deal entra in una fase specifica, crea automaticamente un'attività per il commerciale:

{
  "parameters": {
    "method": "POST",
    "url": "https://api.pipedrive.com/v1/activities",
    "authentication": "genericCredentialType",
    "genericAuthType": "httpHeaderAuth",
    "sendHeaders": true,
    "headerParameters": {
      "parameters": [
        {
          "name": "Authorization",
          "value": "Bearer <PIPEDRIVE_API_TOKEN>"
        }
      ]
    },
    "sendQuery": true,
    "queryParameters": {
      "parameters": [
        {
          "name": "subject",
          "value": "Follow-up obbligatorio - Deal in fase Proposta"
        },
        {
          "name": "type",
          "value": "call"
        },
        {
          "name": "due_date",
          "value": "={{ new Date(Date.now() + 2 * 24 * 60 * 60 * 1000).toISOString().split('T')[0] }}"
        },
        {
          "name": "deal_id",
          "value": "={{ $json.current.deal.id }}"
        },
        {
          "name": "user_id",
          "value": "={{ $json.current.deal.user_id }}"
        },
        {
          "name": "note",
          "value": "Creato automaticamente da n8n: il deal è passato alla fase Proposta. Contattare il cliente entro 48 ore."
        }
      ]
    }
  },
  "type": "n8n-nodes-base.httpRequest",
  "name": "Crea Attività Follow-up"
}

Perché le aziende italiane scelgono n8n

Conformità GDPR e sovranità dei dati

Con il self-hosting di n8n, i dati dei clienti non lasciano i server italiani. Per molte aziende, specialmente nel settore B2B, questo è un requisito non negoziabile. Zapier, al contrario, elabora i dati sui server statunitensi, il che richiede un'analisi approfondita delle clausole contrattuali per la conformità al GDPR.

Costo prevedibile

Le PMI italiane apprezzano la prevedibilità dei costi. Con n8n self-hosted, il costo mensile è fisso (il costo della VPS), indipendentemente dal numero di automazioni eseguite. Con Zapier, un picco di attività (ad esempio, una campagna marketing che genera 5.000 lead in un giorno) puo' trasformarsi in una bolletta salata.

Flessibilità per processi italiani

Le aziende italiane spesso hanno processi specifici che richiedono logiche custom: gestione del codice fiscale, calcolo IVA, integrazione con sistemi di fatturazione elettronica (SDI), gestione dei termini di pagamento (30/60/90 gg). n8n permette di implementare queste logiche senza limitazioni, mentre Zapier richiede spesso workaround complessi o soluzioni premium.

Community e supporto in italiano

La community italiana di n8n sta crescendo rapidamente, con gruppi Telegram, canali Discord e meetup periodici. Per le aziende che preferiscono il supporto in lingua italiana, questo è un vantaggio rispetto a piattaforme con community esclusivamente anglofone.

Conclusione

n8n si posiziona come alternativa seria a Zapier per l'automazione CRM, offrendo costi inferiori, maggiore flessibilità e il controllo completo sui dati. Per le aziende italiane che cercano di ottimizzare i processi di vendita senza investimenti eccessivi, n8n rappresenta una scelta pragmatica e scalabile.

Il consiglio è iniziare con 2-3 workflow critici (lead capture, follow-up automatici, report vendite) e poi espandere gradualmente l'automazione man mano che il team acquisisce confidenza con lo strumento.