Claude Sonnet 4 Now Supports a 1,000,000-Token Context Window — A Practical Guide for Engineers and Product Teams

---

Quick summary — the essentials up front

• 🍂
  
  Claude Sonnet 4 now supports a context window up to 1,000,000 tokens (one million tokens), a substantial increase compared with earlier versions.
• 🍂
  
  This larger window enables single-request processing of much larger information bundles — for example, entire codebases with tens of thousands of lines, or many full research papers — without splitting the content across many requests.
• 🍂
  
  The feature is available as a public beta on the Anthropic API, and is also available on Amazon Bedrock; Google Cloud Vertex AI support is noted as coming soon.
• 🍂
  
  Pricing changes when prompt input exceeds 200,000 tokens; the source includes a two-tier pricing table.
• 🍂
  
  The source recommends cost and latency mitigations such as prompt caching and batch processing, and mentions batch processing can enable significant cost savings in some configurations.
• 🍂
  
  This guide explains what the 1M token window means in practice, the main use cases shown in the source material, how to get started, recommended high-level workflows, cost considerations, and a FAQ section that answers common questions you will have when evaluating this capability.

---

Why a much larger context window matters — plain language explanation

Think of the model’s context window as the size of the backpack you let the model carry into a single session. Previously, the backpack could hold a modest set of pages; now it can carry an entire binder of documents, or even the notes, specs, and test files for a whole project.

That shift matters for three practical reasons:

1. Less fragmentation, more continuity. You no longer need to split a big file into many smaller pieces and stitch the results back together. The model can see a wider body of material at once, which reduces the engineering effort required to keep the model “aware” of everything it needs.

2. Stronger cross-document reasoning. When the model can view many files together, it can connect details that are spread across them. That helps with tasks such as finding cross-file dependencies in a codebase or reconciling clauses across multiple contracts.

3. Better long-running automation and agents. Workflows and agents that rely on long histories or many reference documents can operate with less state management. The model can carry tool definitions, API docs, and prior interaction history together into a single request and use them coherently.

These practical advantages are the primary use cases highlighted in the source material.

---

Main use cases (as presented in the source)

The source document lists several clear scenarios where the 1M token window brings value. Below they are restated and organized for rapid evaluation.

1. Large-scale code analysis and codebase understanding

• 🍂
  
  Load a complete codebase — source files, tests, README, and architecture notes — in one request.
• 🍂
  
  Ask the model for cross-file dependency analysis, identification of architectural patterns, or high-level refactoring suggestions that require a view of the whole repository.

2. Document synthesis and comparison

• 🍂
  
  Input many documents at once: technical specs, contracts, research papers, or policy documents.
• 🍂
  
  Produce summaries, side-by-side comparisons, or consolidated insights that require reading and correlating details across many files.

3. Context-rich automated agents

• 🍂
  
  Run agents whose decision logic benefits from long histories: tool interfaces, API docs, and past conversation logs can be included in a single context.
• 🍂
  
  Long context allows for multi-step reasoning and fewer external state lookups.

These are direct examples and use cases from the source; no extra use cases have been added.

---

Pricing (as stated in the source)

The source provides a two-tiered pricing outline that applies when using the larger context. The units are dollars per million tokens (MToken). The table below reproduces the original pricing information.

Prompts range	Input price	Output price
Prompts ≤ 200K	$3 / MToken	$15 / MToken
Prompts > 200K	$6 / MToken	$22.50 / MToken

Notes pulled from the source:

• 🍂
  
  The table follows the source’s presentation and units (dollars per million tokens).
• 🍂
  
  The source also notes that prompt caching and batch processing are practical techniques to reduce both latency and cost when using large contexts.

---

Cost-control and performance suggestions

The source explicitly calls out two practical techniques to reduce cost and latency. The following descriptions are faithful to the original material and are framed to be operationally useful.

Prompt caching

• 🍂
  
  Cache static or repeating portions of the prompt (the parts that do not change between requests).
• 🍂
  
  When parts of your context are reused across multiple calls (for example, API doc excerpts, style guides, or repeated instructions), caching those segments avoids re-sending and reprocessing them each time.
• 🍂
  
  Prompt caching reduces redundant computation, which helps both response time and billed token usage.

Batch processing

• 🍂
  
  Organize requests that are independent of each other into batches and process them together.
• 🍂
  
  Batch processing can drive per-request efficiencies; the source explicitly mentions that in some configurations, combining large context windows with batch processing yields significant cost savings (the source references an “additional 50% cost saving” potential in those setups).
• 🍂
  
  Use batch processing when your workload allows for grouping or parallelizing many similar requests.

These recommendations are taken directly from the original content and are presented here for practical application.

---

Customer highlights from the source

Two customer examples are included in the source and are summarized below, preserving the original meaning:

• 🍂
  

  Bolt.new — a browser-internal development platform. The Bolt.new team reported that Sonnet 4, with its extended context window, improved code generation workflows and allowed them to maintain higher-quality code generation and analysis on larger projects.

• 🍂
  

  iGent AI (Maestro) — a team in London. iGent AI reported that the 1M token window meaningfully increased Maestro’s ability to operate over many-day conversations and work directly with real codebases, boosting its autonomy in production engineering tasks.

These highlights are direct summaries from the source and are included to illustrate real usage scenarios.

---

How to get started — a practical checklist

The source contains limited but specific guidance on getting started. Below is a step-by-step checklist you can follow, using only the guidance that appears in the source.

1. Confirm availability.

   • 🍂
     
     The 1M token context is available as a public beta on the Anthropic API.
   • 🍂
     
     The feature is also available on Amazon Bedrock.
   • 🍂
     
     Google Cloud Vertex AI is referenced in the source as coming soon.

2. Confirm permissions and quotas.

   • 🍂
     
     Large context support is currently available to customers with Tier 4 access or custom rate limits, per the source. If your organization needs access, follow your normal channel to request the suitable tier or rate limits.

3. Review official documentation.

   • 🍂
     
     The source points readers to the product documentation and billing pages for details about how to configure usage, caching, and batching strategies. Use those official pages for precise API semantics and examples.

4. Run small tests first.

   • 🍂
     
     Begin with a smaller subset of your materials (for example, a single module or a collection of 3–5 documents) to validate the model’s outputs and measure latency.
   • 🍂
     
     Track token counts for both input and output to estimate costs before scaling up.

5. Measure and iterate.

   • 🍂
     
     Observe model behavior, correctness of cross-document reasoning, latency, and cost.
   • 🍂
     
     Apply prompt caching and batch processing where feasible and measure the resulting improvements.

These steps are a direct operational distillation of the source material.

---

A high-level workflow example: performing a codebase review using a 1M token context

The source gives large code analysis as a primary use case. The following workflow pulls together the source’s recommendations into a simple, practical sequence you can use. The steps are high level — the source suggests consulting official docs for API-level examples.

1. Gather assets

   • 🍂
     
     Collect everything that helps the model understand the project: source files, unit tests, README files, architecture notes, and any existing issue lists.

2. Package the context

   • 🍂
     
     Organize these files into a coherent context bundle. Order matters: put key documentation and high-level architecture summaries near the start so the agent sees the most important context first.

3. Design the prompt

   • 🍂
     
     Write a clear prompt that states the scope: what you want the model to do (for example, “scan the repository and list cross-file dependencies, potential performance bottlenecks, and recommended refactorings”).

4. Run a validation pass

   • 🍂
     
     Submit the prompt with your prepared context. Validate whether the returned analysis covers cross-file dependencies, references specific files, and includes actionable findings.

5. Review and verify

   • 🍂
     
     Human-review the most critical recommendations. Use automated tests and code reviews to validate any suggested code changes before application.

6. Optimize

   • 🍂
     
     If you will repeat similar analysis, extract static context into prompt cache entries. Group similar repositories or modules into batches to improve throughput and cost efficiency.

This workflow mirrors the practical scenario described in the source and is intended as a tactical starting point.

---

Practical checklist for teams evaluating 1M token context

Use this checklist to keep the evaluation practical and focused. Each item in this checklist is based on points found in the source.

• 🍂
  
  [ ] Confirm that the feature is available for your account (Tier 4 or custom rate limits).
• 🍂
  
  [ ] Identify the initial test corpus (a code module, a combined set of documents, or a multi-day agent log).
• 🍂
  
  [ ] Measure baseline token usage and latency for a small test.
• 🍂
  
  [ ] Evaluate output completeness: does the model reference cross-document facts correctly?
• 🍂
  
  [ ] Test prompt caching on repeated static content and measure savings.
• 🍂
  
  [ ] Test batch processing and compare cost/latency with single requests.
• 🍂
  
  [ ] Put guardrails in place for high-cost requests (e.g., token limits, cost alerts).
• 🍂
  
  [ ] Plan a human review step for any high-impact suggestions coming from the model.

These items are practical actions drawn from the source and organized into a tangible evaluation plan.

---

Risks and operational considerations

The source reiterates several practical cautions; below are the summarized points and how to operationalize them.

Cost management

• 🍂
  
  Large context windows consume more computation. Always include cost in your feasibility evaluation and monitor token usage per request.

Latency and performance

• 🍂
  
  The larger the context, the greater the potential processing time. Use caching and batching to control latency where responsiveness matters.

Access and quota constraints

• 🍂
  
  Expect that not every account will have immediate access; Tier 4 or custom rate limits are required according to the source. Apply for the appropriate quota through your provider channels.

Output verification

• 🍂
  
  When the model draws inferences that span many documents, include a verification step — manual or automated — particularly for outputs that will be used to make engineering or legal decisions.

These are operational cautions taken directly from the source material and reframed to be actionable.

---

Frequently asked questions (FAQ)

Below are concise answers to practical questions readers often have. All answers are grounded in the original source.

Q: How big is “1M tokens” in practice?
A: The source uses concrete examples: the 1M token window can hold a codebase with 75,000+ lines of code or many research papers in a single request. Use those examples as rough capacity references.

Q: Where can I use Sonnet 4 with 1M token context?
A: The source states it is available as a public beta on Anthropic API, is available on Amazon Bedrock, and that Google Cloud Vertex AI support is coming soon.

Q: Will costs grow a lot when I use very large prompts?
A: The source provides a pricing split. Requests with prompts over 200K tokens are priced at higher per-MToken rates (see the pricing table earlier). The source recommends prompt caching and batch processing as ways to reduce cost and latency.

Q: Who can access the large context window?
A: The source indicates availability is currently targeted to customers with Tier 4 access or those on custom rate limits. Others should follow official channels for access.

Q: How should I test the capability safely?
A: Start small: run a few representative tests with limited subsets of your content, measure token counts and response latency, and verify output correctness before moving to full-scale runs.

Q: Can batching really reduce cost?
A: The source notes batch processing can deliver substantial savings in some setups — in the source it references an “additional 50% cost saving” potential when batch processing is combined with the large context window.

Each FAQ answer comes from the original document and is written to address practical evaluation questions.

---

Suggested public-facing content elements (schema and structured data)

The source suggests including structured markup for discoverability. Below is a JSON-LD block that follows the FAQ and HowTo structures referenced in the original material. You can embed this in a web page’s <script type="application/ld+json"> block if desired.

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "FAQPage",
      "mainEntity": [
        {
          "@type": "Question",
          "name": "How many tokens does Claude Sonnet 4 support?",
          "acceptedAnswer": {
            "@type": "Answer",
            "text": "Claude Sonnet 4 supports a context window up to 1,000,000 tokens."
          }
        },
        {
          "@type": "Question",
          "name": "Where is the 1M token context available?",
          "acceptedAnswer": {
            "@type": "Answer",
            "text": "The 1M token context is available as a public beta on Anthropic API, and is available on Amazon Bedrock. Google Cloud Vertex AI support is noted as coming soon."
          }
        },
        {
          "@type": "Question",
          "name": "How can cost be reduced when using large context windows?",
          "acceptedAnswer": {
            "@type": "Answer",
            "text": "The source advises the use of prompt caching and batch processing to reduce redundant computation and lower costs."
          }
        }
      ]
    },
    {
      "@type": "HowTo",
      "name": "High level codebase review with a large context window",
      "step": [
        {"@type":"HowToStep","name":"Gather assets","text":"Collect source files, tests, README, and architecture notes."},
        {"@type":"HowToStep","name":"Package the context","text":"Order and structure files so key docs appear early in context."},
        {"@type":"HowToStep","name":"Design the prompt","text":"Define the exact scope and attach necessary document excerpts."},
        {"@type":"HowToStep","name":"Run validation","text":"Submit the prompt and validate outputs for coverage and correctness."},
        {"@type":"HowToStep","name":"Verify and optimize","text":"Human review critical suggestions and apply caching or batching as needed."}
      ]
    }
  ]
}