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. Está actualizado a agosto de 2026: los modelos, los precios y la API recomendada han cambiado varias veces desde 2024, y buena parte de los tutoriales que encontrarás por ahí siguen enseñando la forma antigua.

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 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	No se entrena con datos de API por defecto

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

Un detalle que confunde a mucha gente: tu suscripción de ChatGPT Plus no incluye créditos de API. Son dos productos y dos facturaciones distintas. Puedes pagar ChatGPT Plus y tener 0 € de saldo de API.

Crear tu API key

1. En el menú lateral, ve a 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. GitHub detecta las claves de OpenAI automáticamente y OpenAI las revoca al detectarlas, pero para entonces alguien ya ha podido gastar tu saldo.

Configurar facturación

1. Ve a Settings > Billing
2. Añade un método de pago (tarjeta de crédito/débito)
3. Carga saldo inicial. La API funciona con crédito de prepago y la recarga mínima está en torno a los 5 $. Con los ejemplos de este tutorial gastarás céntimos.
4. Configura un límite de gasto mensual en la sección de límites. Recomiendo empezar con 5 o 10 €.
5. Activa las alertas de uso para que te avise cuando llegues al 50% y al 80% del límite

Sin saldo, la API devuelve un error de cuota agotada. Es el error número uno de todo el que empieza: no es que tu código esté mal, es que no has cargado crédito.

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 una versión reciente (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

Error típico aquí: si ya tenías instalada la librería de hace tiempo, puede ser una versión antigua que no conoce los métodos actuales. Fuerza la actualización con pip install --upgrade openai. Si un ejemplo de este tutorial te da un error del tipo "Client object has no attribute", es exactamente esto.

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

Aquí está el primer cambio importante frente a los tutoriales antiguos. OpenAI recomienda hoy la Responses API para proyectos nuevos, no la vieja Chat Completions. Es más simple, y es la que recibe las funciones nuevas.

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.responses.create(
    model="gpt-5.6-luna",
    instructions="Eres un asistente útil que responde en español.",
    input="¿Qué es la inteligencia artificial en 3 frases?"
)

#Imprimir la respuesta
print(response.output_text)

Ejecútalo:

python main.py

Si todo está bien configurado, verás la respuesta en tu terminal. Felicidades: acabas de hacer tu primera llamada a la API.

Fíjate en lo simple que es comparado con el formato antiguo: instructions sustituye al mensaje de sistema, input a la lista de mensajes, y response.output_text te da el texto directamente sin bucear en choices[0].message.content.

Y si prefieres (o necesitas) chat completions

La API antigua sigue funcionando y muchísimo código en producción la usa. Si trabajas sobre un proyecto ya existente, o sigues un tutorial de terceros, este es el formato:

response = client.chat.completions.create(
    model="gpt-5.6-luna",
    messages=[
        {"role": "system", "content": "Eres un asistente útil que responde en español."},
        {"role": "user", "content": "¿Qué es la inteligencia artificial en 3 frases?"}
    ]
)
print(response.choices[0].message.content)

Las dos funcionan. Para empezar de cero, usa Responses.

Paso 4: entender la estructura de la petición

Vamos a descomponer cada parte de la petición.

El modelo

model="gpt-5.6-luna"

El modelo que usas determina la calidad y el coste. Estos son los precios oficiales publicados por OpenAI en agosto de 2026, por millón de tokens:

Modelo	Entrada	Entrada cacheada	Salida	Cuándo usarlo
gpt-5.6-luna	0,20 $	0,02 $	1,20 $	Uso general, chatbots, alto volumen
gpt-5.6-terra	2,00 $	0,20 $	12,00 $	Equilibrio calidad-precio en producción
gpt-5.6-sol	5,00 $	0,50 $	30,00 $	Tareas complejas, razonamiento exigente
gpt-5.4-mini	0,75 $	0,075 $	4,50 $	Generación anterior, todavía útil
gpt-5.4-nano	0,20 $	0,02 $	1,25 $	Clasificación y tareas simples masivas
gpt-4.1-mini	0,40 $	0,10 $	1,60 $	Modelo antiguo, solo por compatibilidad
gpt-4o-mini	0,15 $	0,075 $	0,60 $	Muy antiguo: no lo elijas para proyectos nuevos

Mi recomendación: empieza siempre con gpt-5.6-luna. Es sorprendentemente bueno y muy barato. Sube a gpt-5.6-terra cuando Luna no dé el resultado que necesitas, y a gpt-5.6-sol solo para lo que realmente lo pida.

Y una advertencia sobre lo que vas a leer por internet: si un tutorial te dice que uses gpt-4o o gpt-4o-mini, está desfasado. Esos modelos siguen respondiendo por compatibilidad, pero son de 2024 y hay opciones mejores y más baratas. Lo mismo con gpt-4-turbo y gpt-3.5-turbo: son historia. Consulta siempre la página de precios oficial antes de fijar un modelo, porque OpenAI publica familias nuevas cada pocos meses.

Fíjate también en la columna de entrada cacheada: si repites el mismo prefijo de prompt en muchas peticiones (un system prompt largo, un manual, un catálogo), OpenAI lo cachea y te lo cobra a una décima parte. Es la optimización de coste más rentable que existe y no requiere tocar nada más que el orden de tu prompt: lo estable primero, lo que cambia al final.

La entrada

instructions="...",
input="..."

• instructions: las instrucciones de comportamiento del modelo. Define personalidad, reglas, formato de respuesta. Es el equivalente al antiguo mensaje de sistema.
• input: lo que quieres que procese, sea una pregunta del usuario o un texto.

Para una conversación con memoria, input acepta también una lista de mensajes con sus roles:

response = client.responses.create(
    model="gpt-5.6-luna",
    instructions="Eres un asistente de cocina.",
    input=[
        {"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?"},
    ]
)

Recuerda que la API no tiene memoria: cada petición es independiente. Si quieres que el modelo recuerde la conversación, tienes que enviarle el historial completo cada vez. Y eso cuesta tokens, así que en conversaciones largas conviene recortar o resumir el historial.

Paso 5: parámetros importantes

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

Reasoning effort (cuánto piensa el modelo)

Este es el otro gran cambio respecto a los tutoriales antiguos. Los modelos actuales de OpenAI son modelos de razonamiento, y el parámetro que de verdad mueve la aguja no es la temperatura: es cuánto esfuerzo de razonamiento dedican antes de responder.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Analiza este caso y dame una recomendación...",
    reasoning={"effort": "low"}
)

Los niveles disponibles van de none a max, pasando por low, medium, high y xhigh. La regla práctica:

Nivel	Cuándo usarlo
none / low	Clasificación, extracción de datos, respuestas cortas, alto volumen
medium	Uso general: el punto de equilibrio para la mayoría de aplicaciones
high	Análisis, código, problemas de varios pasos
xhigh / max	Solo cuando la calidad importa más que el coste y la latencia

Ojo con el coste: los tokens de razonamiento se facturan como tokens de salida, que son los caros. Subir el effort de low a high puede multiplicar por varias veces el coste de la misma petición. Empieza siempre bajo y sube solo si la calidad no llega.

Max output tokens (longitud de respuesta)

max_output_tokens=500  # Limita la respuesta

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.

Cuidado: en modelos de razonamiento este límite incluye los tokens de razonamiento, no solo el texto que ves. Si pones un límite muy bajo con effort alto, puedes acabar con una respuesta vacía porque se ha gastado todo el presupuesto pensando. Si te pasa, sube max_output_tokens o baja el effort.

Temperature

En los modelos anteriores, temperature era el mando principal de creatividad, con valores de 0 (determinista) a 2 (caótico). En los modelos de razonamiento actuales su papel es mucho menor y algunos no lo admiten. Si estás en un proyecto que todavía usa modelos antiguos, sigue siendo válido; si empiezas hoy, controla el comportamiento con reasoning.effort y con instrucciones claras en el prompt.

Pro tip: para la mayoría de aplicaciones, reasoning.effort en low o medium y max_output_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()

INSTRUCCIONES = "Eres un asistente amigable que ayuda con preguntas sobre tecnología. Responde de forma concisa y en español."

#Historial de la conversación
history = []

def chat(user_message):
    # Añadir mensaje del usuario al historial
    history.append({"role": "user", "content": user_message})

    # Hacer la petición con todo el historial
    response = client.responses.create(
        model="gpt-5.6-luna",
        instructions=INSTRUCCIONES,
        input=history,
        max_output_tokens=500
    )

    assistant_message = response.output_text

    # Añadir respuesta al historial
    history.append({"role": "assistant", "content": assistant_message})

    # Recortar el historial para que no crezca sin control
    if len(history) > 20:
        del history[:2]

    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
    print(f"\nIA: {chat(user_input)}")

Ese recorte del historial de las últimas líneas es la diferencia entre un chatbot que cuesta céntimos y uno que se te dispara: sin él, cada mensaje reenvía toda la conversación y el coste crece de forma cuadrática.

Ejemplo 2: clasificador de sentimiento

def clasificar_sentimiento(texto):
    response = client.responses.create(
        model="gpt-5.6-luna",
        instructions="Clasifica el sentimiento del texto como POSITIVO, NEGATIVO o NEUTRO. Responde SOLO con la clasificación, nada más.",
        input=texto,
        reasoning={"effort": "none"},
        max_output_tokens=10
    )
    return response.output_text.strip()

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:
    print(f"{clasificar_sentimiento(texto)}: {texto}")

Para clasificar, effort en none o low es lo correcto: no quieres que el modelo divague, quieres una etiqueta.

Ejemplo 3: generador de contenido en lote

def generar_meta_description(titulo_articulo):
    response = client.responses.create(
        model="gpt-5.6-luna",
        instructions="Genera meta descriptions para SEO. Máximo 155 caracteres. Incluye un CTA implícito. En español.",
        input=f"Título del artículo: {titulo_articulo}",
        max_output_tokens=100
    )
    return response.output_text.strip()

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"
]

for titulo in articulos:
    meta = generar_meta_description(titulo)
    print(f"Título: {titulo}")
    print(f"Meta: {meta}")
    print("-" * 40)

Ejemplo 4: salida estructurada (el que más te va a servir)

Cuando integras IA en software real, casi nunca quieres texto libre: quieres un objeto con campos concretos. La forma frágil de hacerlo es pedir "devuélveme un JSON" y cruzar los dedos. La forma correcta es forzar el esquema:

schema = {
    "type": "object",
    "properties": {
        "sentimiento": {"type": "string", "enum": ["POSITIVO", "NEGATIVO", "NEUTRO"]},
        "puntuacion": {"type": "integer"},
        "motivo": {"type": "string"}
    },
    "required": ["sentimiento", "puntuacion", "motivo"],
    "additionalProperties": False
}

response = client.responses.create(
    model="gpt-5.6-luna",
    instructions="Analiza la reseña del cliente.",
    input="El envío tardó una semana pero el producto es excelente.",
    text={"format": {"type": "json_schema", "name": "analisis", "schema": schema, "strict": True}}
)

import json
datos = json.loads(response.output_text)
print(datos["sentimiento"], datos["puntuacion"])

Con strict: True la respuesta cumple el esquema siempre. Se acabaron los try/except alrededor de un json.loads que falla una de cada veinte veces.

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

Cálculos reales con gpt-5.6-luna (0,20 $ por millón de tokens de entrada y 1,20 $ de salida):

• 1 petición típica (500 tokens de entrada + 500 de salida) ≈ 0,0007 $
• 100 peticiones al día ≈ 0,07 $/día ≈ 2 $/mes
• 1.000 peticiones al día ≈ 0,70 $/día ≈ 21 $/mes

Con gpt-5.6-terra esos números se multiplican por unas diez veces, y con gpt-5.6-sol por unas veinticinco. De ahí la insistencia en empezar por el modelo pequeño.

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

Cómo controlar los costes

1. Configura límites de gasto en los ajustes de facturación

   • Presupuesto mensual: el máximo que estás dispuesto a gastar
   • Umbral de alerta: te avisa antes de llegar al límite

2. Usa el modelo más barato que funcione. Luna para el 90% de las cosas, Terra o Sol solo cuando haga falta.

3. Baja el reasoning effort. Es el parámetro que más afecta a la factura en los modelos actuales y el que menos gente toca.

4. Ordena el prompt para aprovechar la caché. Pon lo que no cambia (instrucciones, contexto fijo) al principio y lo variable al final. Los tokens cacheados cuestan una décima parte.

5. Limita max_output_tokens. Si no necesitas respuestas largas, ponlo en 200-300.

6. Cachea respuestas tú también. Si la misma pregunta se repite, guarda la respuesta y devuélvela sin llamar a la API.

7. Usa la Batch API para trabajo no urgente. Si puedes esperar unas horas al resultado, procesar en lote sale bastante más barato que petición a petición.

8. Monitoriza el uso. Revisa el panel de consumo semanalmente.

Ver el coste de cada petición

response = client.responses.create(...)

print(f"Tokens entrada: {response.usage.input_tokens}")
print(f"Tokens salida:  {response.usage.output_tokens}")
print(f"Total:          {response.usage.total_tokens}")

#Coste estimado con gpt-5.6-luna
coste = (response.usage.input_tokens * 0.20 / 1_000_000
         + response.usage.output_tokens * 1.20 / 1_000_000)
print(f"Coste estimado: ${coste:.6f}")

Mete esto en tus pruebas desde el primer día. Ver el número real cambia por completo la forma en que diseñas los prompts.

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(prompt, max_reintentos=3):
    for intento in range(max_reintentos):
        try:
            response = client.responses.create(
                model="gpt-5.6-luna",
                input=prompt
            )
            return response.output_text

        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."

Los tres errores que vas a ver de verdad:

• insufficient_quota: no tienes saldo. No es un bug de tu código, es la cartera. Carga crédito.
• RateLimitError: has superado el límite de peticiones por minuto de tu nivel de cuenta. Los niveles suben automáticamente conforme acumulas gasto e historial. Reintenta con espera exponencial.
• model_not_found: el nombre del modelo no existe o tu cuenta no tiene acceso. Casi siempre es un modelo antiguo copiado de un tutorial viejo.

Pro tip: Siempre implementa reintentos con espera exponencial para RateLimitError. Es la forma estándar de manejar rate limits en cualquier API. La librería oficial ya reintenta por su cuenta un par de veces, pero conviene tener control explícito.

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 por partes, como en ChatGPT:

stream = client.responses.create(
    model="gpt-5.6-luna",
    input="Escribe un poema corto sobre la tecnología",
    stream=True
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

print()  # Nueva línea al final

El streaming es esencial para cualquier interfaz de usuario. Nadie quiere esperar diez segundos mirando una pantalla en blanco, y con modelos de razonamiento la espera puede ser aún mayor.

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.

Copiar nombres de modelo de tutoriales antiguos. gpt-4o, gpt-4-turbo, gpt-3.5-turbo son modelos de otra era. Van a funcionar, pero pagas más por peor resultado. Comprueba siempre la lista oficial de modelos.

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 cuesta dinero. Limita el historial a las últimas N interacciones o usa resúmenes.

No aprovechar la caché de prompt. Si tu system prompt es largo y siempre igual, ponlo al principio y déjalo idéntico entre peticiones. Ahorra un 90% en esa parte.

Pedir JSON en el prompt en vez de forzar el esquema. Usa salida estructurada con strict y te ahorras el 100% de los errores de parseo.

Usar reasoning effort alto por defecto. Es lo que más encarece las peticiones en los modelos actuales, y en la mayoría de tareas no mejora nada.

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 + saldo cargado
2. Python + librería openai actualizada
3. Entiendes la Responses API, sus parámetros y qué modelo elegir
4. Sabes controlar costes y manejar errores
5. Tienes ejemplos prácticos que puedes adaptar

Los próximos pasos naturales:

• Function calling / tools: permite que el modelo ejecute funciones de tu código. Es la base de cualquier agente.
• Embeddings: convierte texto en vectores para búsqueda semántica. Cuestan una miseria (text-embedding-3-small está a 0,02 $ por millón de tokens) y son la puerta de entrada a construir un sistema de búsqueda sobre tus propios documentos con RAG.
• Agentes: cuando quieras que el modelo encadene herramientas y decida por sí mismo, el siguiente paso es el tutorial para crear tu primer agente de IA.
• Visión: envía imágenes al modelo para análisis visual.

Y si estás decidiendo qué proveedor usar antes de comprometerte con OpenAI, en la comparativa de APIs de IA en 2026 están puestas una al lado de otra con sus precios.

Pero no te adelantes. Domina primero lo básico de la Responses API, 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.

Preguntas frecuentes

¿Cuánto cuesta la API de OpenAI?

Se paga por tokens consumidos, no por suscripción. Con el modelo más barato de la generación actual, gpt-5.6-luna, son 0,20 $ por millón de tokens de entrada y 1,20 $ de salida, lo que sitúa un proyecto pequeño entre 2 y 30 € al mes. Los modelos más potentes cuestan de diez a veinticinco veces más, así que el modelo que elijas manda sobre la factura.

¿La API de OpenAI es gratis? ¿Hay créditos de prueba?

No hay un plan gratuito permanente. Antes se daban créditos de bienvenida, pero hoy lo normal es tener que cargar saldo para empezar; la recarga mínima ronda los 5 $. Ojo: pagar ChatGPT Plus no te da crédito de API, son productos y facturaciones distintas.

¿Qué modelo de OpenAI debo usar para empezar?

gpt-5.6-luna. Es el más barato de la generación actual, suficiente para la enorme mayoría de tareas y te permite equivocarte sin arruinarte. Sube a gpt-5.6-terra cuando la calidad no llegue y reserva gpt-5.6-sol para razonamiento realmente exigente.

¿Sigue funcionando gpt-4o o gpt-4o-mini?

Sí, siguen respondiendo por compatibilidad y aparecen en la tabla de precios oficial, pero son modelos de 2024 y hoy no tienen sentido para un proyecto nuevo: hay opciones más baratas y mejores en la familia actual. Si un tutorial te los recomienda como opción principal, está desactualizado.

¿Cuál es la diferencia entre la Responses API y chat completions?

Chat Completions es la interfaz clásica, basada en una lista de mensajes con roles. Responses es la actual y la que OpenAI recomienda para proyectos nuevos: es más simple, devuelve el texto en output_text y es donde se van añadiendo las funciones nuevas. Chat Completions sigue soportada, así que el código existente no se rompe.

¿Cómo evito llevarme un susto con la factura de la API?

Tres cosas, en este orden: configura un límite de gasto mensual en el panel de facturación antes de escribir la primera línea de código, usa el modelo más barato que resuelva tu caso, y baja el reasoning.effort. Y mide: imprime response.usage en tus pruebas para ver el coste real de cada llamada.

¿Puedo usar la API de OpenAI desde JavaScript en el navegador?

Técnicamente sí, pero nunca debes hacerlo: la clave quedaría visible para cualquiera que abra las herramientas de desarrollador y podrían gastar tu saldo. La forma correcta es llamar a la API desde tu servidor o desde una función serverless, y que el navegador hable solo con tu backend.

¿OpenAI entrena sus modelos con los datos que envío por API?

No por defecto. Los datos enviados a través de la API no se usan para entrenar los modelos salvo que lo actives expresamente, a diferencia de lo que ocurre en las cuentas personales de ChatGPT. Aun así, si vas a tratar datos personales, revisa el acuerdo de tratamiento de datos y la política de retención antes de subir nada.

¿Qué es el reasoning effort y cómo afecta al precio?

Es el parámetro que decide cuánto "piensa" el modelo antes de responder, con niveles que van de none a max. Los tokens de razonamiento se facturan como tokens de salida, que son los caros, así que subir el nivel puede multiplicar el coste de la misma petición. Empieza en low o medium y sube solo si la calidad no basta.

¿Por qué me da error de cuota si acabo de crear la cuenta?

Porque no has cargado saldo. Es el fallo número uno de quien empieza: la cuenta existe y la clave es válida, pero sin crédito de prepago la API devuelve insufficient_quota. Entra en la sección de facturación, añade método de pago y carga el mínimo. No es un problema de tu código.