How to Use Less Tokens in Claude: Simple Tips to Reduce Usage and Save Money

1. Choose the Right Model

One of the most straightforward ways to reduce latency is to select the appropriate model for your use case. Anthropic offers a range of models with different capabilities and performance characteristics.

Consider your specific requirements and choose the model that best fits your needs in terms of speed and output quality.

For speed-critical applications, Claude Haiku 4.5 offers the fastest response times while maintaining high intelligence:

import anthropic

client = anthropic.Anthropic()

# For time-sensitive applications, use Claude Haiku 4.5
message = client.messages.create(
    model="claude-haiku-4-5",
    max_tokens=100,
    messages=[{
        "role": "user",
        "content": "Summarize this customer feedback in 2 sentences: [feedback text]"
    }]
)

2. Optimize Prompt and Output Length

1. Be Clear but Concise

Aim to convey your intent clearly and concisely in the prompt. Avoid unnecessary details or redundant information, while keeping in mind that Claude lacks context on your use case and may not make the intended leaps of logic if instructions are unclear.

2. Ask for Shorter Responses

Ask Claude directly to be concise. The Claude 3 family of models has improved steerability over previous generations. If Claude is outputting unwanted length, ask Claude to curb its chattiness.

Due to how LLMs count tokens instead of words, asking for an exact word count or a word count limit is not as effective a strategy as asking for paragraph or sentence count limits.

3. Set Appropriate Output Limits

Use the max_tokens parameter to set a hard limit on the maximum length of the generated response. This prevents Claude from generating overly long outputs.

The max_tokens parameter allows you to set an upper limit on how many tokens Claude generates. Here’s an example:

truncated_response = client.messages.create(
    model="claude-3-haiku-20240307",
    max_tokens=10,
    messages=[
        {"role": "user", "content": "Write me a poem"}
    ]
)
print(truncated_response.content[0].text)

When the response hits max_tokens, it may be cut off mid-word or mid-sentence. This blunt method often requires post-processing and works best for short answers or multiple-choice questions where the key content appears at the start.

You can check the stop_reason property on the response Message object to see why the model stopped generating:

truncated_response.stop_reason

4. Experiment with Temperature

The temperature parameter controls the randomness of the output. Lower values (e.g., 0.2) can sometimes lead to more focused and shorter responses, while higher values (e.g., 0.8) may result in more diverse but potentially longer outputs.

Temperature is a parameter that controls the randomness of a model’s predictions during text generation. Temperature has a default value of 1.

3. Use Token-Efficient Tool Use

Starting with Claude Sonnet 3.7, the model can call tools in a token-efficient way. Requests can save an average of 14 percent in output tokens and in some cases up to 70 percent, which also helps reduce latency, depending on response size and shape.

Token-efficient tool use is a beta feature for Claude Sonnet 3.7 and requires the header token-efficient-tools-2025-02-19. All Claude 4 models support token-efficient tools by default, so no beta header is needed there.

curl https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: token-efficient-tools-2025-02-19" \
  -d '{
    "model": "claude-3-7-sonnet-20250219",
    "max_tokens": 1024,
    "tools": [
      {
        "name": "get_weather",
        "description": "Get the current weather in a given location",
        "input_schema": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "The city and state, e.g. San Francisco, CA"
            }
          },
          "required": [
            "location"
          ]
        }
      }
    ],
    "messages": [
      {
        "role": "user",
        "content": "Tell me the weather in San Francisco."
      }
    ]
  }' | jq '.usage'

4. Use Prompt Caching for Repeated Context

Prompt caching is one of the most powerful token-optimization methods, reducing input token costs by up to 90% when the same content is reused across requests.

When you repeatedly send large system prompts, documentation, or codebases, Claude stores this content in a cache and charges only 10% of the normal input token cost for cached content.

How Prompt Caching Works:

• Cache persists for 5 minutes after the last use
• Minimum 1,024 tokens required for caching
• Cache hits cost 10% of normal input token pricing
• Works automatically when using cache_control blocks

Implementation Example:

import anthropic

client = anthropic.Anthropic()
# Designate content for caching with cache_control
message = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "You are an AI assistant for a large codebase..."
        },
        {
            "type": "text",
            "text": "[Large code documentation - 50K tokens]",
            "cache_control": {"type": "ephemeral"}  # Cache this block
        }
    ],
    messages=[
        {"role": "user", "content": "Explain the authentication system"}
    ]
)

When to Use Prompt Caching:

• Large system prompts that rarely change
• Extensive documentation or code repositories
• Multi-turn conversations with consistent context
• Batch processing with shared instructions

Token Savings Example:

5. Use Stop Sequences

The stop_sequence parameter lets you define strings that tell Claude when to stop generating. When the model produces one of these sequences, it stops immediately, which helps control output length and prevents unnecessary extra text.

response = client.messages.create(
    model="claude-3-haiku-20240307",
    max_tokens=500,
    messages=[{"role": "user", "content": "Generate a JSON object representing a person with a name, email, and phone number."}],
    stop_sequences=["}"]
)
print(response.content[0].text)

The resulting output does not include the closing “}”, so you may need to add it back for parsing. You can inspect stop_reason to confirm the model stopped due to a stop sequence, and stop_sequence to see which one was triggered.

Best Practices for Token Monitoring

1. Always inspect the usage property – Check both input and output token counts after each request to understand consumption patterns
2. Monitor stop_reason – Understanding why generation stopped helps optimize your token usage strategy
3. Track token efficiency – When using token-efficient features, compare usage metrics with and without those features enabled to measure savings
4. Set appropriate max_tokens – Monitor actual output_tokens against your max_tokens setting to find the optimal balance
5. Account for token variability – Remember that token counts can vary based on language and content complexity

If you mostly chat with Claude in the browser

Goal: cheaper, smoother everyday usage.

If you use Claude Code for programming

Goal: avoid scanning your entire codebase.

If you call the Claude API in production

Goal: predictable cost and steady performance.

Quick Decision Matrix

If you want the fastest way to choose a model, this matrix gives you the exact setup for each common use case. Pick the row that matches your workflow and you’ll get an efficient configuration instantly.

Controlling Extended Thinking Budget

Extended thinking allows Claude to “think through” complex problems before responding, improving quality but consuming additional tokens. You control this with the thinking.budget_tokens parameter:

curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--data \
'{
  "model": "claude-sonnet-4-5",
  "max_tokens": 16000,
  "thinking": {
    "type": "enabled",
    "budget_tokens": 10000
  },
  "messages": [
    {
      "role": "user",
      "content": "Are there an infinite number of prime numbers such that n mod 4 == 3?"
    }
  ]
}'

Budget Guidelines:

The budget_tokens parameter determines the maximum number of tokens Claude is allowed to use for its internal reasoning process:

Important constraint: budget_tokens must be set to a value less than max_tokens

Cost Impact: