Cómo usar la API de OpenAI y Claude desde Python — Paso a paso

Si llevas un tiempo programando Python y has visto el boom de los LLMs, seguro que te ha pasado: quieres meter ChatGPT o Claude en tu propio script y no sabes por dónde empezar. Esta entrada es la guía paso a paso que me hubiera gustado tener cuando empecé.

Vamos directo al grano. Al final de esta entrada vas a tener un script funcionando que llama tanto a OpenAI como a Claude, recibe respuesta en streaming y maneja errores correctamente.

Lo que necesitas

1. Python 3.10+ instalado.
2. Cuenta y API key en la plataforma que vayas a usar:
   – OpenAI: platform.openai.com
   – Anthropic (Claude): console.anthropic.com
3. Saldo en la cuenta. Las dos plataformas son de pago por uso. Con 5-10 USD tienes para experimentar muchísimo.
4. Un editor decente (PyCharm o VS Code).

⚠️ Importante con las API keys: una key es como una contraseña que da acceso a tu saldo. Nunca la subas a GitHub, nunca la pegues en código que vayas a publicar. Aprende ya a usar variables de entorno (te lo enseño abajo).

Paso 1 — Setup del entorno

Abre una terminal en una carpeta nueva y ejecuta:

# Crear entorno virtual
python -m venv venv
source venv/bin/activate    # Linux/Mac
# venv\Scripts\activate     # Windows

# Instalar las dos librerías
pip install openai anthropic python-dotenv

Después crea un archivo .env (con el punto delante) en la misma carpeta:

OPENAI_API_KEY=sk-tu-clave-de-openai
ANTHROPIC_API_KEY=sk-ant-tu-clave-de-claude

Y un .gitignore para no subir .env por accidente:

venv/
.env
__pycache__/
*.pyc

Ya estás listo para escribir código.

Paso 2 — Primer mensaje a OpenAI

Crea chat_openai.py:

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Eres un asistente que responde en español, con tono casual."},
        {"role": "user", "content": "Explícame qué es una list comprehension en 2 frases."}
    ]
)

print(response.choices[0].message.content)

Ejecuta con python chat_openai.py. Te debería responder algo como:

Una list comprehension es una forma compacta de crear listas en Python en una sola línea, combinando un bucle for con una expresión opcional…

Coste aproximado: menos de 0,001 USD. No es broma, son fracciones de céntimo.

Qué está pasando

• model="gpt-4o-mini": el modelo. gpt-4o-mini es barato y rápido. Para algo más potente: gpt-4o. Hay una lista de modelos en su web.
• messages: una lista de mensajes con role (system, user, assistant) y content.
• response.choices[0].message.content: la respuesta de texto.

Paso 3 — Primer mensaje a Claude

Crea chat_claude.py:

import os
import anthropic
from dotenv import load_dotenv

load_dotenv()

client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    system="Eres un asistente que responde en español, con tono casual.",
    messages=[
        {"role": "user", "content": "Explícame qué es una list comprehension en 2 frases."}
    ]
)

print(response.content[0].text)

Ejecuta. Diferencias con OpenAI:

• El system prompt va aparte (no como mensaje).
• Tienes que indicar max_tokens (cuántos tokens máximos quieres en la respuesta).
• Se accede a response.content[0].text (no a .choices[0]).

Por lo demás, conceptualmente es igual.

Paso 4 — Streaming (recibir respuesta token a token)

Si la respuesta es larga, esperar a que se genere entera te deja con el script congelado. Streaming te permite imprimir cada palabra a medida que llega.

Streaming con OpenAI

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

stream = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Cuéntame un microcuento de programadores."}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
print()

Streaming con Claude

import os
import anthropic
from dotenv import load_dotenv

load_dotenv()
client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

with client.messages.stream(
    model="claude-opus-4-7",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Cuéntame un microcuento de programadores."}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
print()

Verás cómo el texto aparece poco a poco. Mucho mejor experiencia que esperar.

Paso 5 — Conversación multi-turno

Hasta ahora hicimos llamadas de un solo turno. Para una conversación de verdad, mantenemos el historial de mensajes y lo enviamos cada vez.

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

historia = [
    {"role": "system", "content": "Eres un asistente Python en español."}
]

while True:
    pregunta = input("\nTú: ")
    if pregunta.lower() in ("salir", "exit"):
        break

    historia.append({"role": "user", "content": pregunta})

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=historia
    )

    respuesta = response.choices[0].message.content
    historia.append({"role": "assistant", "content": respuesta})
    print(f"\nAsistente: {respuesta}")

Ya tienes un mini-ChatGPT en tu terminal. La clave es mantener el historial completo y enviarlo cada vez — el modelo no recuerda nada por sí solo.

⚠️ Cuidado con el coste: cada turno envías toda la historia previa. En conversaciones largas el coste sube exponencialmente. Para producción real hay que truncar el historial o usar caché de prompts.

Paso 6 — Function calling (la pieza que cambia todo)

Hasta aquí los LLMs solo hablan. Con function calling los conviertes en agentes que pueden llamar a tu código.

Ejemplo: un asistente que puede consultar el tiempo:

import os
import json
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

# Tu funcion real (aqui simulada)
def consultar_tiempo(ciudad):
    return f"En {ciudad} hace 22ºC y soleado."

# Definicion de la herramienta para el LLM
tools = [{
    "type": "function",
    "function": {
        "name": "consultar_tiempo",
        "description": "Consulta el tiempo actual en una ciudad",
        "parameters": {
            "type": "object",
            "properties": {
                "ciudad": {"type": "string", "description": "Nombre de la ciudad"}
            },
            "required": ["ciudad"]
        }
    }
}]

mensajes = [
    {"role": "user", "content": "¿Qué tiempo hace en Madrid?"}
]

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=mensajes,
    tools=tools
)

# El modelo decide llamar a la funcion
tool_call = response.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
resultado = consultar_tiempo(**args)

# Devolvemos el resultado al modelo
mensajes.append(response.choices[0].message)
mensajes.append({
    "role": "tool",
    "tool_call_id": tool_call.id,
    "content": resultado
})

response_final = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=mensajes
)

print(response_final.choices[0].message.content)

El flujo: tú defines herramientas, el modelo decide cuándo usarlas, ejecutas la función real y devuelves el resultado al modelo. Esto es la base de todos los agentes que existen hoy.

Paso 7 — Cuánto cuesta esto realmente

El precio de los LLMs se mide en tokens (1 token ≈ 0,75 palabras en español).

Pricing aproximado en mayo 2026:

En la práctica:
– Una pregunta corta + respuesta corta: 0,0001 – 0,001 USD.
– Una conversación de 20 turnos con contexto: 0,01 – 0,10 USD.
– Un script que procesa 1000 documentos: 1-10 USD según modelo.

💡 Consejo: empieza siempre con el modelo más barato (gpt-4o-mini o claude-haiku). Solo escalas si el resultado no es suficiente. Nunca empieces por Opus “por si acaso” — gastas 100× más sin necesidad.

Errores típicos y cómo manejarlos

import os
from openai import OpenAI, RateLimitError, APIError
from dotenv import load_dotenv

load_dotenv()
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

try:
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": "Hola"}]
    )
    print(response.choices[0].message.content)
except RateLimitError:
    print("Demasiadas peticiones. Espera unos segundos.")
except APIError as e:
    print(f"Error de la API: {e}")
except Exception as e:
    print(f"Error inesperado: {e}")

Errores que vas a ver seguro:
– AuthenticationError: API key incorrecta o no configurada.
– RateLimitError: estás haciendo demasiadas peticiones por minuto.
– BadRequestError: el formato del request es incorrecto.
– InsufficientQuotaError: no tienes saldo en la cuenta.

Tu primer proyecto LLM

Ahora que sabes lo básico, te propongo 3 proyectos por dificultad creciente:

1. Asistente para resumir tus notas. Lees una carpeta de archivos .txt, mandas el contenido al LLM y guardas un resumen en otro archivo.
2. Bot de Telegram que responde preguntas usando GPT-4o-mini y mantiene contexto por usuario.
3. Mini RAG sobre tus documentos: vectorizas N PDFs, cuando preguntas algo el sistema busca los fragmentos relevantes y los manda al LLM con la pregunta.

Cualquiera de los 3 te convierte en alguien que sabe construir con LLMs, no solo usar ChatGPT.

Conclusión

Conectar Python con LLMs es mucho más fácil de lo que parece. En 30 líneas de código tienes un asistente funcional. Lo difícil no es la API — es saber qué construir y cómo manejar bien los costes.

Si te ha resultado útil esta entrada y quieres aprender Python desde la base, en El Pythonista tienes el curso completo en español. Cuando sales de él, conectar APIs como las de OpenAI o Claude es trivial.

Un abrazo,
Oscar