Passer au contenu principal

​
À quoi sert ce node ?

Le node Loop traite les tableaux en répétant une séquence de nodes pour chaque élément. Il est essentiel pour les opérations en lot : parcourir plusieurs URL, traiter des lignes de feuille de calcul ou gérer des listes de réponses API. Usages courants :
  • Traiter une liste d’URL
  • Parcourir les lignes d’une feuille de calcul
  • Gérer les tableaux de réponses API
  • Traiter des éléments en lot

​
Configuration rapide

1

Ajouter le node Loop

Trouvez-le dans Tools → Loop
2

Connecter la source de données

Connectez un node qui produit un tableau
3

Ajouter des nodes dans la boucle

Ils s’exécuteront pour chaque élément
4

Définir les limites de la boucle

Configurez le nombre max d’itérations et les délais

​
Configuration

​
Champs obligatoires

​
items
array
requis
Le tableau à parcourir.Exemples :
  • Depuis Sheets : {{GoogleSheets_0.data}}
  • Depuis une API : {{HTTP_0.body.results}}
  • Manuel : ["url1", "url2", "url3"]

​
Champs optionnels

​
max_iterations
number
défaut:"100"
Nombre maximum d’itérations pour éviter les boucles infinies.À définir systématiquement comme mesure de sécurité.
​
delay_ms
number
défaut:"0"
Délai en millisecondes entre chaque itération.Recommandations :
  • Appels API : 1000-2000 ms
  • Scraping web : 2000-3000 ms
  • Sans appel externe : 0 ms

​
Variables de boucle

Dans une boucle, vous pouvez utiliser ces variables :
VariableDescriptionExemple
{{Loop_0.currentItem}}Élément courant"https://example.com"
{{Loop_0.index}}Index courant (à partir de 0)0, 1, 2…
{{Loop_0.totalItems}}Nombre total d’éléments10

​
Accéder aux propriétés des éléments

Si les éléments sont des objets : 
// Tableau d'éléments
[
  {"url": "https://a.com", "name": "Site A"},
  {"url": "https://b.com", "name": "Site B"}
]
Accès aux propriétés : 
{{Loop_0.currentItem.url}}   → "https://a.com"
{{Loop_0.currentItem.name}}  → "Site A"

​
Sortie

À la fin, la boucle fournit : 
{
  "results": [
    // Tableau des résultats de chaque itération
  ],
  "totalItems": 10,
  "processedItems": 10,
  "errors": []
}
Accès aux résultats : {{Loop_0.results}}

​
Exemples

​
Scraper plusieurs URL

Entrée : Liste d’URL depuis Google Sheets Configuration :
  • Items : {{GoogleSheets_0.data}}
  • Max iterations : 50
  • Delay : 2000 ms
Dans la boucle :
  • URL du Web Scraper : {{Loop_0.currentItem.url}}

​
Traiter les résultats d’une API

Entrée : Réponse API avec un tableau d’enregistrements Configuration :
  • Items : {{HTTP_0.body.results}}

​
Envoyer des e-mails à plusieurs destinataires

Entrée : Liste de contacts Dans la boucle :
  • Destinataire : {{Loop_0.currentItem.email}}
  • Variable nom : {{Loop_0.currentItem.name}}

​
Boucles imbriquées

Pour traiter des données multidimensionnelles : Configuration :
  • Boucle externe : {{categories}}
  • Boucle interne : {{OuterLoop_0.currentItem.products}}
Les boucles imbriquées multiplient les itérations. 10 catégories × 50 produits = 500 itérations. Définissez des limites raisonnables.

​
Bonnes pratiques

​
Toujours définir un nombre max d’itérations

Pour éviter les boucles infinies ou incontrôlées : 
Max iterations : 100
Même si vous attendez moins d’éléments, fixez une limite.

​
Ajouter des délais pour les appels externes

Lors d’appels API ou de scraping : 
Delay : 2000 ms (2 secondes)
Cela limite le rate limiting et la surcharge des serveurs.

​
Gérer les erreurs dans la boucle

Prévoyez une gestion des erreurs à chaque itération : Utilisez des nodes Conditional pour détecter les échecs.

​
Traiter les gros jeux de données par lots

Pour des milliers d’éléments :
  1. Découper en lots de 50 à 100
  2. Traiter chaque lot dans une boucle
  3. Ajouter des délais entre les lots
  4. Suivre la progression dans un log

​
Donner des noms explicites aux nodes

Dans les boucles, nommez clairement les nodes : 
❌ WebScraper_0
✅ ScrapeCurrentURL

❌ LLM_0
✅ AnalyzeContent

​
Modèles courants

​
Collecter et agréger

Parcourir les éléments en boucle
  → Traiter chacun
  → Ajouter au tableau des résultats

Après la boucle :
  → Agréger les résultats
  → Générer un résumé

​
Filtrer pendant le traitement

Parcourir les éléments en boucle
  → Vérifier une condition
  → Si ça correspond, traiter
  → Sinon, ignorer

​
Suivi de progression

Parcourir les éléments en boucle
  → Traiter
  → Logger la progression : "Traité {{Loop_0.index + 1}} sur {{Loop_0.totalItems}}"

​
Problèmes fréquents

  • Réduire le nombre max d’itérations
  • Réduire les délais
  • Traiter par lots plus petits
  • Vérifier qu’il n’y a pas de condition de boucle infinie
  • Augmenter le délai entre les itérations
  • Réduire la taille des lots
  • Mettre en place un backoff exponentiel
  • Vérifier les limites de l’API
  • Ajouter un node Conditional pour gérer les erreurs
  • Logger les éléments en échec pour analyse
  • Utiliser une logique de retry pour les erreurs temporaires
  • Vérifier que les nodes dans la boucle produisent une sortie
  • Vérifier que les résultats sont bien collectés
  • Vérifier que le tableau d’entrée contient des éléments

​
Nodes associés

Conditional

Filtrer les éléments dans les boucles

Merge

Remplir des modèles avec des données