Con la API de OpenAI, puedes usar un modelo de lenguaje de gran tamaño para generar texto a partir de un prompt, como lo harías con ChatGPT. Los modelos pueden generar casi cualquier tipo de respuesta de texto, como código, ecuaciones matemáticas, datos JSON estructurados o prosa similar a la que escribiría una persona.
Usa la API de Responses para enviar solicitudes directamente al modelo, como en esta llamada para generar texto.
1
2
3
4
5
6
7
8
9import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-6-astra",
input: "Write a one-sentence bedtime story about a unicorn.",
});
console.log(response.output_text);
1
2
3
4
5
6
7
8
9
10from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-6-astra",
input="Write a one-sentence bedtime story about a unicorn.",
)
print(response.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/responses"
)
func main() {
client := openai.NewClient()
resp, err := client.Responses.New(context.TODO(), responses.ResponseNewParams{
Model: "gpt-6-astra",
Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Say this is a test")},
})
if err != nil {
panic(err.Error())
}
fmt.Println(resp.OutputText())
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
public class Main {
public static void main(String[] args) {
OpenAIClient client = OpenAIOkHttpClient.fromEnv();
ResponseCreateParams params =
ResponseCreateParams.builder().input("Say this is a test").model("gpt-6-astra").build();
Response response = client.responses().create(params);
response.output().stream()
.flatMap(item -> item.message().stream())
.flatMap(message -> message.content().stream())
.flatMap(content -> content.outputText().stream())
.forEach(outputText -> System.out.println(outputText.text()));
}
}
1
2
3
4
5
6
7
8
9
10
11
12using OpenAI.Responses;
#pragma warning disable OPENAI001
string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);
ResponseResult response = await client.CreateResponseAsync(
"gpt-6-astra",
"Say 'this is a test.'"
);
Console.WriteLine($"[ASSISTANT]: {response.GetOutputText()}");
1
2
3
4
5
6
7
8
9
10require "openai"
openai = OpenAI::Client.new
response = openai.responses.create(
model: "gpt-6-astra",
input: "Write a one-sentence bedtime story about a unicorn."
)
puts(response.output_text)
1
2
3
4
5openai responses create \
--model "gpt-6-astra" \
--input "Write a one-sentence bedtime story about a unicorn." \
--raw-output \
--transform 'output.#(type=="message").content.0.text'
1
2
3
4
5
6
7curl "https://api.openai.com/v1/responses" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "gpt-6-astra",
"input": "Write a one-sentence bedtime story about a unicorn."
}'
La propiedad output de la respuesta contiene un arreglo con el contenido que generó el modelo. En este ejemplo sencillo, el arreglo tiene un solo elemento:
1234567891011121314[
{
"id": "msg_67b73f697ba4819183a15cc17d011509",
"type": "message",
"role": "assistant",
"content": [
{
"type": "output_text",
"text": "Under the soft glow of the moon, Luna the unicorn danced through fields of twinkling stardust, leaving trails of dreams for every child asleep.",
"annotations": []
}
]
}
]
¡El arreglo output suele contener más de un elemento! Puede incluir llamadas a herramientas, datos sobre los tokens de razonamiento que generan los modelos de razonamiento y otros elementos. No des por hecho que el texto generado por el modelo se encuentra en output[0].content[0].text.
Algunos de nuestros SDK oficiales incluyen en las respuestas del modelo la propiedad output_text, que reúne todas las salidas de texto del modelo en una sola cadena. Esta propiedad puede servirte para acceder directamente al texto generado.
Además de texto sin formato, puedes pedirle al modelo que devuelva datos estructurados en formato JSON. Esta función se llama resultados estructurados.
La ingeniería de prompts consiste en escribir instrucciones eficaces para que un modelo genere de forma sistemática contenido que cumpla tus requisitos.
Como el contenido que genera un modelo no es determinista, escribir prompts que produzcan el resultado que buscas tiene tanto de arte como de ciencia. Aun así, puedes aplicar técnicas y buenas prácticas para obtener buenos resultados de forma constante.
Algunas técnicas de ingeniería de prompts funcionan con todos los modelos, como el uso de roles de mensaje. Sin embargo, es posible que debas formular los prompts de manera distinta para obtener los mejores resultados con cada modelo. Incluso distintas versiones de modelos de una misma familia pueden producir resultados diferentes. Por eso, a medida que desarrolles aplicaciones más complejas, te recomendamos especialmente que sigas estas prácticas:
- Configura tus aplicaciones de producción para que usen versiones específicas de los modelos (por ejemplo,
gpt-5.5-2026-04-23) y así mantengan un comportamiento consistente.
- Crea pruebas y conjuntos de evaluaciones que midan cómo se comportan los prompts. Así podrás monitorear su rendimiento a medida que los ajustes o cuando cambies de versión del modelo o lo actualices.
Veamos algunas herramientas y técnicas que puedes usar para crear prompts.
OpenAI ofrece muchos modelos y varias API entre los que puedes elegir. Los modelos de razonamiento, como gpt-6-astra, se comportan de manera distinta a los modelos de chat y responden mejor a otro tipo de prompts. Ten en cuenta que los modelos de razonamiento ofrecen un mejor rendimiento y demuestran mayor inteligencia cuando los usas con la API de Responses.
Si desarrollas una aplicación que genera texto, te recomendamos usar la API de Responses en lugar de la API para completar chats, que es anterior. Si usas un modelo de razonamiento, te resultará especialmente útil migrar a Responses.
Puedes darle al modelo instrucciones con distintos niveles de autoridad mediante el parámetro instructions de la API y los roles de mensaje.
El parámetro instructions le da al modelo instrucciones generales sobre cómo debe comportarse al generar una respuesta, incluidos el tono, los objetivos y ejemplos de respuestas correctas. Las instrucciones que proporciones de esta manera tendrán prioridad sobre el prompt del parámetro input.
1
2
3
4
5
6
7
8
9
10
11import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-6-astra",
reasoning: { effort: "low" },
instructions: "Talk like a pirate.",
input: "Are semicolons optional in JavaScript?",
});
console.log(response.output_text);
1
2
3
4
5
6
7
8
9
10
11
12from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-6-astra",
reasoning={"effort": "low"},
instructions="Talk like a pirate.",
input="Are semicolons optional in JavaScript?",
)
print(response.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/responses"
)
func main() {
client := openai.NewClient()
response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
Model: "gpt-6-astra",
Instructions: openai.String("Talk like a pirate."),
Reasoning: responses.ReasoningParam{
Effort: responses.ReasoningEffortLow,
},
Input: responses.ResponseNewParamsInputUnion{
OfString: openai.String("Are semicolons optional in JavaScript?"),
},
})
if err != nil {
panic(err)
}
fmt.Println(response.OutputText())
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.Reasoning;
import com.openai.models.ReasoningEffort;
import com.openai.models.responses.ResponseCreateParams;
String semicolonsDevMsg = "Talk like a pirate.";
String semicolonsPrompt = "Are semicolons optional in JavaScript?";
ResponseCreateParams params =
ResponseCreateParams.builder()
.model("gpt-6-astra")
.input(semicolonsPrompt)
.instructions(semicolonsDevMsg)
.reasoning(Reasoning.builder().effort(ReasoningEffort.LOW).build())
.build();
client.responses().create(params).output().stream()
.flatMap(item -> item.message().stream())
.flatMap(message -> message.content().stream())
.flatMap(content -> content.outputText().stream())
.forEach(text -> System.out.println(text.text()));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22using OpenAI.Responses;
#pragma warning disable OPENAI001
string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);
CreateResponseOptions options = new()
{
Model = "gpt-6-astra",
Instructions = "Talk like a pirate.",
ReasoningOptions = new ResponseReasoningOptions
{
ReasoningEffortLevel = ResponseReasoningEffortLevel.Low,
},
};
options.InputItems.Add(
ResponseItem.CreateUserMessageItem("Are semicolons optional in JavaScript?")
);
ResponseResult response = await client.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());
1
2
3
4
5
6
7
8
9
10
11require "openai"
client = OpenAI::Client.new
response = client.responses.create(
model: "gpt-6-astra",
instructions: "Talk like a pirate.",
reasoning: { effort: :low },
input: "Are semicolons optional in JavaScript?"
)
puts(response.output_text)
1
2
3
4
5
6
7
8
9curl "https://api.openai.com/v1/responses" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "gpt-6-astra",
"reasoning": {"effort": "low"},
"instructions": "Talk like a pirate.",
"input": "Are semicolons optional in JavaScript?"
}'
El ejemplo anterior equivale, a grandes rasgos, a usar los siguientes mensajes de entrada en el arreglo input:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-6-astra",
reasoning: { effort: "low" },
input: [
{
role: "developer",
content: "Talk like a pirate.",
},
{
role: "user",
content: "Are semicolons optional in JavaScript?",
},
],
});
console.log(response.output_text);
1
2
3
4
5
6
7
8
9
10
11
12
13
14from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-6-astra",
reasoning={"effort": "low"},
input=[
{"role": "developer", "content": "Talk like a pirate."},
{"role": "user", "content": "Are semicolons optional in JavaScript?"},
],
)
print(response.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/responses"
)
func main() {
client := openai.NewClient()
response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
Model: "gpt-6-astra",
Reasoning: responses.ReasoningParam{
Effort: responses.ReasoningEffortLow,
},
Input: responses.ResponseNewParamsInputUnion{
OfInputItemList: responses.ResponseInputParam{
responses.ResponseInputItemParamOfMessage(
"Talk like a pirate.",
responses.EasyInputMessageRoleDeveloper,
),
responses.ResponseInputItemParamOfMessage(
"Are semicolons optional in JavaScript?",
responses.EasyInputMessageRoleUser,
),
},
},
})
if err != nil {
panic(err)
}
fmt.Println(response.OutputText())
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.Reasoning;
import com.openai.models.ReasoningEffort;
import com.openai.models.responses.EasyInputMessage;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputItem;
import java.util.List;
String semicolonsDevMsg = "Talk like a pirate.";
String semicolonsPrompt = "Are semicolons optional in JavaScript?";
ResponseCreateParams params =
ResponseCreateParams.builder()
.model("gpt-6-astra")
.input(
ResponseCreateParams.Input.ofResponse(
List.of(
ResponseInputItem.ofEasyInputMessage(
EasyInputMessage.builder()
.role(EasyInputMessage.Role.DEVELOPER)
.content(semicolonsDevMsg)
.build()),
ResponseInputItem.ofEasyInputMessage(
EasyInputMessage.builder()
.role(EasyInputMessage.Role.USER)
.content(semicolonsPrompt)
.build()))))
.reasoning(Reasoning.builder().effort(ReasoningEffort.LOW).build())
.build();
client.responses().create(params).output().stream()
.flatMap(item -> item.message().stream())
.flatMap(message -> message.content().stream())
.flatMap(content -> content.outputText().stream())
.forEach(text -> System.out.println(text.text()));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24using OpenAI.Responses;
#pragma warning disable OPENAI001
string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);
CreateResponseOptions options = new()
{
Model = "gpt-6-astra",
ReasoningOptions = new ResponseReasoningOptions
{
ReasoningEffortLevel = ResponseReasoningEffortLevel.Low,
},
};
options.InputItems.Add(
ResponseItem.CreateDeveloperMessageItem("Talk like a pirate.")
);
options.InputItems.Add(
ResponseItem.CreateUserMessageItem("Are semicolons optional in JavaScript?")
);
ResponseResult response = await client.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19require "openai"
client = OpenAI::Client.new
response = client.responses.create(
model: "gpt-6-astra",
reasoning: { effort: :low },
input: [
{
role: :developer,
content: "Talk like a pirate."
},
{
role: :user,
content: "Are semicolons optional in JavaScript?"
}
]
)
puts(response.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17curl "https://api.openai.com/v1/responses" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "gpt-6-astra",
"reasoning": {"effort": "low"},
"input": [
{
"role": "developer",
"content": "Talk like a pirate."
},
{
"role": "user",
"content": "Are semicolons optional in JavaScript?"
}
]
}'
El parámetro instructions solo se aplica a la solicitud actual de generación de respuesta. Si administras el estado de la conversación con el parámetro previous_response_id, el contexto no incluirá las instrucciones que hayas pasado en instructions en turnos anteriores.
Las especificaciones del modelo de OpenAI describen cómo nuestros modelos asignan distintos niveles de prioridad a los mensajes según su rol.
| developer | user | assistant |
|---|
Los mensajes developer contienen instrucciones de quien desarrolla la aplicación y tienen prioridad sobre los mensajes del usuario. | Los mensajes user contienen instrucciones del usuario final y tienen menor prioridad que los mensajes del desarrollador. | Los mensajes que genera el modelo tienen el rol assistant. |
Una conversación de varios turnos puede incluir varios mensajes de estos tipos, además de otros tipos de contenido que aporten tanto tú como el modelo. Consulta cómo administrar el estado de la conversación.
Puedes pensar en los mensajes developer y user como en una función y sus argumentos en un lenguaje de programación.
- Los mensajes
developer establecen las reglas del sistema y la lógica de negocio, como la definición de una función.
- Los mensajes
user proporcionan los datos de entrada y la configuración a los que se aplican las instrucciones del mensaje developer, como los argumentos de una función.
Guarda los prompts de producción en el código de tu aplicación en lugar de crear objetos de prompt reutilizables. Al gestionar los prompts en el código, puedes usar entradas tipadas, revisiones de código, pruebas y tu proceso habitual de despliegue para cambiar el comportamiento del modelo.
OpenAI está retirando los objetos de prompt reutilizables de la API. A partir del 3 de junio de 2026, la creación de prompts pasará a segundo plano y está previsto que v1/prompts deje de funcionar el 30 de noviembre de 2026. Consulta el calendario vigente en la página de funciones en desuso.
Cuando desarrolles nuevas funciones de generación de texto:
- Guarda las funciones que construyen los prompts en un módulo pequeño, cerca del código que las usa.
- Usa argumentos de función tipados o esquemas para los valores dinámicos, como datos de clientes, archivos u opciones de la tarea.
- Pasa los valores generados de
instructions e input directamente a la API de Responses.
- Agrega datos de prueba representativos, pruebas y comprobaciones de evaluación antes de cambiar los prompts de producción.
- Implementa los cambios en los prompts mediante tu sistema de despliegue. Usa indicadores de funcionalidad u opciones de configuración cuando necesites hacer el despliegue por etapas.
Si tu integración ya invoca un prompt guardado mediante su ID o su versión, usa la guía de migración de objetos de prompt para trasladar ese prompt al código.
Ahora que conoces los fundamentos de las entradas y salidas de texto, puedes explorar alguno de estos recursos.
Crea un prompt en el Playground
Usa el Playground para crear y perfeccionar tus prompts.
Genera datos JSON con resultados estructurados
Asegúrate de que los datos JSON que genere el modelo se ajusten a un esquema JSON.
Referencia completa de la API
Consulta todas las opciones de generación de texto en la referencia de la API.
