Cómo Utilizar la API de Claude Opus 4.7

TL;DR

Claude Opus 4.7 (claude-opus-4-7) es el modelo GA más capaz de Anthropic. Soporta una ventana de contexto de 1M de tokens, salida máxima de 128K, pensamiento adaptativo, un nuevo nivel de esfuerzo xhigh, presupuestos de tareas, visión de alta resolución (3.75 MP) y uso de herramientas. Esta guía cubre la configuración de la API, la autenticación y ejemplos de código funcionales en Python, TypeScript y cURL para cada capacidad principal.

Introducción

Anthropic lanzó Claude Opus 4.7 el 16 de abril de 2026. Es el modelo más potente de la familia Claude y la opción preferida para razonamiento complejo, agentes autónomos y flujos de trabajo con mucha visión.

Si ya has utilizado la API de Claude, la mayor parte de la interfaz te resultará familiar. Pero Opus 4.7 introduce varias capacidades nuevas y cambios importantes que requieren actualizaciones de código. Los presupuestos de pensamiento extendido han desaparecido. Los parámetros de muestreo (temperature, top_p, top_k) han desaparecido. El modo de pensamiento ahora solo admite el pensamiento adaptativo, y está desactivado por defecto.

Esta guía te lleva a través de cada paso: obtener tu clave API, hacer tu primera solicitud, usar el pensamiento adaptativo, enviar imágenes de alta resolución, configurar el uso de herramientas, configurar presupuestos de tareas y transmitir respuestas. Cada ejemplo ha sido probado y está listo para copiar. También verás cómo depurar y probar tus llamadas API con Apidog, lo que hace que inspeccionar conversaciones de uso de herramientas de múltiples turnos sea mucho más fácil que analizar JSON en bruto.

Primeros pasos

Obtén tu clave API

1. Regístrate en console.anthropic.com
2. Navega a Claves API en el panel de control
3. Haz clic en Crear clave y copia la clave
4. Guárdala como una variable de entorno:

export ANTHROPIC_API_KEY="sk-ant-your-key-here"

Instala el SDK

Python:

pip install anthropic

TypeScript/Node.js:

npm install @anthropic-ai/sdk

Punto final de la API

Todas las solicitudes van a:

POST https://api.anthropic.com/v1/messages

Encabezados requeridos:

x-api-key: YOUR_API_KEY
anthropic-version: 2023-06-01
content-type: application/json

Solicitud de texto básica

La llamada API más sencilla. Envía un mensaje, obtén una respuesta.

Python:

import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain how HTTP/2 server push works in three sentences."}
    ]
)

print(message.content[0].text)

TypeScript:

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

const client = new Anthropic();

const message = await client.messages.create({
  model: "claude-opus-4-7",
  max_tokens: 1024,
  messages: [
    { role: "user", content: "Explain how HTTP/2 server push works in three sentences." }
  ],
});

console.log(message.content[0].text);

cURL:

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-4-7",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Explain how HTTP/2 server push works in three sentences."}
    ]
  }'

Pensamiento adaptativo

El pensamiento adaptativo es el único modo de pensamiento compatible en Opus 4.7. Permite a Claude asignar dinámicamente tokens de razonamiento en función de la complejidad de la tarea. Está desactivado por defecto; debes habilitarlo explícitamente.

Python:

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16384,
    thinking={
        "type": "adaptive",
        "display": "summarized"  # optional: see thinking output
    },
    messages=[
        {"role": "user", "content": "Analyze this algorithm's time complexity and suggest optimizations:\n\ndef find_pairs(arr, target):\n    result = []\n    for i in range(len(arr)):\n        for j in range(i+1, len(arr)):\n            if arr[i] + arr[j] == target:\n                result.append((arr[i], arr[j]))\n    return result"}
    ]
)

for block in message.content:
    if block.type == "thinking":
        print("Thinking:", block.thinking)
    elif block.type == "text":
        print("Response:", block.text)

Puntos clave:

• "type": "adaptive" habilita el pensamiento. No configures budget_tokens — eso ahora devuelve un error 400
• "display": "summarized" hace que el contenido del pensamiento sea visible en la respuesta. El valor predeterminado es "omitted"
• Combina con el parámetro effort para controlar la profundidad del razonamiento

Uso del parámetro de esfuerzo

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16384,
    thinking={"type": "adaptive"},
    output_config={"effort": "xhigh"},  # xhigh | high | medium | low
    messages=[
        {"role": "user", "content": "Review this pull request for security vulnerabilities..."}
    ]
)

Niveles de esfuerzo para Opus 4.7:

Visión de alta resolución

Opus 4.7 acepta imágenes de hasta 2.576 píxeles en el borde largo (3.75 megapíxeles). Las coordenadas se mapean 1:1 a los píxeles reales.

Python — analiza una imagen desde una URL:

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://example.com/architecture-diagram.png"
                    }
                },
                {
                    "type": "text",
                    "text": "Describe this architecture diagram. List every service and the connections between them."
                }
            ]
        }
    ]
)

print(message.content[0].text)

Python — analiza una imagen local con base64:

import base64

with open("screenshot.png", "rb") as f:
    image_data = base64.standard_b64encode(f.read()).decode("utf-8")

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/png",
                        "data": image_data
                    }
                },
                {
                    "type": "text",
                    "text": "What UI bugs do you see in this screenshot?"
                }
            ]
        }
    ]
)

Las imágenes de mayor resolución consumen más tokens. Si no necesitas una fidelidad completa, redimensiona las imágenes antes de enviarlas para reducir costes.

Uso de herramientas (Llamada a funciones)

El uso de herramientas permite a Claude llamar a funciones que defines. Opus 4.7 tiende a usar menos llamadas a herramientas por defecto, prefiriendo el razonamiento. Aumenta el nivel de esfuerzo para incrementar el uso de herramientas.

Python:

import json

tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a city. Returns temperature, conditions, and humidity.",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "City name, e.g. 'San Francisco'"
                },
                "units": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Temperature unit"
                }
            },
            "required": ["city"]
        }
    }
]

messages = [
    {"role": "user", "content": "What's the weather like in Tokyo right now?"}
]

# First call — Claude requests a tool
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    tools=tools,
    messages=messages,
)

# Process tool calls
if response.stop_reason == "tool_use":
    messages.append({"role": "assistant", "content": response.content})

    tool_results = []
    for block in response.content:
        if block.type == "tool_use":
            # Execute your function here
            result = {"temperature": 22, "conditions": "Partly cloudy", "humidity": 65}

            tool_results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": json.dumps(result)
            })

    messages.append({"role": "user", "content": tool_results})

    # Second call — Claude uses the tool result
    final_response = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )
    print(final_response.content[0].text)

Patrón de bucle de agente

Para agentes autónomos que ejecutan múltiples llamadas a herramientas en secuencia:

def run_agent(system_prompt: str, tools: list, user_message: str) -> str:
    messages = [{"role": "user", "content": user_message}]

    while True:
        response = client.messages.create(
            model="claude-opus-4-7",
            max_tokens=16384,
            system=system_prompt,
            tools=tools,
            thinking={"type": "adaptive"},
            output_config={"effort": "xhigh"},
            messages=messages,
        )

        messages.append({"role": "assistant", "content": response.content})

        if response.stop_reason != "tool_use":
            return "".join(
                block.text for block in response.content
                if hasattr(block, "text")
            )

        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                result = execute_tool(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result,
                })

        messages.append({"role": "user", "content": tool_results})

Presupuestos de tareas (Beta)

Los presupuestos de tareas otorgan a Claude una asignación de tokens para todo un bucle de agente. El modelo ve una cuenta regresiva y finaliza el trabajo a medida que se consume el presupuesto.

response = client.beta.messages.create(
    model="claude-opus-4-7",
    max_tokens=128000,
    output_config={
        "effort": "high",
        "task_budget": {"type": "tokens", "total": 128000},
    },
    messages=[
        {"role": "user", "content": "Review the codebase and propose a refactor plan."}
    ],
    betas=["task-budgets-2026-03-13"],
)

Restricciones clave:

• Presupuesto mínimo: 20,000 tokens
• Asesoramiento, no un límite estricto — Claude puede excederse
• Diferente de max_tokens (un límite estricto que el modelo no puede ver)
• Requiere el encabezado beta task-budgets-2026-03-13

Respuestas en streaming

Transmite respuestas para salida en tiempo real en interfaces de chat.

Python:

with client.messages.stream(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=[
        {"role": "user", "content": "Write a Python function to parse CSV files with error handling."}
    ]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

TypeScript:

const stream = await client.messages.stream({
  model: "claude-opus-4-7",
  max_tokens: 4096,
  messages: [
    { role: "user", content: "Write a Python function to parse CSV files with error handling." }
  ],
});

for await (const event of stream) {
  if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
    process.stdout.write(event.delta.text);
  }
}

Si habilitaste el pensamiento adaptativo con display: "summarized", los bloques de pensamiento se transmiten primero, seguidos de la respuesta de texto. Sin display: "summarized", los usuarios ven una pausa durante el pensamiento seguida de la salida de texto.

Almacenamiento en caché de prompts

Reduce los costos para el contexto repetido (prompts del sistema, documentos largos) almacenándolos en caché.

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "You are a senior code reviewer. Review code for security vulnerabilities, performance issues, and best practices violations...",
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[
        {"role": "user", "content": "Review this function:\n\ndef process_user_input(data):\n    return eval(data)"}
    ]
)

Precios de caché para Opus 4.7:

Una sola lectura de caché cubre la escritura en caché de 5 minutos. Dos lecturas cubren la escritura de 1 hora.

Conversaciones multi-turno

Mantén el contexto a lo largo de los turnos agregando al array de mensajes.

messages = []

# Turn 1
messages.append({"role": "user", "content": "I need to build a REST API for a todo app."})

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=messages,
)

messages.append({"role": "assistant", "content": response.content})

# Turn 2
messages.append({"role": "user", "content": "Add authentication with JWT tokens."})

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=messages,
)

Probando tus llamadas API con Apidog

Construir una integración de la API de Claude implica cargas útiles complejas: mensajes de múltiples turnos, definiciones de herramientas, resultados de herramientas, imágenes base64 y respuestas en streaming. Una herramienta como Apidog simplifica la depuración y las pruebas.

Configura tu entorno:

1. Crea un nuevo proyecto en Apidog y añade el punto final de la API de mensajes de Claude
2. Almacena tu ANTHROPIC_API_KEY en variables de entorno
3. Configura los encabezados requeridos (x-api-key, anthropic-version, content-type)

Prueba flujos de uso de herramientas:

Apidog te permite encadenar solicitudes, así puedes simular un bucle completo de uso de herramientas: envía el mensaje inicial, inspecciona la llamada a la herramienta de Claude, construye el resultado de la herramienta y envíalo de vuelta. El inspector visual de solicitud/respuesta muestra exactamente lo que hay en cada carga útil.

Compara modelos:

Ejecuta los mismos prompts contra claude-opus-4-6 y claude-opus-4-7 para comparar el recuento de tokens, la calidad de la respuesta y la latencia. El ejecutor de pruebas de Apidog hace que las comparaciones A/B sean repetibles.

Valida esquemas:

Define esquemas JSON para el formato de respuesta esperado y deja que Apidog valide automáticamente que las respuestas de Claude coinciden. Esto detecta regresiones cuando cambias los prompts o los modelos.

Errores comunes y soluciones

Referencia de precios

Nota: El nuevo tokenizador de Opus 4.7 puede usar hasta un 35% más de tokens para el mismo texto en comparación con Opus 4.6. Utiliza el punto final /v1/messages/count_tokens para estimar los costos antes de la implementación en producción.

Conclusión

Claude Opus 4.7 es el modelo más capaz de la familia Claude. La API es en gran medida compatible con Opus 4.6, pero la eliminación de los presupuestos de pensamiento extendido y los parámetros de muestreo requiere cambios en el código. Las nuevas capacidades — pensamiento adaptativo, esfuerzo xhigh, presupuestos de tareas y visión de alta resolución — te dan más control sobre cómo razona el modelo y cuánto cuesta.

Comienza con la solicitud de texto básica, añade pensamiento adaptativo para tareas complejas e incorpora el uso de herramientas y los presupuestos de tareas a medida que tu agente crece. Utiliza Apidog para probar tu integración, validar cargas útiles y comparar el rendimiento entre versiones del modelo.