ChatGPT 5.5 API

Buble exposes ChatGPT 5.5 through the public chat model API as openai/gpt-5.5.

Model identity

Field	Value
Buble model key	`openai/gpt-5.5`
Runtime model id	`gpt-5-5`
Provider	OpenAI
Public capabilities	Reasoning, image attachments, tool calling

Pricing

Unit	Credits
Input	110 credits per 1,000,000 tokens
Output	650 credits per 1,000,000 tokens
Cached input	11 credits per 1,000,000 tokens

Model options

Option	Type	Default	Values
`reasoning_effort`	string	`medium`	`none`, `low`, `medium`, `high`, `xhigh`

Set reasoning: true to enable reasoning. Pass the configured effort through options.reasoning_effort.

OpenAI-compatible example

curl https://buble.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $BUBLE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.5",
    "messages": [
      {
        "role": "system",
        "content": "You are a concise technical assistant."
      },
      {
        "role": "user",
        "content": "Summarize the tradeoffs in adopting this model for research and coding."
      }
    ],
    "reasoning": true,
    "options": {
      "reasoning_effort": "medium"
    },
    "max_completion_tokens": 800
  }'

Anthropic Messages-compatible example

curl https://buble.ai/api/v1/messages \
  -H "Authorization: Bearer $BUBLE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.5",
    "system": "You are a concise technical assistant.",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "Summarize the tradeoffs in adopting this model for research and coding."
          }
        ]
      }
    ],
    "thinking": true,
    "options": {
      "reasoning_effort": "medium"
    },
    "max_tokens": 800
  }'

Gemini-compatible example

curl https://buble.ai/api/v1beta/models/openai/gpt-5.5:generateContent \
  -H "Authorization: Bearer $BUBLE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "systemInstruction": {
      "parts": [
        {
          "text": "You are a concise technical assistant."
        }
      ]
    },
    "contents": [
      {
        "role": "user",
        "parts": [
          {
            "text": "Summarize the tradeoffs in adopting this model for research and coding."
          }
        ]
      }
    ],
    "reasoning": true,
    "options": {
      "reasoning_effort": "medium"
    },
    "generationConfig": {
      "maxOutputTokens": 800
    }
  }'

For Gemini-compatible streaming, use /api/v1beta/models/openai/gpt-5.5:streamGenerateContent.

SDK examples

The examples below use this page's Buble chat model key through the OpenAI-compatible Chat Completions SDK method. They assume you have already initialized the SDK client as shown in the Quickstart and imported the required language SDK types. Anthropic Messages and Gemini-compatible calls use the same model key; Gemini streaming must use the SDK's streamGenerateContent / stream_generate_content method.

JavaScript / TypeScript

const completion = await buble.chat.completions.create({
  model: 'openai/gpt-5.5',
  messages: [
    { role: 'system', content: 'You are a concise technical assistant.' },
    {
      role: 'user',
      content:
        'Summarize the tradeoffs in adopting this model for research and coding.',
    },
  ],
  reasoning: true,
  options: {
    reasoning_effort: 'medium',
  },
  max_completion_tokens: 800,
});

console.log(completion.choices?.[0]?.message?.content);

Python

completion = client.chat.completions.create(
    model="openai/gpt-5.5",
    messages=[
        {"role": "system", "content": "You are a concise technical assistant."},
        {"role": "user", "content": "Summarize the tradeoffs in adopting this model for research and coding."},
    ],
    reasoning=True,
    options={"reasoning_effort": "medium"},
    max_completion_tokens=800,
)

print(completion["choices"][0]["message"]["content"])

Go

completion, err := client.Chat.Completions.Create(ctx, buble.ChatRequest{
	"model": "openai/gpt-5.5",
	"messages": []any{
		map[string]any{"role": "system", "content": "You are a concise technical assistant."},
		map[string]any{"role": "user", "content": "Summarize the tradeoffs in adopting this model for research and coding."},
	},
	"reasoning":             true,
	"options": map[string]any{"reasoning_effort": "medium"},
	"max_completion_tokens": 800,
})
if err != nil {
	return err
}
fmt.Println(completion)

Rust

let completion = client.chat().completions().create(serde_json::json!({
    "model": "openai/gpt-5.5",
    "messages": [
        { "role": "system", "content": "You are a concise technical assistant." },
        { "role": "user", "content": "Summarize the tradeoffs in adopting this model for research and coding." }
    ],
    "reasoning": true,
    "options": { "reasoning_effort": "medium" },
    "max_completion_tokens": 800
})).await?;

Swift

let completion = try await client.chat.completions.create([
    "model": "openai/gpt-5.5",
    "messages": [
        ["role": "system", "content": "You are a concise technical assistant."],
        ["role": "user", "content": "Summarize the tradeoffs in adopting this model for research and coding."]
    ],
    "reasoning": true,
    "options": ["reasoning_effort": "medium"],
    "max_completion_tokens": 800
])

Dart / Flutter

final completion = await client.chat.completions.create({
  'model': 'openai/gpt-5.5',
  'messages': [
    {'role': 'system', 'content': 'You are a concise technical assistant.'},
    {'role': 'user', 'content': 'Summarize the tradeoffs in adopting this model for research and coding.'},
  ],
  'reasoning': true,
  'options': {'reasoning_effort': 'medium'},
  'max_completion_tokens': 800,
});

Elixir

{:ok, completion} =
  Buble.Chat.Completions.create(client, %{
    model: "openai/gpt-5.5",
    messages: [
      %{role: "system", content: "You are a concise technical assistant."},
      %{role: "user", content: "Summarize the tradeoffs in adopting this model for research and coding."}
    ],
    reasoning: true,
    options: %{reasoning_effort: "medium"},
    max_completion_tokens: 800
  })

Java

var completion = client.chat().completions().create(Map.of(
        "model", "openai/gpt-5.5",
        "messages", List.of(
                Map.of("role", "system", "content", "You are a concise technical assistant."),
                Map.of("role", "user", "content", "Summarize the tradeoffs in adopting this model for research and coding.")),
        "reasoning", true,
        "options", Map.of("reasoning_effort", "medium"),
        "max_completion_tokens", 800));

.NET

var completion = await client.Chat.Completions.CreateAsync(new Dictionary<string, object?>
{
    ["model"] = "openai/gpt-5.5",
    ["messages"] = new[]
    {
        new Dictionary<string, object?> { ["role"] = "system", ["content"] = "You are a concise technical assistant." },
        new Dictionary<string, object?> { ["role"] = "user", ["content"] = "Summarize the tradeoffs in adopting this model for research and coding." }
    },
    ["reasoning"] = true,
    ["options"] = new Dictionary<string, object?>
    {
        ["reasoning_effort"] = "medium"
    },
    ["max_completion_tokens"] = 800
});

PHP

$completion = $client->chat()->completions()->create([
    'model' => 'openai/gpt-5.5',
    'messages' => [
        ['role' => 'system', 'content' => 'You are a concise technical assistant.'],
        ['role' => 'user', 'content' => 'Summarize the tradeoffs in adopting this model for research and coding.'],
    ],
    'reasoning' => true,
    'options' => [
        'reasoning_effort' => 'medium',
    ],
    'max_completion_tokens' => 800,
]);

Ruby

completion = client.chat.completions.create(
  model: "openai/gpt-5.5",
  messages: [
    { role: "system", content: "You are a concise technical assistant." },
    { role: "user", content: "Summarize the tradeoffs in adopting this model for research and coding." }
  ],
  reasoning: true,
  options: {reasoning_effort: "medium"},
  max_completion_tokens: 800
)