Ir al contenido principal
Español— Elegir un idioma
Menú

Tu primera llamada a la API

Lección 5 de 22 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Tu primera llamada a la API
  2. La llamada más sencilla
  3. Qué contiene realmente la respuesta
  4. Los parámetros que importan
  5. Paso a una entrada estructurada
  6. Nunca dejes una llamada sin protección
  7. Puntos clave

Lección actualizada el 3 de noviembre de 2026 según la documentación de OpenAI: temperature y top_p solo se aceptan con un esfuerzo de razonamiento (reasoning effort) de none, mientras que los modelos GPT-5.6 razonan por defecto (medium). Por tanto, las llamadas que establezcan estos parámetros deben especificar reasoning={"effort": "none"} (API de Respuestas) o reasoning_effort="none" (Completaciones de Chat). Fuentes: Uso de GPT-6 · GPT-5.6 Terra.

Tu primera llamada a la API

Tu entorno está listo: manos a la obra. Estás a punto de realizar tu primera llamada a la API de Respuestas, diseccionar el objeto que devuelve y manipular los parámetros que marcan la diferencia entre una respuesta genérica y una útil.

La llamada más sencilla

Solo necesitas dos parámetros: model, el identificador del modelo que vas a consultar, e input, tu indicación (prompt), que puede ser una cadena de texto o una lista de mensajes, como veremos en breve.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="What is the difference between Python and JavaScript?"
)

print(response.output_text)
# Resultado: Python es un lenguaje versátil orientado a la ciencia de datos
# y al desarrollo backend, mientras que JavaScript se usa principalmente para
# el desarrollo web frontend y backend (vía Node.js)...

Qué contiene realmente la respuesta

output_text es solo un atajo práctico. El objeto response también incluye su ID único —esencial para encadenar intercambios y consultar llamadas en tus registros—, el modelo real utilizado y un desglose del consumo de tokens. Acostúmbrate a registrar estas tres piezas de información desde tus primeros scripts. Esto es lo que te permitirá responder más adelante a la pregunta: «¿Por qué se ha duplicado la factura este mes?».

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Hello, how are you?"
)

# El texto de la respuesta (atajo)
print(response.output_text)

# El ID único de la respuesta
print(f"ID: {response.id}")

# El modelo utilizado
print(f"Modelo: {response.model}")

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

# Resultado:
# ¡Hola! Estoy muy bien, gracias. ¿En qué puedo ayudarte?
# ID: resp_abc123xyz
# Modelo: gpt-5.6-terra
# Tokens de entrada: 14
# Tokens de salida: 19
# Total de tokens: 33

Los parámetros que importan

temperature gobierna la variabilidad de la generación. En 0,0, el modelo elige sistemáticamente la continuación más probable: esta es la configuración para preguntas factuales, extracción de datos y cualquier caso en el que necesites reproducir resultados idénticos. En 1,0, explora más, que es lo que buscas para crear nombres, escritura creativa o generar variantes.

# Temperatura baja (0.0) = determinista, factual
response_factual = client.responses.create(
    model="gpt-5.6-terra",
    reasoning={"effort": "none"},  # temperature requiere effort none
    input="What is the capital of Germany?",
    temperature=0.0
)
print(response_factual.output_text)
# Resultado: La capital de Alemania es Berlín.

# Temperatura alta (1.0) = creativa, variada
response_creative = client.responses.create(
    model="gpt-5.6-terra",
    reasoning={"effort": "none"},  # temperature requiere effort none
    input="Invent a name for a literary café.",
    temperature=1.0
)
print(response_creative.output_text)
# Resultado: "Las Páginas Errantes": un café donde cada mesa lleva
# el nombre de un capítulo famoso.

El parámetro instructions ocupa el lugar del antiguo mensaje de sistema: define el rol, el tono y las restricciones que el modelo debe mantener durante todo el intercambio, independientemente de la pregunta formulada. En el ejemplo siguiente, la misma pregunta hecha sin instrucciones produciría una lista de consejos generales; con ellas, produce recetas.

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions="Eres un experto en cocina francesa. "
                 "Responde siempre sugiriendo recetas.",
    input="No sé qué hacer con los calabacines."
)
print(response.output_text)
# Resultado: Aquí tienes tres ideas para tus calabacines:
# 1. Gratinado de calabacín con queso de cabra...
# 2. Ratatouille provenzal...
# 3. Velouté frío de calabacín con menta...

Por último, max_output_tokens limita la longitud de la respuesta. Se trata de una salvaguarda presupuestaria, no de una instrucción de redacción: la respuesta se corta abruptamente una vez alcanzado el límite. Si deseas una respuesta corta y bien formada, pídelo también en el prompt.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain general relativity.",
    max_output_tokens=100
)
print(response.output_text)
print(f"Tokens usados: {response.usage.output_tokens}")
# La respuesta se truncará aproximadamente en 100 tokens

Paso a una entrada estructurada

Cuando una cadena simple no es suficiente, input acepta una lista de mensajes. La forma mínima contiene un único turno, pero la ventaja aparece en cuanto proporcionas historial: el modelo tiene entonces acceso a lo que ya se ha dicho y responde en consecuencia. Aquí, «mejorar» se entiende en el contexto de Python, no en abstracto.

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": "Translate to English: Hello world"
        }
    ]
)
print(response.output_text)
# Resultado: Hello world

# Con contexto de conversación
response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": "My favorite language is Python."
        },
        {
            "role": "assistant",
            "content": "Python is an excellent choice! It is very versatile."
        },
        {
            "role": "user",
            "content": "Give me a tip to improve."
        }
    ]
)
print(response.output_text)
# Resultado: Para mejorar en Python, te recomiendo que...

Nunca dejes una llamada sin protección

Las llamadas de red fallan y las claves caducan. Tres excepciones cubren la mayoría de los casos al empezar: AuthenticationError por una clave faltante o inválida, RateLimitError cuando superas el throughput permitido y APIError como red de seguridad genérica. Toda una lección volverá sobre la estrategia completa, pero desde hoy, envuelve tus llamadas.

from openai import OpenAI, APIError, AuthenticationError, RateLimitError

client = OpenAI()

try:
    response = client.responses.create(
        model="gpt-5.6-terra",
        input="Hello!"
    )
    print(response.output_text)
except AuthenticationError:
    print("Error: Clave de API inválida o faltante")
except RateLimitError:
    print("Error: Demasiadas solicitudes, espera un momento")
except APIError as e:
    print(f"Error de API: {e.message}")

Para consolidar todo esto, escribe un script que haga tres preguntas y acumule los tokens consumidos. Combinarás el bucle de llamadas, una temperatura de 0,0 para respuestas estables y la lectura de usage: los tres reflejos básicos.

from openai import OpenAI

client = OpenAI()

questions = [
    "What is the largest ocean in the world?",
    "Who painted the Mona Lisa?",
    "How many planets are in the solar system?"
]

total_tokens = 0

for question in questions:
    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requiere effort none
        input=question,
        temperature=0.0
    )
    tokens = response.usage.total_tokens
    total_tokens += tokens
    print(f"P: {question}")
    print(f"R: {response.output_text}")
    print(f"   ({tokens} tokens)\n")

print(f"Total: {total_tokens} tokens consumidos")

Puntos clave

  • Una llamada básica solo requiere model e input
  • response.output_text proporciona el texto de la respuesta
  • response.usage detalla el consumo de tokens
  • temperature controla la creatividad (0,0 = factual, 1,0 = creativa)
  • instructions reemplaza el mensaje de sistema de las Completaciones de Chat
  • Gestiona siempre los errores con bloques try/except