How to pass conversation history to Anthropic Claude reliably in n8n?

To pass conversation history to Claude reliably in n8n, you should explicitly build and control the conversation array yourself (usually inside a Function node) and then send that array as the messages field to the Anthropic API node or an HTTP Request node. Do not rely on “item chaining” or storing entire history in a single string field unless you intentionally format it that way. Keep the history small, store it in a predictable structure, and trim it before sending to Claude. This avoids runaway payload sizes, unexpected formatting, and memory/time‑limit problems in real n8n workflows.

 

Why this works

 

Claude expects a structured message array like:

• { role: "user", content: "..." }
• { role: "assistant", content: "..." }

n8n workflows don’t maintain “conversation state” automatically; each node only receives the current item JSON. So you must maintain the entire chat history yourself (usually an array inside a field like chatHistory). Each turn, you append the new message, trim the array if needed, and then send that full array to Claude.

 

Core pattern you can reuse in real production

 

The safest, most production-proof approach is:

• Store your running conversation history in a predictable array (inside a Function node or external DB).
• Append the current user message.
• Optionally trim old messages (to avoid hitting Claude token limits).
• Pass that cleaned array to the Claude node.
• Append Claude’s reply to the history and store it again.

 

// Function node: Build/Update conversation history
// Incoming: userMessage (string), chatHistory (array) or empty
// Output: { messages: [...historyIncludingNewUserMsg] }

const userMessage = $json.userMessage;
let history = $json.chatHistory || [];   // Load previous history if exists

// Append the new user message
history.push({
  role: "user",
  content: userMessage
});

// Optional trimming for safety
// e.g., keep only last 10 messages
history = history.slice(-10);

// Return for next node (Claude API)
return [
  {
    json: {
      messages: history
    }
  }
];

 

Sending it to Claude from n8n

 

You can use the official Anthropic node or a generic HTTP Request node. The critical part is sending the messages array as-is.

Here’s the payload structure when using HTTP Request:

{
  "model": "claude-3-5-sonnet-latest",
  "max_tokens": 1024,
  "messages": {{ $json.messages }}
}

In the Anthropic node, you put the same array into the Messages field using an expression like:

// Inside field:
// {{$json["messages"]}}

 

Capturing Claude’s reply and storing history

 

Claude returns something like:

{
  "content": [
    { "type": "text", "text": "Hello! ..." }
  ]
}

So you need another Function node right after Claude:

// Function node: Append Claude's reply to history and store
const history = $json.messages;       // The same array we sent
const reply = $json.content[0].text;  // Claude’s actual text

history.push({
  role: "assistant",
  content: reply
});

return [
  {
    json: {
      chatHistory: history,
      assistantReply: reply
    }
  }
];

 

Important production‑level considerations

 

• Limit the history size. Token costs and API request sizes grow fast. Slice the array regularly.
• Consider storing history externally (Postgres, Redis, or n8n’s built-in Data Store). This avoids losing context if the workflow restarts.
• Avoid building history as one giant string. Claude performs better and more predictably with structured role messages.
• Watch for n8n memory/time limits if your history grows too large or your execution is long-running.
• Always validate what you pass to the API. A malformed array (e.g., strings instead of objects) will cause cryptic Anthropic errors.

 

Final practical explanation

 

n8n does not automatically remember anything. To pass conversation history to Claude, you manually store the history array, append to it each turn, trim it, and send that whole array to Claude. This is the same pattern used in real production chatbots running on n8n today, and it’s stable, predictable, and easy to maintain.