How to Avoid Exceeding Token Limits When Chaining LLM Calls in n8n

Insert a Code node between your data source and the first LLM node. This node approximates the token count of the input text using the common heuristic of roughly 4 characters per token for English text. While not exact, this estimate is close enough to prevent most overflows. Set the Code node to Run Once for All Items so it processes the combined input. The node outputs the estimated token count alongside the original text, letting downstream logic decide whether to proceed or truncate.

1// Code node — Run Once for All Items
2const items = $input.all();
3const results = [];
4
5for (const item of items) {
6  const text = item.json.text || '';
7  const estimatedTokens = Math.ceil(text.length / 4);
8  results.push({
9    json: {
10      text: text,
11      estimatedTokens: estimatedTokens,
12      exceedsLimit: estimatedTokens > 120000
13    }
14  });
15}
16
17return results;

After the token estimation Code node, add an IF node that checks the exceedsLimit field. When the value is true, route the item to a branch that splits and summarizes the text before sending it to the LLM. When false, route it directly to the LLM node. This prevents wasted API calls that would fail with a 400 error. Set the IF condition to check whether the expression {{ $json.exceedsLimit }} equals true. The true output connects to a SplitInBatches node, and the false output connects directly to your LLM node.

On the true branch of the IF node, add a Code node that splits the text into chunks of roughly 80,000 tokens (about 320,000 characters). Each chunk becomes a separate item. Then connect this to a SplitInBatches node with a batch size of 1, so each chunk is processed individually by the LLM. The SplitInBatches node ensures that only one chunk is sent to the LLM at a time, preventing parallel calls from overwhelming your rate limit. After the LLM processes each chunk, the results loop back through SplitInBatches until all chunks are processed.

1// Code node — Run Once for All Items
2const items = $input.all();
3const CHUNK_SIZE = 320000; // ~80K tokens
4const chunks = [];
5
6for (const item of items) {
7  const text = item.json.text || '';
8  for (let i = 0; i < text.length; i += CHUNK_SIZE) {
9    chunks.push({
10      json: {
11        chunk: text.substring(i, i + CHUNK_SIZE),
12        chunkIndex: Math.floor(i / CHUNK_SIZE),
13        totalChunks: Math.ceil(text.length / CHUNK_SIZE),
14        originalId: item.json.id || 'unknown'
15      }
16    });
17  }
18}
19
20return chunks;

When chaining multiple LLM calls, the output of one call becomes the input of the next, and outputs can be verbose. Insert a summarization step between chained LLM nodes to reduce the token count. Use a dedicated LLM call with a system prompt that instructs the model to compress the previous output into a concise summary. Set the max_tokens parameter on this summarization call to a low value like 500-1000 tokens, forcing the model to be brief. This compressed output then feeds into the next LLM node without risk of exceeding the context window.

After all chunks have been processed by the LLM and the SplitInBatches loop completes, add another Code node to merge the individual chunk results back into a single coherent output. This node collects all chunk responses, sorts them by chunkIndex, and concatenates the results. Connect this Code node to the done output of the SplitInBatches node. The merged result can then continue through the rest of your workflow as a single item, ready for the next chained LLM call or a final output step.

1// Code node — Run Once for All Items
2const items = $input.all();
3
4const sorted = items.sort(
5  (a, b) => (a.json.chunkIndex || 0) - (b.json.chunkIndex || 0)
6);
7
8const mergedText = sorted
9  .map(item => item.json.response || '')
10  .join('\n\n');
11
12return [{
13  json: {
14    mergedResponse: mergedText,
15    totalChunks: sorted.length
16  }
17}];

Even with estimation, edge cases can still trigger token limit errors. Configure the On Error setting on each LLM node to Continue (using error output) instead of Stop Workflow. This routes failed items to a separate error-handling branch where you can log the error, re-chunk the input into smaller pieces, and retry. Add an Error Trigger node in a separate workflow to capture these failures and send notifications. On the error output, connect a Code node that halves the chunk size and re-routes the item back through the splitting logic.