Pourquoi n8n + Claude pour l'automatisation métier
n8n est une plateforme d'automatisation de workflows open source — pensez Zapier mais auto-hébergé, sans facturation à la tâche et avec contrôle total des données. Claude est la famille de modèles IA d'Anthropic, particulièrement performante pour l'analyse structurée, la revue de documents et le respect de grilles de scoring complexes.
Ensemble, ils traitent les tâches métier trop complexes pour de simples règles if/then mais trop répétitives pour justifier du temps expert manuel : trier 200 CV, catégoriser 500 notes de frais, qualifier 1 000 emails de support par semaine. Le pattern est toujours le même — déclencheur → récupérer le document → Claude analyse → router/stocker/notifier — et n8n rend ça visuel et maintenable.
| Workflow | Volume/mois | Manuel → Auto | Coût API |
|---|
| 1. Tri CV avec scoring | 200 CV | 40h → 4h | ~1,20$ |
| 2. Traitement factures + OPCO | 150 factures | 15h → 1h | ~0,90$ |
| 3. Qualification leads commercial | 500 leads | 25h → 2h | ~2,50$ |
| 4. Triage emails + sentiment | 2 000 emails | 10h → 0,5h | ~1,60$ |
| 5. Catégorisation notes de frais | 300 justificatifs | 8h → 0,5h | ~0,60$ |
| 6. Réponse automatique tickets support | 800 tickets | 20h → 1h | ~0,64$ |
| 7. Revue contrats + score risque | 50 contrats | 30h → 3h | ~3,00$ |
| 8. Contrôle conformité paie | 100 fiches | 12h → 1h | ~0,50$ |
| 9. Génération de briefs campagne | 20 briefs | 10h → 1h | ~1,00$ |
| 10. Enrichissement données clients | 200 fiches | 20h → 2h | ~1,00$ |
Prérequis : installation n8n + Claude
# docker-compose.yml — coller et exécuter sur n'importe quel VPS (Hetzner CX11 à 4 EUR/mois)
version: "3.8"
services:
n8n:
image: n8nio/n8n:latest
restart: always
ports:
- "5678:5678"
environment:
- N8N_BASIC_AUTH_ACTIVE=true
- N8N_BASIC_AUTH_USER=admin
- N8N_BASIC_AUTH_PASSWORD=changer_ce_mot_de_passe
- WEBHOOK_URL=https://n8n.votreentreprise.fr
- N8N_ENCRYPTION_KEY=cle_aleatoire_32_caracteres
- EXECUTIONS_DATA_PRUNE=true
- EXECUTIONS_DATA_MAX_AGE=720
volumes:
- n8n_data:/home/node/.n8n
volumes:
n8n_data:
# Ajouter les credentials Claude dans n8n :
# Paramètres → Credentials → Nouveau → HTTP Header Auth
# Nom : Claude API
# Header Name : x-api-key
# Header Value : sk-ant-api03-... (depuis console.anthropic.com)
Chaque workflow utilise un seul node HTTP Request pour appeler Claude. La structure de base de la requête est identique pour tous les 10 workflows :
# Appel API Claude (réutilisable pour tous les 10 workflows)
Méthode : POST
URL : https://api.anthropic.com/v1/messages
Headers :
x-api-key : {{ $credentials.claude_api.headerValue }}
anthropic-version : 2023-06-01
content-type : application/json
Body (JSON) :
{
"model": "claude-haiku-4-5-20251001",
"max_tokens": 1024,
"messages": [
{
"role": "user",
"content": "{{ $json.prompt }}"
}
]
}
# Sortie : $json.content[0].text (réponse Claude sous forme de texte)
Workflow 1 : Tri de CV avec scoring de décision
Problème métier
Une PME de 50 personnes reçoit 200 CV par poste ouvert. L'équipe RH passe 40 heures sur le premier tri — lecture de PDF, vérification des critères, classement des candidats. Ce workflow automatise le premier passage : extraction des données clés, scoring par rapport à la fiche de poste, et routage des meilleurs candidats vers une shortlist avec envoi d'un email d'accusé de réception automatique.
Architecture du flux
Gmail Trigger (nouvelle pièce jointe, label : "candidatures")
→ IF : pièce jointe est PDF ou DOCX
→ HTTP Request : extraction texte via PDF.co API (0,002$/page)
→ Set node : construction du prompt Claude avec fiche de poste
→ HTTP Request : analyse Claude Haiku
→ JSON Parse : extraction score + justification
→ Switch node :
score >= 80 → Google Sheets onglet "Shortlist" + alerte Slack
score 50-79 → Google Sheets onglet "À examiner"
score < 50 → Google Sheets onglet "Rejeté"
→ Gmail : envoi email d'accusé de réception au candidat
Configuration du prompt Claude
Système : Vous êtes un analyste RH expert. Évaluez le CV du candidat par rapport aux critères du
poste. Retournez UNIQUEMENT du JSON valide, aucun autre texte. Ne tenez pas compte du nom,
du genre, de la nationalité ou de l'âge.
Prompt utilisateur (construit dans le Set node) :
"Évaluez ce candidat pour le poste de {{ $node["Données poste"].json.intitule }}.
CRITÈRES DU POSTE :
{{ $node["Données poste"].json.criteres }}
CV DU CANDIDAT :
{{ $node["Extraction texte"].json.text }}
Retournez du JSON :
{
'score': <entier 0-100>,
'recommandation': 'shortlist' | 'a_examiner' | 'rejeter',
'points_forts': ['...', '...', '...'],
'ecarts': ['...', '...'],
'annees_experience': <nombre>,
'competences_cles_correspondantes': ['...'],
'synthese': '<résumé en 2 phrases>'
}"
Modèle : claude-haiku-4-5-20251001
Max tokens : 512
Temperature : 0 (scoring cohérent)
Métriques réelles
- 200 CV triés en 45 minutes contre 40 heures manuellement
- Précision de la shortlist : 87% de concordance avec le recruteur senior sur les 20 meilleurs candidats
- Coût : 1,20$/mois pour 200 CV (moy. 800 tokens/CV × 0,00075$/1K)
- Temps de mise en place : 90 minutes, configuration OAuth2 Gmail incluse
- Réduction des biais : scoring anonymisé (nom et photo absents du prompt)
Workflow 2 : Traitement de factures avec cartographie OPCO
Problème métier
Les équipes financières traitant 150+ factures par mois passent des heures en saisie, affectation de comptes analytiques et contrôle d'éligibilité OPCO pour les factures de formation. Ce workflow lit les factures, extrait les données structurées, affecte les codes comptables, et signale les factures de formation pour remboursement OPCO avec l'identifiant OPCO correct basé sur le code NAF/APE de l'entreprise.
Architecture du flux
Email Trigger (compta@entreprise.fr, filtre pièce jointe)
OU Google Drive Trigger (nouveau fichier dans /Factures/Entrant/)
→ HTTP Request : extraction texte (PDF.co ou API OCR Mindee)
→ HTTP Request : analyse Claude Sonnet
→ JSON Parse : extraction champs facture
→ IF : type_facture == "formation"
OUI → HTTP Request : lookup OPCO par code NAF (opco-mapping.json)
→ Airtable : ajout dans la base "Formations OPCO"
→ Email : notification responsable formation + DAF
NON → Google Sheets : ajout dans "Factures fournisseurs"
→ HTTP Request : création brouillon dans le logiciel comptable (Pennylane/Sage API)
Prompt Claude (extraction facture)
"Extrayez tous les champs de cette facture et classifiez-la.
Retournez UNIQUEMENT du JSON valide.
TEXTE DE LA FACTURE :
{{ $json.text }}
Retournez :
{
'fournisseur': '...',
'siret_fournisseur': '...',
'numero_facture': '...',
'date_facture': 'AAAA-MM-JJ',
'date_echeance': 'AAAA-MM-JJ',
'total_ht': <nombre>,
'montant_tva': <nombre>,
'total_ttc': <nombre>,
'devise': 'EUR',
'lignes': [{'description': '...', 'quantite': <n>, 'prix_unitaire': <n>, 'total': <n>}],
'type_facture': 'formation' | 'logiciel' | 'services' | 'marchandises' | 'autre',
'code_comptable_suggere': '...',
'conditions_paiement': '...',
'numero_tva_intracommunautaire': '...'
}"
Modèle : claude-sonnet-4-6 (meilleure précision sur l'extraction structurée)
Max tokens : 1024
Logique de cartographie OPCO (node Code n8n)
// Correspondance code NAF/APE → OPCO (France — 11 OPCOs en 2026)
const nafVersOpco = {
// Industrie → OPCO 2i
'28': 'OPCO 2i', '29': 'OPCO 2i', '30': 'OPCO 2i',
// Commerce → OPCO Commerce
'47': 'OPCO Commerce', '46': 'OPCO Commerce',
// Tech/Numérique → Atlas
'62': 'Atlas', '63': 'Atlas', '58': 'AFDAS',
// Santé → OPCO Santé
'86': 'OPCO Santé', '87': 'OPCO Santé',
// Services aux entreprises → OPCO EP
'69': 'OPCO EP', '70': 'OPCO EP', '73': 'OPCO EP',
// BTP → Constructys
'41': 'Constructys', '42': 'Constructys', '43': 'Constructys',
// Transport/Logistique → OPCO Mobilités
'49': 'OPCO Mobilités', '52': 'OPCO Mobilités',
// Agriculture → OCAPIAT
'01': 'OCAPIAT', '02': 'OCAPIAT', '03': 'OCAPIAT',
};
const nafEntreprise = $node["Config entreprise"].json.code_naf.substring(0, 2);
const opco = nafVersOpco[nafEntreprise] || 'Inconnu — vérification manuelle requise';
const plafondRemboursement = 3500; // EUR, à ajuster selon accord de branche
return [{ json: { opco, plafondRemboursement } }];
Métriques réelles
- 150 factures/mois traitées en 1 heure contre 15 heures manuellement
- Précision extraction : 96% sur PDF natifs, 88% sur documents scannés
- Flags OPCO : 100% des factures de formation correctement identifiées pour remboursement
- Coût : 0,90$/mois Claude API + 8$/mois Mindee OCR (ou PDF.co à 0,002$/page)
Workflow 3 : Qualification de leads commerciaux depuis LinkedIn
Problème métier
Les équipes commerciales perdent 25 heures/mois à scorer manuellement les leads entrants depuis les formulaires LinkedIn, les contacts via le site web et les inscriptions événements. Ce workflow enrichit chaque lead avec des données d'entreprise, le score sur l'adéquation ICP, et route les leads chauds directement aux commerciaux via Slack avec un brouillon de premier message.
Architecture du flux
Webhook Trigger (LinkedIn Lead Gen Form ou Typeform)
→ HTTP Request : enrichissement entreprise via API Clearbit (0,05$/lookup)
OU Brandfetch (logo + données de base, gratuit) + données LinkedIn
→ HTTP Request : scoring lead par Claude
→ JSON Parse : score ICP + qualification
→ Switch :
score >= 75 (Chaud) → Slack DM au commercial assigné + création opportunité HubSpot
score 50-74 (Tiède) → Contact HubSpot + séquence nurturing automatique
score < 50 (Froid) → Contact HubSpot + newsletter mensuelle uniquement
→ HubSpot : création/mise à jour contact avec score et justification
Prompt Claude (scoring lead)
"Évaluez ce lead B2B par rapport à notre Profil Client Idéal (ICP).
Retournez UNIQUEMENT du JSON valide.
DONNÉES LEAD :
Nom : {{ $json.nom }}
Entreprise : {{ $json.entreprise }}
Poste : {{ $json.poste }}
Email : {{ $json.email }}
Message : {{ $json.message }}
DONNÉES ENTREPRISE ENRICHIES :
{{ $json.donnees_entreprise }}
NOTRE ICP :
- Taille entreprise : 20-500 salariés
- Secteurs : Tech, SaaS, Services professionnels, Industrie
- Décisionnaires : DSI, DAF, DG, Directeur Ops, Responsable IA
- Points de douleur : processus manuels, silos de données, scaling équipes
- Signaux budgétaires : Série A+, PME profitable, business unit grand groupe
Retournez :
{
'score_icp': <0-100>,
'segment': 'chaud' | 'tiede' | 'froid',
'est_decideur': true | false,
'adequation_entreprise': 'forte' | 'partielle' | 'faible',
'points_douleur_identifies': ['...'],
'amorce_recommandee': '<2 phrases personnalisées pour le commercial>',
'prochaine_action': '...',
'disqualifiants': ['...']
}"
Modèle : claude-haiku-4-5-20251001
Max tokens : 512
Métriques réelles
- 500 leads/mois scorés en 2 heures contre 25 heures manuellement
- Taux de conversion leads chauds : +34% vs scoring manuel (moins de subjectivité, suivi plus rapide)
- Temps commercial libéré : focus uniquement sur le segment chaud (120 leads/mois)
- Coût : 2,50$ Claude API + 25$ Clearbit (ou 0$ avec sources d'enrichissement gratuites)
Workflow 4 : Triage des emails clients avec routage par sentiment
Problème métier
Une équipe customer success reçoit 2 000 emails/mois mélangés : demandes support, questions facturation, suggestions de fonctionnalités et escalades. Le triage manuel prend 10 heures/semaine. Ce workflow classe chaque email, détecte le sentiment (dont les signaux de risque churn), attribue une priorité et route vers la bonne équipe avec un brouillon de réponse suggéré.
Architecture du flux
Gmail Trigger (support@entreprise.fr, toutes les 5 minutes)
→ Filtre : exclure auto-replies et newsletters (vérification headers)
→ HTTP Request : analyse email par Claude
→ JSON Parse : catégorie + sentiment + priorité
→ Switch (par catégorie) :
facturation → Email vers compta@, création ticket Zendesk (facturation)
escalade → Slack #escalades + PagerDuty (P1 uniquement)
risque_churn → Slack #alertes-churn + tâche HubSpot pour CSM
support → Ticket Zendesk + auto-reply avec numéro de ticket
produit → Ajout base Notion + auto-reply "enregistré pour le produit"
→ Gmail : envoi auto-reply (depuis template par catégorie)
Prompt Claude (triage email)
"Analysez cet email client et retournez une classification structurée.
Retournez UNIQUEMENT du JSON valide.
DE : {{ $json.from.name }} <{{ $json.from.email }}>
OBJET : {{ $json.subject }}
CORPS :
{{ $json.body.substring(0, 2000) }}
Retournez :
{
'categorie': 'facturation' | 'support' | 'escalade' | 'suggestion_produit' | 'risque_churn' | 'satisfaction' | 'autre',
'sentiment': 'positif' | 'neutre' | 'frustre' | 'en_colere',
'risque_churn': true | false,
'priorite': 'P1' | 'P2' | 'P3',
'probleme_principal': '<résumé en une phrase>',
'brouillon_reponse': '<brouillon 3-4 phrases reconnaissant le problème et précisant la prochaine étape>',
'signaux_urgence': ['...']
}
Règles de priorité :
P1 = en_colere + facturation OU mention panne de service
P2 = frustre OU risque_churn
P3 = neutre/positif, demande standard"
Modèle : claude-haiku-4-5-20251001 (rapide et économique pour 2 000 emails/mois)
Max tokens : 512
Métriques réelles
- 2 000 emails/mois classifiés en temps réel (moy. 3 secondes par email)
- Détection risque churn : 78% des comptes résiliés avaient un email risque_churn=true 14+ jours avant l'annulation
- Délai de première réponse : de 4 heures en moyenne à 12 minutes (auto-reply + routage immédiat)
- Coût : 1,60$/mois (moy. 1 000 tokens/email × 2 000 × 0,00080$/1K)
Workflow 5 : Catégorisation des notes de frais avec détection de fraude
Problème métier
Les équipes financières passent 8 heures/mois à catégoriser les notes de frais et contrôler le respect de la politique. Les soumissions en double et dépenses personnelles déclarées comme professionnelles sont des problèmes courants. Ce workflow catégorise chaque justificatif de dépense, vérifie les règles de politique, signale les anomalies et pré-remplit l'export comptable.
Architecture du flux
Webhook Trigger (soumission depuis outil frais : Spendesk, Expensify, N2F)
OU Email Trigger (transfert justificatif vers frais@entreprise.fr)
→ HTTP Request : extraction données justificatif (Google Cloud Vision OCR — 1000 gratuits/mois)
→ HTTP Request : catégorisation + contrôle politique par Claude
→ JSON Parse : catégorie + flags de conformité
→ IF : anomalies_politique détectées
OUI → Email manager + salarié avec violation spécifique
→ Airtable : flag pour revue manuelle
NON → Airtable : table dépenses approuvées
→ HTTP Request : envoi vers API comptable (Pennylane/Sage)
→ Hebdomadaire : Code node agrège par salarié → Email récapitulatif frais
Prompt Claude (analyse note de frais)
"Analysez ce justificatif de dépense et contrôlez la conformité avec la politique.
Retournez UNIQUEMENT du JSON valide.
DONNÉES JUSTIFICATIF :
{{ $json.texte_justificatif }}
SALARIÉ : {{ $json.nom_salarie }}, {{ $json.departement }}
MISSION/PROJET : {{ $json.code_projet }}
DATE DE SOUMISSION : {{ $json.date_soumission }}
POLITIQUE NOTES DE FRAIS :
- Repas : max 25 EUR/personne déjeuner, max 60 EUR/personne dîner client
- Hôtels : max 150 EUR/nuit (Paris 200 EUR)
- Transport : classe économique uniquement
- Divertissement : pré-approbation requise au-delà de 80 EUR
- Justificatifs obligatoires pour tout montant supérieur à 25 EUR
Retournez :
{
'fournisseur': '...',
'montant': <nombre>,
'devise': 'EUR',
'date': 'AAAA-MM-JJ',
'categorie': 'repas' | 'transport' | 'hebergement' | 'divertissement' | 'logiciel' | 'bureau' | 'autre',
'code_comptable': '...',
'conforme_politique': true | false,
'violations': ['...'],
'signaux_fraude': ['...'],
'confiance': <0-100>
}"
Modèle : claude-haiku-4-5-20251001
Max tokens : 256
Métriques réelles
- 300 justificatifs/mois catégorisés automatiquement avec 94% de précision
- Violations de politique détectées : 12/mois en moyenne (vs 3-4 détectées manuellement)
- Détection doublons : le node Code compare fournisseur + montant + date ± 3 jours entre soumissions
- Coût : 0,60$/mois Claude API + OCR gratuit (Google Vision 1 000 gratuites/mois)
Workflow 6 : Réponse automatique tickets support avec règles d'escalade
Problème métier
L'équipe support d'un éditeur SaaS traite 800 tickets/mois. 60% sont des questions récurrentes couvertes dans leur documentation. Ce workflow fait correspondre les tickets à une base de connaissances, rédige des réponses précises pour les problèmes connus, et n'escalade aux agents humains que les problèmes genuinement nouveaux.
Architecture du flux
Zendesk Trigger (nouveau ticket)
→ HTTP Request : recherche dans la base Notion (API de recherche)
→ Set node : construction prompt Claude avec ticket + contexte BC
→ HTTP Request : génération réponse par Claude
→ JSON Parse : réponse + flag escalade
→ IF : escalade == true OU confiance < 70
OUI → Zendesk : assignation agent humain + note interne avec analyse Claude
NON → Zendesk : publication réponse publique en tant que "Bot Support"
→ Zendesk : tag ticket "auto-repondu"
→ Attente 24h → IF pas de réponse client : fermeture ticket
SINON : escalade vers humain
Prompt Claude (réponse support)
"Vous êtes un agent support utile pour [Entreprise]. Répondez à la question
du client en utilisant uniquement le contexte de la base de connaissances fournie.
Si vous ne pouvez pas répondre avec confiance, mettez escalade=true.
TICKET CLIENT :
Objet : {{ $json.subject }}
Message : {{ $json.description }}
Formule client : {{ $json.plan }}
Ancienneté compte : {{ $json.anciennete_jours }} jours
CONTEXTE BASE DE CONNAISSANCES :
{{ $json.articles_bc }}
Retournez UNIQUEMENT du JSON valide :
{
'peut_repondre': true | false,
'confiance': <0-100>,
'escalade': true | false,
'raison_escalade': '...',
'reponse': '<réponse complète et amicale utilisant le contexte BC>',
'tags_suggeres': ['...'],
'sentiment': 'frustre' | 'neutre' | 'positif'
}
Règles :
- confiance < 70 → escalade
- problème facturation/compte → toujours escalader
- 'résilier' ou 'remboursement' mentionné → escalader
- La réponse doit citer l'article BC utilisé si applicable"
Modèle : claude-sonnet-4-6 (meilleure qualité pour les réponses côté client)
Max tokens : 768
Métriques réelles
- 800 tickets/mois, 58% résolus automatiquement (sans intervention humaine)
- CSAT sur réponses auto : 4,1/5 contre 4,3/5 pour les agents humains
- Délai de première réponse : 45 secondes contre 4 heures en moyenne auparavant
- Coût : 0,64$/mois Haiku pour le routage + 3,20$ Sonnet pour la génération de réponse
Workflow 7 : Revue de contrats avec scoring de risque
Problème métier
Les équipes juridiques et achats examinent 50 contrats fournisseurs/mois. Chaque contrat nécessite 30 à 60 minutes pour vérifier les clauses non standard, les dispositions manquantes et les indicateurs de risque. Ce workflow fournit une première revue automatique qui signale les clauses spécifiques, score le risque global et génère une checklist pour le relecteur — réduisant le temps de revue de 30 heures à 3 heures.
Architecture du flux
Google Drive Trigger (nouveau PDF dans /Juridique/Contrats/Entrant/)
→ HTTP Request : extraction texte intégral (PDF.co — gère les contrats 50+ pages)
→ HTTP Request : analyse contrat par Claude (Sonnet — raisonnement complexe)
→ JSON Parse : score risque + clauses signalées
→ IF : score_risque >= 70
OUI → Slack #revue-juridique (urgent) + email juridique@
NON (moyen 40-69) → Slack #revue-juridique (normal)
NON (faible < 40) → Email récapitulatif uniquement
→ Google Docs : création rapport de revue depuis template
→ Google Drive : déplacement contrat dans /Juridique/Contrats/Examiné/
→ Airtable : enregistrement contrat + score risque + date de revue
Prompt Claude (analyse contrat)
"Examinez ce contrat et identifiez les facteurs de risque. Vous êtes analyste juridique.
Retournez UNIQUEMENT du JSON valide.
TEXTE DU CONTRAT (8 000 premiers caractères) :
{{ $json.text.substring(0, 8000) }}
TYPE DE CONTRAT : {{ $json.type_contrat }}
COCONTRACTANT : {{ $json.nom_fournisseur }}
Analysez :
1. Plafonds de responsabilité et indemnisation (notre responsabilité est-elle illimitée ?)
2. Propriété intellectuelle (conservons-nous nos droits sur notre production ?)
3. Clauses de résiliation (préavis, résiliation pour faute vs convenance)
4. Reconductions automatiques (délai de préavis pour non-renouvellement)
5. Droit applicable et juridiction (tribunal compétent)
6. Obligations de traitement des données (conformité RGPD pour données UE)
7. SLA et clauses pénales
8. Conditions de paiement et pénalités de retard
Retournez :
{
'score_risque': <0-100>,
'niveau_risque': 'faible' | 'moyen' | 'eleve',
'clauses_signalees': [
{'clause': '...', 'probleme': '...', 'severite': 'eleve'|'moyen'|'faible', 'ref_page': '...'}
],
'dispositions_manquantes': ['...'],
'termes_favorables': ['...'],
'droit_applicable': '...',
'reconduction_automatique': true | false,
'preavis_reconduction_jours': <nombre ou null>,
'plafond_responsabilite': '...',
'action_recommandee': 'approuver' | 'negocier' | 'rejeter',
'notes_relecteur': '...'
}"
Modèle : claude-sonnet-4-6
Max tokens : 2048
Métriques réelles
- 50 contrats/mois examinés en première passe en 3 heures contre 30 heures
- Contrats à haut risque signalés : 100% correctement escaladés au conseil juridique
- Pièges de reconduction automatique détectés : 8 au premier mois (délais de préavis 30 jours manqués précédemment)
- Coût : 3,00$/mois (moy. 3 000 tokens/contrat × 50 × 0,002$/1K Sonnet)
Workflow 8 : Contrôle de conformité de la paie
Problème métier
Les équipes RH passent 12 heures/mois à recouper les données de paie avec les contrats de travail, les conventions collectives et les minima réglementaires. Les erreurs engagent la responsabilité juridique. Ce workflow valide chaque bulletin de paie selon des règles configurées et génère un rapport d'anomalies avant le traitement final de la paie.
Architecture du flux
Trigger Planifié : 1er de chaque mois, 8h00
→ Google Sheets : lecture export paie (salarié, salaire, heures, cotisations)
→ HTTP Request : récupération SMIC en vigueur via API gouvernementale
→ Boucle : pour chaque bulletin de paie
→ HTTP Request : contrôle conformité par Claude
→ JSON Parse : flags de conformité
→ IF violations → ajout à la liste des anomalies
→ Code node : compilation du rapport d'anomalies
→ Email : envoi rapport au DRH + DAF
→ IF violations critiques → Slack #rh-urgent immédiatement
Prompt Claude (conformité paie)
"Vérifiez ce bulletin de paie pour détecter les anomalies de conformité.
Retournez UNIQUEMENT du JSON valide.
DONNÉES BULLETIN :
{{ $json.donnees_salarie }}
CONTEXTE RÉGLEMENTAIRE (France 2026) :
- SMIC horaire : 11,88 EUR (mensuel temps plein : 1 801,80 EUR)
- Heures supplémentaires : majoration 25% pour les 8 premières h/semaine au-delà de 35h, 50% ensuite
- Congés payés : 2,5 jours/mois travaillé (30 jours/an)
- 13e mois : obligatoire selon convention collective
- Tickets restaurant : max 13,00 EUR/jour (part patronale max 60%)
- Indemnité transport : 50% du titre de transport en commun (obligatoire)
CONVENTION COLLECTIVE : {{ $json.convention_collective }}
Retournez :
{
'conforme': true | false,
'violations': [{'regle': '...', 'severite': 'critique'|'avertissement', 'detail': '...'}],
'controle_brut_net': {'net_attendu': <nombre>, 'net_reel': <nombre>, 'ecart': <nombre>},
'heures_sup_correctes': true | false,
'conges_corrects': true | false,
'recommandations': ['...']
}"
Modèle : claude-haiku-4-5-20251001
Max tokens : 512
Métriques réelles
- 100 bulletins/mois validés en 45 minutes contre 12 heures
- Violations détectées : 3,2/mois en moyenne (erreurs de calcul heures supplémentaires le plus fréquent)
- Mises à jour réglementaires : valeur du SMIC récupérée automatiquement via API — aucune mise à jour manuelle
- Coût : 0,50$/mois (moy. 500 tokens/bulletin × 100 × 0,00075$/1K)
Workflow 9 : Génération de briefs de campagne marketing
Problème métier
Les équipes marketing passent 10 heures/mois à rédiger des briefs de campagne depuis zéro — objectifs, personas cibles, piliers de message, contexte concurrentiel. Ce workflow récupère les données structurées d'un formulaire d'intake, les enrichit et génère un brief de campagne complet prêt pour la revue agence ou équipe interne.
Architecture du flux
Typeform Trigger (soumission formulaire brief campagne)
→ HTTP Request : génération brief par Claude (Sonnet)
→ JSON Parse : extraction des sections
→ HTTP Request : création Google Docs depuis template
(Google Docs API — remplacement placeholders avec contenu généré)
→ HTTP Request : création projet Asana avec tâches standard
→ Slack : publication dans #marketing-nouvelles-campagnes avec lien doc
→ Email : envoi au demandeur avec lien brief + prochaines étapes
Prompt Claude (génération brief)
"Rédigez un brief de campagne marketing complet à partir de ces données.
Produisez un contenu professionnel et spécifique — pas de placeholders génériques.
DONNÉES FORMULAIRE :
Produit/Service : {{ $json.produit }}
Objectif campagne : {{ $json.objectif }}
Cible : {{ $json.cible }}
Budget : {{ $json.budget }}
Calendrier : {{ $json.calendrier }}
Différenciateurs clés : {{ $json.differenciateurs }}
Concurrents à référencer : {{ $json.concurrents }}
Canaux prévus : {{ $json.canaux }}
KPIs à suivre : {{ $json.kpis }}
Générez un brief complet avec ces sections :
1. Résumé exécutif (3 phrases)
2. Objectifs de campagne (objectifs SMART avec chiffres précis)
3. Personas cibles (2-3 profils avec démographie + psychographie)
4. Messages clés (message principal + 3 messages de soutien par persona)
5. Stratégie canaux (répartition budget % par canal avec justification)
6. Direction créative (ton, style visuel, piliers de contenu)
7. Indicateurs de succès (KPIs spécifiques avec objectifs et méthode de mesure)
8. Calendrier et jalons (semaine par semaine sur la durée de campagne)
9. Répartition budgétaire (estimation production, médias, outils)
10. Risques et mitigations (top 3 risques)
Retournez en JSON avec chaque section comme clé."
Modèle : claude-sonnet-4-6
Max tokens : 3000
Métriques réelles
- 20 briefs/mois générés en moins de 5 minutes chacun contre 2 à 3 heures manuellement
- Taux d'acceptation agence : 85% des briefs IA approuvés sans révision majeure
- Cohérence : tous les briefs suivent la même structure, facilitant la comparaison inter-campagnes
- Coût : 1,00$/mois (moy. 1 500 tokens × 20 × 0,003$/1K Sonnet)
Workflow 10 : Enrichissement des données clients depuis sources web
Problème métier
Les équipes commerciales et CS importent 200 nouvelles fiches entreprises/mois depuis diverses sources avec des profils incomplets. L'enrichissement manuel (effectif, stack technique, actualités récentes, stade de financement) prend 6 minutes par fiche = 20 heures/mois. Ce workflow enrichit automatiquement chaque fiche avec des API publiques et Claude pour synthétiser les résultats.
Architecture du flux
Webhook Trigger (nouveau contact HubSpot avec entreprise)
OU Planifié : batch quotidien depuis vue Airtable "Nouvelles entreprises"
→ HTTP Request : Clearbit Enrichment API (0,05$/entreprise)
OU fallback : Brandfetch (logo + données de base, gratuit)
→ HTTP Request : récupération page LinkedIn entreprise via Proxycurl (0,01$/profil)
→ HTTP Request : recherche actualités récentes (NewsAPI — 100 gratuites/jour)
→ Set node : compilation de toutes les sources
→ HTTP Request : synthèse Claude
→ JSON Parse : profil enrichi
→ HubSpot : mise à jour fiche entreprise avec tous les champs enrichis
→ IF : stade_financement == 'Série A' OU 'Série B'
→ Slack #alertes-icp-chaud avec résumé entreprise
Prompt Claude (synthèse données)
"Synthétisez ces données entreprise en un profil structuré pour notre équipe commerciale.
Retournez UNIQUEMENT du JSON valide.
DONNÉES CLEARBIT : {{ $json.clearbit }}
DONNÉES LINKEDIN : {{ $json.linkedin }}
ACTUALITÉS RÉCENTES (90 derniers jours) : {{ $json.actualites }}
Retournez :
{
'nom_entreprise': '...',
'site_web': '...',
'effectif': <nombre>,
'tranche_effectif': '1-10' | '11-50' | '51-200' | '201-500' | '500+',
'secteur': '...',
'pays_siege': '...',
'code_naf': '...',
'annee_creation': <nombre>,
'stade_financement': 'autofinance' | 'pre-seed' | 'seed' | 'Série A' | 'Série B' | 'Série C+' | 'cotee' | 'inconnu',
'arr_estime': '...',
'stack_technique': ['...'],
'resume_actualites': '<résumé 2 phrases des 90 derniers jours>',
'signaux_croissance': ['...'],
'points_douleur_inferres': ['...'],
'score_adequation_icp': <0-100>,
'approche_recommandee': '...',
'arguments_cles': ['...']
}"
Modèle : claude-haiku-4-5-20251001
Max tokens : 768
Métriques réelles
- 200 fiches/mois enrichies automatiquement (contre 20 heures manuellement)
- Complétude des données : de 35% en moyenne (imports CRM) à 78% de champs renseignés
- Précision score ICP : 82% de corrélation avec l'évaluation manuelle du commercial
- Coût : 1,00$ Claude + 10$ Clearbit + 2$ Proxycurl = 13$/mois pour 200 fiches
Pattern de gestion d'erreurs pour les 10 workflows
Tout workflow de production nécessite un gestionnaire d'erreurs. Ajoutez ce pattern à chaque workflow :
# Dans n8n : ajoutez un node Error Trigger pour intercepter tous les échecs
Configuration du node Error Trigger :
→ Set node : formatage du message d'erreur
{
"workflow": "{{ $json.workflow.name }}",
"node_echoue": "{{ $json.execution.lastNodeExecuted }}",
"erreur": "{{ $json.execution.error.message }}",
"donnees_entree": "{{ JSON.stringify($json.execution.data).substring(0, 500) }}",
"url_execution": "{{ $env.N8N_URL }}/workflow/{{ $json.workflow.id }}/executions/{{ $json.execution.id }}"
}
→ Slack node : publication dans #n8n-erreurs
→ Gmail node : email ops@entreprise.fr pour erreurs P1 (contrats, paie)
# Ajoutez aussi un pattern de retry sur les appels Claude API :
# Dans le node HTTP Request → En cas d'erreur : "Continuer (utiliser la sortie d'erreur)"
# Puis ajoutez un node IF vérifiant $json.error — retry avec backoff exponentiel :
Node Attente : 30 secondes
→ HTTP Request : même appel Claude
→ IF toujours en échec : router vers le gestionnaire d'erreurs
Récapitulatif des coûts : les 10 workflows
| Composant | Mensuel | Notes |
|---|
| VPS auto-hébergé n8n | 6 EUR | Hetzner CX21, 4 vCPU, 8 Go RAM |
| API Claude Haiku | ~8$ | ~10M tokens/mois pour toutes les tâches de classification |
| API Claude Sonnet | ~6$ | Contrats, réponses support, briefs campagne |
| Extraction texte PDF | ~4$ | PDF.co ou Mindee (~200 documents) |
| APIs d'enrichissement | ~12$ | Clearbit 200 lookups + Proxycurl |
| Total | ~36 EUR | Remplace 180h de travail manuel/mois |
Au coût complet de 50 EUR/heure pour un travailleur qualifié, 180 heures/mois de travail manuel = 9 000 EUR/mois. Automatisation avec n8n + Claude : 36 EUR/mois. ROI : 250 pour 1.
Questions fréquentes
Faut-il des compétences techniques pour déployer ces workflows ?
Non. Ces workflows utilisent l'interface visuelle de n8n et des nodes HTTP Request pour appeler l'API Claude. Vous devez savoir lire du JSON (pour coller les configs), créer des clés API sur la console Anthropic, et configurer des credentials dans n8n. Si vous avez déjà utilisé Zapier ou Make, vous serez à l'aise. Les appels à l'API Claude sont des requêtes HTTP POST — aucun SDK requis.
Quel est le coût total pour les 10 workflows ?
Infrastructure : n8n auto-hébergé sur un VPS à 5-10 EUR/mois (Hetzner CX21 gère 10 workflows en parallèle). API Claude : Claude Haiku pour les tâches de classification (~0,0008$/1K tokens en entrée) et Claude Sonnet pour les analyses complexes (~0,003$/1K). Pour 500 documents/mois sur l'ensemble des workflows : ~15-30$ de coûts API. Total : 20-40 EUR/mois pour remplacer 60 à 120 heures de travail manuel.
Ces workflows fonctionnent-ils avec d'autres LLM que Claude ?
Oui. Tous ces workflows peuvent remplacer l'appel Claude par Ollama (local, gratuit — Qwen3-14B ou Llama 3.3), OpenAI GPT-4o ou l'API Mistral. Le format du node HTTP Request change légèrement mais la logique reste identique. Claude est recommandé car sa sortie structurée (JSON) et son respect des instructions sont les plus fiables pour l'automatisation métier — moins d'hallucinations dans les grilles de scoring.
Comment gérer les données sensibles (RGPD, CV, contrats) ?
Les 10 workflows traitent les données en transit — Claude ne stocke rien. Bonnes pratiques : (1) auto-hébergez n8n pour que les données ne quittent pas votre infrastructure avant l'appel LLM, (2) l'API Anthropic dispose d'un accord de traitement des données (DPA) conforme RGPD, (3) pour les données de résidents UE, envisagez Ollama auto-hébergé pour éviter tout transfert transfrontalier, (4) ne loguez que les métadonnées dans l'historique d'exécution n8n, pas le contenu complet des documents.
Combien de temps faut-il pour mettre en place un workflow ?
Avec les configs JSON ci-dessous : 30 à 60 minutes par workflow, configuration des credentials incluse. En partant de zéro : 2 à 4 heures. La partie la plus longue est généralement la configuration du déclencheur (OAuth2 Gmail, URL webhook, surveillance de dossier) — l'appel à l'API Claude lui-même est un seul node HTTP Request. Le temps de déploiement tombe à 15-20 minutes à partir du troisième workflow grâce à la réutilisation des patterns credentials et gestion d'erreurs.