Comment utiliser le nœud Loop Over Items (Split in Batches) dans n8n 

Dans n8n, la boucle sur les éléments (Loop Over Items) est l’une des techniques les plus puissantes pour traiter des listes de données, telles que des adresses e-mail, des réponses API ou des enregistrements de base de données.

Alors que de nombreux nœuds n8n traitent les éléments individuellement par défaut, certaines situations nécessitent plus de contrôle, par exemple lorsque vous devez envoyer des messages par lots ou limiter le nombre de requêtes par cycle.

C’est là qu’intervient le nœud Loop Over Items (Split in Batches). Vous définissez une taille de lot, et il divise l’ensemble de données en groupes plus petits, traitant chaque lot un par un.

Cet article explique ce que signifie la boucle dans n8n, comment fonctionne le nœud Loop Over Items et quand l’utiliser. Vous apprendrez également à itérer sur des éléments à travers des exemples pratiques, tels que l’envoi d’e-mails en masse et le traitement de grands ensembles de données en morceaux gérables.

Que signifie “looping“ dans n8n ?

Dans n8n, le bouclage (looping) désigne la répétition d’un ensemble d’actions pour chaque élément d’une liste ou d’un tableau dans un flux de travail. Cela vous permet d’automatiser des tâches pour chaque élément d’un ensemble de données sans intervention manuelle.

Par exemple, si vous avez une liste de 100 contacts et que vous souhaitez envoyer un e-mail à chacun d’entre eux, la boucle permet à n8n de traiter chaque contact de manière séquentielle (en envoyant un e-mail après l’autre) plutôt que d’envoyer des e-mails en masse à tous les contacts en même temps.

Par défaut, de nombreux nœuds n8n traitent les tableaux ou les listes entrants élément par élément. Lorsqu’un nœud reçoit un tableau, il transmet chaque élément au flux de travail, un à la fois.

Mais une boucle explicite devient nécessaire lorsqu’un nœud ne peut traiter qu’un seul élément à la fois, lorsque vous avez besoin d’un meilleur contrôle sur l’ordre et le regroupement des opérations, ou lorsque le traitement d’un trop grand nombre d’éléments à la fois pourrait surcharger votre système.

Comment fonctionne le nœud “Loop Over Items“ dans n8n ?

Le nœud n8n Loop Over Items (Split in Batches) fonctionne en divisant une liste d’éléments entrants en lots plus petits et gérables, puis en les traitant un lot à la fois.

En définissant la taille des lots, vous pouvez contrôler le nombre d’éléments qui transitent par votre flux de travail à chaque itération.

Voici un aperçu détaillé de son fonctionnement :

1. Le nœud Boucle sur les éléments (division en lots) divise un tableau d’éléments d’entrée en lots en fonction de la taille que vous définissez, par exemple un élément par lot.
2. Chaque lot est ensuite transmis au nœud connecté suivant, qui effectue l’action souhaitée, telle que l’envoi d’un e-mail ou la création d’une requête API.
3. Après avoir traité un lot, le flux de travail revient au nœud « Boucle sur les éléments » pour continuer à traiter le prochain ensemble d’éléments.
4. Ce processus se répète automatiquement jusqu’à ce que tous les lots soient traités.

Le nœud Boucle sur les éléments traite uniquement la liste d’éléments qu’il reçoit, puis s’arrête. Vous n’avez donc pas à vous soucier d’une boucle infinie.

Mais si vous l’utilisez pour traiter des données paginées, telles que la récupération de pages à partir d’une API, vous devez ajouter une logique conditionnelle, comme un nœud If, pour vérifier s’il existe d’autres pages.

Cette condition indique au workflow quand s’arrêter, ce qui l’empêche de parcourir des pages vides.

Quand utiliser le nœud Boucle sur les éléments ?

Vous devez utiliser le nœud Boucle sur les éléments lorsque vous devez diviser les données en petits morceaux et traiter les éléments un par un.

Cela est particulièrement utile pour les grands ensembles de données, lorsque chaque élément nécessite une action individuelle ou lorsque vous souhaitez contrôler le nombre d’éléments traités à chaque itération.

Voici quelques exemples d’utilisation du nœud Boucle sur les éléments :

• Envoyer un email ou un message individuel à chaque contact d’une liste.
• Effectuer des appels API distincts pour chaque entrée d’un ensemble de données, par exemple pour mettre à jour les dossiers clients.
• Traiter les enregistrements d’une feuille de calcul ou d’une base de données un par un, en veillant à ce que chaque ligne soit traitée individuellement.
• Traiter les réponses API paginées pour récupérer toutes les données disponibles d’une API via plusieurs requêtes.
• Générer et envoyer des rapports ou factures personnalisés pour chaque client d’une liste.
• Surveiller l’état de plusieurs serveurs ou de plusieurs sites web en vérifiant chacun d’entre eux individuellement et en consignant les résultats.

Comment boucler sur des éléments dans n8n ?

Pour parcourir les éléments dans n8n, combinez plusieurs nœuds afin de traiter chaque élément individuellement dans une liste.

Loop Over Items (Split in Batches) est le nœud principal pour cela, mais vous l’associerez à d’autres nœuds, tels que Edit Fields (Set) pour préparer les données, HTTP Request pour interagir avec des services externes, et If pour ajouter une logique ou définir des conditions d’arrêt.

La structure générale d’une boucle sur des éléments ressemble à ceci :

1. Entrée : commencez par un nœud qui fournit une source de données, tel que Edit Fields (Set) ou Google Sheets.
2. Split Out (facultatif) : ajoutez ce nœud si votre nœud d’entrée ne peut pas diviser les données en éléments individuels.
3. Boucle : utilisez le nœud Boucle sur les éléments (division en lots) pour diviser la liste en lots plus petits, généralement un élément par lot (ou plus, selon vos besoins).
4. Processus : ajoutez un nœud de traitement, tel que HTTP Request, si vous devez interagir avec des services externes, ou d’autres nœuds d’outils tiers, en fonction de votre flux de travail.
5. If ou Wait (facultatif) : utilisez le nœud If pour appliquer des conditions ou gérer la pagination, et ajoutez Wait pour faire une pause après une itération avant de continuer.
6. Fin : la boucle se termine automatiquement une fois que tous les éléments ont été traités.

Explorons maintenant trois exemples d’utilisation pratique pour voir comment cette configuration fonctionne dans des scénarios réels.

Envoi d’e-mails en masse par lots contrôlés

Dans cet exemple, vous disposez de 100 adresses e-mail et souhaitez envoyer des messages par lots de cinq à la fois, avec une pause de cinq minutes entre chaque lot.

Pourquoi une boucle est-elle nécessaire ?

Les fournisseurs de services de messagerie électronique appliquent des limites strictes au nombre d’e-mails sortants. L’envoi de 100 e-mails à la fois peut dépasser ces limites, entraînant des échecs ou des suspensions temporaires de compte.

La boucle avec des délais entre les lots vous aide à respecter ces limites, à conserver une réputation d’expéditeur légitime et à réduire le risque que vos e-mails soient marqués comme spam.

Instructions pour envoyer des e-mails en masse par lots contrôlés dans n8n :

1. Commencer par le déclencheur manuel

Faites glisser le nœud Manual Trigger vers le canevas pour démarrer le flux de travail.

2. Préparer la liste d’e-mails

Utilisez le nœud Edit Fields (Set) pour créer un tableau de 100 adresses e-mail factices. Définissez les paramètres suivants :

• Nom : emails
• Type : array
• Valeur : ={{ Array.from({length: 100}, (_, i) => email${i + 1}@exemple.com) }}

Si vous avez déjà connecté n8n à Google Sheets, vous pouvez extraire les adresses e-mail réelles d’une feuille de calcul à l’aide du nœud Google Sheets.

3. Diviser le tableau en éléments individuels

Ajoutez un nœud Split Out et définissez le champ sur emails pour séparer le tableau en éléments e-mail individuels.

4. Regrouper les éléments en lots

Ajoutez le nœud Loop Over Items (Split in Batches) et définissez la taille du lot sur 5. Cela permettra de traiter les e-mails par groupes de cinq.

5. Envoyer les e-mails

Utilisez le nœud Send Email pour configurer les paramètres suivants :

• From Email : votre adresse e-mail d’expéditeur
• To Email : ={{ $json.emails }}
• Subject : “E-mail test“
• Email Format : texte
• Text : “Bonjour, ceci est un e-mail test via n8n.“

Configurez également les identifiants SMTP pour votre fournisseur de messagerie.

6. Pause entre les lots

Ajoutez un nœud Wait et définissez l’unité sur minutes avec une valeur de 5, créant ainsi une pause de cinq minutes après chaque lot.

7. Boucler jusqu’à ce que tous les e-mails soient envoyés

Reconnectez le nœud Wait au nœud Split in Batches pour continuer la boucle jusqu’à ce que tous les e-mails soient traités.

Traitement de grands ensembles de données avec le traitement par lots

Imaginez que vous deviez traiter un ensemble de données volumineux tout en respectant les limites de débit ou les contraintes du système. Ce workflow traite 500 enregistrements clients par lots de 10.

Pourquoi la boucle est-elle nécessaire ?

De nombreuses API imposent des limites de débit, par exemple 100 requêtes par minute. Le traitement des 500 enregistrements en une seule fois dépasse ces limites, ce qui entraîne des échecs.

La boucle divise les données en petits morceaux, ce qui évite les surcharges sur n8n et le système cible tout en garantissant un traitement plus fluide et plus fiable.

Instructions pour gérer de grands ensembles de données avec un traitement par lots dans n8n :

1. Configurer le déclencheur du flux de travail

Utilisez le nœud Manual Trigger pour lancer le processus.

2. Générer des enregistrements clients

Utilisez le nœud Code pour créer 500 enregistrements clients fictifs à l’aide du code JavaScript ci-dessous :

const customers = [];
for (let i = 1; i <= 500; i++) {
customers.push({
id: i,
name: `Customer ${i}`,
email: `customer_${i}@example.com`,
registration_date: new Date().toISOString().slice(0, 10)
});
}
return customers.map(customer => ({json: customer}));

Si disponible, vous pouvez utiliser les données réelles des clients à l’aide du nœud Google Sheets ou PostgreSQL.

3. Diviser les données en lots

Ajoutez le nœud Split in Batches, définissez la taille du lot sur 10 et désactivez l’option Reset.

4. Faire une pause entre les lots

Insérez le nœud Wait après Split in Batches pour introduire un délai entre les lots. Définissez l’intervalle sur 90 secondes, ou selon vos préférences.

5. Configurer les actions de traitement

Ajoutez le nœud No Operation, do nothing comme espace réservé. Remplacez-le ensuite par un nœud HTTP Request pour envoyer chaque lot de clients vers l’API cible, telle qu’un service CRM ou de messagerie électronique.

6. Créer la boucle

Reliez le nœud No Operation, do nothing à Split in Batches afin que la boucle se poursuive jusqu’à ce que tous les lots soient traités.

Traitement séquentiel de plusieurs flux RSS

Ce scénario suppose que vous souhaitez mettre en place un système automatisé qui récupère le contenu de plusieurs sources RSS (tutoriels et blog Hostinger) de manière séquentielle, avec des délais contrôlés.

Pourquoi la boucle est-elle nécessaire ?

Effectuer des requêtes simultanées vers plusieurs flux RSS, qu’ils proviennent du même nom de domaine ou de noms de domaines différents, peut être interprété comme un comportement agressif.

La boucle avec des délais permet de gérer les ressources du serveur, réduit le risque de blocage d’IP ou de limitation de débit, et garantit un accès fiable aux flux.

Instructions pour traiter plusieurs flux RSS de manière séquentielle dans n8n :

1. Déclencher le flux de travail

Démarrez le workflow à l’aide du nœud Manual Trigger.

2. Définir les URL des flux RSS

Ajoutez le nœud Code pour définir les URL des flux à l’aide de ce code JavaScript :

return [
{ json: { url: 'https://www.hostinger.com/tutorials/feed' } },
{ json: { url: 'https://www.hostinger.com/blog/feed' } }
];

Modifiez ou ajoutez d’autres URL selon vos besoins.

3. Diviser les flux en éléments individuels

Dans le nœud Split in Batches, définissez la taille du lot sur 1 pour traiter un flux à la fois.

4. Lire les flux RSS
   • Connectez le nœud RSS Read après Split in Batches.
   • Définissez le paramètre URL sur ={{ $json.url }} pour utiliser l’URL dynamique du flux de chaque lot.
5. Ajouter un délai entre les requêtes

Définissez un délai de 15 minutes dans le nœud Wait pour éviter d’envoyer des requêtes trop rapidement.

6. Créer la boucle

Connectez le nœud Wait au nœud Split in Batches pour continuer à traiter tous les flux.

Quels sont les meilleurs conseils pour boucler sur des éléments dans n8n ?

Voici quelques bonnes pratiques à suivre lors de la boucle sur des éléments dans n8n afin d’éviter les problèmes et de garder vos flux de travail propres :

• Utilisez le nœud Split Out lorsque votre entrée est un tableau JSON unique qui n’a pas été divisé en éléments individuels.
• Définissez le nœud Loop Over Items (Split in Batches) sur une taille de lot de 1 pour un traitement élément par élément, ou augmentez-la si le traitement en masse convient à votre cas.
• Connectez toujours la boucle de votre nœud de traitement à Loop Over Items (Split in Batches) pour continuer jusqu’à ce que tous les éléments soient traités.
• Définissez une condition de sortie claire pour éviter les boucles infinies, en particulier lorsque vous travaillez avec une pagination ou une logique de répétition.
• Évitez les boucles inutiles, car de nombreux nœuds n8n prennent déjà en charge les entrées de tableau et traitent automatiquement chaque élément.
• Respectez les limites de débit de l’API en ajoutant un nœud Wait entre les requêtes afin d’éviter les ralentissements ou les blocages.
• Gardez votre boucle légère. Moins elle contient de nœuds, meilleures seront ses performances et sa maintenabilité.

Où héberger vos workflows n8n ?

Si vous créez des flux de travail n8n qui bouclent sur des éléments, planifient des tâches ou s’exécutent en production, vous avez besoin d’un environnement stable et toujours actif.

L’exécution de n8n en local convient pour les tests, mais présente des inconvénients majeurs : votre ordinateur doit rester allumé et les tâches planifiées échoueront si l’appareil se met en veille ou perd sa connexion Internet.

Pour des performances et une disponibilité fiables, nous vous suggérons d’héberger n8n sur un serveur privé virtuel (VPS). Un VPS permet à vos flux de travail de fonctionner 24h/24 et 7j/7, offre un accès distant sécurisé et s’adapte à vos besoins en automatisation.

Avec la solution VPS n8n de Hostinger, à partir de €4.99/mois, n8n et tous les composants nécessaires sont préinstallés, vous n’avez donc pas besoin de tout installer manuellement.

Vous pouvez exécuter des automatisations avancées sans interruption, grâce à un matériel et une infrastructure puissants qui garantissent une disponibilité de 99,9 %.

La mise à l’échelle est simple. Avec jusqu’à 8 cœurs vCPU, 32 Go de RAM, 400 Go de stockage NVMe et 32 To de bande passante, vous pouvez commencer modestement et mettre à niveau en quelques clics à mesure que vos flux de travail se développent.

Que faut-il apprendre après avoir utilisé le nœud Loop Over Items dans n8n ?

Maintenant que nous avons vu comment boucler sur des éléments dans n8n, vous pouvez commencer à utiliser l’un des modèles les plus puissants pour créer des flux de travail dynamiques et flexibles.

Que vous envoyiez des e-mails personnalisés, traitiez des données API paginées ou synchronisiez des entrées entre différents outils, la boucle vous offre un contrôle total pour automatiser les tâches par lots.

À partir de là, essayez des actions avancées pour mettre à l’échelle, optimiser et combiner la boucle avec d’autres logiques, telles que :

• Fusionner les résultats traités à l’aide du nœud Merge.
• Déclencher des workflows de suivi ou des appels API en fonction de la sortie de la boucle.
• Stocker ou analyser les données dans des bases de données, des feuilles de calcul ou des tableaux de bord.
• Envoyer des notifications récapitulatives par e-mail, Slack ou d’autres canaux.
• Nettoyer les données temporaires ou les entrées de journal pour un suivi futur.

De plus, pour créer des automatisations plus intelligentes, explorez d’autres exemples de workflows n8n afin de voir comment les boucles s’intègrent dans des configurations plus vastes et plus avancées.