Claude Thinking

Overview

Claude Thinking uses Anthropic’s extended thinking feature to solve complex problems with a visible chain-of-thought. The model first produces a detailed thinking trace (enclosed in a thinking block), then generates a final answer. This is ideal for math, logic, code analysis, multi-step reasoning, and any task where transparent deliberation improves accuracy. Supports Claude Opus and Sonnet models with configurable thinking budget. Temperature must be 1 when thinking is enabled.

Node Type

Action — processes input items and produces output

Input / Output

Direction	Port(s)
Input	Input
Output	Output, Error

Credentials

This tool requires Anthropic credentials. See the Credentials Guide for setup instructions.

Parameters

Parameter	Type	Required	Default	Description
Model	options	No	Claude Sonnet	The Claude model to use for thinking. Always uses the latest version (auto-updated). Haiku is not available — extended thinking is only supported on Opus and Sonnet.
				Options: Claude Opus (most capable — best for highly complex reasoning tasks), Claude Sonnet (balanced — great reasoning at lower cost). Each option tracks the current release of its tier, so the underlying model ID updates without any change to your node.
System Prompt	string	No	—	Optional system prompt to guide the model’s behavior and thinking. Supports expressions.
User Message	string	Yes	—	The message or question for Claude to think about and answer. Supports expressions like {{ $json.prompt }}.
Attachment File ID	string	No	—	Optional Anthropic file_id from a previous Claude File Upload node. When set, the file is attached to the user message so Claude can reason over it. Falls back to item.fileId if empty. Supports expressions.
Attachment Type	options	No	document	How Claude should interpret the attached file. Ignored when Attachment File ID is empty.
				Options: document (PDF, plaintext, or other document file), image (JPG, PNG, GIF, or WebP image)
Thinking Budget	number	No	10000	Token budget for the thinking phase (1024-100000). Higher values allow more detailed reasoning.
Options	collection	No	{}	Advanced output settings.
— Max Tokens	number	No	16384	Maximum number of output tokens (must be greater than thinkingBudget).
— Response Field Name	string	No	response	The key name under which the response text will be stored in the output item.
— Include Thinking	boolean	No	true	Whether to include the thinking trace text in the output item.
Include Input	boolean	No	false	Whether to merge the input item’s JSON fields into the output item.
Web Search	boolean	No	false	Enable Claude’s server-side web search tool. When on, Claude may run searches before answering and returns cited sources in the sources output field.
Max Web Searches	number	No	5	Maximum number of searches Claude may run for a single message. Each search is billed by Anthropic against your own API key. (shown when Web Search is on)
Search Allowed Domains	string	No	—	Restrict search to these domains. Comma-separated, or a JSON array from an expression. Cannot be combined with Search Blocked Domains — if both are set, allowed wins. Supports expressions. (shown when Web Search is on)
Search Blocked Domains	string	No	—	Exclude these domains from search. Comma-separated, or a JSON array from an expression. Ignored whenever Search Allowed Domains is set. Supports expressions. (shown when Web Search is on)
Max Concurrency	number	No	10	Maximum number of items to process concurrently.

Output Data

One API call per input item, and one output item per input item. The final answer lands on the field named by Response Field Name (response by default), and binary data on the input item is forwarded unchanged. With Include Input on, the original item fields are merged in alongside the result.

{
  "response": "The final answer text",
  "thinking": "The model's step-by-step reasoning trace",
  "model": "claude-...",
  "usage": { "input_tokens": 380, "output_tokens": 4210 },
  "stopReason": "end_turn"
}

• thinking is present only when Include Thinking is on and the model returned a thinking block.
• model is the model that actually answered, as reported by Anthropic.
• usage is the token accounting Anthropic returned for the call — thinking tokens are billed as output tokens, so a large Thinking Budget is a real cost.
• stopReason says why generation stopped — for example end_turn (finished naturally) or max_tokens (hit the Max Tokens cap).

Reference the result downstream by expression, e.g. {{ $json.response }}.

Example Configuration

Minimal — reason about one question per item:

{
  "type": "claude_thinking",
  "parameters": {
    "userMessage": "What is the most efficient sorting algorithm for nearly-sorted data, and why?"
  }
}

Batch reasoning with the trace suppressed for a leaner output:

{
  "type": "claude_thinking",
  "parameters": {
    "systemPrompt": "You are an expert software architect. Reason carefully before answering.",
    "userMessage": "{{ $json.question }}",
    "thinkingBudget": 10000,
    "includeInput": true,
    "maxConcurrency": 5,
    "options": {
      "maxTokens": 16384,
      "responseFieldName": "response",
      "includeThinking": false
    }
  }
}

Deep single-item analysis where the reasoning trace is itself a deliverable:

{
  "type": "claude_thinking",
  "parameters": {
    "systemPrompt": "You are an expert analyst. Think through every angle thoroughly.",
    "userMessage": "{{ $json.scenario }}",
    "thinkingBudget": 32000,
    "includeInput": false,
    "maxConcurrency": 1,
    "options": {
      "maxTokens": 40000,
      "responseFieldName": "analysis",
      "includeThinking": true
    }
  }
}

Error Handling

Mode	Behavior
stop	Halts workflow on first error
continue	Skips failed items, passes successful ones through
errorPort	Routes failed items to Error output port

Tips

Claude Thinking performs extended reasoning to solve complex problems with a visible thought process. It is the right tool for math, logic, code analysis, and multi-step reasoning where transparent deliberation improves accuracy over standard inference. It produces a detailed thinking trace within a thinking block, followed by the final answer text.