Claude Thinking

Use Claude extended thinking for complex reasoning with visible thought process.

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.

Category: AI
Tool Name: claude_thinking
Version: 1

Appearance: Icon: anthropic | Color: #d4a574

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.
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 }}.

Usage Examples

• Solve a complex math problem step by step
• Analyze code and explain the reasoning
• Break down a multi-step logic puzzle
• Generate a detailed analysis with visible reasoning
• Answer a complex question with chain-of-thought

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 runs Anthropic extended thinking to generate a visible chain-of-thought trace before delivering a final answer using Claude Opus or Sonnet models. Use it when solving complex math, logic puzzles, code analysis, or multi-step reasoning tasks where transparent deliberation improves accuracy over standard inference. It outputs a main channel containing both the full reasoning trace in a thinking block and the final answer text, plus an error channel for failure handling.