API de Claude — Guía completa de la API de Anthropic

# Linux / macOS
export ANTHROPIC_API_KEY="sk-ant-..."

# Windows PowerShell
$env:ANTHROPIC_API_KEY = "sk-ant-..."

# .env (con python-dotenv o dotenv en Node.js)
ANTHROPIC_API_KEY=sk-ant-...

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" \
  -d '{
    "model": "claude-sonnet-4-6",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Hola Claude. Explica que es una API REST en dos frases."}
    ]
  }'

pip install anthropic

import anthropic

# Lee ANTHROPIC_API_KEY del entorno automaticamente
client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hola Claude. Explica que es una API REST en dos frases."}
    ]
)

# response.content es una lista de bloques de contenido
for block in message.content:
    if block.type == "text":
        print(block.text)

npm install @anthropic-ai/sdk

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

// Lee ANTHROPIC_API_KEY del entorno automaticamente
const client = new Anthropic();

const message = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  messages: [
    { role: "user", content: "Hola Claude. Explica que es una API REST en dos frases." }
  ],
});

// Iterar sobre los bloques de contenido y comprobar el tipo antes de acceder a .text
for (const block of message.content) {
  if (block.type === "text") {
    console.log(block.text);
  }
}

{
  "id": "msg_01XFDUDYJgAACzvnptvVoYEL",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Una API REST es una interfaz que permite..."
    }
  ],
  "model": "claude-sonnet-4-6-20250929",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 42,
    "output_tokens": 87,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

import anthropic
import json

client = anthropic.Anthropic()

tools = [
    {
        "name": "obtener_clima",
        "description": "Devuelve el clima actual de una ciudad.",
        "input_schema": {
            "type": "object",
            "properties": {
                "ciudad": {
                    "type": "string",
                    "description": "Nombre de la ciudad, por ejemplo Madrid"
                }
            },
            "required": ["ciudad"]
        }
    }
]

messages = [{"role": "user", "content": "Como esta el clima en Barcelona hoy?"}]

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    tools=tools,
    messages=messages
)

# Si Claude quiere usar la herramienta:
if response.stop_reason == "tool_use":
    tool_block = next(b for b in response.content if b.type == "tool_use")

    # Ejecutar la herramienta con los argumentos que propone Claude
    resultado = f"En {tool_block.input['ciudad']}: 22 C, parcialmente nublado."

    # Devolver el resultado al modelo para que genere la respuesta final
    messages.append({"role": "assistant", "content": response.content})
    messages.append({
        "role": "user",
        "content": [{
            "type": "tool_result",
            "tool_use_id": tool_block.id,
            "content": resultado
        }]
    })

    respuesta_final = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        tools=tools,
        messages=messages
    )
    print(respuesta_final.content[0].text)

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "image",
                "source": {
                    "type": "url",
                    "url": "https://ejemplo.com/diagrama.png"
                }
            },
            {
                "type": "text",
                "text": "Describe este diagrama y explica el flujo de datos."
            }
        ]
    }]
)

# El SDK expone .stream() como context manager
with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Escribe una guia sobre APIs REST."}]
) as stream:
    # Iteracion sobre tokens de texto en tiempo real
    for texto in stream.text_stream:
        print(texto, end="", flush=True)

# Mensaje final con uso de tokens disponible tras cerrar el stream
mensaje_final = stream.get_final_message()
print(f"\nTokens de salida: {mensaje_final.usage.output_tokens}")

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    output_config={"effort": "high"},
    messages=[{
        "role": "user",
        "content": "Analiza los pros y contras de arquitecturas de microservicios vs monolito para una startup."
    }]
)

for block in response.content:
    if block.type == "thinking":
        print(f"[Razonamiento interno]\n{block.thinking}\n")
    elif block.type == "text":
        print(f"[Respuesta]\n{block.text}")

system_prompt_largo = """
Eres un asistente especializado en analisis financiero.
[... miles de tokens de instrucciones y contexto ...]
"""

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=[{
        "type": "text",
        "text": system_prompt_largo,
        "cache_control": {"type": "ephemeral"}  # TTL 5 min por defecto
    }],
    messages=[{"role": "user", "content": "Cual es el EBITDA de la empresa del informe?"}]
)

# Verificar tokens servidos desde cache
print(f"Tokens de entrada normales: {response.usage.input_tokens}")
print(f"Tokens de cache creados: {response.usage.cache_creation_input_tokens}")
print(f"Tokens leidos de cache: {response.usage.cache_read_input_tokens}")