Com a API da OpenAI, você pode usar um modelo de linguagem de grande porte para gerar texto a partir de um prompt, como faria no ChatGPT. Os modelos podem gerar quase qualquer tipo de resposta em texto, como código, equações matemáticas, dados estruturados em JSON ou textos que parecem escritos por uma pessoa.
Use a API Responses para enviar solicitações diretamente ao modelo, como nesta chamada de geração de 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."
}'
A propriedade output da resposta contém um array com o conteúdo gerado pelo modelo. Neste exemplo simples, o array tem apenas um item:
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": []
}
]
}
]
O array output costuma ter mais de um item! Ele pode conter chamadas de ferramentas, dados sobre os tokens de raciocínio gerados por modelos de raciocínio e outros itens. Não presuma que o texto gerado pelo modelo estará em output[0].content[0].text.
Alguns dos nossos SDKs oficiais incluem nas respostas do modelo a propriedade output_text, que reúne todas as saídas de texto do modelo em uma única string. Essa propriedade pode servir de atalho para acessar o texto gerado pelo modelo.
Além de texto simples, o modelo também pode retornar dados estruturados em formato JSON. Esse recurso se chama saídas estruturadas.
Engenharia de prompt é a prática de escrever instruções eficazes para que o modelo gere, de forma consistente, conteúdo que atenda aos seus requisitos.
Como a geração de conteúdo pelo modelo não é determinística, formular um prompt para obter o resultado desejado é uma combinação de arte e ciência. Ainda assim, você pode aplicar técnicas e boas práticas para obter bons resultados de forma consistente.
Algumas técnicas de engenharia de prompt funcionam com todos os modelos, como o uso de papéis nas mensagens. Para obter os melhores resultados, talvez você precise ajustar o prompt de acordo com o modelo. Até versões específicas de modelos da mesma família podem produzir resultados diferentes. Por isso, ao desenvolver aplicativos mais complexos, recomendamos enfaticamente que você:
- Configure seus aplicativos de produção para usar versões fixas dos modelos (como
gpt-5.5-2026-04-23) para garantir um comportamento consistente.
- Crie testes e conjuntos de avaliações que meçam o comportamento dos prompts. Assim, você pode acompanhar o desempenho ao refinar os prompts, trocar de modelo ou atualizar sua versão.
A seguir, veja algumas ferramentas e técnicas para criar prompts.
A OpenAI oferece vários modelos e APIs. Os modelos de raciocínio, como gpt-6-astra, se comportam de maneira diferente dos modelos de chat. Os tipos de prompt que funcionam melhor também variam entre esses modelos. Os modelos de raciocínio têm melhor desempenho e demonstram maior inteligência quando usados com a API Responses.
Para qualquer aplicativo de geração de texto, recomendamos usar a API Responses em vez da API chat completions, que é mais antiga. Se você usa um modelo de raciocínio, vale especialmente a pena migrar para a API Responses.
Você pode fornecer ao modelo instruções com diferentes níveis de autoridade usando o parâmetro instructions da API em conjunto com os papéis das mensagens.
O parâmetro instructions fornece orientações gerais sobre como o modelo deve se comportar ao gerar uma resposta, incluindo o tom, os objetivos e exemplos de respostas corretas. Todas as instruções fornecidas dessa forma têm prioridade sobre um prompt enviado no 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?"
}'
O exemplo acima equivale, em linhas gerais, a usar as mensagens de entrada a seguir no array 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?"
}
]
}'
O parâmetro instructions se aplica apenas à solicitação atual de geração de resposta. Se você estiver gerenciando o estado da conversa com o parâmetro previous_response_id, as instruções enviadas em instructions nas interações anteriores não estarão no contexto.
A especificação do modelo da OpenAI descreve como nossos modelos atribuem diferentes níveis de prioridade às mensagens de acordo com seus papéis.
| developer | user | assistant |
|---|
As mensagens developer contêm instruções de quem desenvolve o aplicativo
e têm prioridade sobre as mensagens do usuário. | As mensagens user contêm instruções do usuário final e têm prioridade
menor que as mensagens do desenvolvedor. | As mensagens geradas pelo modelo têm o papel assistant. |
Uma conversa com várias interações pode conter diversas mensagens desses tipos, além de outros tipos de conteúdo fornecidos por você e pelo modelo. Saiba mais sobre como gerenciar o estado da conversa.
Em uma analogia com uma linguagem de programação, as mensagens developer e user correspondem a uma função e seus argumentos.
- As mensagens
developer definem as regras e a lógica de negócio do sistema, como a definição de uma função.
- As mensagens
user fornecem os dados de entrada e a configuração aos quais se aplicam as instruções da mensagem developer, como os argumentos de uma função.
Armazene os prompts de produção no código do aplicativo em vez de criar objetos de prompt reutilizáveis. Ao gerenciar os prompts no código, você pode usar entradas tipadas, revisão de código, testes e seu processo habitual de implantação para alterar o comportamento do modelo.
A OpenAI está descontinuando os objetos de prompt reutilizáveis na API. A criação de prompts
passará a ter menos destaque a partir de 3 de junho de 2026, e a desativação de v1/prompts
está prevista para 30 de novembro de 2026. Consulte o cronograma atualizado
na página de descontinuações.
Ao desenvolver novos recursos de geração de texto:
- Mantenha as funções que montam os prompts em um módulo pequeno, próximo ao código do recurso que as utiliza.
- Use argumentos de função tipados ou schemas para valores dinâmicos, como dados de clientes, arquivos ou opções da tarefa.
- Envie os valores gerados de
instructions e input diretamente à API Responses.
- Antes de alterar os prompts de produção, adicione dados de teste representativos, testes e verificações de avaliação.
- Publique as alterações nos prompts pelo seu sistema de implantação. Use flags de recurso ou opções de configuração quando precisar liberar as alterações em etapas.
Se a sua integração já usa um ID ou uma versão para chamar um prompt salvo, siga o guia de migração de objetos de prompt para transferir esse prompt para o código.
Agora que você conhece os conceitos básicos de entradas e saídas de texto, explore um dos recursos a seguir.
Crie um prompt no Playground
Use o Playground para desenvolver e refinar prompts.
Gere dados JSON com saídas estruturadas
Garanta que os dados JSON gerados pelo modelo sigam um schema JSON.
Referência completa da API
Consulte todas as opções de geração de texto na referência da API.
