Continue continue

When to Use

• Filter invalid or null items: Skip items that are null, malformed, or missing required fields without wrapping the entire loop body in a nested IfCondition branch.
• Skip already-processed records: Check a processed-IDs set at the top of each iteration — if the current item has already been handled in a previous run, Continue skips it, making the loop idempotent.
• Resilient batch processing: If an API call fails for one item in a bulk operation, log the failure and Continue to the next item rather than aborting the entire loop with a Break.
• Conditional processing within a loop: Only send email to recipients who have opted in, only update records that are in a specific status, only enrich items that are missing a particular field — Continue handles the "skip" path cleanly.

Configuration

How It Works

When a Continue node executes, it calls Memory.SignalContinue(), which writes a continue signal into ExecutionMemory. The enclosing Loop node monitors for this signal and responds by:

1. Discarding any remaining body nodes for the current iteration (they do not execute).
2. Clearing the continue signal from ExecutionMemory.
3. Incrementing the current index.
4. Firing the body port again for the next item (or firing done if no more items remain).

Variables set before Continue fired in the current iteration are preserved — they are not rolled back.

Output Ports

Validation

Break vs Continue — Quick Reference

Node Policies and GuardRails

• Pair with a condition check: Continue is almost always connected from the true or false port of an IfCondition at the top of the loop body. An unconditional Continue on every item means no items are ever processed — use IfCondition to identify which items should be skipped.
• Variables set before Continue are preserved: If a VariableAssignment node ran before the Continue fired in a given iteration, its assignments remain in ExecutionMemory. Only the nodes that come after Continue in the body subgraph are skipped.
• Loop still runs to completion: Unlike Break, Continue does not stop the loop. After a Continue the loop increments the index and processes the next item. If you want to stop the entire loop, use Break instead.
• Works with Break in the same loop: A single loop body can have both a Continue path (skip invalid items) and a Break path (stop on critical error). The IfCondition at the top of the body routes to the appropriate control node.

Pattern Examples

Pattern 1 — Skip Null / Invalid Items

An array from an external API may contain null entries or items missing a required field. Skip those silently and process only valid items.

Loop  [key: "processItems"]
  Items: {{ $output.fetchRecords.items }}
  ├─► body ──► IfCondition  [key: "validateItem"]
  │             Condition: {{ $var.current_item !== null &&
  │                           $var.current_item.email !== null }}
  │             ├─► false ──► Continue  (skip null or invalid items)
  │             └─► true  ──► EmailSmtp
  │                             To: {{ $var.current_item.email }}
  └─► done ──► SlackNode  (batch complete)

Pattern 2 — Idempotent Processing (Skip Already-Handled Records)

A scheduled sync loop uses a set of processed record IDs stored in a variable. Items already in the set are skipped via Continue, making the loop safe to re-run after a partial failure.

VariableAssignment (processedIds = [])
  └─► Loop  [key: "syncRecords"]
        Items: {{ $output.fetchAll.records }}
        ├─► body ──► IfCondition  [key: "alreadyDone"]
        │             Condition: {{ $var.processedIds.includes($var.current_item.id) }}
        │             ├─► true  ──► Continue   (already processed — skip)
        │             └─► false ──► HttpRequest  (POST /sync/record)
        │                             └─► VariableAssignment
        │                                   processedIds = $var.processedIds
        │                                                  .concat([$var.current_item.id])
        └─► done ──► [finalize sync]

Pattern 3 — Resilient Batch (Log Error, Continue to Next)

Call an enrichment API for each item. If the API returns an error for one item, log it and continue to the next — process as many items as possible rather than aborting the whole batch.

Loop  [key: "enrichRecords"]
  Items: {{ $json.records }}
  ├─► body ──► HttpRequest  [key: "callEnrich"]
  │             GET /enrich/{{ $var.current_item.id }}
  │             ├─► success ──► VariableAssignment
  │             │               (store enriched result, accumulate)
  │             └─► error   ──► VariableAssignment
  │                             (append error to failedItems list)
  │                               └─► Continue  (skip to next record)
  └─► done ──► IfCondition
                 Condition: {{ $var.failedItems.length > 0 }}
                 ├─► true  ──► SlackNode  (alert: N items failed enrichment)
                 └─► false ──► [all records enriched successfully]

Sample Output

Success Port

Continue produces no data output. It signals the loop engine to skip the remainder of the current iteration and advance to the next item. The loop resumes with the next item's data.

{
  "_control": "continue",
  "_iterationIndex": 3,
  "_skippedItem": { "id": "item_004", "status": "duplicate" },
  "_reason": "Item already processed — skipping"
}

Expression Reference