Chat
Create a chat completion
Creates a chat completion from the supplied request.
Headerparameter
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.
Anforderungstext
The request body.
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.
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.
prompt_cache_retention
enum
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
mode
enum
messages
OpenAI.ChatCompletionRequestMessage[]
Erforderlich
model
string
Erforderlich
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.
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.
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.
enum
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
Erforderlich
approximate
OpenAI.WebSearchLocation
Erforderlich
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.
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.
text
OpenAI.CreateChatCompletionRequestResponseFormatResponseFormatText
Default response format. Used to generate text responses.
type
enum
Erforderlich
The type of response format being defined. Always 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
Erforderlich
The type of response format being defined. Always json_object.
json_schema
OpenAI.ResponseFormatJsonSchema
JSON Schema response format. Used to generate structured JSON responses. Learn more about Structured Outputs.
type
enum
Erforderlich
The type of response format being defined. Always json_schema.
json_schema
OpenAI.ResponseFormatJsonSchemaJsonSchema
Erforderlich
schema
OpenAI.ResponseFormatJsonSchemaSchema
The schema for the response format, described as a JSON Schema object. Learn how to build JSON schemas here.
audio
OpenAI.CreateChatCompletionRequestAudio | null
Parameters for audio output. Required when audio output is requested with modalities: ["audio"]. Learn more.
voice
OpenAI.VoiceIdsShared | object
Erforderlich
A built-in voice name or a custom voice reference.
enum
format
enum
Erforderlich
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
Erforderlich
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
Erforderlich
output
OpenAI.ModerationConfigParam | null
The moderation policy for the response input.
mode
enum
Erforderlich
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.
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.
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
Erforderlich
The type of the predicted content you want to provide. This type is currently always content.
content
string | OpenAI.ChatCompletionRequestMessageContentPartText[]
Erforderlich
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.
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.
enum
type
enum
Erforderlich
Allowed tool configuration type. Always allowed_tools.
allowed_tools
OpenAI.ChatCompletionAllowedTools
Erforderlich
Constrains the tools available to the model to a pre-defined set.
mode
enum
Erforderlich
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.
tools
object[]
Erforderlich
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
Erforderlich
For function calling, the type is always function.
function
OpenAI.ChatCompletionNamedToolChoiceFunction
Erforderlich
type
enum
Erforderlich
For custom tool calling, the type is always custom.
custom
OpenAI.ChatCompletionNamedToolChoiceCustomCustom
Erforderlich
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.
enum
name
string
Erforderlich
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.
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.
Antworten
The request has succeeded.
Text
id
string
Erforderlich
A unique identifier for the chat completion.
choices
OpenAI.CreateChatCompletionResponseChoices[]
Erforderlich
A list of chat completion choices. Can be more than one if n is greater than 1.
created
integer
Erforderlich
The Unix timestamp (in seconds) of when the chat completion was created.
model
string
Erforderlich
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.
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.
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
Erforderlich
The object type, which is always chat.completion.
usage
OpenAI.CompletionUsage
Usage statistics for the completion request.
completion_tokens_details
OpenAI.CompletionUsageCompletionTokensDetails
prompt_tokens_details
OpenAI.CompletionUsagePromptTokensDetails
moderation
OpenAI.ChatCompletionModeration | null
Moderation results or errors for the request input and generated output.
input
moderation_results | error
Erforderlich
Moderation results or an error for a chat completion moderation check.
moderation_results
OpenAI.ChatCompletionModerationResults
Successful moderation results for the request input or generated output.
type
enum
Erforderlich
The object type, which is always moderation_results.
model
string
Erforderlich
The moderation model used to generate the results.
results
OpenAI.ModerationResultBody[]
Erforderlich
A list of moderation results.
error
OpenAI.ChatCompletionModerationError
An error produced while attempting moderation.
type
enum
Erforderlich
The object type, which is always error.
code
string
Erforderlich
The error code.
message
string
Erforderlich
The error message.
output
moderation_results | error
Erforderlich
Moderation results or an error for a chat completion moderation check.
moderation_results
OpenAI.ChatCompletionModerationResults
Successful moderation results for the request input or generated output.
type
enum
Erforderlich
The object type, which is always moderation_results.
model
string
Erforderlich
The moderation model used to generate the results.
results
OpenAI.ModerationResultBody[]
Erforderlich
A list of moderation results.
error
OpenAI.ChatCompletionModerationError
An error produced while attempting moderation.
type
enum
Erforderlich
The object type, which is always error.
code
string
Erforderlich
The error code.
message
string
Erforderlich
The error message.
model_selection_details
ModelSelectionDetails
Model selection metadata providing visibility into routing decisions.
model_router_details
ModelRouterDetails
Erforderlich
Routing decision metadata from Model Router.
mode
string | enum
Erforderlich
The routing mode used by Model Router for the request.
enum
session_affinity
SessionAffinityDetails
Effective Model Router session affinity metadata for a request.
mode
string | enum
Erforderlich
Effective modes reported for Model Router session affinity.
enum
source
string | enum
Conversation identifier sources supported by Model Router session affinity.
enum
decision
string | enum
Final outcomes reported for Model Router session affinity.
enum
routing_trace
RoutingTraceEntry[]
Erforderlich
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.
Anfordern
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)
Antwort
{
"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"
}
Anfordern
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)
Antwort
{
"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"
}
Anfordern
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)
Antwort
{"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"}]}
Anfordern
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)
Antwort
{
"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
}
}
}
Anfordern
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)
Antwort
{
"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
}