Template n8n per la qualificazione lead con AI

Perché qualificare i lead con l'AI

La qualificazione manuale dei lead è un collo di bottiglia per qualsiasi team commerciale. Un commerciale esperto impiega 5-10 minuti per valutare un singolo lead: cercare l'azienda online, verificare la dimensione, capire il settore, stimare il potenziale. Con 50 lead al giorno, parliamo di 4-8 ore spese solo per capire con chi vale la pena parlare.

L'AI può fare questo lavoro in secondi, con risultati comparabili a un commerciale esperto, liberando il team per le attività che generano valore: le conversazioni con i clienti.

In questa guida costruiamo passo-passo un workflow n8n completo che qualifica automaticamente i lead usando GPT-4, arricchisce i dati e li instrada al commerciale giusto.

Il workflow completo

Ecco l'architettura che costruiremo:

Lead entra (webhook/form/CRM)
  |
  v
Arricchimento dati
  -> Ricerca azienda (API)
  -> Profilo LinkedIn (opzionale)
  -> Storico interazioni (CRM)
  |
  v
Qualificazione AI (GPT-4)
  -> Analizza tutti i dati
  -> Assegna score 0-100
  -> Genera motivazione
  -> Suggerisce next action
  |
  v
Routing e azioni
  -> Hot (70+): notifica immediata al senior
  -> Warm (40-69): inserisci in sequenza nurturing
  -> Cold (0-39): nurturing automatico long-term

Passo 1: configurare il trigger

Opzione A: webhook (per form del sito)

Crea un nodo Webhook in n8n con metodo POST. L'URL generato sarà qualcosa come:

https://n8n.tuodominio.it/webhook/lead-qualification

Configura il tuo form per inviare i dati a questo URL:

// Esempio: form HTML con fetch
const formData = {
  first_name: document.getElementById('nome').value,
  last_name: document.getElementById('cognome').value,
  email: document.getElementById('email').value,
  company: document.getElementById('azienda').value,
  phone: document.getElementById('telefono').value,
  message: document.getElementById('messaggio').value,
  page_url: window.location.href,
  utm_source: new URLSearchParams(window.location.search).get('utm_source')
};

fetch('https://n8n.tuodominio.it/webhook/lead-qualification', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify(formData)
});

Opzione B: trigger CRM

Se i lead entrano già nel CRM, usa il trigger nativo:

• HubSpot Trigger: evento "Contact Created"
• Pipedrive Trigger: evento "New Person"

Opzione C: polling email

Per lead che arrivano via email (es. richieste da sito che finiscono in una casella dedicata):

IMAP Email Trigger
  -> Filtra: solo email da form (subject contiene "Richiesta info")
  -> Estrai dati dal corpo email (regex o AI)

Passo 2: arricchimento dati automatico

Prima di chiedere all'AI di qualificare il lead, raccogliamo più informazioni possibili.

2.1 Ricerca azienda

Usa un servizio di arricchimento dati aziendali. Ecco alcune opzioni:

Con l'API di OpenAI (metodo semplice):

// Nodo Code: prepara prompt per ricerca azienda
const lead = $json;

const prompt = `Cerca informazioni sull'azienda "${lead.company}" in Italia.
Rispondi SOLO in formato JSON con questa struttura:
{
  "company_name": "nome ufficiale",
  "industry": "settore",
  "estimated_size": "micro/piccola/media/grande",
  "estimated_employees": numero,
  "description": "descrizione breve 1 riga",
  "website": "url se noto",
  "city": "sede principale se nota",
  "confidence": "alta/media/bassa"
}
Se non trovi informazioni, rispondi con confidence "bassa" e valori null.`;

return [{ json: { prompt, lead } }];

Con API dedicate (più affidabili per dati italiani):

• Atoka API: database delle imprese italiane con dati camerali
• OpenCorporates: dati societari pubblici
• Clearbit/Apollo: arricchimento B2B internazionale

2.2 Arricchimento dal CRM

Se il lead ha un'email aziendale, cerca interazioni precedenti:

// Cerca nel CRM per dominio email
const emailDomain = lead.email.split('@')[1];

// Query CRM: tutti i contatti con lo stesso dominio
// Risultato: storico acquisti, ticket supporto, interazioni passate

2.3 Aggregazione dati

// Nodo Code: aggrega tutti i dati raccolti
const lead = $('Webhook').first().json;
const companyData = $('Company Lookup').first().json;
const crmHistory = $('CRM Search').first().json;

const enrichedLead = {
  // Dati originali
  ...lead,

  // Dati aziendali
  company_info: {
    industry: companyData.industry || 'sconosciuto',
    size: companyData.estimated_size || 'sconosciuto',
    employees: companyData.estimated_employees || null,
    city: companyData.city || null
  },

  // Storico CRM
  crm_history: {
    previous_contacts: crmHistory.contacts?.length || 0,
    previous_deals: crmHistory.deals?.length || 0,
    total_revenue: crmHistory.total_revenue || 0,
    last_interaction: crmHistory.last_activity || null,
    open_tickets: crmHistory.open_tickets || 0
  },

  // Comportamento web (se tracciato)
  behavior: {
    pages_visited: lead.pages_visited || 0,
    pricing_page: lead.visited_pricing || false,
    content_downloaded: lead.downloads || 0,
    source: lead.utm_source || 'direct'
  }
};

return [{ json: enrichedLead }];

Passo 3: qualificazione con GPT-4

Questo è il cuore del workflow. Usiamo GPT-4 per analizzare tutti i dati raccolti e produrre una valutazione strutturata.

Il prompt di qualificazione

// Nodo Code: costruisci il prompt
const lead = $json;

const systemPrompt = `Sei un esperto di vendite B2B per il mercato italiano.
Il tuo compito è qualificare lead basandoti sui dati forniti.

CRITERI DI QUALIFICAZIONE (framework BANT adattato):

1. BUDGET (0-25 punti):
   - Azienda grande (50+ dipendenti): 20-25 punti
   - Azienda media (10-50 dipendenti): 10-20 punti
   - Azienda piccola (1-10 dipendenti): 5-10 punti
   - Freelance/individuale: 0-5 punti

2. AUTORITÀ (0-25 punti):
   - Ruolo decisionale (CEO, CTO, Direttore): 20-25 punti
   - Ruolo influente (Manager, Team Lead): 10-20 punti
   - Ruolo operativo: 5-10 punti
   - Non specificato: 5 punti

3. NECESSITÀ (0-25 punti):
   - Messaggio specifico con problema chiaro: 20-25 punti
   - Richiesta generica ma pertinente: 10-20 punti
   - Curiosità senza urgenza: 5-10 punti
   - Nessun messaggio: 5 punti

4. TEMPISTICA (0-25 punti):
   - Ha visitato la pagina prezzi: +10
   - Ha richiesto demo: +15
   - Ha scaricato contenuti: +5
   - Cliente precedente: +10
   - Fonte paid (ads): +5 rispetto a organico

Rispondi SOLO in formato JSON con questa struttura esatta:
{
  "score": numero_da_0_a_100,
  "category": "hot|warm|cool|cold",
  "reasoning": "spiegazione in 2-3 frasi del punteggio",
  "budget_score": numero,
  "authority_score": numero,
  "need_score": numero,
  "timing_score": numero,
  "suggested_action": "azione consigliata per il commerciale",
  "talking_points": ["punto 1", "punto 2", "punto 3"],
  "risk_factors": ["rischio 1 se presente"],
  "estimated_deal_size": "piccolo|medio|grande",
  "urgency": "alta|media|bassa"
}`;

const userPrompt = `Qualifica questo lead:

DATI LEAD:
- Nome: ${lead.first_name} ${lead.last_name}
- Email: ${lead.email}
- Telefono: ${lead.phone || 'non fornito'}
- Azienda: ${lead.company || 'non specificata'}
- Messaggio: "${lead.message || 'nessuno'}"

DATI AZIENDALI:
- Settore: ${lead.company_info?.industry || 'sconosciuto'}
- Dimensione: ${lead.company_info?.size || 'sconosciuta'}
- Dipendenti stimati: ${lead.company_info?.employees || 'n/d'}
- Sede: ${lead.company_info?.city || 'n/d'}

STORICO CRM:
- Contatti precedenti: ${lead.crm_history?.previous_contacts || 0}
- Deal precedenti: ${lead.crm_history?.previous_deals || 0}
- Revenue storico: ${lead.crm_history?.total_revenue || 0} EUR
- Ticket aperti: ${lead.crm_history?.open_tickets || 0}

COMPORTAMENTO:
- Pagine visitate: ${lead.behavior?.pages_visited || 0}
- Pagina prezzi: ${lead.behavior?.pricing_page ? 'si' : 'no'}
- Contenuti scaricati: ${lead.behavior?.content_downloaded || 0}
- Fonte: ${lead.behavior?.source || 'direct'}`;

return [{
  json: {
    system_prompt: systemPrompt,
    user_prompt: userPrompt,
    lead_data: lead
  }
}];

Configurazione nodo OpenAI

Nel nodo OpenAI di n8n:

• Model: gpt-4o (miglior rapporto costo/qualità)
• Temperature: 0.1 (vogliamo risposte consistenti, non creative)
• Max tokens: 500
• Response format: JSON

Parsing della risposta

// Nodo Code: parsa e valida la risposta AI
const aiResponse = JSON.parse($json.message.content);
const leadData = $('Aggregate Data').first().json;

// Validazione
if (aiResponse.score < 0 || aiResponse.score > 100) {
  throw new Error(`Score fuori range: ${aiResponse.score}`);
}

const validCategories = ['hot', 'warm', 'cool', 'cold'];
if (!validCategories.includes(aiResponse.category)) {
  // Fallback basato sullo score
  if (aiResponse.score >= 70) aiResponse.category = 'hot';
  else if (aiResponse.score >= 40) aiResponse.category = 'warm';
  else if (aiResponse.score >= 20) aiResponse.category = 'cool';
  else aiResponse.category = 'cold';
}

return [{
  json: {
    ...leadData,
    qualification: aiResponse,
    qualified_at: new Date().toISOString()
  }
}];

Passo 4: routing e azioni automatiche

Switch per categoria

Usa un nodo Switch in n8n basato su $json.qualification.category:

Percorso HOT (score 70-100)

-> Crea/aggiorna contatto nel CRM con score e note AI
-> Assegna al commerciale senior (lead routing)
-> Invia notifica urgente su Slack/Telegram:

LEAD HOT - Azione immediata richiesta

{{ firstName }} {{ lastName }} di {{ company }}
Score: {{ score }}/100 - {{ category }}

Motivazione AI: {{ reasoning }}

Talking points suggeriti:
{{ talkingPoints }}

Azione consigliata: {{ suggestedAction }}

Contatta entro 1 ora.
CRM: {{ crmUrl }}
Tel: {{ phone }}

-> Crea task nel CRM: "Chiamare {{ name }} entro 1 ora"
-> Invia email di conferma al lead (risposta rapida)

Percorso WARM (score 40-69)

-> Crea/aggiorna contatto nel CRM
-> Assegna al commerciale appropriato
-> Inserisci in sequenza email di nurturing
-> Crea task nel CRM: "Follow-up {{ name }} entro 2 giorni"
-> Notifica standard su Slack

Percorso COOL/COLD (score 0-39)

-> Crea contatto nel CRM con tag "nurturing"
-> Inserisci in sequenza email educativa (lungo termine)
-> Nessuna notifica al commerciale
-> Re-qualifica dopo 30 giorni se ci sono nuove interazioni

Passo 5: monitoraggio e ottimizzazione

Log delle qualificazioni

Registra ogni qualificazione in un foglio Google Sheets:

// Dati da registrare per ogni lead qualificato
{
  timestamp: new Date().toISOString(),
  lead_name: `${lead.first_name} ${lead.last_name}`,
  email: lead.email,
  company: lead.company,
  source: lead.behavior?.source,
  ai_score: qualification.score,
  ai_category: qualification.category,
  ai_reasoning: qualification.reasoning,
  assigned_to: lead.assignee,
  // Questi campi li aggiorni dopo
  actual_outcome: '',  // won/lost/no_response
  actual_deal_value: '',
  feedback: ''  // commerciale conferma/corregge lo score
}

Calcolo accuratezza del modello

Ogni mese, confronta le previsioni AI con i risultati reali:

// Nodo Code: calcola accuratezza mensile
const qualifications = $json.rows; // dal Google Sheet

const results = qualifications.filter(q => q.actual_outcome);

const accuracy = {
  total_qualified: results.length,
  hot_correct: results.filter(
    q => q.ai_category === 'hot' && q.actual_outcome === 'won'
  ).length,
  hot_total: results.filter(q => q.ai_category === 'hot').length,
  false_positives: results.filter(
    q => q.ai_category === 'hot' && q.actual_outcome === 'no_response'
  ).length,
  missed_opportunities: results.filter(
    q => q.ai_category === 'cold' && q.actual_outcome === 'won'
  ).length
};

accuracy.hot_precision = (
  accuracy.hot_correct / Math.max(accuracy.hot_total, 1) * 100
).toFixed(1);

return [{ json: accuracy }];

Affinamento del prompt

Basandoti sui risultati, aggiorna il prompt di qualificazione:

• Se ci sono troppi falsi positivi (lead segnati hot che non rispondono), aumenta la soglia
• Se ci sono opportunità perse (lead segnati cold che poi comprano), aggiungi criteri
• Se un settore specifico converte bene, aggiungi peso al settore nel prompt

Costi dell'AI

Quanto costa far qualificare i lead a GPT-4?

Modello	Costo per qualificazione	100 lead/mese	500 lead/mese
GPT-4o	circa 0,005 euro	0,50 euro	2,50 euro
GPT-4o-mini	circa 0,001 euro	0,10 euro	0,50 euro
Claude 3.5 Haiku	circa 0,001 euro	0,10 euro	0,50 euro

Il costo è trascurabile. Anche con 500 lead al mese, parliamo di 2-3 euro di costi AI. Il vero risparmio è il tempo del team commerciale: qualificare 500 lead manualmente richiede 40-80 ore.

Varianti avanzate

Qualificazione con RAG (dati interni)

Se hai uno storico di deal vinti e persi, puoi arricchire il prompt con esempi reali:

"Ecco 5 esempi di lead che abbiamo convertito con successo:
[esempi dal tuo database]

Ecco 5 esempi di lead che non hanno convertito:
[esempi dal tuo database]

Basandoti su questi pattern, qualifica il seguente lead..."

Multi-modello per validazione

Per lead di alto valore, usa due modelli diversi e confronta:

Lead -> GPT-4o (score A)
     -> Claude 3.5 (score B)
     -> IF differenza > 20 punti:
        -> Review manuale
     -> ELSE:
        -> Media dei due score

Qualificazione continua

Non limitarti al momento dell'ingresso. Ri-qualifica quando:

• Il lead apre un'email dopo settimane di silenzio
• Il lead visita la pagina prezzi
• Il lead scarica un nuovo contenuto
• L'azienda del lead viene citata in una notizia rilevante

Riepilogo del template

Questo template completo ti permette di:

1. Catturare lead da qualsiasi fonte
2. Arricchire i dati automaticamente
3. Qualificare con AI in modo consistente e scalabile
4. Instradare al commerciale giusto con contesto e suggerimenti
5. Monitorare e migliorare l'accuratezza nel tempo

Il tempo di implementazione è di circa 4-6 ore per la versione base, 1-2 giorni per la versione completa con tutti gli arricchimenti.

---

Vuoi il template pronto da importare nel tuo n8n? Contattaci e te lo configuriamo per il tuo caso specifico.