Cómo Usar la API de Claude Sonnet 4.6

TL;DR / Respuesta Rápida

Claude Sonnet 4.6 es el modelo de nivel medio más reciente de Anthropic, que combina un rendimiento de codificación de nivel de vanguardia con una ventana de contexto de 1M de tokens (beta) a solo $3/$15 por millón de tokens de entrada/salida. Para empezar a usar la API: 1) Obtenga una clave API en console.anthropic.com, 2) Instale el SDK (pip install anthropic), 3) Use el ID de modelo claude-sonnet-4-6, y 4) Cambie a pensamiento adaptativo (thinking: {type: "adaptive"}) para obtener los mejores resultados. Los primeros probadores lo prefirieron al 70% sobre Sonnet 4.5 e incluso al 59% sobre Opus 4.5.

Introducción

Anthropic lanzó Claude Sonnet 4.6, y este inmediatamente redefine la categoría de modelos de IA de nivel medio. Esta no es una actualización incremental, es un modelo que supera al anterior modelo de nivel premium Opus 4.5 en pruebas directas por un 59% según los primeros usuarios, todo ello manteniendo el precio de Sonnet.

Los cambios principales: una ventana de contexto de 1M de tokens que entra en beta, un nuevo modo de pensamiento adaptativo que reemplaza el antiguo enfoque de pensamiento extendido binario, y un conjunto de herramientas (búsqueda web, ejecución de código, memoria y búsqueda de herramientas) que alcanzan la disponibilidad general. Para los desarrolladores que construyen aplicaciones agentivas, Sonnet 4.6 ofrece las capacidades que antes estaban reservadas para modelos de vanguardia costosos a aproximadamente un tercio del costo.

Las mejoras en la codificación son tangibles. Los usuarios reportan una mejor obediencia a las instrucciones en la generación de código, una comprensión más inteligente del contexto antes de realizar modificaciones y una reducción de la duplicación de código mediante la consolidación automática de la lógica. El uso de la computadora alcanza el 94% de precisión en flujos de trabajo de seguros complejos. La puntuación verificada de SWE-bench llega al 79.6%.

Esta guía cubre todo lo que necesita para comenzar a construir con la API de Claude Sonnet 4.6 hoy mismo: autenticación, ejemplos de código prácticos en Python y JavaScript, el nuevo parámetro de pensamiento adaptativo, cómo desbloquear la ventana de contexto de 1M y cómo probar su integración con el cliente API visual de Apidog.

Novedades en Claude Sonnet 4.6

Modo de Pensamiento Adaptativo

El antiguo patrón thinking: {type: "enabled", budget_tokens: N} está obsoleto en Sonnet 4.6. El reemplazo es el pensamiento adaptativo: thinking: {type: "adaptive"}. Claude ahora decide dinámicamente cuánto razonamiento necesita una tarea.

Combine el pensamiento adaptativo con el parámetro effort (ahora disponible en GA) para ajustar el costo frente al rendimiento:

• effort: "high" (predeterminado) — Claude casi siempre piensa, ideal para problemas complejos
• effort: "medium" — recomendado para la mayoría de los casos de uso de Sonnet 4.6, equilibra velocidad y calidad
• effort: "low" — pensamiento mínimo, respuestas más rápidas para tareas sencillas

Rendimiento de Codificación Mejorado

Sonnet 4.6 trae tres mejoras concretas a la generación de código:

1. Mejor seguimiento de instrucciones — genera código que coincide más precisamente con las especificaciones
2. Comprensión del contexto — lee y entiende el código existente antes de modificarlo, reduciendo regresiones
3. Consolidación de lógica — identifica patrones duplicados y sugiere abstracciones compartidas

Los primeros probadores que ejecutaron pruebas de rendimiento de codificación informaron que preferían las salidas de Sonnet 4.6 sobre Sonnet 4.5 en el 70% de los casos y sobre Opus 4.5 en el 59% de los casos.

Mejoras en el Uso de la Computadora

La precisión del uso de la computadora alcanza el 72.5% en OSWorld-Verified (dentro del 0.2% de Opus 4.6), un aumento significativo respecto a Sonnet 4.5. El modelo muestra un 94% de precisión en flujos de trabajo de seguros que requieren navegación de interfaz de usuario, manipulación de hojas de cálculo y finalización de formularios de varios pasos. También es más resistente a los ataques de inyección de prompts durante las tareas automatizadas.

Avance ARC-AGI-2

El número de referencia más llamativo: el rendimiento de ARC-AGI-2 salta del 13.6% al 58.3% — una mejora de 4.3x. Esto mide la resolución novedosa de problemas en tareas para las que el modelo no ha visto patrones, sugiriendo mejoras genuinas en el razonamiento en lugar de la memorización.

Especificaciones y Precios de la API

Opciones de reducción de costos:

• Caché de prompt: Almacene en caché las partes estáticas de su prompt del sistema y ahorre hasta un 90%
• API por lotes: Procese solicitudes de forma asíncrona para obtener un 50% de descuento
• Precios de contexto largo: Las solicitudes que exceden los 200K tokens utilizan una tarifa de contexto largo separada

Para presupuestos de producción: una conversación de un millón de tokens en modo de pensamiento adaptativo con effort: "medium" cuesta aproximadamente $3 en tokens de entrada. La mayoría de las llamadas API individuales cuestan mucho menos de un centavo.

Cómo Empezar con la API de Claude Sonnet 4.6

Paso 1: Obtenga su Clave API

1. Inicie sesión en platform.anthropic.com
2. Navegue a API Keys en la configuración
3. Haga clic en Create Key y copie el valor inmediatamente (solo se muestra una vez)

Almacene su clave como una variable de entorno; nunca la codifique directamente:

export ANTHROPIC_API_KEY="sk-ant-..."

Paso 2: Instale el SDK

Python:

pip install anthropic

JavaScript/Node.js:

npm install @anthropic-ai/sdk

Paso 3: Realice su Primera Solicitud

import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY from environment

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain the difference between async/await and promises in JavaScript."}
    ]
)

print(response.content[0].text)

Esa es la llamada mínima viable. El objeto de respuesta incluye estadísticas de uso (tokens de entrada, tokens de salida), motivo de parada y versión del modelo.

Ejemplos de Código Python

Generación Básica de Texto

import anthropic

client = anthropic.Anthropic()

def ask_claude(question: str, system: str = None) -> str:
    """Simple wrapper for Claude Sonnet 4.6 text generation."""
    messages = [{"role": "user", "content": question}]

    kwargs = {
        "model": "claude-sonnet-4-6",
        "max_tokens": 2048,
        "messages": messages,
    }
    if system:
        kwargs["system"] = system

    response = client.messages.create(**kwargs)
    return response.content[0].text

# Example usage
answer = ask_claude(
    "Review this Python function for performance issues:\n\ndef find_duplicates(lst):\n    return [x for x in lst if lst.count(x) > 1]",
    system="You are a senior Python engineer. Be specific and provide corrected code."
)
print(answer)

Respuestas en Streaming

Para salidas largas o UX en tiempo real, use el streaming:

import anthropic

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    messages=[{
        "role": "user",
        "content": "Write a complete REST API handler in FastAPI for user authentication with JWT."
    }]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

# Get final message with usage stats after stream completes
message = stream.get_final_message()
print(f"\n\nTokens usados: {message.usage.input_tokens} de entrada, {message.usage.output_tokens} de salida")

Llamada a Herramientas / Uso de Funciones

import anthropic
import json

client = anthropic.Anthropic()

# Define tools
tools = [
    {
        "name": "get_repository_info",
        "description": "Fetch information about a GitHub repository including stars, forks, and recent commits.",
        "input_schema": {
            "type": "object",
            "properties": {
                "owner": {
                    "type": "string",
                    "description": "Repository owner or organization name"
                },
                "repo": {
                    "type": "string",
                    "description": "Repository name"
                }
            },
            "required": ["owner", "repo"]
        }
    }
]

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    tools=tools,
    messages=[{
        "role": "user",
        "content": "What can you tell me about the anthropics/anthropic-sdk-python repository?"
    }]
)

# Handle tool use response
for block in response.content:
    if block.type == "tool_use":
        print(f"Herramienta llamada: {block.name}")
        print(f"Argumentos: {json.dumps(block.input, indent=2)}")
        # In production, call your actual implementation here
        # result = get_repository_info(block.input["owner"], block.input["repo"])

Visión y Análisis de Imágenes

import anthropic
import base64
from pathlib import Path

client = anthropic.Anthropic()

def analyze_image(image_path: str, question: str) -> str:
    """Analyze an image with Claude Sonnet 4.6."""
    image_data = base64.standard_b64encode(Path(image_path).read_bytes()).decode("utf-8")

    # Detect media type from extension
    ext = Path(image_path).suffix.lower()
    media_type_map = {
        ".jpg": "image/jpeg",
        ".jpeg": "image/jpeg",
        ".png": "image/png",
        ".gif": "image/gif",
        ".webp": "image/webp"
    }
    media_type = media_type_map.get(ext, "image/jpeg")

    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": media_type,
                        "data": image_data,
                    },
                },
                {
                    "type": "text",
                    "text": question
                }
            ],
        }]
    )
    return response.content[0].text

# Ejemplo: analizar una captura de pantalla de la interfaz de usuario en busca de problemas de accesibilidad
result = analyze_image(
    "screenshot.png",
    "Identifique cualquier problema de accesibilidad en este diseño de interfaz de usuario. Verifique las relaciones de contraste, los indicadores de texto alternativo faltantes y los problemas de navegación con teclado."
)
print(result)

Ejemplos de JavaScript/Node.js

Configuración Básica y Solicitud

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY, // predeterminado, mostrado explícitamente para mayor claridad
});

async function askClaude(userMessage, systemPrompt = null) {
  const params = {
    model: "claude-sonnet-4-6",
    max_tokens: 2048,
    messages: [{ role: "user", content: userMessage }],
  };

  if (systemPrompt) {
    params.system = systemPrompt;
  }

  const response = await client.messages.create(params);
  return response.content[0].text;
}

// Uso
const answer = await askClaude(
  "Refactor this Express route to use async/await:\n\napp.get('/users', (req, res) => {\n  User.find({}, (err, users) => {\n    if (err) return res.status(500).send(err);\n    res.json(users);\n  });\n});",
  "You are a senior Node.js developer. Return only the refactored code with a brief explanation."
);

console.log(answer);

Streaming con TypeScript

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

async function streamCodeReview(codeSnippet: string): Promise<void> {
  const stream = await client.messages.stream({
    model: "claude-sonnet-4-6",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: `Perform a thorough code review of this TypeScript function:\n\n\`\`\`typescript\n${codeSnippet}\n\`\`\`\n\nFocus on: type safety, edge cases, performance, and security.`,
      },
    ],
  });

  // Transmitir texto a medida que llega
  stream.on("text", (text) => {
    process.stdout.write(text);
  });

  // Obtener estadísticas finales
  const finalMessage = await stream.finalMessage();
  console.log(
    `\n\n---\nTotal tokens: ${finalMessage.usage.input_tokens + finalMessage.usage.output_tokens}`
  );
}

Conversación Multi-turno

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

class ConversationManager {
  constructor(systemPrompt = null) {
    this.messages = [];
    this.systemPrompt = systemPrompt;
  }

  async chat(userMessage) {
    this.messages.push({ role: "user", content: userMessage });

    const params = {
      model: "claude-sonnet-4-6",
      max_tokens: 2048,
      messages: this.messages,
    };

    if (this.systemPrompt) {
      params.system = this.systemPrompt;
    }

    const response = await client.messages.create(params);
    const assistantMessage = response.content[0].text;

    // Mantener el historial de la conversación
    this.messages.push({ role: "assistant", content: assistantMessage });

    return assistantMessage;
  }
}

// Ejemplo: sesión de depuración multi-turno
const debugSession = new ConversationManager(
  "You are an expert debugger. Ask clarifying questions and walk through issues step by step."
);

console.log(await debugSession.chat("My API keeps returning 401 errors."));
console.log(await debugSession.chat("I'm including the Authorization header."));
console.log(
  await debugSession.chat("The token is coming from localStorage after login.")
);

Pensamiento Adaptativo: El Nuevo Pensamiento Extendido

El pensamiento adaptativo reemplaza el antiguo modelo de pensamiento extendido en Sonnet 4.6. La diferencia clave: en lugar de establecer un presupuesto de tokens fijo para el pensamiento, usted establece un nivel de effort y Claude determina cuánto razonamiento justifica realmente el problema.

Cómo Usar el Pensamiento Adaptativo

import anthropic

client = anthropic.Anthropic()

# Recomendado: pensamiento adaptativo con esfuerzo medio para la mayoría de los casos de uso
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    effort="medium",  # opciones: "low", "medium", "high" (predeterminado: high)
    messages=[{
        "role": "user",
        "content": """
        Design a database schema for a SaaS analytics platform that needs to:
        - Track events from millions of users
        - Support real-time queries on the last 24 hours
        - Archive historical data cost-effectively
        - Handle tenant isolation for enterprise customers
        """
    }]
)

# Los bloques de pensamiento aparecen antes de la respuesta de texto
for block in response.content:
    if block.type == "thinking":
        print(f"[Razonamiento de Claude - {len(block.thinking)} caracteres]")
    elif block.type == "text":
        print(block.text)

Niveles de Esfuerzo en la Práctica

Nota de migración:thinking: {type: "enabled", budget_tokens: N}thinking: {type: "adaptive"}effort

Ventana de Contexto de 1M de Tokens

La ventana de contexto de 1M de tokens le permite alimentar a Claude con bases de código enteras, conjuntos extensos de documentos o meses de historial de conversaciones. Eso es aproximadamente 750,000 palabras o el equivalente a 5-10 bases de código completas en una sola solicitud.

Cómo Habilitar el Contexto de 1M

Pase el encabezado beta context-1m-2025-08-07 en su solicitud:

import anthropic

client = anthropic.Anthropic()

# Read an entire large codebase
with open("large_codebase.txt", "r") as f:
    codebase_content = f.read()

response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    betas=["context-1m-2025-08-07"],
    messages=[{
        "role": "user",
        "content": f"""
        Here is our entire backend codebase:\n\n{codebase_content}\n\n
        Find all database queries that could cause N+1 problems and suggest fixes.
        """
    }]
)

print(response.content[0].text)

// Equivalente en JavaScript
const response = await client.beta.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 4096,
  betas: ["context-1m-2025-08-07"],
  messages: [
    {
      role: "user",
      content: `Review this entire codebase for security vulnerabilities:\n\n${codebaseContent}`,
    },
  ],
});

Qué Permite 1M de Tokens

• Análisis completo de la base de código: Envíe su repositorio completo y pida a Claude que encuentre errores, sugiera refactorizaciones o genere pruebas
• Procesamiento de documentos largos: Analice contratos legales completos, informes financieros o trabajos de investigación
• Sesiones agentivas extendidas: Mantenga el historial completo de tareas de varios pasos sin perder el contexto
• Rastreo de dependencias entre archivos: Encuentre todos los usos de una función o clase en un proyecto grande

Nota de precios: Las solicitudes que exceden los 200K tokens utilizan precios de contexto largo. Planifique en consecuencia para un uso de alto volumen.

Búsqueda Web y Filtrado Dinámico

Las herramientas de búsqueda web y recuperación web ahora admiten filtrado dinámico en beta pública en Sonnet 4.6. Claude escribe y ejecuta código para filtrar los resultados de búsqueda antes de que entren en la ventana de contexto, manteniendo solo la información relevante y reduciendo significativamente el uso de tokens.

La ejecución de código es gratuita cuando se utiliza junto con las herramientas de búsqueda web o recuperación web (sin facturación separada).

Configuración de la Búsqueda Web Dinámica

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    betas=["code-execution-web-tools-2026-02-09"],
    tools=[
        {
            "type": "web_search_20260209",  # Use this version for dynamic filtering
            "name": "web_search",
        }
    ],
    messages=[{
        "role": "user",
        "content": "Find the latest CVEs for Apache Log4j published in the last 30 days and summarize the severity levels."
    }]
)

for block in response.content:
    if hasattr(block, "text"):
        print(block.text)

Recuperación Web con Filtrado Dinámico

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    betas=["code-execution-web-tools-2026-02-09"],
    tools=[
        {
            "type": "web_fetch_20260209",  # New version with dynamic filtering
            "name": "web_fetch",
        }
    ],
    messages=[{
        "role": "user",
        "content": "Fetch the Anthropic pricing page and extract only the Claude Sonnet pricing rows."
    }]
)

print(response.content[-1].text)

Por qué es importante el filtrado dinámico: Sin filtrado, recuperar una página web completa podría consumir 100K tokens para una página donde solo necesita 2K tokens de contenido relevante. El filtrado dinámico permite a Claude analizar la página en código y devolver solo lo necesario, reduciendo los costos en un 90%+ en páginas con mucho contenido.

API de Compactación de Contexto

La compactación de contexto maneja sesiones agentivas de larga duración donde el contexto se acumula más allá del límite de la ventana. La API resume automáticamente las partes más antiguas de la conversación en el lado del servidor cuando se acerca al límite, lo que permite una longitud de conversación ilimitada.

import anthropic

client = anthropic.Anthropic()

# Enable context compaction via beta header
response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    betas=["interleaved-thinking-2025-05-14"],  # Enables compaction in beta
    system="You are a long-running software development agent. Maintain context about the codebase changes made during this session.",
    messages=[
        {"role": "user", "content": "Start a refactoring session for our authentication module."},
        # ... many more turns would go here in a real session
    ]
)

# The compaction_details field shows when summarization occurred
if hasattr(response, "usage") and hasattr(response.usage, "cache_read_input_tokens"):
    print(f"Tokens de contexto guardados mediante caché: {response.usage.cache_read_input_tokens}")

Cuándo usar la compactación: Cualquier flujo de trabajo agentivo que se ejecute durante más de unos pocos minutos y acumule historial — agentes CI/CD, sesiones de codificación largas, hilos de soporte al cliente o tareas de investigación de varios pasos.

Probando Claude Sonnet 4.6 con Apidog

Antes de escribir código SDK, use Apidog para explorar la API de Claude Sonnet 4.6 visualmente. Apidog acelera el desarrollo al permitirle configurar encabezados, construir cuerpos de solicitud e inspeccionar respuestas de transmisión sin código repetitivo.

Configurando la API de Anthropic en Apidog

1. Abra Apidog y cree una nueva solicitud HTTP
2. Establezca el método en POST y la URL en https://api.anthropic.com/v1/messages
3. Agregue estos encabezados:

1. Establezca el cuerpo de la solicitud en JSON:

{
  "model": "claude-sonnet-4-6",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "¿Cuáles son las mejoras clave en Claude Sonnet 4.6?"
    }
  ]
}

Probando el Pensamiento Adaptativo

Para probar el modo de pensamiento adaptativo en Apidog, agregue los campos thinking y effort al cuerpo de su solicitud:

{
  "model": "claude-sonnet-4-6",
  "max_tokens": 8192,
  "thinking": {
    "type": "adaptive"
  },
  "effort": "medium",
  "messages": [
    {
      "role": "user",
      "content": "Diseñe una estrategia de limitación de velocidad para una API pública que atienda 10M de solicitudes por día."
    }
  ]
}

Probando Funciones Beta en Apidog

Para funciones beta (contexto de 1M, búsqueda web dinámica, compactación de contexto), agregue el encabezado beta:

O para el filtrado dinámico de búsqueda web:

Apidog le permite guardar estas configuraciones como ajustes preestablecidos y compartirlas con su equipo, para que todos tengan entornos de prueba de API consistentes.

Nuevas Herramientas Ahora en GA

Varias herramientas que antes estaban en beta ahora están generalmente disponibles en Sonnet 4.6, lo que significa que no se requieren encabezados beta especiales:

Herramienta de Ejecución de Código

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    tools=[{"type": "code_execution_20250522", "name": "code_execution"}],
    messages=[{
        "role": "user",
        "content": "Calculate the compound interest on $10,000 at 5% annual rate over 10 years, compounding monthly. Show the year-by-year breakdown."
    }]
)

for block in response.content:
    if block.type == "tool_result":
        print("Salida de ejecución:", block.content)
    elif hasattr(block, "text"):
        print(block.text)

Herramienta de Memoria

La herramienta de memoria permite a Claude persistir información a través de las sesiones de conversación, útil para construir asistentes con estado:

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    tools=[{"type": "memory_20250416", "name": "memory"}],
    messages=[{
        "role": "user",
        "content": "Remember that our API base URL is https://api.company.com/v2 and we require Bearer token auth on all endpoints."
    }]
)

Llamada a Herramientas Programáticas

La llamada a herramientas programáticas permite a Claude generar llamadas API estructuradas directamente:

import anthropic

client = anthropic.Anthropic()

# Claude can now call tools programmatically without human-in-the-loop
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    tools=[
        {
            "name": "execute_sql",
            "description": "Execute a SQL query and return results",
            "input_schema": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "The SQL query to execute"},
                    "database": {"type": "string", "description": "Database name"}
                },
                "required": ["query", "database"]
            }
        }
    ],
    messages=[{
        "role": "user",
        "content": "Find all users who signed up in January 2026 and haven't made a purchase."
    }]
)

Sonnet 4.6 vs Modelos Anteriores

En resumen: Si usa Sonnet 4.5, actualizar a Sonnet 4.6 es una obviedad: el mismo precio, un rendimiento de codificación significativamente mejor y pensamiento adaptativo. Si usa Opus 4.5, Sonnet 4.6 ahora lo iguala o supera en la mayoría de los casos de uso a un 60% del costo.

Mejores Prácticas y Consejos

1. Use el Pensamiento Adaptativo con Esfuerzo Medio por Defecto

Para la mayoría de los casos de uso de Sonnet 4.6, effort: "medium" proporciona el mejor equilibrio costo-rendimiento. Reserve effort: "high" para tareas genuinamente complejas como el diseño arquitectónico, cadenas de razonamiento de varios pasos o pruebas matemáticas.

# Good default pattern for Sonnet 4.6
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    thinking={"type": "adaptive"},
    effort="medium",  # Punto óptimo para la mayoría de las tareas
    messages=[...]
)

2. Use Streaming para Salidas de Más de 1K Tokens

Las respuestas grandes se benefician del streaming para evitar los tiempos de espera HTTP y ofrecer a los usuarios tiempos de respuesta percibidos más rápidos:

# Para cualquier respuesta que se espere sea larga
with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=8192,
    messages=[...]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

3. Habilite el Caché de Prompt para Prompts de Sistema Repetidos

Si utiliza el mismo prompt de sistema en muchas llamadas, almacénelo en caché para ahorrar hasta un 90%:

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "Your lengthy system prompt here...",
            "cache_control": {"type": "ephemeral"}  # Almacenar en caché este bloque
        }
    ],
    messages=[{"role": "user", "content": user_input}]
)

4. Maneje los Límites de Tasa con Gracia

Sonnet 4.6 tiene límites de tasa generosos, pero los sistemas de producción deben implementar retroceso exponencial:

import anthropic
import time

def create_with_retry(client, max_retries=3, **kwargs):
    for attempt in range(max_retries):
        try:
            return client.messages.create(**kwargs)
        except anthropic.RateLimitError:
            if attempt == max_retries - 1:
                raise
            wait_time = (2 ** attempt) + 1  # 2s, 3s, 5s
            time.sleep(wait_time)

5. Migre del Prefill en Sonnet 4.6

El prellenado de mensajes del asistente (rellenos de última turno) no es compatible con los modelos Claude 4.6. En su lugar, use salidas estructuradas:

# Enfoque antiguo (no funciona en Claude 4.6):
# messages = [
#     {"role": "user", "content": "Give me JSON..."},
#     {"role": "assistant", "content": "{"}  # Prefill
# ]

# Nuevo enfoque: usar salidas estructuradas
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    output_config={
        "format": {
            "type": "json_schema",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "score": {"type": "number"}
                }
            }
        }
    },
    messages=[{"role": "user", "content": "Generate a sample user object."}]
)

6. Especifique AWS o GCP para la Residencia de Datos

Si sus requisitos de cumplimiento exigen una inferencia solo en EE. UU., utilice el parámetro inference_geo:

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    inference_geo="us",  # Asegura que la inferencia se ejecute en centros de datos de EE. UU.
    messages=[...]
)

La inferencia solo en EE. UU. tiene un precio de 1.1x la tarifa estándar en Sonnet 4.6.

¿Listo para construir con Claude Sonnet 4.6? Descargue Apidog gratis para probar sus llamadas API visualmente, colaborar con su equipo en las configuraciones de solicitud y generar automáticamente código SDK, no se requiere tarjeta de crédito.