Développement de Nœuds n8n

Pourquoi développer des nœuds personnalisés ?

Les nœuds personnalisés permettent d'étendre n8n avec des fonctionnalités spécifiques à votre entreprise. Que ce soit pour intégrer une API propriétaire, créer des logiques métier complexes ou ajouter des traitements de données avancés, nous développons des nœuds sur mesure parfaitement adaptés à vos workflows.

⚡

Performance Optimisée

Code JavaScript/Python natif pour des traitements rapides et efficaces.

🔧

Totalement Personnalisé

Interface utilisateur adaptée à vos besoins spécifiques et logique métier.

🔄

Réutilisable

Nœuds packageables et distribuables sur NPM ou en interne.

🛡️

Sécurisé

Gestion avancée des credentials et chiffrement des données sensibles.

Développement JavaScript & Python

Créez des nœuds performants avec les langages que vous maîtrisez

⚡

JavaScript (Node.js)

Développement natif en JavaScript avec accès complet à l'écosystème NPM et aux APIs n8n.

Exemple de nœud JavaScript :

export class CustomNode implements INodeType {
    description: INodeTypeDescription = {
        displayName: 'Mon Nœud Custom',
        name: 'monNoeudCustom',
        group: ['transform'],
        version: 1,
        description: 'Traite les données selon la logique métier',
        defaults: {
            name: 'Mon Nœud Custom',
        },
        inputs: ['main'],
        outputs: ['main'],
        properties: [
            {
                displayName: 'Mode de traitement',
                name: 'mode',
                type: 'options',
                options: [
                    { name: 'Rapide', value: 'fast' },
                    { name: 'Complet', value: 'full' }
                ],
                default: 'fast'
            }
        ]
    };

    async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
        const items = this.getInputData();
        const mode = this.getNodeParameter('mode', 0) as string;
        
        const returnData: INodeExecutionData[] = [];
        
        for (let i = 0; i < items.length; i++) {
            const item = items[i];
            
            // Logique de traitement personnalisée
            const processedData = await this.processData(item.json, mode);
            
            returnData.push({
                json: processedData,
                pairedItem: { item: i }
            });
        }
        
        return [returnData];
    }
}

🐍

Python Integration

Intégrez des scripts Python pour l'IA, le machine learning et l'analyse de données avancée.

Exemple d'intégration Python :

// Nœud n8n appelant un script Python
                        from n8n import IExecuteFunctions  # Hypothétique import Python pour n8n
import subprocess
import json

class MyCustomNode:
    def execute(self: IExecuteFunctions):
        items = self.get_input_data()
        return_data = []

        for i, item in enumerate(items):
            input_data = json.dumps(item['json'])

            # Lance le script Python externe
            process = subprocess.Popen(
                ['python3', './scripts/data_analysis.py', input_data],
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                text=True
            )
            stdout, stderr = process.communicate()

            if process.returncode != 0:
                raise Exception(f"Script error: {stderr}")

            processed_data = json.loads(stdout)

            return_data.append({
                'json': processed_data,
                'pairedItem': {'item': i}
            })

        return return_data

Webhooks & Déclencheurs Personnalisés

Créez des points d'entrée flexibles pour vos workflows automatisés

🎯

Webhooks Avancés

Créez des endpoints HTTP personnalisés avec authentification, validation et transformation des données.

✅ Authentification JWT/API Key

✅ Validation de schéma JSON

✅ Transformation automatique

✅ Logging et monitoring

⏰

Triggers Temporels

Développez des déclencheurs basés sur des planifications complexes et des conditions métier.

✅ CRON expressions avancées

✅ Conditions conditionnelles

✅ Retry et error handling

✅ État persistant

📡

Événements Externes

Intégrez des systèmes externes comme déclencheurs (MQTT, WebSockets, Files, DB).

✅ Surveillance de fichiers

✅ Écoute MQTT/WebSocket

✅ Polling de bases de données

✅ Intégration API real-time

Exemple de webhook personnalisé :

export class CustomWebhook implements IWebhookFunctions {
    async webhook(this: IWebhookFunctions): Promise<IWebhookResponseData> {
        const req = this.getRequestObject();
        const res = this.getResponseObject();
        
        // Validation de l'authentification
        const apiKey = req.headers['x-api-key'];
        if (!this.validateApiKey(apiKey)) {
            return {
                webhookResponse: {
                    status: 401,
                    body: { error: 'Unauthorized' }
                }
            };
        }
        
        // Validation du payload
        const schema = this.getNodeParameter('jsonSchema') as string;
        if (!this.validatePayload(req.body, schema)) {
            return {
                webhookResponse: {
                    status: 400,
                    body: { error: 'Invalid payload' }
                }
            };
        }
        
        // Transformation des données
        const transformedData = this.transformData(req.body);
        
        // Log de l'événement
        console.log('Webhook triggered:', {
            timestamp: new Date().toISOString(),
            source: req.ip,
            data: transformedData
        });
        
        return {
            workflowData: [transformedData],
            webhookResponse: {
                status: 200,
                body: { success: true, message: 'Data processed' }
            }
        };
    }
}

Interfaçage IA dans les Processus

Intégrez l'intelligence artificielle directement dans vos nœuds personnalisés

🧠

IA Conversationnelle

Intégrez ChatGPT, Claude, et autres LLMs pour le traitement de texte intelligent.

Analyse de sentiment Classification automatique des émotions et opinions

Génération de contenu Création automatique de textes personnalisés

Résumé intelligent Synthèse automatique de documents longs

👁️

IA Visuelle

Traitez images et documents avec des APIs de vision artificielle avancées.

OCR intelligent Extraction de texte avec contextualisation

Classification d'images Reconnaissance et catégorisation automatiques

Détection d'objets Identification et localisation d'éléments

📊

IA Prédictive

Implémentez des modèles de machine learning pour des prédictions métier.

Analyse prédictive Prévisions basées sur l'historique des données

Détection d'anomalies Identification automatique d'éléments inhabituels

Recommandations Suggestions personnalisées basées sur les patterns

Exemple d'intégration IA :

export class AIProcessorNode implements INodeType {
    async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
        const items = this.getInputData();
        const aiProvider = this.getNodeParameter('aiProvider', 0) as string;
        const operation = this.getNodeParameter('operation', 0) as string;
        
        const returnData: INodeExecutionData[] = [];
        
        for (let i = 0; i < items.length; i++) {
            const item = items[i];
            let result;
            
            switch (operation) {
                case 'sentiment':
                    result = await this.analyzeSentiment(item.json.text, aiProvider);
                    break;
                case 'generate':
                    result = await this.generateContent(item.json.prompt, aiProvider);
                    break;
                case 'classify':
                    result = await this.classifyContent(item.json.content, aiProvider);
                    break;
                case 'extract':
                    result = await this.extractEntities(item.json.text, aiProvider);
                    break;
            }
            
            returnData.push({
                json: {
                    ...item.json,
                    aiResult: result,
                    processedAt: new Date().toISOString(),
                    confidence: result.confidence || 1.0
                },
                pairedItem: { item: i }
            });
        }
        
        return [returnData];
    }
    
    private async analyzeSentiment(text: string, provider: string) {
        // Intégration avec OpenAI, Claude, ou Google AI
        const response = await this.aiCall(provider, {
            model: 'gpt-4',
            messages: [{
                role: 'system',
                content: 'Analyze the sentiment of the following text. Return JSON with sentiment (positive/negative/neutral) and confidence score.'
            }, {
                role: 'user',
                content: text
            }]
        });
        
        return JSON.parse(response.choices[0].message.content);
    }
}

Exemples de Nœuds Développés

Nœud ERP Custom

Développement d'un nœud pour interfacer avec un ERP propriétaire, incluant l'authentification SSO et la synchronisation bidirectionnelle des données.

JavaScript API REST SSO Sync

Nœud IA Document

Nœud spécialisé dans l'analyse de documents PDF avec OCR, extraction d'entités et classification automatique par IA.

Python OCR OpenAI NLP

Trigger IoT MQTT

Déclencheur personnalisé écoutant les messages MQTT d'appareils IoT avec filtrage avancé et gestion des reconnexions.

MQTT IoT Real-time Filtering

Webhook Sécurisé

Endpoint webhook avec authentification JWT, validation JSON Schema et transformation de données en temps réel.

Webhook JWT Validation Transform