# Handling Maximum Token Limits and Long Prompts with Claude: A Practical Guide > Master Claude's token limits and long prompts. Learn practical strategies like chunking and summarizing to optimize your API requests and ensure prompt success. - Repository: [Anthropic/prompt-eng-interactive-tutorial](https://github.com/anthropics/prompt-eng-interactive-tutorial) - Tags: how-to-guide - Published: 2026-03-09 --- **Claude's API enforces hard token limits by rejecting any request where prompt tokens plus the requested `max_tokens` exceed the model's context window, requiring developers to chunk inputs, summarize content, and strategically position critical instructions at the end of long prompts.** The `anthropics/prompt-eng-interactive-tutorial` repository demonstrates production-ready patterns for managing **maximum token limits** when working with the Anthropic Messages API. These techniques ensure your application handles large documents and complex workflows without hitting context window boundaries or truncating critical responses. ## Understanding Claude's Token Constraints Every Claude API call operates within two distinct boundaries: the model's fixed **context window** and the user-defined **`max_tokens`** parameter. ### Context Window Capacities According to the Anthropic API documentation referenced in the tutorial, current Claude models enforce these approximate limits: - **Claude 3 Opus**: ~100,000 tokens - **Claude 3 Sonnet**: ~75,000 tokens - **Claude 3 Haiku**: ~50,000 tokens The API validates that `prompt_tokens + max_tokens ≤ context_window` and rejects requests that violate this inequality. ### Default max_tokens in the Tutorial In `Anthropic 1P/01_Basic_Prompt_Structure.ipynb` at line 39, the tutorial establishes a conservative baseline of **2000 tokens** for the `max_tokens` parameter. This default provides a safety margin for the model's response while leaving ample room for multi-shot prompts and few-shot examples. ## Six Strategies for Handling Long Prompts The `09_Complex_Prompts_from_Scratch.ipynb` notebook dedicates significant coverage to **long prompt management**, introducing specific architectural patterns that minimize token waste and prevent truncation. ### Set max_tokens Conservatively Reserve only the tokens you actually need for the response. The tutorial recommends starting with the 2000-token default from `01_Basic_Prompt_Structure.ipynb`, then increasing incrementally after measuring your prompt length with `anthropic.Tokenizer().count(prompt)`. ### Chunk Large Input Data Break documents exceeding your budget into smaller segments. Create a helper function like `chunk_text(text, size)` (which you can add to [`hints.py`](https://github.com/anthropics/prompt-eng-interactive-tutorial/blob/main/hints.py)) to split inputs into processable blocks, then feed each chunk sequentially through multiple API calls. ### Summarize Before Sending Insert an intermediate summarization step to compress long context. Use Claude itself to generate concise representations: call `client.messages.create()` with a focused summarization prompt and a modest `max_tokens=500` budget, then feed that summary into your main prompt. ### Position the Immediate Task Last In `09_Complex_Prompts_from_Scratch.ipynb` (lines 151-166), the tutorial demonstrates placing the `IMMEDIATE_TASK` definition and user question at the **very end** of the prompt. Claude weights recent tokens more heavily, ensuring your actual instruction remains within the freshest context window even if earlier sections push against the limit. ### Leverage Stop Sequences Prevent unnecessary token consumption by halting generation at predefined markers. The `05_Formatting_Output_and_Speaking_for_Claude.ipynb` example at line 40 shows using `stop_sequences=[""]` to cut off output immediately after the closing tag, avoiding trailing whitespace or partial sentences. ### Add a Precognition Step Force step-by-step reasoning to reduce back-and-forth clarification. As implemented in `09_Complex_Prompts_from_Scratch.ipynb` (lines 60-64), adding `PRECOGNITION = "Think about your answer first before you respond."` consumes slightly more input tokens but often reduces overall conversation length by improving first-response accuracy. ## Complete Workflow for Token Budget Management Follow this structured approach when constructing long prompts for Claude: 1. **Measure prompt length** using `anthropic.Tokenizer().count(prompt)` to determine the static portion's token cost. 2. **Reserve response space** by setting `max_tokens` to a conservative value (e.g., 1500) that leaves sufficient margin. 3. **Truncate or summarize** early sections if the total exceeds your budget, or split the work into sequential calls. 4. **Append the immediate task and user question at the bottom** of the prompt structure to maximize recency weighting. 5. **Include a precognition directive** to improve reasoning quality without expanding the conversation. 6. **Configure `stop_sequences`** with your expected closing delimiter to prevent token waste on trailing content. ## Implementation: Building a Token-Aware Prompt The following pattern from the tutorial illustrates chunking, immediate task placement, and stop sequence configuration: ```python import anthropic client = anthropic.Anthropic(api_key="YOUR_API_KEY") # placeholder only def build_prompt(intro, data_chunks, question): # 1. Intro & instructions prompt = f"{intro}\n\n" # 2. Add data chunks (already trimmed/summarized) for chunk in data_chunks: prompt += f"
{chunk}
\n" # 3. Immediate task & question at the end prompt += ( "# Immediate task\n" "IMMEDIATE_TASK = \"Answer the user's question.\"\n" "# Question\n" f"{question}\n" ) return prompt # Example usage intro_text = "You are a helpful assistant that formats responses in XML." large_document = "..." # could be a long string chunks = [large_document[i:i+4000] for i in range(0, len(large_document), 4000)] prompt = build_prompt(intro_text, chunks, "What are the main risks of AI adoption?") response = client.messages.create( model="claude-3-haiku-20240307", max_tokens=1500, # conservative budget temperature=0, messages=[{"role": "user", "content": prompt}], stop_sequences=[""], # stop when closing tag appears ) print(response.content[0].text) ``` This implementation applies the token-budgeting principles demonstrated across `01_Basic_Prompt_Structure.ipynb`, `09_Complex_Prompts_from_Scratch.ipynb`, and `05_Formatting_Output_and_Speaking_for_Claude.ipynb`. ## Summary - **Token limits are absolute**: The sum of prompt tokens plus `max_tokens` cannot exceed the model's context window (~100k for Opus, 75k for Sonnet, 50k for Haiku). - **Default conservatively**: The tutorial uses `max_tokens=2000` as a safe starting point in `01_Basic_Prompt_Structure.ipynb`. - **Structure for recency**: Place critical instructions and the user question at the end of long prompts, as shown in `09_Complex_Prompts_from_Scratch.ipynb`. - **Cut waste with stop_sequences**: Define explicit termination strings like `` to halt generation immediately after the desired output. - **Chunk and summarize**: Process documents exceeding your budget by splitting them into sequential calls or pre-summarizing with dedicated API requests. ## Frequently Asked Questions ### What happens if my prompt exceeds Claude's maximum token limit? The Anthropic API returns an error and rejects the request before processing begins. You must either reduce the `max_tokens` value, truncate the prompt content, or switch to a model with a larger context window (e.g., moving from Haiku to Opus). ### How do I count tokens before sending a request to Claude? Use the `anthropic.Tokenizer().count(prompt)` method to get an exact token count for your prompt string. Measure your static prompt template first, then subtract that from your target model's context window to determine the safe `max_tokens` budget for the response. ### Why should I place the user question at the end of a long prompt? Claude applies recency bias, weighting tokens at the end of the context window more heavily than those at the beginning. By placing the `IMMEDIATE_TASK` and user question last—as demonstrated in `09_Complex_Prompts_from_Scratch.ipynb`—you ensure the model prioritizes your actual instruction over earlier background context. ### What is the difference between max_tokens and the context window? The **context window** is the model's fixed total capacity (e.g., 100,000 tokens for Opus) that cannot be exceeded by any single API call. The **`max_tokens`** parameter is a user-configurable cap on the model's *output* length within that window. The API requires that `input_tokens + max_tokens ≤ context_window` for every request.