<!-- BusyBot node reference — https://busybot.net/tools/claude-thinking/ -->

> Node: Claude Thinking (`claude_thinking`) · Action · v1
> Category: AI · Credentials: Anthropic (`anthropic`)
> Updated: 2026-08-16

# 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](https://busybot.net/credentials/anthropic/) 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.

```json
{
  "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:

```json
{
  "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:

```json
{
  "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:

```json
{
  "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.