La API de Anthropic sin miedo: tu primera llamada

Hasta ahora has estado usando Claude a través de la web: entras a Claude.ai, escribes tu pregunta y obtienes la respuesta. Funciona, es cómodo, pero tiene un límite claro: está pensado para uso manual. Si quieres que Claude trabaje dentro de tu código, tu aplicación o tu flujo automatizado de SAP, necesitas la API.

La buena noticia: la API de Anthropic es tan sencilla de usar que en 15 minutos tendrás tu primer programa funcionando. No necesitas ser programador avanzado. Vamos a hacerlo juntos.

¿Qué es una API key y por qué la necesitas?

Una API key es como la contraseña de acceso a Claude, pero con superpoderes. No es tu usuario y contraseña de Claude.ai. Es un token único que identifica tu cuenta de Anthropic y autoriza cada llamada que hagas.

Piénsalo así: cuando usas Claude en la web, Anthropic sabe que eres tú porque has iniciado sesión. Cuando llamas a Claude desde tu código (desde Python, JavaScript, o donde sea), no hay navegador. ¿Cómo sabe Claude que eres tú? Por la API key que incluyes en cada petición.

Dónde obtenerla:

Ve a console.anthropic.com
Inicia sesión con tu cuenta de Anthropic (la misma de Claude.ai)
Busca la sección "API keys" o "Keys"
Crea una nueva clave
Cópiala y guárdala en un lugar seguro (no la compartas en Slack, GitHub o correos)

Una regla de oro: nunca, nunca hardcodees la API key en tu código. Úsala como variable de entorno. Te lo mostraremos en ejemplos.

Modelos, precios y costes reales

Anthropoic tiene varios modelos de Claude disponibles. Cada uno tiene diferentes velocidades, capacidades y, sobre todo, precios distintos. Para saberlo actualizado, siempre consulta la página de precios de Anthropic, pero te doy el patrón:

Modelos típicos:

Claude 3.5 Sonnet: el más rápido y eficiente. La mejor opción para la mayoría de casos. Menor coste por token.
Claude 3 Opus: más potente, más caro. Para tareas complejas donde necesitas máxima precisión.
Modelos más antiguos: más baratos, pero menos capaces.

¿Cuánto cuesta? Se cobra por tokens. Un token ≈ 4 caracteres.

Hay un precio por tokens de entrada (lo que envías)
Hay un precio distinto por tokens de salida (lo que Claude genera)

Ejemplo real de oficina: si envías un extracto de SAP (5.000 caracteres ≈ 1.250 tokens) a Claude y obtienes una respuesta (1.000 caracteres ≈ 250 tokens), pagarás por ambos. Con Claude 3.5 Sonnet, eso te cuesta centavos (menos de 1 céntimo de euro típicamente).

Consejo práctico: empieza siempre con Claude 3.5 Sonnet. Es como el "turismo" de los modelos: rápido, barato y muy capaz. Solo migra a Opus si ves que no es suficiente.

Tu primera llamada: con Python

Vamos a hacer tu primer programa. Necesitas:

Python instalado (cualquier versión reciente)
La librería oficial de Anthropic: pip install anthropic

import os
from anthropic import Anthropic

# La API key viene de variable de entorno (NUNCA hardcodeada)
client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

# Hacer una llamada a Claude
message = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "¿Cuál es la diferencia entre una nota de compra y un pedido en SAP?"}
    ]
)

# Mostrar la respuesta
print(message.content[0].text)

Línea a línea:

import os y from anthropic import Anthropic: Importas la librería de Anthropic y el módulo de entorno.
client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY")): Creas un cliente de Anthropic. Busca la variable de entorno ANTHROPIC_API_KEY (que tú habrás configurado en tu sistema).
client.messages.create(...): Realizas la llamada a Claude. Los parámetros clave:
- model: qué versión de Claude usar. Siempre especifica el nombre exacto del modelo (el que ves en la consola de Anthropic).
- max_tokens: cuántos tokens máximo debe generar Claude en la respuesta. Límite de seguridad.
- messages: lista de mensajes. Cada uno tiene un role ("user" o "assistant") y un content (el texto).
message.content[0].text: Claude devuelve un objeto con la respuesta. Accedes al texto con .content[0].text.

¿Cómo ejecutar esto?

En tu terminal:

export ANTHROPIC_API_KEY="tu-clave-aqui"
python tu_script.py

O en Windows (PowerShell):

$env:ANTHROPIC_API_KEY="tu-clave-aqui"
python tu_script.py

Ejemplo más realista: contexto de SAP

Lo anterior está bien, pero en la oficina querrás enviar contexto real. Por ejemplo, un extracto de un report de SAP:

import os
from anthropic import Anthropic

client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

# Simular un extracto de SAP (en realidad, lo leerías de un archivo o BD)
sap_extract = """
Materiales sin recepción en las últimas 48 horas:
- Código: MAT-2024-001 | Descripción: Tornillo M5 | Cantidad esperada: 500 | Proveedor: ACME Corp
- Código: MAT-2024-002 | Descripción: Cable USB | Cantidad esperada: 200 | Proveedor: TechParts Ltd
- Código: MAT-2024-003 | Descripción: Sensor IR | Cantidad esperada: 50 | Proveedor: SensorWorld
"""

message = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": f"Eres un especialista en logística de SAP. Analiza estos materiales pendientes y sugiere acciones prioritarias:\n\n{sap_extract}"
        }
    ]
)

print("=== Análisis de Claude ===")
print(message.content[0].text)
print(f"\n[Tokens usados - entrada: {message.usage.input_tokens}, salida: {message.usage.output_tokens}]")

Nota la última línea: message.usage te muestra cuántos tokens gastaste. Es útil para monitorear costes.

Con curl (sin Python)

Si prefieres ver la API en su forma más pura, aquí está con 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-3-5-sonnet-20241022",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "¿Qué es un número de documento en SAP?"}
    ]
  }'

La respuesta que obtendrás es un JSON con la respuesta de Claude. Es la misma API que Python usa por debajo.

Costes típicos y cómo monitorearlos

Un proyecto real de oficina:

Procesar 100 extractos de SAP pequeños (cada uno, ~500 tokens entrada + 200 tokens salida): ~2-3 céntimos de euro.
Generar un reporte con contexto grande (5.000 tokens entrada + 1.000 salida): menos de 1 céntimo.
Revisar código ABAP (10 lineas de código = 50 tokens, respuesta = 200 tokens): negligible.

En la consola de Anthropic ves tu uso en tiempo real. Fija un límite de gasto si quieres dormir tranquilo.

Para recordar

API key es tu contraseña de acceso: guárdala como variable de entorno, nunca la hardcodees.
Elige Claude 3.5 Sonnet como primer modelo: es el equilibrio perfecto entre coste y potencia. Cambia a Opus solo si es necesario.
Pagas por tokens: entrada y salida tienen precios distintos. Monitorea en la consola de Anthropic.
Con Python es trivial: tres líneas de código y tienes a Claude en tu aplicación. Hazlo con Anthropic(api_key=...).messages.create(...).

Para ir más allá

Ahora que sabes hacer una llamada básica, el siguiente paso es integrar esto en tu flujo de trabajo real. Si trabajas con SAP, la próxima lección te mostrará exactamente cómo:

Próxima lección: Claude + ABAP: generar, explicar y revisar código SAP