Cómo Usar la API de OpenAI: Tutorial para Principiantes

La API de OpenAI es la puerta de entrada a integrar inteligencia artificial en cualquier proyecto. No importa si quieres crear un chatbot, automatizar la generación de contenido, analizar sentimientos o construir cualquier aplicación con IA: todo empieza aquí.

Y la buena noticia es que usarla es mucho más fácil de lo que parece. Si sabes copiar y pegar código, puedes hacer tu primera petición a la API en 10 minutos.

En este tutorial vamos desde cero absoluto hasta tener una aplicación funcional que usa la API de OpenAI.

Qué es la API de OpenAI

Antes de empezar, aclaremos qué es y qué no es:

• Es: Un servicio web que te permite enviar texto a los modelos de OpenAI (GPT-4o, GPT-4, etc.) y recibir respuestas de forma programática
• No es: ChatGPT. ChatGPT es el producto final para consumidores. La API es la herramienta para que tú construyas tus propios productos

¿Por qué usar la API en vez de ChatGPT?

Aspecto	ChatGPT	API de OpenAI
Interacción	Chat manual en el navegador	Programática, automatizable
Personalización	Limitada (GPTs)	Total (tú controlas todo)
Integración	Copiar/pegar	Se integra en tu software
Escalabilidad	Una conversación a la vez	Miles de peticiones simultáneas
Coste	20€/mes fijo	Pago por uso (puede ser más barato o más caro)
Datos	Los datos pasan por OpenAI	Puedes configurar data privacy

Si necesitas IA dentro de tu aplicación, producto o flujo automatizado, necesitas la API.

Paso 1: Crear una Cuenta y Obtener tu API Key

Registro

1. Ve a platform.openai.com
2. Regístrate con tu email, Google o Microsoft
3. Verifica tu número de teléfono (obligatorio)
4. Accede al dashboard

Crear tu API Key

1. En el menú lateral, ve a API Keys (o directamente a platform.openai.com/api-keys)
2. Haz clic en "Create new secret key"
3. Ponle un nombre descriptivo ("mi-proyecto-tutorial", por ejemplo)
4. COPIA LA KEY INMEDIATAMENTE. Solo la verás una vez. Si la pierdes, tienes que crear otra.
5. Guárdala en un lugar seguro. Un archivo .env, un gestor de contraseñas, pero NUNCA en tu código fuente ni en un repo de Git.

IMPORTANTE: Tu API key es como una contraseña. Si alguien la obtiene, puede hacer peticiones a tu cuenta y te cobrarán a ti. Nunca la compartas, nunca la subas a GitHub.

Configurar facturación

1. Ve a Settings > Billing
2. Añade un método de pago (tarjeta de crédito/débito)
3. Configura un límite de gasto mensual (recomiendo empezar con 10€ para el tutorial)
4. Activa las alertas de uso para que te avise cuando llegues al 50% y al 80% del límite

Sin método de pago, la API no funcionará. Pero tranquilo, con los ejemplos de este tutorial gastarás céntimos.

Paso 2: Preparar el Entorno de Desarrollo

Vamos a usar Python porque es el lenguaje más sencillo y tiene la librería oficial de OpenAI. Pero la API funciona con cualquier lenguaje que pueda hacer peticiones HTTP.

Instalar Python (si no lo tienes)

1. Ve a python.org/downloads
2. Descarga la última versión (3.11 o superior)
3. Instala marcando la opción "Add Python to PATH"
4. Verifica abriendo un terminal y escribiendo:

python --version

Crear tu proyecto

# Crear carpeta del proyecto
mkdir mi-primer-proyecto-openai
cd mi-primer-proyecto-openai

# Crear entorno virtual (recomendado)
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate

# Instalar la librería de OpenAI
pip install openai python-dotenv

Configurar tu API Key de forma segura

Crea un archivo .env en la raíz del proyecto:

OPENAI_API_KEY=sk-tu-api-key-aqui

Crea un archivo .gitignore para que nunca se suba al repositorio:

.env
venv/
__pycache__/

Paso 3: Tu Primera Petición a la API

Crea un archivo main.py:

from openai import OpenAI
from dotenv import load_dotenv

# Cargar la API key desde .env
load_dotenv()

# Crear el cliente
client = OpenAI()

# Hacer la petición
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Eres un asistente útil que responde en español."},
        {"role": "user", "content": "¿Qué es la inteligencia artificial en 3 frases?"}
    ]
)

# Imprimir la respuesta
print(response.choices[0].message.content)

Ejecútalo:

python main.py

Si todo está bien configurado, verás la respuesta de GPT-4o-mini en tu terminal. Felicidades, acabas de hacer tu primera llamada a la API.

Paso 4: Entender la Estructura de la Petición

Vamos a descomponer cada parte de la petición:

El modelo

model="gpt-4o-mini"

El modelo que usas determina la calidad y el coste:

Modelo	Calidad	Velocidad	Coste (input/1M tokens)	Coste (output/1M tokens)	Cuándo usarlo
gpt-4o	Muy alta	Rápido	~2.50$	~10.00$	Tareas complejas, análisis
gpt-4o-mini	Alta	Muy rápido	~0.15$	~0.60$	Uso general, chatbots
gpt-4-turbo	Muy alta	Medio	~10.00$	~30.00$	Proyectos que necesitan máxima calidad
gpt-3.5-turbo	Media	Muy rápido	~0.50$	~1.50$	Tareas simples, alto volumen

Mi recomendación: Empieza siempre con gpt-4o-mini. Es sorprendentemente bueno y muy barato. Solo sube a gpt-4o cuando gpt-4o-mini no dé el resultado que necesitas.

Los mensajes

messages=[
    {"role": "system", "content": "..."},
    {"role": "user", "content": "..."},
]

La API usa un formato de conversación con tres roles:

• system: Instrucciones de comportamiento para el modelo. Define personalidad, reglas, formato de respuesta. Se envía una vez al principio.
• user: Lo que dice el usuario humano.
• assistant: Lo que ha respondido el modelo anteriormente (para mantener el contexto de la conversación).

Para una conversación con memoria, envías todo el historial:

messages=[
    {"role": "system", "content": "Eres un asistente de cocina."},
    {"role": "user", "content": "Dame una receta de tortilla."},
    {"role": "assistant", "content": "Aquí tienes una receta de tortilla española..."},
    {"role": "user", "content": "¿Puedo hacerla sin cebolla?"},
]

Paso 5: Parámetros Importantes

Estos son los parámetros que controlan el comportamiento del modelo:

Temperature (creatividad)

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[...],
    temperature=0.7  # Valor entre 0 y 2
)

Valor	Comportamiento	Cuándo usarlo
0	Determinista, siempre igual	Extracción de datos, clasificación
0.3	Bastante consistente	Resúmenes, análisis
0.7	Equilibrado (por defecto)	Uso general
1.0	Creativo	Brainstorming, escritura creativa
1.5-2.0	Muy aleatorio	Casi nunca útil

Max tokens (longitud de respuesta)

max_tokens=500  # Limita la respuesta a 500 tokens

Un token es aproximadamente 3/4 de una palabra en español. 500 tokens son unas 375 palabras. Esto controla el largo máximo de la respuesta y también afecta al coste.

Top_p (muestreo)

top_p=0.9  # Alternativa a temperature

Otra forma de controlar la aleatoriedad. Si usas top_p, pon temperature en 1. No sueles necesitar ajustar los dos.

Pro tip: Para la mayoría de aplicaciones, temperature entre 0 y 0.7 y max_tokens ajustado a tus necesidades es todo lo que necesitas tocar.

Paso 6: Ejemplos Prácticos

Ejemplo 1: Chatbot con memoria

from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()

# Historial de la conversación
history = [
    {"role": "system", "content": "Eres un asistente amigable que ayuda con preguntas sobre tecnología. Responde de forma concisa y en español."}
]

def chat(user_message):
    # Añadir mensaje del usuario al historial
    history.append({"role": "user", "content": user_message})
    
    # Hacer la petición
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=history,
        temperature=0.7,
        max_tokens=500
    )
    
    # Extraer respuesta
    assistant_message = response.choices[0].message.content
    
    # Añadir respuesta al historial
    history.append({"role": "assistant", "content": assistant_message})
    
    return assistant_message

# Bucle de conversación
print("Chat con IA (escribe 'salir' para terminar)")
print("-" * 40)

while True:
    user_input = input("\nTú: ")
    if user_input.lower() == "salir":
        break
    response = chat(user_input)
    print(f"\nIA: {response}")

Ejemplo 2: Clasificador de sentimiento

def clasificar_sentimiento(texto):
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": """Clasifica el sentimiento del texto como POSITIVO, NEGATIVO o NEUTRO.
            Responde SOLO con la clasificación, nada más."""},
            {"role": "user", "content": texto}
        ],
        temperature=0,  # Determinista para clasificación
        max_tokens=10
    )
    return response.choices[0].message.content.strip()

# Ejemplos
textos = [
    "Me encanta este producto, es increíble",
    "El servicio fue horrible, nunca volveré",
    "El paquete llegó el martes por la tarde"
]

for texto in textos:
    sentimiento = clasificar_sentimiento(texto)
    print(f"{sentimiento}: {texto}")

Ejemplo 3: Generador de contenido en lote

import json

def generar_meta_description(titulo_articulo):
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "Genera meta descriptions para SEO. Máximo 155 caracteres. Incluye un CTA implícito. En español."},
            {"role": "user", "content": f"Título del artículo: {titulo_articulo}"}
        ],
        temperature=0.5,
        max_tokens=100
    )
    return response.choices[0].message.content.strip()

# Procesar una lista de artículos
articulos = [
    "Cómo empezar a invertir en bolsa desde cero",
    "Las mejores recetas de cocina para principiantes",
    "Guía completa de marketing digital para pymes"
]

resultados = []
for titulo in articulos:
    meta = generar_meta_description(titulo)
    resultados.append({"titulo": titulo, "meta_description": meta})
    print(f"Título: {titulo}")
    print(f"Meta: {meta}")
    print("-" * 40)

Paso 7: Control de Costes

Este es el tema que más preocupa a la gente. Y con razón, porque sin control puedes llevarte un susto.

Cuánto cuesta realmente

Vamos a hacer cálculos reales con gpt-4o-mini (el modelo más coste-efectivo):

• 1 petición típica (500 tokens input + 500 tokens output) = ~0.0004$
• 100 peticiones al día = ~0.04$/día = ~1.20$/mes
• 1000 peticiones al día = ~0.40$/día = ~12$/mes

Para la mayoría de proyectos personales y de pequeña empresa, el coste mensual está entre 1 y 20 euros.

Cómo controlar los costes

1. Configura límites de gasto en Settings > Billing > Usage limits

   • Monthly budget: el máximo que estás dispuesto a gastar
   • Alert threshold: te avisa antes de llegar al límite

2. Usa el modelo más barato que funcione. gpt-4o-mini para el 90% de las cosas, gpt-4o solo cuando necesites máxima calidad.

3. Limita max_tokens. Si no necesitas respuestas largas, ponlo en 200-300.

4. Cachea respuestas. Si la misma pregunta se repite, guarda la respuesta y devuélvela sin llamar a la API.

5. Monitoriza el uso. Revisa el dashboard de Usage semanalmente.

Script para monitorizar costes

# Ver el uso de la respuesta
response = client.chat.completions.create(...)

# Tokens utilizados
print(f"Tokens input: {response.usage.prompt_tokens}")
print(f"Tokens output: {response.usage.completion_tokens}")
print(f"Total tokens: {response.usage.total_tokens}")

# Coste estimado (gpt-4o-mini)
input_cost = response.usage.prompt_tokens * 0.00000015
output_cost = response.usage.completion_tokens * 0.0000006
total_cost = input_cost + output_cost
print(f"Coste estimado: ${total_cost:.6f}")

Paso 8: Manejo de Errores

Tu aplicación va a fallar si no manejas errores. La API puede fallar por varias razones:

from openai import OpenAI, RateLimitError, APIError, AuthenticationError
import time

client = OpenAI()

def llamar_api_con_reintentos(messages, max_reintentos=3):
    for intento in range(max_reintentos):
        try:
            response = client.chat.completions.create(
                model="gpt-4o-mini",
                messages=messages,
                temperature=0.7
            )
            return response.choices[0].message.content
        
        except AuthenticationError:
            print("Error: API key inválida o expirada.")
            raise  # No reintentar, es un error de configuración
        
        except RateLimitError:
            espera = 2 ** intento  # Espera exponencial: 1s, 2s, 4s
            print(f"Rate limit alcanzado. Esperando {espera}s...")
            time.sleep(espera)
        
        except APIError as e:
            print(f"Error de API: {e}. Reintentando...")
            time.sleep(1)
    
    return "Error: No se pudo obtener respuesta después de varios intentos."

Pro tip: Siempre implementa reintentos con espera exponencial para RateLimitError. Es la forma estándar de manejar rate limits en cualquier API.

Paso 9: Streaming (Respuestas en Tiempo Real)

Por defecto, la API espera a generar toda la respuesta antes de enviarla. Con streaming, recibes la respuesta token por token, como en ChatGPT:

stream = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "user", "content": "Escribe un poema corto sobre la tecnología"}
    ],
    stream=True  # Activar streaming
)

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

print()  # Nueva línea al final

El streaming es esencial para cualquier interfaz de usuario. Nadie quiere esperar 10 segundos mirando una pantalla en blanco.

Errores Comunes

Exponer la API key en el frontend. Nunca pongas tu API key en JavaScript del navegador. Cualquiera puede verla. Siempre haz las llamadas desde tu servidor (backend).

No poner límites de gasto. Configura un límite mensual antes de empezar a desarrollar. Si hay un bug que hace llamadas en bucle, el límite te protege.

Enviar demasiado contexto. Cada token del historial de mensajes cuesta dinero. Limita el historial a las últimas N conversaciones o usa resúmenes.

No cachear respuestas repetidas. Si 100 usuarios preguntan lo mismo, no hagas 100 llamadas a la API. Cachea la primera respuesta.

Usar temperature alta para tareas deterministas. Si clasificas datos o extraes información, temperature debe ser 0. Temperature alta = respuestas diferentes cada vez.

Conclusión y Próximos Pasos

Ya tienes todo lo que necesitas para empezar a usar la API de OpenAI en tus proyectos. Recapitulando:

1. Cuenta + API key + billing configurado
2. Python + librería openai instalada
3. Entiendes la estructura de mensajes y parámetros
4. Sabes controlar costes y manejar errores
5. Tienes ejemplos prácticos que puedes adaptar

Los próximos pasos naturales:

• Function calling: Permite que el modelo ejecute funciones de tu código
• Embeddings: Convierte texto en vectores para búsqueda semántica
• Assistants API: Crea asistentes persistentes con herramientas y memoria
• Vision: Envía imágenes al modelo para análisis visual

Pero no te adelantes. Domina primero lo básico de chat completions, que es el 80% de lo que necesitas para la mayoría de proyectos. Empieza con el ejemplo del chatbot, modifícalo para tu caso de uso, y desde ahí evoluciona.