Hai una lista lunga di elementi da processare e vuoi gestirli a blocchi per evitare limiti API, rallentamenti o caos nel flusso? Il nodo loop over items n8n ha una risposta potente e semplice: il nodo “Split In Batches”. In questa guida pratica imparerai quando usare i loop espliciti invece dell’iterazione implicita n8n, come configurare correttamente il nodo “Split In Batches” (Batch Size, flusso di looping, condizione di uscita), e come collegarlo a “HTTP Request” per paginazione API con n8n, rate limit e controllo del flusso n8n. Vedremo esempi reali (invio di richieste in batch, piccoli delay, rami di errore), espressioni n8n per loop e best practice per scegliere il batch size. Chiudiamo con una checklist, quick takeaways e FAQ per uscire velocemente dai dubbi tipici. Obiettivo: farti costruire loop robusti, con prestazioni prevedibili e zero sorprese in produzione.

[IMG: Canvas con Manual Trigger → Item Lists → Split In Batches → HTTP Request → Wait → Split In Batches (Execute Next Batch) e ramo “No Items” verso End]

---

Iterazione implicita vs loop esplicito: quando serve “Split In Batches”

Molti nodi in n8n elaborano nativamente più item in ingresso senza che tu debba costruire un loop manuale (iterazione implicita n8n). Questo è perfetto per trasformazioni leggere, mapping o passaggi che non toccano limiti di servizio. Tuttavia, quando la tua automazione chiama API esterne, invia notifiche o aggiorna sistemi terzi, è meglio controllare il ritmo: nasce l’esigenza di looping n8n guida con un ciclo esplicito.

Quando preferire “Split In Batches”:

• Vuoi limitare il throughput (rate limit API n8n) per non sforare il limite richieste/minuto.
• Devi suddividere una lista in blocchi gestibili (es. 10–100 elementi) e proseguire batch dopo batch.
• Vuoi inserire attese tra un gruppo e l’altro oppure verifiche/condizioni specifiche a fine batch.
• Stai orchestrando paginazione API con n8n: processi una pagina di risultati, poi “chiedi” la prossima quando hai finito.

Esempi tipici:

• Marketing Ops: invio di lead a un CRM in blocchi da 25 per rispetti di rate limiting.
• Content Ops: fetch di URL per scraping o enrichment in batch da 10 con una breve pausa.
• Data Ops: aggiornamenti massivi su fogli/DB, suddivisi per ridurre tempi di lock e timeout.

In sintesi: l’iterazione implicita n8n va benissimo per operazioni “stateless” e leggere; il loop esplicito con n8n split in batches è la scelta giusta quando devi “governare” velocità, quantità e resilienza.

---

Il nodo “Split In Batches”: come funziona davvero

“Split In Batches” suddivide gli item in più gruppi, li fa passare nel flusso e, quando il gruppo è processato, ti permette di chiedere il gruppo successivo. Tre concetti chiave:

• Batch Size

• È il parametro che definisce quanti item prendere per volta (es. 10).

• Sceglilo in base a limiti API e durata media di lavorazione per batch (vedi più avanti “batch size n8n consigli”).

• Avanzamento del loop: “Execute Next Batch”

• Dopo aver processato il primo gruppo, collega l’uscita del tuo ultimo nodo nel ramo di lavorazione all’ingresso “Execute Next Batch” di “Split In Batches”.

• In questo modo “chiedi” esplicitamente di proseguire con il batch successivo finché ci sono item disponibili.

• Condizione di uscita

• Il nodo espone un’uscita che segnala quando non ci sono più elementi da processare (“No Items”).

• Collega questa uscita all’azione finale (es. un log di completamento o End) per chiudere il ciclo. Questa è la condizione di uscita loop n8n più sicura e chiara.

Schema di collegamento consigliato:

• Ingresso: lista completa di item → Split In Batches (Batch Size=10)
• Uscita “Items” → blocco di lavorazione (HTTP Request, Set, IF, ecc.)
• Ultimo nodo del blocco → ritorno a “Split In Batches” sull’ingresso “Execute Next Batch”
• Uscita “No Items” → End o report finale

[IMG: Dettaglio del nodo Split In Batches con porta “Execute Next Batch” evidenziata e ramo “No Items” verso End]

---

Scegliere il Batch Size e prevenire problemi di performance

Il batch size giusto dipende da:

• Limiti del fornitore (requests/minute): se un’API accetta 60 req/min, un batch size di 10 con una breve pausa tra batch potrebbe essere ideale.
• Tempo medio per item: se ogni item richiede 150–300 ms, 10–20 item/batch tengono il tempo batch sotto pochi secondi.
• Timeout dei nodi a valle: evita batch troppo grandi se c’è rischio di timeout su HTTP/DB.

Linee guida pratiche (batch size n8n consigli):

• Parti da 10–25, misura tempi e errori, poi aumenta o diminuisci.
• Se processi “heavy” (AI, scraping) scegli batch più piccoli (5–10) per avere feedback rapido e meno impatti se fallisce un blocco.
• Per invii massivi a canali di notifica, meglio batch piccoli e costanti per non incappare in rate limit API n8n.

Inserire un breve “Wait” tra batch

• A valle del blocco operazioni, prima di riconnetterti a “Execute Next Batch”, inserisci un “Wait” di 1–3 secondi.
• Questo micro‑backoff attenua picchi e riduce i 429 (Too Many Requests).

Esempio:

• Split In Batches (Batch Size=20) → HTTP Request (crea/aggiorna record) → Wait (2s) → Split In Batches (Execute Next Batch).
• “No Items” → End + invio report (es. Slack: “Processati 240 record in 12 batch”).

---

Paginazione API e flussi robusti con “HTTP Request”

Un caso d’uso comune: hai una lista di URL/record e devi chiamare una API per ciascun item. Con “Split In Batches” controlli la coda, con “HTTP Request” esegui l’azione.

Passo‑passo:
1) Origine dati

• “Manual Trigger” + un “Item Lists” o un “Set” con un array di oggetti; oppure un “HTTP Request” iniziale che restituisce un array nel suo json.

2) Split In Batches

• Imposta “Batch Size” alla dimensione desiderata (es. 10).

3) Lavorazione per batch

• Collega l’uscita “Items” del nodo alla tua pipeline di lavorazione (es. “HTTP Request” che usa espressioni n8n per loop).
• Esempio di mappatura nel body:
• JSON/Body:
  {
  “id”: “={{$json.id}}”,
  “email”: “={{$json.email}}”,
  “status”: “active”
  }

4) Backoff breve

• Inserisci “Wait” (1–3 s) per esser gentile con le API.

5) Avanza batch

• Ritorna a “Split In Batches” collegando l’ultimo nodo all’ingresso “Execute Next Batch”.

6) Uscita quando finiti

• Collega l’uscita “No Items” a un nodo “IF” o direttamente all’End. Puoi inviare un riepilogo su Slack/Email.

Error handling in loop n8n:

• Se temi errori intermittenti dell’API, usa un ramo con IF su statusCode e un loop di retry limitato (1–3 tentativi) con “Wait” crescente (2s → 5s → 10s).
• Se un item fallisce in modo definitivo, loggalo (es. su un foglio “errori”) e continua con gli altri batch.

[IMG: HTTP Request configurato con Body JSON e espressioni {{ $json… }}; accanto, nodo Wait con 2s]

---

Controllo del flusso, espressioni e “Execute Once” nei punti giusti

Controllo del flusso n8n:

• Un “IF” a valle di “HTTP Request” può dirti se tutto è andato a buon fine (status 2xx). In caso contrario, devia su un ramo di gestione (retry/log).
• A fine batch, prima del ritorno al “Execute Next Batch”, puoi inserire nodi di monitoraggio (es. calcolo di quanti item corretti/errati).

Espressioni n8n per loop:

• Accedi ai campi dell’item corrente con {{ $json.field }}.
• Se devi referenziare un nodo precedente specifico, usa {{ $node[“NomeNodo”].json.campo }} per evitare ambiguità nei fork.
• Valorizza di default per evitare undefined (es. {{ $json.email || “” }}).

Esecuzione una sola volta n8n (“Execute Once”):

• In alcuni nodi è presente l’opzione “Execute Once”: utile per nodi che non devono ripetersi a ogni item o batch (es. inizializzazioni, pre‑check).
• Nei flussi con batch, sposta operazioni globali fuori dal loop e mantieni dentro solo ciò che deve ripetersi per item/batch.

Micro‑checklist per la coerenza:

• Gli item in ingresso a “Split In Batches” sono davvero un array? In caso contrario, normalizza prima (Item Lists → “Create items from list”).
• Hai collegato “No Items” a una chiusura esplicita del flusso?
• Hai aggiunto un “Wait” tra batch per evitare burst?

---

Esempio completo: da elenco contatti a invii in batch verso una API

Scenario: devi inviare 230 contatti a un endpoint “/subscribers” con limite 60 req/min.

Flusso:
1) Manual Trigger
2) Item Lists → crea gli item a partire da un array contatti (id, email, source)
3) Split In Batches (Batch Size=20)
4) HTTP Request (POST /subscribers)

• Body JSON:

{
  "id": "={{$json.id}}",
  "email": "={{$json.email}}",
  "source": "={{$json.source}}"
}

5) IF → verifica status 2xx (espressione su {{$json.statusCode}} se gestito come output)

• true: prosegui
• false: logga errore su un ramo parallelo (Sheets/DB)
  6) Wait (2s)
  7) Ritorna a Split In Batches → ingresso “Execute Next Batch”
  8) Uscita “No Items” → Slack (messaggio: “Elaborati 230 contatti in 12 batch, errori: X”)

Perché funziona:

• Batch di 20 con pausa di 2s mantiene un ritmo medio ~40–60 req/min (dipende dalla latenza singola).
• Gli errori non bloccano il loop; vengono deviati e loggati.
• La condizione di fine è chiara e produce un report al team.

[IMG: Canvas con i collegamenti descritti e i rami IF/Errore/Slack evidenziati]

---

Best practice e trappole da evitare

• Mantieni i batch piccoli e costanti: più prevedibilità, meno probabilità di 429/timeout.
• Sposta fuori dal loop il setup globale (token, pre‑fetch, mapping statici) e usa “Execute Once” dove disponibile.
• Evita loop infiniti: assicurati sempre che l’uscita “No Items” sia collegata e che il flusso non si richiami da solo all’infinito.
• Metrica utile: tempo per batch, numero medio di errori per batch, richieste/min. Traccia questi dati in un log finale.
• Se una pagina API restituisce risultati impacchettati (array dentro un singolo item), normalizza prima: “Item Lists” per esplodere in item singoli.
• Sii “gentile” con i provider: rispettare limiti oggi evita blocchi domani.

---

Quick Takeaways

• “Split In Batches” ti dà controllo sul ritmo: imposta un Batch Size, elabora, poi avanza con “Execute Next Batch”.
• Usa l’uscita “No Items” come condizione di uscita loop n8n per chiudere il ciclo in modo pulito.
• Inserisci brevi “Wait” tra batch per assorbire i rate limit; gestisci retry su errori temporanei.
• Mantieni operazioni globali fuori dal loop e usa “Execute Once” dove disponibile.
• Scegli il batch size in base a limiti API, tempi medi per item e timeout dei nodi a valle.
• Normalizza i dati prima del loop e verifica sempre la forma degli item (array).

---

Conclusione

I loop in n8n diventano semplici e robusti quando usi il nodo “Split In Batches” con criterio: definisci un Batch Size sensato, costruisci un blocco di lavorazione stabile (HTTP Request, IF, Wait), rientra con “Execute Next Batch” e chiudi con “No Items”. Questo pattern ti consente di scalare in sicurezza, rispettare i limiti dei servizi esterni e mantenere tempi di esecuzione prevedibili. Per i marketer, significa processi affidabili: import di lead, aggiornamenti in CRM, pubblicazioni o invii massivi senza timore di picchi e blocchi. Parti dagli esempi, misura i tempi per batch e gli errori, poi ottimizza il batch size e i backoff. Con pochi accorgimenti, trasformi una lista di 10 o 10.000 record in un flusso che scorre regolare, dando al tuo team automazioni più stabili e risultati più rapidi.

---

FAQ

1) Qual è la differenza tra iterazione implicita e “Split In Batches”?
L’iterazione implicita n8n fa scorrere automaticamente tutti gli item nei nodi. Con n8n split in batches, invece, controlli il ritmo: prendi N item per volta, lavori il batch e poi chiedi il successivo con “Execute Next Batch”.

2) Come scelgo il Batch Size?
Parti da 10–25 e misura. Considera i limiti del provider (requests/min), il tempo medio per item e i timeout. Aumenta solo se non incontri errori o rallentamenti.

3) Come gestisco la fine del loop?
Collega l’uscita “No Items” a un End o a un nodo di riepilogo. È la condizione di uscita loop n8n più affidabile per evitare loop infiniti.

4) Posso usare “Split In Batches” per paginazione API?
Sì. Recupera una pagina, processa gli item in batch, poi chiedi la successiva. Inserisci “Wait” per evitare rate limit API n8n e usa IF/Retry per gli errori temporanei.

5) Devo usare “Execute Once”?
Usalo nei nodi che non devono ripetersi a ogni item/batch (setup globale, pre‑check). Mantieni nel loop solo le operazioni che vanno eseguite per batch o per singolo item.

---

Ci dai una mano?

Quale flusso vuoi ottimizzare con “Split In Batches”: invio lead al CRM, enrich URL o pubblicazioni massime? Condividi la tua scelta e questo articolo con il team: scambiamoci pattern e miglioriamo insieme i nostri loop!