Saltar para o conteúdo principal

Este browser já não é suportado.

Atualize para o Microsoft Edge para tirar partido das mais recentes funcionalidades, atualizações de segurança e de suporte técnico.

Transferir Microsoft Edge Mais informações sobre o Internet Explorer e o Microsoft Edge
microsoft-foundry.rest.security.o-auth2-auth

Chat

Create a chat completion

POST /openai/v1/chat/completions

Creates a chat completion from the supplied request.

Parâmetros do cabeçalho

x-ms-session-id string

An opaque, application-owned conversation identifier. The value is not returned in the response and must not contain secrets or personally identifiable information.

Corpo do Pedido

The request body.

Content-Type: application/json
metadata OpenAI.Metadata | null

Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard. Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.

[key: string] string
top_logprobs integer | null
temperature number | null
top_p number | null
user string | null

This field is being replaced by safety_identifier and prompt_cache_key. Use prompt_cache_key instead to maintain caching optimizations. A stable identifier for your end-users. Used to boost cache hit rates by better bucketing similar requests and to help OpenAI detect and prevent abuse. Learn more.

safety_identifier string | null
prompt_cache_key string | null
prompt_cache_retention enum
in_memory24h
prompt_cache_options OpenAI.PromptCacheOptionsParam

Options for prompt caching. Supported for gpt-5.6 and later models. By default, OpenAI automatically chooses one implicit cache breakpoint. You can add explicit breakpoints to content blocks with prompt_cache_breakpoint. Each request can write up to four breakpoints. For cache matching, OpenAI considers up to the latest 80 breakpoints in the conversation, without a content-block lookback limit. Set mode to explicit to disable the implicit breakpoint. The ttl defaults to 30m, which is currently the only supported value. See the prompt caching guide for current details.

ttl enum
30m
mode enum
implicitexplicit
messages OpenAI.ChatCompletionRequestMessage[] obrigatório

A list of messages comprising the conversation so far. Depending on the model you use, different message types (modalities) are supported, like text, images, and audio.

model string obrigatório

The model deployment to use for this chat completion.

service_tier enum

Specifies the processing type used for serving the request. - If set to 'auto', then the request will be processed with the service tier configured in the Project settings. Unless otherwise configured, the Project will use 'default'. - If set to 'default', then the request will be processed with the standard pricing and performance for the selected model. - If set to 'flex', then the request will be processed with the Flex Processing service tier. - To opt-in to Fast mode at the request level, include the service_tier=fast or service_tier=priority parameter for Responses or Chat Completions. The response will show service_tier=priority regardless of if you specify service_tier=fast or priority in your request. - When not set, the default behavior is 'auto'. When the service_tier parameter is set, the response body will include the service_tier value based on the processing mode actually used to serve the request. This response value may be different from the value set in the parameter.

autodefaultflexscalepriorityfast
modalities enum[] | null

Output types that you would like the model to generate. Most models are capable of generating text, which is the default: ["text"] The gpt-4o-audio-preview model can also be used to generate audio. To request that this model generate both text and audio responses, you can use: ["text", "audio"]

verbosity enum

Constrains the verbosity of the model's response. Lower values will result in more concise responses, while higher values will result in more verbose responses. Currently supported values are low, medium, and high. The default is medium.

lowmediumhigh
reasoning_effort string | enum | null

Constrains effort on reasoning for reasoning models. Currently supported values are none, minimal, low, medium, high, xhigh, and max. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response. Not all reasoning models support every value. See the reasoning guide for model-specific support.

Qualquer uma das seguintes opções:
string
enum
noneminimallowmediumhighxhighmax
max_completion_tokens integer | null

An upper bound for the number of tokens that can be generated for a completion, including visible output tokens and reasoning tokens.

frequency_penalty number | null

Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.

presence_penalty number | null

Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.

web_search_options OpenAI.CreateChatCompletionRequestWebSearchOptions
user_location OpenAI.CreateChatCompletionRequestWebSearchOptionsUserLocation | null
type enum obrigatório
approximate
approximate OpenAI.WebSearchLocation obrigatório

Approximate location parameters for the search.

country string

The user's two-letter ISO 3166-1 alpha-2 code, for example, US.

region string

Free text input for the region of the user, e.g. California.

city string

Free text input for the city of the user, e.g. San Francisco.

timezone string

The IANA timezone of the user, e.g. America/Los_Angeles.

search_context_size enum

High level guidance for the amount of context window space to use for the search. One of low, medium, or high. medium is the default.

lowmediumhigh
response_format text | json_object | json_schema

An object specifying the format that the model must output. Setting to { "type": "json_schema", "json_schema": {...} } enables Structured Outputs which ensures the model will match your supplied JSON schema. Learn more in the Structured Outputs guide. Setting to { "type": "json_object" } enables the older JSON mode, which ensures the message the model generates is valid JSON. Using json_schema is preferred for models that support it.

Um dos seguintes:
text OpenAI.CreateChatCompletionRequestResponseFormatResponseFormatText

Default response format. Used to generate text responses.

type enum obrigatório

The type of response format being defined. Always text.

text
json_object OpenAI.CreateChatCompletionRequestResponseFormatResponseFormatJsonObject

JSON object response format. An older method of generating JSON responses. Using json_schema is recommended for models that support it. Note that the model will not generate JSON without a system or user message instructing it to do so.

type enum obrigatório

The type of response format being defined. Always json_object.

json_object
json_schema OpenAI.ResponseFormatJsonSchema

JSON Schema response format. Used to generate structured JSON responses. Learn more about Structured Outputs.

type enum obrigatório

The type of response format being defined. Always json_schema.

json_schema
json_schema OpenAI.ResponseFormatJsonSchemaJsonSchema obrigatório
description string
name string obrigatório
schema OpenAI.ResponseFormatJsonSchemaSchema

The schema for the response format, described as a JSON Schema object. Learn how to build JSON schemas here.

strict boolean | null
audio OpenAI.CreateChatCompletionRequestAudio | null

Parameters for audio output. Required when audio output is requested with modalities: ["audio"]. Learn more.

voice OpenAI.VoiceIdsShared | object obrigatório

A built-in voice name or a custom voice reference.

Qualquer uma das seguintes opções:
Qualquer uma das seguintes opções:
string
enum
alloyashballadcoralechosageshimmerversemarincedar
id string obrigatório
format enum obrigatório
wavaacmp3flacopuspcm16
store boolean | null

Whether or not to store the output of this chat completion request for use in our model distillation or evals products. Supports text and image inputs. Note: image inputs over 8MB will be dropped.

moderation OpenAI.ModerationParam | null

Configuration for running moderation on the input and output of this response.

model string obrigatório

The moderation model to use for moderated completions, e.g. 'omni-moderation-latest'.

policy OpenAI.ModerationPolicyParam | null

The policy to apply to moderated response input and output.

input OpenAI.ModerationConfigParam | null

The moderation policy for the response input.

mode enum obrigatório
scoreblock
output OpenAI.ModerationConfigParam | null

The moderation policy for the response input.

mode enum obrigatório
scoreblock
stream boolean | null

If set to true, the model response data will be streamed to the client as it is generated using server-sent events. See the Streaming section below for more information, along with the streaming responses guide for more information on how to handle the streaming events.

stop string | string[] | null

Not supported with latest reasoning models o3 and o4-mini. Up to 4 sequences where the API will stop generating further tokens. The returned text will not contain the stop sequence.

Um dos seguintes:
string
string[]
logit_bias object | null

Modify the likelihood of specified tokens appearing in the completion. Accepts a JSON object that maps tokens (specified by their token ID in the tokenizer) to an associated bias value from -100 to 100. Mathematically, the bias is added to the logits generated by the model prior to sampling. The exact effect will vary per model, but values between -1 and 1 should decrease or increase likelihood of selection; values like -100 or 100 should result in a ban or exclusive selection of the relevant token.

[key: string] integer
logprobs boolean | null

Whether to return log probabilities of the output tokens or not. If true, returns the log probabilities of each output token returned in the content of message.

max_tokens integer | null

The maximum number of tokens that can be generated in the chat completion. This value can be used to control costs for text generated via API. This value is now deprecated in favor of max_completion_tokens, and is not compatible with o-series models.

n integer | null

How many chat completion choices to generate for each input message. Note that you will be charged based on the number of generated tokens across all of the choices. Keep n as 1 to minimize costs.

prediction OpenAI.PredictionContent | null

Configuration for a Predicted Output, which can greatly improve response times when large parts of the model response are known ahead of time. This is most common when you are regenerating a file with only minor changes to most of the content.

type enum obrigatório

The type of the predicted content you want to provide. This type is currently always content.

content
content string | OpenAI.ChatCompletionRequestMessageContentPartText[] obrigatório

The content that should be matched when generating a model response. If generated tokens would match this content, the entire model response can be returned much more quickly.

Um dos seguintes:
string
OpenAI.ChatCompletionRequestMessageContentPartText[]
seed integer | null

This feature is in Beta. If specified, our system will make a best effort to sample deterministically, such that repeated requests with the same seed and parameters should return the same result. Determinism is not guaranteed, and you should refer to the system_fingerprint response parameter to monitor changes in the backend.

stream_options OpenAI.ChatCompletionStreamOptions | null

Options for streaming response. Only set this when you set stream: true.

include_usage boolean

If set, an additional chunk will be streamed before the data: [DONE] message. The usage field on this chunk shows the token usage statistics for the entire request, and the choices field will always be an empty array. All other chunks will also include a usage field, but with a null value. NOTE: If the stream is interrupted, you may not receive the final usage chunk which contains the total token usage for the request.

include_obfuscation boolean

When true, stream obfuscation will be enabled. Stream obfuscation adds random characters to an obfuscation field on streaming delta events to normalize payload sizes as a mitigation to certain side-channel attacks. These obfuscation fields are included by default, but add a small amount of overhead to the data stream. You can set include_obfuscation to false to optimize for bandwidth if you trust the network links between your application and the OpenAI API.

tools (OpenAI.ChatCompletionTool | OpenAI.CustomToolChatCompletions)[]

A list of tools the model may call. You can provide either custom tools or function tools.

tool_choice enum | OpenAI.ChatCompletionAllowedToolsChoice | OpenAI.ChatCompletionNamedToolChoice | OpenAI.ChatCompletionNamedToolChoiceCustom

Controls which (if any) tool is called by the model. none means the model will not call any tool and instead generates a message. auto means the model can pick between generating a message or calling one or more tools. required means the model must call one or more tools. Specifying a particular tool via {"type": "function", "function": {"name": "my_function"}} forces the model to call that tool. none is the default when no tools are present. auto is the default if tools are present.

Um dos seguintes:
enum
noneautorequired
type enum obrigatório

Allowed tool configuration type. Always allowed_tools.

allowed_tools
allowed_tools OpenAI.ChatCompletionAllowedTools obrigatório

Constrains the tools available to the model to a pre-defined set.

mode enum obrigatório

Constrains the tools available to the model to a pre-defined set. auto allows the model to pick from among the allowed tools and generate a message. required requires the model to call one or more of the allowed tools.

autorequired
tools object[] obrigatório

A list of tool definitions that the model should be allowed to call. For the Chat Completions API, the list of tool definitions might look like: json [ { "type": "function", "function": { "name": "get_weather" } }, { "type": "function", "function": { "name": "get_time" } } ]

type enum obrigatório

For function calling, the type is always function.

function
function OpenAI.ChatCompletionNamedToolChoiceFunction obrigatório
name string obrigatório
type enum obrigatório

For custom tool calling, the type is always custom.

custom
custom OpenAI.ChatCompletionNamedToolChoiceCustomCustom obrigatório
name string obrigatório
parallel_tool_calls boolean

Whether to enable parallel function calling during tool use.

function_call enum | OpenAI.ChatCompletionFunctionCallOption

Deprecated in favor of tool_choice. Controls which (if any) function is called by the model. none means the model will not call a function and instead generates a message. auto means the model can pick between generating a message or calling a function. Specifying a particular function via {"name": "my_function"} forces the model to call that function. none is the default when no functions are present. auto is the default if functions are present.

Um dos seguintes:
enum
noneauto
name string obrigatório

The name of the function to call.

functions OpenAI.ChatCompletionFunctions[]

Deprecated in favor of tools. A list of functions the model may generate JSON inputs for.

user_security_context AzureUserSecurityContext

User security context contains several parameters that describe the application itself, and the end user that interacts with the application. These fields assist your security operations teams to investigate and mitigate security incidents by providing a comprehensive approach to protecting your AI applications. Learn more about protecting AI applications using Microsoft Defender for Cloud.

application_name string

The name of the application. Sensitive personal information should not be included in this field.

end_user_id string

This identifier is the Microsoft Entra ID (formerly Azure Active Directory) user object ID used to authenticate end-users within the generative AI application. Sensitive personal information should not be included in this field.

end_user_tenant_id string

The Microsoft 365 tenant ID the end user belongs to. It's required when the generative AI application is multitenant.

source_ip string

Captures the original client's IP address.

routing_config RoutingConfiguration

Per-request configuration for Model Router inference calls. Supported on Model Router endpoints (deployed or instant if supported). Returns a 400 (Bad Request) error when the target is not a Model Router endpoint.

session_affinity SessionAffinityConfiguration

Request settings that control Model Router session affinity.

mode enum

Request modes supported by Model Router session affinity.

stickynone
session_id string

An opaque, application-owned conversation identifier. Use the same value for related requests. The value is not returned in the response and must not contain secrets or personally identifiable information.

Respostas

The request has succeeded.

Corpo

Content-Type: application/json
id string obrigatório

A unique identifier for the chat completion.

choices OpenAI.CreateChatCompletionResponseChoices[] obrigatório

A list of chat completion choices. Can be more than one if n is greater than 1.

created integer obrigatório

The Unix timestamp (in seconds) of when the chat completion was created.

model string obrigatório

The model deployment used for the creation of this chat completion.

metadata OpenAI.Metadata | null

Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard. Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.

[key: string] string
service_tier enum

Specifies the processing type used for serving the request. - If set to 'auto', then the request will be processed with the service tier configured in the Project settings. Unless otherwise configured, the Project will use 'default'. - If set to 'default', then the request will be processed with the standard pricing and performance for the selected model. - If set to 'flex', then the request will be processed with the Flex Processing service tier. - To opt-in to Fast mode at the request level, include the service_tier=fast or service_tier=priority parameter for Responses or Chat Completions. The response will show service_tier=priority regardless of if you specify service_tier=fast or priority in your request. - When not set, the default behavior is 'auto'. When the service_tier parameter is set, the response body will include the service_tier value based on the processing mode actually used to serve the request. This response value may be different from the value set in the parameter.

autodefaultflexscalepriorityfast
system_fingerprint string

This fingerprint represents the backend configuration that the model runs with. Can be used in conjunction with the seed request parameter to understand when backend changes have been made that might impact determinism.

object enum obrigatório

The object type, which is always chat.completion.

chat.completion
usage OpenAI.CompletionUsage

Usage statistics for the completion request.

completion_tokens integer obrigatório
prompt_tokens integer obrigatório
total_tokens integer obrigatório
completion_tokens_details OpenAI.CompletionUsageCompletionTokensDetails
accepted_prediction_tokens integer
audio_tokens integer
reasoning_tokens integer
text_tokens integer
rejected_prediction_tokens integer
prompt_tokens_details OpenAI.CompletionUsagePromptTokensDetails
audio_tokens integer
cached_tokens integer
text_tokens integer
image_tokens integer
cache_write_tokens integer
moderation OpenAI.ChatCompletionModeration | null

Moderation results or errors for the request input and generated output.

input moderation_results | error obrigatório

Moderation results or an error for a chat completion moderation check.

Um dos seguintes:
moderation_results OpenAI.ChatCompletionModerationResults

Successful moderation results for the request input or generated output.

type enum obrigatório

The object type, which is always moderation_results.

moderation_results
model string obrigatório

The moderation model used to generate the results.

results OpenAI.ModerationResultBody[] obrigatório

A list of moderation results.

error OpenAI.ChatCompletionModerationError

An error produced while attempting moderation.

type enum obrigatório

The object type, which is always error.

error
code string obrigatório

The error code.

message string obrigatório

The error message.

output moderation_results | error obrigatório

Moderation results or an error for a chat completion moderation check.

Um dos seguintes:
moderation_results OpenAI.ChatCompletionModerationResults

Successful moderation results for the request input or generated output.

type enum obrigatório

The object type, which is always moderation_results.

moderation_results
model string obrigatório

The moderation model used to generate the results.

results OpenAI.ModerationResultBody[] obrigatório

A list of moderation results.

error OpenAI.ChatCompletionModerationError

An error produced while attempting moderation.

type enum obrigatório

The object type, which is always error.

error
code string obrigatório

The error code.

message string obrigatório

The error message.

model_selection_details ModelSelectionDetails

Model selection metadata providing visibility into routing decisions.

model_router_details ModelRouterDetails obrigatório

Routing decision metadata from Model Router.

mode string | enum obrigatório

The routing mode used by Model Router for the request.

Qualquer uma das seguintes opções:
string
enum
balancedcostquality
session_affinity SessionAffinityDetails

Effective Model Router session affinity metadata for a request.

mode string | enum obrigatório

Effective modes reported for Model Router session affinity.

Qualquer uma das seguintes opções:
string
enum
stickynone
source string | enum

Conversation identifier sources supported by Model Router session affinity.

Qualquer uma das seguintes opções:
string
enum
session_id_payloadsession_id_headernot_availableconversationprevious_response_id
decision string | enum

Final outcomes reported for Model Router session affinity.

Qualquer uma das seguintes opções:
string
enum
initializeretainswitch
routing_trace RoutingTraceEntry[] obrigatório

Ordered trace of routing decisions. Contains one entry for Chat Completions, and may contain multiple entries for Responses API or agent scenarios where multiple inference turns occur.

Client error

Corpo

Content-Type: application/json
error OpenAI.Error obrigatório
code string | null obrigatório
message string obrigatório
param string | null
type string
misalignment OpenAI.MisalignmentErrorDetailsResource
review_target string | null
error_type string | enum
Qualquer uma das seguintes opções:
string
enum
potentially_unintended_data_transferpotentially_unintended_data_accesspotentially_unintended_destructive_activityother
detailed_explanation string

The public explanation for this block.

steer OpenAI._MisalignmentSteer
message string obrigatório

The public continuation instruction.

details OpenAI.Error[]
additionalInfo object
debugInfo object

Server error

Corpo

Content-Type: application/json
error OpenAI.Error obrigatório
code string | null obrigatório
message string obrigatório
param string | null
type string
misalignment OpenAI.MisalignmentErrorDetailsResource
review_target string | null
error_type string | enum
Qualquer uma das seguintes opções:
string
enum
potentially_unintended_data_transferpotentially_unintended_data_accesspotentially_unintended_destructive_activityother
detailed_explanation string

The public explanation for this block.

steer OpenAI._MisalignmentSteer
message string obrigatório

The public continuation instruction.

details OpenAI.Error[]
additionalInfo object
debugInfo object

Pedir

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "VAR_chat_model_id",
    "messages": [
      {
        "role": "developer",
        "content": "You are a helpful assistant."
      },
      {
        "role": "user",
        "content": "Hello!"
      }
    ]
  }'
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),  # This is the default and can be omitted
)
for completion in client.chat.completions.create(
    messages=[{
        "content": "string",
        "role": "developer",
    }],
    model="gpt-5.4",
):
  print(completion)
import OpenAI from "openai";

const openai = new OpenAI();

async function main() {
  const completion = await openai.chat.completions.create({
    messages: [{ role: "developer", content: "You are a helpful assistant." }],
    model: "VAR_chat_model_id",
    store: true,
  });

  console.log(completion.choices[0]);
}

main();
using System;
using System.Collections.Generic;

using OpenAI.Chat;

ChatClient client = new(
    model: "gpt-5.4",
    apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY")
);

List<ChatMessage> messages =
[
    new SystemChatMessage("You are a helpful assistant."),
    new UserChatMessage("Hello!")
];

ChatCompletion completion = client.CompleteChat(messages);

Console.WriteLine(completion.Content[0].Text);
import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env['OPENAI_API_KEY'], // This is the default and can be omitted
});

const chatCompletion = await client.chat.completions.create({
  messages: [{ content: 'string', role: 'developer' }],
  model: 'gpt-5.4',
});

console.log(chatCompletion);
package main

import (
    "context"
    "fmt"

    "github.com/openai/openai-go"
    "github.com/openai/openai-go/option"
    "github.com/openai/openai-go/shared"
)

func main() {
    client := openai.NewClient(
        option.WithAPIKey("My API Key"),
    )
    chatCompletion, err := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
        Messages: []openai.ChatCompletionMessageParamUnion{{
            OfDeveloper: &openai.ChatCompletionDeveloperMessageParam{
                Content: openai.ChatCompletionDeveloperMessageParamContentUnion{
                    OfString: openai.String("string"),
                },
            },
        }},
        Model: shared.ChatModelGPT5_4,
    })
    if err != nil {
        panic(err.Error())
    }
    fmt.Printf("%+v
", chatCompletion)
}
package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.ChatModel;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
            .addDeveloperMessage("string")
            .model(ChatModel.GPT_5_4)
            .build();
        ChatCompletion chatCompletion = client.chat().completions().create(params);
    }
}
require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

chat_completion = openai.chat.completions.create(messages: [{content: "string", role: :developer}], model: :"gpt-5.4")

puts(chat_completion)

Response

{
  "id": "chatcmpl-B9MBs8CjcvOU2jLn4n570S5qMJKcT",
  "object": "chat.completion",
  "created": 1741569952,
  "model": "gpt-5.4",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! How can I assist you today?",
        "refusal": null,
        "annotations": []
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 19,
    "completion_tokens": 10,
    "total_tokens": 29,
    "prompt_tokens_details": {
      "cached_tokens": 0,
      "audio_tokens": 0
    },
    "completion_tokens_details": {
      "reasoning_tokens": 0,
      "audio_tokens": 0,
      "accepted_prediction_tokens": 0,
      "rejected_prediction_tokens": 0
    }
  },
  "service_tier": "default"
}

Pedir

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-5.4",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "What is in this image?"
          },
          {
            "type": "image_url",
            "image_url": {
              "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
            }
          }
        ]
      }
    ],
    "max_tokens": 300
  }'
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),  # This is the default and can be omitted
)
for completion in client.chat.completions.create(
    messages=[{
        "content": "string",
        "role": "developer",
    }],
    model="gpt-5.4",
):
  print(completion)
import OpenAI from "openai";

const openai = new OpenAI();

async function main() {
  const response = await openai.chat.completions.create({
    model: "gpt-5.4",
    messages: [
      {
        role: "user",
        content: [
          { type: "text", text: "What's in this image?" },
          {
            type: "image_url",
            image_url: {
              "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg",
            },
          }
        ],
      },
    ],
  });
  console.log(response.choices[0]);
}
main();
using System;
using System.Collections.Generic;

using OpenAI.Chat;

ChatClient client = new(
    model: "gpt-5.4",
    apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY")
);

List<ChatMessage> messages =
[
    new UserChatMessage(
    [
        ChatMessageContentPart.CreateTextPart("What's in this image?"),
        ChatMessageContentPart.CreateImagePart(new Uri("https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"))
    ])
];

ChatCompletion completion = client.CompleteChat(messages);

Console.WriteLine(completion.Content[0].Text);
import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env['OPENAI_API_KEY'], // This is the default and can be omitted
});

const chatCompletion = await client.chat.completions.create({
  messages: [{ content: 'string', role: 'developer' }],
  model: 'gpt-5.4',
});

console.log(chatCompletion);
package main

import (
    "context"
    "fmt"

    "github.com/openai/openai-go"
    "github.com/openai/openai-go/option"
    "github.com/openai/openai-go/shared"
)

func main() {
    client := openai.NewClient(
        option.WithAPIKey("My API Key"),
    )
    chatCompletion, err := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
        Messages: []openai.ChatCompletionMessageParamUnion{{
            OfDeveloper: &openai.ChatCompletionDeveloperMessageParam{
                Content: openai.ChatCompletionDeveloperMessageParamContentUnion{
                    OfString: openai.String("string"),
                },
            },
        }},
        Model: shared.ChatModelGPT5_4,
    })
    if err != nil {
        panic(err.Error())
    }
    fmt.Printf("%+v
", chatCompletion)
}
package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.ChatModel;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
            .addDeveloperMessage("string")
            .model(ChatModel.GPT_5_4)
            .build();
        ChatCompletion chatCompletion = client.chat().completions().create(params);
    }
}
require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

chat_completion = openai.chat.completions.create(messages: [{content: "string", role: :developer}], model: :"gpt-5.4")

puts(chat_completion)

Response

{
  "id": "chatcmpl-B9MHDbslfkBeAs8l4bebGdFOJ6PeG",
  "object": "chat.completion",
  "created": 1741570283,
  "model": "gpt-5.4",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "The image shows a wooden boardwalk path running through a lush green field or meadow. The sky is bright blue with some scattered clouds, giving the scene a serene and peaceful atmosphere. Trees and shrubs are visible in the background.",
        "refusal": null,
        "annotations": []
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 1117,
    "completion_tokens": 46,
    "total_tokens": 1163,
    "prompt_tokens_details": {
      "cached_tokens": 0,
      "audio_tokens": 0
    },
    "completion_tokens_details": {
      "reasoning_tokens": 0,
      "audio_tokens": 0,
      "accepted_prediction_tokens": 0,
      "rejected_prediction_tokens": 0
    }
  },
  "service_tier": "default"
}

Pedir

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "VAR_chat_model_id",
    "messages": [
      {
        "role": "developer",
        "content": "You are a helpful assistant."
      },
      {
        "role": "user",
        "content": "Hello!"
      }
    ],
    "stream": true
  }'
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),  # This is the default and can be omitted
)
for completion in client.chat.completions.create(
    messages=[{
        "content": "string",
        "role": "developer",
    }],
    model="gpt-5.4",
):
  print(completion)
import OpenAI from "openai";

const openai = new OpenAI();

async function main() {
  const completion = await openai.chat.completions.create({
    model: "VAR_chat_model_id",
    messages: [
      {"role": "developer", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Hello!"}
    ],
    stream: true,
  });

  for await (const chunk of completion) {
    console.log(chunk.choices[0].delta.content);
  }
}

main();
using System;
using System.ClientModel;
using System.Collections.Generic;
using System.Threading.Tasks;

using OpenAI.Chat;

ChatClient client = new(
    model: "gpt-5.4",
    apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY")
);

List<ChatMessage> messages =
[
    new SystemChatMessage("You are a helpful assistant."),
    new UserChatMessage("Hello!")
];

AsyncCollectionResult<StreamingChatCompletionUpdate> completionUpdates = client.CompleteChatStreamingAsync(messages);

await foreach (StreamingChatCompletionUpdate completionUpdate in completionUpdates)
{
    if (completionUpdate.ContentUpdate.Count > 0)
    {
        Console.Write(completionUpdate.ContentUpdate[0].Text);
    }
}
import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env['OPENAI_API_KEY'], // This is the default and can be omitted
});

const chatCompletion = await client.chat.completions.create({
  messages: [{ content: 'string', role: 'developer' }],
  model: 'gpt-5.4',
});

console.log(chatCompletion);
package main

import (
    "context"
    "fmt"

    "github.com/openai/openai-go"
    "github.com/openai/openai-go/option"
    "github.com/openai/openai-go/shared"
)

func main() {
    client := openai.NewClient(
        option.WithAPIKey("My API Key"),
    )
    chatCompletion, err := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
        Messages: []openai.ChatCompletionMessageParamUnion{{
            OfDeveloper: &openai.ChatCompletionDeveloperMessageParam{
                Content: openai.ChatCompletionDeveloperMessageParamContentUnion{
                    OfString: openai.String("string"),
                },
            },
        }},
        Model: shared.ChatModelGPT5_4,
    })
    if err != nil {
        panic(err.Error())
    }
    fmt.Printf("%+v
", chatCompletion)
}
package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.ChatModel;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
            .addDeveloperMessage("string")
            .model(ChatModel.GPT_5_4)
            .build();
        ChatCompletion chatCompletion = client.chat().completions().create(params);
    }
}
require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

chat_completion = openai.chat.completions.create(messages: [{content: "string", role: :developer}], model: :"gpt-5.4")

puts(chat_completion)

Response

{"id":"chatcmpl-123","object":"chat.completion.chunk","created":1694268190,"model":"gpt-4o-mini", "system_fingerprint": "fp_44709d6fcb", "choices":[{"index":0,"delta":{"role":"assistant","content":""},"logprobs":null,"finish_reason":null}]}

{"id":"chatcmpl-123","object":"chat.completion.chunk","created":1694268190,"model":"gpt-4o-mini", "system_fingerprint": "fp_44709d6fcb", "choices":[{"index":0,"delta":{"content":"Hello"},"logprobs":null,"finish_reason":null}]}

....

{"id":"chatcmpl-123","object":"chat.completion.chunk","created":1694268190,"model":"gpt-4o-mini", "system_fingerprint": "fp_44709d6fcb", "choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"stop"}]}

Pedir

curl https://api.openai.com/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
  "model": "gpt-5.4",
  "messages": [
    {
      "role": "user",
      "content": "What is the weather like in Boston today?"
    }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_current_weather",
        "description": "Get the current weather in a given location",
        "parameters": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "The city and state, e.g. San Francisco, CA"
            },
            "unit": {
              "type": "string",
              "enum": ["celsius", "fahrenheit"]
            }
          },
          "required": ["location"]
        }
      }
    }
  ],
  "tool_choice": "auto"
}'
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),  # This is the default and can be omitted
)
for completion in client.chat.completions.create(
    messages=[{
        "content": "string",
        "role": "developer",
    }],
    model="gpt-5.4",
):
  print(completion)
import OpenAI from "openai";

const openai = new OpenAI();

async function main() {
  const messages = [{"role": "user", "content": "What's the weather like in Boston today?"}];
  const tools = [
      {
        "type": "function",
        "function": {
          "name": "get_current_weather",
          "description": "Get the current weather in a given location",
          "parameters": {
            "type": "object",
            "properties": {
              "location": {
                "type": "string",
                "description": "The city and state, e.g. San Francisco, CA",
              },
              "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
            },
            "required": ["location"],
          },
        }
      }
  ];

  const response = await openai.chat.completions.create({
    model: "gpt-5.4",
    messages: messages,
    tools: tools,
    tool_choice: "auto",
  });

  console.log(response);
}

main();
using System;
using System.Collections.Generic;

using OpenAI.Chat;

ChatClient client = new(
    model: "gpt-5.4",
    apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY")
);

ChatTool getCurrentWeatherTool = ChatTool.CreateFunctionTool(
    functionName: "get_current_weather",
    functionDescription: "Get the current weather in a given location",
    functionParameters: BinaryData.FromString("""
        {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "The city and state, e.g. San Francisco, CA"
                },
                "unit": {
                    "type": "string",
                    "enum": [ "celsius", "fahrenheit" ]
                }
            },
            "required": [ "location" ]
        }
    """)
);

List<ChatMessage> messages =
[
    new UserChatMessage("What's the weather like in Boston today?"),
];

ChatCompletionOptions options = new()
{
    Tools =
    {
        getCurrentWeatherTool
    },
    ToolChoice = ChatToolChoice.CreateAutoChoice(),
};

ChatCompletion completion = client.CompleteChat(messages, options);
import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env['OPENAI_API_KEY'], // This is the default and can be omitted
});

const chatCompletion = await client.chat.completions.create({
  messages: [{ content: 'string', role: 'developer' }],
  model: 'gpt-5.4',
});

console.log(chatCompletion);
package main

import (
    "context"
    "fmt"

    "github.com/openai/openai-go"
    "github.com/openai/openai-go/option"
    "github.com/openai/openai-go/shared"
)

func main() {
    client := openai.NewClient(
        option.WithAPIKey("My API Key"),
    )
    chatCompletion, err := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
        Messages: []openai.ChatCompletionMessageParamUnion{{
            OfDeveloper: &openai.ChatCompletionDeveloperMessageParam{
                Content: openai.ChatCompletionDeveloperMessageParamContentUnion{
                    OfString: openai.String("string"),
                },
            },
        }},
        Model: shared.ChatModelGPT5_4,
    })
    if err != nil {
        panic(err.Error())
    }
    fmt.Printf("%+v
", chatCompletion)
}
package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.ChatModel;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
            .addDeveloperMessage("string")
            .model(ChatModel.GPT_5_4)
            .build();
        ChatCompletion chatCompletion = client.chat().completions().create(params);
    }
}
require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

chat_completion = openai.chat.completions.create(messages: [{content: "string", role: :developer}], model: :"gpt-5.4")

puts(chat_completion)

Response

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1699896916,
  "model": "gpt-4o-mini",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": null,
        "tool_calls": [
          {
            "id": "call_abc123",
            "type": "function",
            "function": {
              "name": "get_current_weather",
              "arguments": "{
"location": "Boston, MA"
}"
            }
          }
        ]
      },
      "logprobs": null,
      "finish_reason": "tool_calls"
    }
  ],
  "usage": {
    "prompt_tokens": 82,
    "completion_tokens": 17,
    "total_tokens": 99,
    "completion_tokens_details": {
      "reasoning_tokens": 0,
      "accepted_prediction_tokens": 0,
      "rejected_prediction_tokens": 0
    }
  }
}

Pedir

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "VAR_chat_model_id",
    "messages": [
      {
        "role": "user",
        "content": "Hello!"
      }
    ],
    "logprobs": true,
    "top_logprobs": 2
  }'
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),  # This is the default and can be omitted
)
for completion in client.chat.completions.create(
    messages=[{
        "content": "string",
        "role": "developer",
    }],
    model="gpt-5.4",
):
  print(completion)
import OpenAI from "openai";

const openai = new OpenAI();

async function main() {
  const completion = await openai.chat.completions.create({
    messages: [{ role: "user", content: "Hello!" }],
    model: "VAR_chat_model_id",
    logprobs: true,
    top_logprobs: 2,
  });

  console.log(completion.choices[0]);
}

main();
using System;
using System.Collections.Generic;

using OpenAI.Chat;

ChatClient client = new(
    model: "gpt-5.4",
    apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY")
);

List<ChatMessage> messages =
[
    new UserChatMessage("Hello!")
];

ChatCompletionOptions options = new()
{
    IncludeLogProbabilities = true,
    TopLogProbabilityCount = 2
};

ChatCompletion completion = client.CompleteChat(messages, options);

Console.WriteLine(completion.Content[0].Text);
import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env['OPENAI_API_KEY'], // This is the default and can be omitted
});

const chatCompletion = await client.chat.completions.create({
  messages: [{ content: 'string', role: 'developer' }],
  model: 'gpt-5.4',
});

console.log(chatCompletion);
package main

import (
    "context"
    "fmt"

    "github.com/openai/openai-go"
    "github.com/openai/openai-go/option"
    "github.com/openai/openai-go/shared"
)

func main() {
    client := openai.NewClient(
        option.WithAPIKey("My API Key"),
    )
    chatCompletion, err := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
        Messages: []openai.ChatCompletionMessageParamUnion{{
            OfDeveloper: &openai.ChatCompletionDeveloperMessageParam{
                Content: openai.ChatCompletionDeveloperMessageParamContentUnion{
                    OfString: openai.String("string"),
                },
            },
        }},
        Model: shared.ChatModelGPT5_4,
    })
    if err != nil {
        panic(err.Error())
    }
    fmt.Printf("%+v
", chatCompletion)
}
package com.openai.example;

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.ChatModel;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.fromEnv();

        ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
            .addDeveloperMessage("string")
            .model(ChatModel.GPT_5_4)
            .build();
        ChatCompletion chatCompletion = client.chat().completions().create(params);
    }
}
require "openai"

openai = OpenAI::Client.new(api_key: "My API Key")

chat_completion = openai.chat.completions.create(messages: [{content: "string", role: :developer}], model: :"gpt-5.4")

puts(chat_completion)

Response

{
  "id": "chatcmpl-123",
  "object": "chat.completion",
  "created": 1702685778,
  "model": "gpt-4o-mini",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! How can I assist you today?"
      },
      "logprobs": {
        "content": [
          {
            "token": "Hello",
            "logprob": -0.31725305,
            "bytes": [72, 101, 108, 108, 111],
            "top_logprobs": [
              {
                "token": "Hello",
                "logprob": -0.31725305,
                "bytes": [72, 101, 108, 108, 111]
              },
              {
                "token": "Hi",
                "logprob": -1.3190403,
                "bytes": [72, 105]
              }
            ]
          },
          {
            "token": "!",
            "logprob": -0.02380986,
            "bytes": [
              33
            ],
            "top_logprobs": [
              {
                "token": "!",
                "logprob": -0.02380986,
                "bytes": [33]
              },
              {
                "token": " there",
                "logprob": -3.787621,
                "bytes": [32, 116, 104, 101, 114, 101]
              }
            ]
          },
          {
            "token": " How",
            "logprob": -0.000054669687,
            "bytes": [32, 72, 111, 119],
            "top_logprobs": [
              {
                "token": " How",
                "logprob": -0.000054669687,
                "bytes": [32, 72, 111, 119]
              },
              {
                "token": "<|end|>",
                "logprob": -10.953937,
                "bytes": null
              }
            ]
          },
          {
            "token": " can",
            "logprob": -0.015801601,
            "bytes": [32, 99, 97, 110],
            "top_logprobs": [
              {
                "token": " can",
                "logprob": -0.015801601,
                "bytes": [32, 99, 97, 110]
              },
              {
                "token": " may",
                "logprob": -4.161023,
                "bytes": [32, 109, 97, 121]
              }
            ]
          },
          {
            "token": " I",
            "logprob": -3.7697225e-6,
            "bytes": [
              32,
              73
            ],
            "top_logprobs": [
              {
                "token": " I",
                "logprob": -3.7697225e-6,
                "bytes": [32, 73]
              },
              {
                "token": " assist",
                "logprob": -13.596657,
                "bytes": [32, 97, 115, 115, 105, 115, 116]
              }
            ]
          },
          {
            "token": " assist",
            "logprob": -0.04571125,
            "bytes": [32, 97, 115, 115, 105, 115, 116],
            "top_logprobs": [
              {
                "token": " assist",
                "logprob": -0.04571125,
                "bytes": [32, 97, 115, 115, 105, 115, 116]
              },
              {
                "token": " help",
                "logprob": -3.1089056,
                "bytes": [32, 104, 101, 108, 112]
              }
            ]
          },
          {
            "token": " you",
            "logprob": -5.4385737e-6,
            "bytes": [32, 121, 111, 117],
            "top_logprobs": [
              {
                "token": " you",
                "logprob": -5.4385737e-6,
                "bytes": [32, 121, 111, 117]
              },
              {
                "token": " today",
                "logprob": -12.807695,
                "bytes": [32, 116, 111, 100, 97, 121]
              }
            ]
          },
          {
            "token": " today",
            "logprob": -0.0040071653,
            "bytes": [32, 116, 111, 100, 97, 121],
            "top_logprobs": [
              {
                "token": " today",
                "logprob": -0.0040071653,
                "bytes": [32, 116, 111, 100, 97, 121]
              },
              {
                "token": "?",
                "logprob": -5.5247097,
                "bytes": [63]
              }
            ]
          },
          {
            "token": "?",
            "logprob": -0.0008108172,
            "bytes": [63],
            "top_logprobs": [
              {
                "token": "?",
                "logprob": -0.0008108172,
                "bytes": [63]
              },
              {
                "token": "?
",
                "logprob": -7.184561,
                "bytes": [63, 10]
              }
            ]
          }
        ]
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 9,
    "completion_tokens": 9,
    "total_tokens": 18,
    "completion_tokens_details": {
      "reasoning_tokens": 0,
      "accepted_prediction_tokens": 0,
      "rejected_prediction_tokens": 0
    }
  },
  "system_fingerprint": null
}
pt-pt
Suas opções de privacidade
  • Exclusão de responsabilidade de IA
  • Versões anteriores
  • Blogue
  • Contribuir
  • Privacidade
  • Privacidade da Saúde do Consumidor
  • Termos de Utilização
  • Marcas Comerciais
  • © Microsoft 2026