Integrar la API de OpenAI con Python permite añadir generación de texto, clasificación, extracción de información y asistentes conversacionales a tus programas. La parte técnica inicial es sencilla, pero una integración confiable necesita proteger la clave, validar entradas, controlar costes, manejar errores y separar la lógica de la interfaz. En esta guía utilizaremos la API Responses, que es la interfaz recomendada para proyectos nuevos.
Antes de comenzar, revisa cómo usar variables de entorno en Python, crear entornos virtuales con venv, instalar bibliotecas con pip, aplicar try y except y trabajar con JSON en Python.
Las fuentes externas principales son el inicio rápido oficial de la API de OpenAI, la guía oficial de generación de texto y las prácticas de seguridad para aplicaciones.
API y ChatGPT no son lo mismo
ChatGPT es una aplicación para usuarios. La API es un servicio para desarrolladores que se integra mediante código y se factura según el uso y la configuración de la cuenta. Una suscripción a ChatGPT no implica automáticamente crédito para la API. Revisa siempre el panel de la plataforma, los límites y los precios actuales antes de desplegar.
Crear el proyecto
mkdir openai_python
cd openai_python
python -m venv .venv
Activa el entorno. En Windows:
.venv\Scripts\activate
En macOS o Linux:
source .venv/bin/activate
Instala el SDK oficial y python-dotenv:
python -m pip install openai python-dotenv
Guardar la clave de forma segura
Crea una clave en la plataforma de OpenAI y guárdala en un archivo .env local:
OPENAI_API_KEY=tu_clave_aqui
Añade el archivo a .gitignore:
.env
.venv/
__pycache__/
No pegues la clave en GitHub, notebooks públicos, capturas o código del navegador. Las llamadas deben realizarse desde un backend controlado. Si una clave se expone, revócala y crea otra.
Primera solicitud con Responses API
from dotenv import load_dotenv
from openai import OpenAI
load_dotenv()
client = OpenAI()
response = client.responses.create(
model="gpt-5.6",
instructions=(
"Responde en español claro para una persona principiante. "
"No inventes datos que no estén en la pregunta."
),
input="Explica qué es una función de Python en cinco líneas.",
)
print(response.output_text)
El SDK lee OPENAI_API_KEY desde el entorno. instructions define el comportamiento general y input contiene la petición del usuario. El nombre de modelo disponible puede cambiar según la cuenta, por lo que debes revisar la documentación y el panel antes de fijarlo en producción.
Separar la llamada en una función
from openai import OpenAI
client = OpenAI()
def generar_respuesta(pregunta: str) -> str:
pregunta = pregunta.strip()
if not pregunta:
raise ValueError("La pregunta no puede estar vacía")
response = client.responses.create(
model="gpt-5.6",
instructions="Responde de forma breve, precisa y segura.",
input=pregunta,
)
return response.output_text.strip()
Separar la función permite probar la validación, sustituir el cliente durante tests y reutilizar la integración en una CLI, una API o una aplicación web.
Manejar errores
import logging
from openai import APIConnectionError, APIStatusError, RateLimitError
logging.basicConfig(level=logging.INFO)
try:
texto = generar_respuesta("¿Qué es una lista en Python?")
except RateLimitError:
logging.error("Se alcanzó un límite temporal de la API")
except APIConnectionError:
logging.error("No fue posible conectar con la API")
except APIStatusError as error:
logging.error("La API respondió con estado %s", error.status_code)
except ValueError as error:
logging.error("Entrada inválida: %s", error)
else:
print(texto)
No muestres detalles internos al usuario final. Registra un identificador de solicitud cuando esté disponible, pero nunca claves o datos sensibles.
Reintentos limitados
Algunos errores temporales pueden resolverse con reintentos y espera exponencial. El SDK ya puede gestionar determinados reintentos, pero tu aplicación debe definir límites y evitar bucles infinitos.
import time
def ejecutar_con_reintentos(pregunta, max_intentos=3):
for intento in range(max_intentos):
try:
return generar_respuesta(pregunta)
except (RateLimitError, APIConnectionError):
if intento == max_intentos - 1:
raise
time.sleep(2 ** intento)
No reintentes errores de validación o autenticación como si fueran temporales.
Crear un chatbot de terminal
def main():
print("Escribe salir para terminar")
while True:
pregunta = input("Tú: ").strip()
if pregunta.lower() == "salir":
break
try:
respuesta = generar_respuesta(pregunta)
except Exception:
logging.exception("Fallo al generar respuesta")
print("No fue posible responder ahora")
continue
print(f"Asistente: {respuesta}")
if __name__ == "__main__":
main()
Este ejemplo trata cada solicitud de forma independiente. Para conservar contexto, puedes enviar mensajes anteriores o utilizar mecanismos de estado documentados por la API. Limita el historial para controlar privacidad, latencia y consumo.
Usar una estructura de mensajes
historial = [
{"role": "user", "content": "Mi nombre es Ana"},
{"role": "assistant", "content": "Encantado, Ana"},
{"role": "user", "content": "¿Cómo me llamo?"},
]
response = client.responses.create(
model="gpt-5.6",
input=historial,
)
No almacenes conversaciones indefinidamente sin informar al usuario. Define una política de retención y elimina datos que ya no sean necesarios.
Controlar longitud y coste
Las entradas largas y las respuestas extensas aumentan el consumo. Recorta contenido irrelevante, establece límites razonables y registra métricas agregadas. No confíes en el modelo para decidir por sí mismo cuánto gastar.
Antes de publicar, configura presupuestos y alertas en la plataforma. Separa claves de desarrollo y producción y evita compartir una misma clave entre varios proyectos.
Validar la salida
Un modelo puede producir información incorrecta o un formato inesperado. Si la respuesta alimentará otro sistema, utiliza salidas estructuradas cuando corresponda y valida cada campo.
import json
def validar_json(texto):
try:
datos = json.loads(texto)
except json.JSONDecodeError as error:
raise ValueError("La respuesta no contiene JSON válido") from error
if not isinstance(datos, dict):
raise ValueError("Se esperaba un objeto JSON")
return datos
No ejecutes código, SQL o comandos generados sin revisión y restricciones estrictas.
Protección contra instrucciones maliciosas
Si tu aplicación procesa documentos o contenido externo, ese texto puede incluir instrucciones que intenten cambiar el comportamiento. Trata el contenido recuperado como datos, separa claramente las instrucciones del sistema y permite únicamente las herramientas indispensables.
Para acciones sensibles, exige confirmación y autorización del usuario. Un modelo no debe poder enviar pagos, borrar archivos o publicar contenido solamente porque un texto externo lo solicitó.
Privacidad
No envíes contraseñas, tokens, datos financieros o información personal innecesaria. Informa a los usuarios sobre el procesamiento y consulta las políticas vigentes para el tipo de cuenta y servicio utilizado.
Cuando trabajes con datos empresariales, revisa requisitos legales, acuerdos y configuración de retención antes de integrar la API.
Probar sin consumir la API
class ClienteFalso:
def responder(self, pregunta):
return "Respuesta simulada"
def procesar_pregunta(pregunta, cliente):
if not pregunta.strip():
raise ValueError("Pregunta vacía")
return cliente.responder(pregunta)
def test_procesar_pregunta():
assert procesar_pregunta("Hola", ClienteFalso()) == "Respuesta simulada"
Separa el código del proveedor para probar validación, interfaz y almacenamiento sin llamadas reales.
Arquitectura recomendada
openai_python/
├── app/
│ ├── __init__.py
│ ├── servicio_openai.py
│ ├── validacion.py
│ └── interfaz.py
├── tests/
├── .env
├── .gitignore
└── requirements.txt
Centraliza la configuración, evita crear clientes por todas partes y registra errores en una capa controlada.
Errores frecuentes
Los problemas más comunes son usar ejemplos antiguos, exponer la clave, no elegir el intérprete correcto, capturar todas las excepciones sin analizarlas, enviar historiales ilimitados y confiar ciegamente en las respuestas. También es frecuente confundir la cuenta de ChatGPT con la facturación de la API.
Conclusión
Integrar la API de OpenAI con Python empieza con el SDK oficial, una clave protegida y una llamada a Responses API. Para convertir el ejemplo en una aplicación real, añade validación, manejo de errores, límites, pruebas, observabilidad y controles de seguridad. Mantén el modelo y las funciones configurables, consulta documentación actual y diseña la aplicación asumiendo que las respuestas pueden ser incompletas o incorrectas. Así podrás aprovechar la API sin comprometer credenciales, datos ni estabilidad.
