Integrar IA por API: OpenAI, Anthropic y Google en tu aplicación (2026)

Las APIs de IA son la forma más rápida de añadir inteligencia artificial a una aplicación. No necesitas GPUs, no necesitas entrenar modelos, no necesitas un equipo de ML. Envías una petición HTTP, recibes una respuesta inteligente. Es tan simple como una API de pagos o de email, con una diferencia: la respuesta no es determinista. Cada llamada puede producir un resultado diferente.

En 2026 hay tres proveedores principales: OpenAI (GPT-4o, o1, GPT-4o-mini), Anthropic (Claude Sonnet, Claude Haiku, Claude Opus) y Google (Gemini 2.5 Pro, Gemini 2.5 Flash). Cada uno tiene sus fortalezas, sus SDKs y sus modelos de pricing. Esta guía cubre todo lo que necesitas para integrar cualquiera de ellos en tu aplicación, con código real y decisiones de arquitectura.

Por qué usar APIs de IA

Hay tres formas de añadir IA a una aplicación: modelos self-hosted (desplegar tu propio LLM), modelos fine-tuneados (personalizar un modelo existente) y APIs (llamar a un modelo hospedado por el proveedor). Para la mayoría de aplicaciones en 2026, las APIs son la opción correcta.

Ventajas de las APIs:

• Sin infraestructura. No necesitas GPUs, ni servidores dedicados, ni gestionar VRAM. El proveedor se encarga de todo.
• Últimos modelos siempre. Cuando OpenAI o Anthropic lanzan un modelo nuevo, cambias una línea de código y lo tienes.
• Escalabilidad automática. De 10 a 10.000 peticiones/minuto sin cambiar nada. El proveedor gestiona la escala.
• Coste variable. Pagas por uso. Si tu app tiene 100 usuarios, pagas poco. Si crece a 10.000, pagas más pero facturas más.
• Time to market. De idea a implementación en horas, no semanas.

Cuándo NO usar APIs:

• Datos regulados. Si procesas datos de salud (HIPAA), financieros o de seguridad nacional, necesitas control total. Modelos self-hosted en infraestructura propia.
• Latencia ultrabaja. Si necesitas respuestas en menos de 100ms, las APIs no dan esa latencia. Modelos locales optimizados (ONNX, vLLM) sí.
• Volumen extremo. A partir de 1M+ peticiones/día, self-hosting puede ser más barato que API. Haz los números.
• Personalización profunda. Si necesitas que el modelo entienda tu dominio a nivel de experto, un fine-tuning o RAG sobre modelo propio puede dar mejores resultados. Para elegir el LLM adecuado, consulta nuestra guía de elección de LLM.

API keys y autenticación

Todas las APIs de IA usan API keys para autenticación. Una API key es un token secreto que identifica tu cuenta y autoriza las peticiones. Parece simple, pero la gestión de API keys es donde la mayoría de los problemas de seguridad empiezan.

Reglas fundamentales:

1. Nunca en el código fuente. La API key va en variables de entorno o en un gestor de secretos (AWS Secrets Manager, Vault, Doppler). Nunca en un archivo .py o .js que se suba a git.
2. Nunca en el frontend. Si pones la API key en JavaScript del navegador, cualquier usuario puede verla en las DevTools. Las llamadas a la API siempre van desde tu backend.
3. Rotación periódica. Genera nuevas API keys cada 30-90 días. Si una key se filtra, el impacto se limita al período entre rotaciones.
4. Keys por entorno. Una key para desarrollo, otra para staging, otra para producción. Así puedes revocar una sin afectar las demás.
5. Límites de gasto. Todos los proveedores permiten configurar un límite de gasto mensual. Configúralo siempre. Un bug en un loop puede consumir miles de dólares en minutos.

# Correcto: API key desde variable de entorno
import os
api_key = os.environ["ANTHROPIC_API_KEY"]

# INCORRECTO: API key hardcoded
api_key = "sk-ant-api03-xxxx..."  # NUNCA hagas esto

Obtener API keys:

• OpenAI: platform.openai.com → API Keys → Create new secret key
• Anthropic: console.anthropic.com → API Keys → Create Key
• Google: aistudio.google.com → Get API Key → Create API key

SDKs: Python y Node.js

Los tres proveedores tienen SDKs oficiales para Python y Node.js. Los SDKs simplifican la autenticación, el manejo de errores, el streaming y el tipado.

Instalación:

# Python
pip install anthropic openai google-generativeai

# Node.js
npm install @anthropic-ai/sdk openai @google/generative-ai

Llamada básica a cada API (Python):

# Anthropic (Claude)
import anthropic
client = anthropic.Anthropic()  # Lee ANTHROPIC_API_KEY del entorno
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Explica qué es una API en 3 frases"}]
)
print(message.content[0].text)

# OpenAI (GPT-4o)
from openai import OpenAI
client = OpenAI()  # Lee OPENAI_API_KEY del entorno
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Explica qué es una API en 3 frases"}]
)
print(response.choices[0].message.content)

# Google (Gemini)
import google.generativeai as genai
genai.configure()  # Lee GOOGLE_API_KEY del entorno
model = genai.GenerativeModel("gemini-2.5-pro")
response = model.generate_content("Explica qué es una API en 3 frases")
print(response.text)

Los tres SDKs siguen un patrón similar: crear un cliente, llamar al método de generación, y leer el resultado. Las diferencias están en los nombres de los métodos y la estructura de la respuesta, pero el concepto es idéntico.

Streaming: respuestas en tiempo real

Sin streaming, tu usuario espera 3-10 segundos viendo una pantalla en blanco antes de recibir la respuesta completa. Con streaming, los tokens aparecen uno a uno en tiempo real, como si la IA estuviera "escribiendo". La experiencia de usuario mejora drásticamente.

Streaming en Python (Anthropic):

with client.messages.stream(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Escribe un resumen ejecutivo"}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)  # Imprime token a token

Streaming en Node.js (OpenAI):

const stream = await openai.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Escribe un resumen ejecutivo" }],
  stream: true,
});
for await (const chunk of stream) {
  const content = chunk.choices[0]?.delta?.content || "";
  process.stdout.write(content);  // Imprime token a token
}

Para enviar streaming al frontend, usa Server-Sent Events (SSE) o WebSockets. SSE es más simple y suficiente para el 90% de los casos. Tu backend recibe los tokens del LLM y los reenvía al frontend vía SSE. El frontend los renderiza en tiempo real.

Function calling y tools

Function calling (o tool use) permite que el LLM "llame" a funciones de tu aplicación. No es que el LLM ejecute código directamente. Lo que hace es: analiza el prompt, decide que necesita llamar a una función, genera los parámetros en JSON, y tu aplicación ejecuta la función y devuelve el resultado al LLM.

Es el mecanismo fundamental para construir agentes de IA y cualquier integración que vaya más allá de generar texto.

Ejemplo: tool use con Anthropic (Python):

tools = [{
    "name": "get_weather",
    "description": "Obtiene el clima actual de una ciudad",
    "input_schema": {
        "type": "object",
        "properties": {
            "city": {"type": "string", "description": "Nombre de la ciudad"},
            "units": {"type": "string", "enum": ["celsius", "fahrenheit"]}
        },
        "required": ["city"]
    }
}]

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "¿Qué tiempo hace en Madrid?"}]
)

# Claude responde con un tool_use block:
# {"type": "tool_use", "name": "get_weather", "input": {"city": "Madrid", "units": "celsius"}}
# Tu app ejecuta get_weather("Madrid", "celsius") y devuelve el resultado

Structured output (JSON mode). Cuando no necesitas tools sino que el LLM devuelva JSON estructurado, usa structured output. OpenAI tiene response_format con JSON schema. Anthropic usa tool use con un solo tool que actúa como schema del output. Google tiene response_mime_type para JSON. Es extremadamente útil para extraer datos, clasificar contenido o generar configuraciones.

Rate limits y retry

Todas las APIs tienen límites de velocidad (rate limits). Si envías demasiadas peticiones por minuto, recibes un error 429 (Too Many Requests). Gestionar esto correctamente es la diferencia entre una app de producción y una demo.

Estrategia de retry con exponential backoff:

import time
import anthropic

client = anthropic.Anthropic()

def call_with_retry(messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            return client.messages.create(
                model="claude-sonnet-4-20250514",
                max_tokens=1024,
                messages=messages
            )
        except anthropic.RateLimitError:
            wait = 2 ** attempt  # 1s, 2s, 4s
            time.sleep(wait)
        except anthropic.APIStatusError as e:
            if e.status_code >= 500:  # Error del servidor, reintentar
                time.sleep(2 ** attempt)
            else:
                raise  # Error del cliente (400, 401), no reintentar
    raise Exception("Max retries exceeded")

Los SDKs de Anthropic y OpenAI incluyen retry automático por defecto. Pero para producción, implementa tu propia lógica para tener control total: timeouts personalizados, logging de reintentos, alertas cuando se superan los límites.

Rate limits típicos (tier 1):

• Anthropic: 50 RPM (requests/min), 40K tokens/min para Claude Sonnet.
• OpenAI: 60 RPM, 30K tokens/min para GPT-4o (tier 1).
• Google: 60 RPM, 1M tokens/min para Gemini 2.5 Pro (free tier generoso).

Los límites suben automáticamente con el uso (tiers). OpenAI y Anthropic tienen 5 tiers. Cuanto más gastas, más límite tienes. Para aplicaciones de alto volumen, solicita un aumento de límites directamente al proveedor.

Precios por API en 2026

El pricing de las APIs de IA se basa en tokens (unidades de texto procesadas). Los precios se dividen en tokens de input (lo que envías) y tokens de output (lo que recibes). El output siempre es más caro porque requiere más computación.

Prompt caching. Anthropic y Google ofrecen prompt caching: si envías el mismo system prompt o contexto en múltiples llamadas, el proveedor lo cachea y cobra solo una fracción. Anthropic cobra el 10% del precio de input para tokens cacheados. Esto es enorme para aplicaciones donde el system prompt es largo y constante (chatbots, agentes con contexto fijo). Puede reducir costes un 50-90% en esos escenarios. Para una comparativa detallada de modelos, consulta nuestro artículo sobre ChatGPT vs Claude vs Gemini.

Ejemplos de código

Tres ejemplos prácticos que cubren los patrones más comunes en aplicaciones reales.

1. Chat completion con historial (Anthropic):

import anthropic

client = anthropic.Anthropic()
conversation = []

def chat(user_message):
    conversation.append({"role": "user", "content": user_message})
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        system="Eres un asistente de soporte técnico. Responde en español, sé conciso.",
        messages=conversation
    )
    assistant_message = response.content[0].text
    conversation.append({"role": "assistant", "content": assistant_message})
    return assistant_message

# Uso
print(chat("No puedo conectarme al WiFi"))
print(chat("Ya reinicié el router"))  # Mantiene el contexto

2. Structured output (extracción de datos):

# Extraer datos estructurados de texto libre
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=[{
        "name": "extract_invoice",
        "description": "Extrae datos de una factura",
        "input_schema": {
            "type": "object",
            "properties": {
                "vendor": {"type": "string"},
                "amount": {"type": "number"},
                "currency": {"type": "string"},
                "date": {"type": "string", "format": "date"},
                "items": {"type": "array", "items": {"type": "string"}}
            },
            "required": ["vendor", "amount", "currency", "date"]
        }
    }],
    tool_choice={"type": "tool", "name": "extract_invoice"},
    messages=[{"role": "user", "content": "Factura de Acme Corp, 15 mayo 2026, 1.500 EUR. Conceptos: consultoría IA, setup automación, formación equipo."}]
)
# Devuelve: {"vendor": "Acme Corp", "amount": 1500, "currency": "EUR", ...}

3. Vision (análisis de imagen):

# Analizar una imagen con Claude
import base64

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

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": [
            {"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": image_data}},
            {"type": "text", "text": "Describe qué muestra esta captura de pantalla y si hay algún error visible."}
        ]
    }]
)

Errores comunes

1. API key en el frontend. El error más grave y más común. Si tu API key está en JavaScript del navegador, cualquiera puede robarla y usarla en tu cuenta. Las llamadas a la API siempre van desde el backend. El frontend llama a tu backend, tu backend llama a la API.

2. No gestionar errores de la API. Las APIs de IA fallan: timeouts, rate limits, errores 500, respuestas vacías. Si tu app no gestiona estos errores, se rompe en producción. Implementa retry con backoff, timeouts, y mensajes de error claros para el usuario.

3. No cachear respuestas. Si 100 usuarios hacen la misma pregunta, no necesitas 100 llamadas a la API. Cachea respuestas para consultas comunes. Redis o un simple diccionario en memoria para prototipos. El ahorro puede ser del 50-70% en aplicaciones con consultas repetitivas.

4. Hardcodear el modelo. Si tu código dice model="gpt-4o" en 50 sitios, cambiar de modelo es un dolor. Usa una variable de configuración o un enum. Mejor aún: una capa de abstracción que te permita cambiar de proveedor (OpenAI a Anthropic) sin tocar la lógica de negocio.

5. No poner límites de gasto. Un bug en un loop puede generar miles de llamadas a la API en minutos. A 0.03 USD por llamada, 10.000 llamadas son 300 USD. Configura siempre un límite de gasto mensual en la consola del proveedor. Y en tu código, pon un max_iterations en cualquier loop que llame a la API.

6. Prompts en el código. Los prompts evolucionan rápido. Si están hardcodeados en funciones Python, cada cambio de prompt es un cambio de código con deploy. Guarda los prompts en archivos separados (YAML, texto) o en una base de datos. Así el equipo de producto puede iterar prompts sin tocar código. Para saber cuándo elegir API vs modelos locales, consulta nuestra guía sobre agentes de IA.

Preguntas frecuentes