Documentation 2026-11-09 23:02 UTC to 2026-11-10 23:02 UTC

17Unless safety or compliance concerns require a faster timeline, we provide the following minimum notice periods before model retirement:17Unless safety or compliance concerns require a faster timeline, we provide the following minimum notice periods before model retirement:

18 18 

19- **Generally available models:** At least 6 months.19- **Generally available models:** At least 6 months.

20- **Specialized variants of generally available models:** At least 3 months. Examples include chat variants such as `gpt-5.1-chat-latest`, Codex variants such as `gpt-5.3-codex`, and deep research variants such as `o3-deep-research`.20- **Specialized variants of generally available models and image generation models:** At least 3 months. Examples include chat variants such as `gpt-5.1-chat-latest`, Codex variants such as `gpt-5.3-codex`, and deep research variants such as `o3-deep-research`.

21- **Preview models:** Preview models, identified by `preview` in the model name, may be retired with much shorter notice, such as 2 weeks. Examples include `computer-use-preview` and `gpt-4o-audio-preview`. We don't recommend using preview models for business-critical production workloads unless you can migrate on short notice.21- **Preview models:** Preview models, identified by `preview` in the model name, may be retired with much shorter notice, such as 2 weeks. Examples include `computer-use-preview` and `gpt-4o-audio-preview`. We don't recommend using preview models for business-critical production workloads unless you can migrate on short notice.

22 22 

23If safety or compliance concerns require us to retire a model sooner, we will provide as much notice as reasonably possible.23If safety or compliance concerns require us to retire a model sooner, we will provide as much notice as reasonably possible.

36 36 

37Upcoming deprecations are listed below, with the most recent announcements at the top.37Upcoming deprecations are listed below, with the most recent announcements at the top.

38 38 

39### 2026-11-10: GPT Image 2

40 

41The `gpt-image-2` model and `gpt-image-2-2026-04-21` snapshot are deprecated and will be removed from the API on February 10, 2027.

42 

43| Shutdown date | Model / system | Recommended replacement |

44| ----------------- | ----------------------------------------- | ------------------------------------------------- |

45| February 10, 2027 | `gpt-image-2` \| `gpt-image-2-2026-04-21` | `gpt-image-2.6-sunburst` or `gpt-image-2.6-flare` |

46 

39### 2026-11-05: GPT-5.5-Cyber47### 2026-11-05: GPT-5.5-Cyber

40 48 

41The `gpt-5.5-cyber-preview` model is deprecated and will be removed from the API on February 1, 2027. Migrate to the most capable cyber model available to you before the shutdown date.49The `gpt-5.5-cyber-preview` model is deprecated and will be removed from the API on February 1, 2027. Migrate to the most capable cyber model available to you before the shutdown date.

536 544 

537### Plain-text aliases545### Plain-text aliases

538 546 

547- gpt-image-2 | gpt-image-2-2026-04-21

539- gpt-5.4-nano | gpt-5.4-nano-2026-03-17548- gpt-5.4-nano | gpt-5.4-nano-2026-03-17

540- gpt-5.1 | gpt-5.1-2025-11-13549- gpt-5.1 | gpt-5.1-2025-11-13

541- gpt-4o-mini-tts | gpt-4o-mini-tts-2025-03-20550- gpt-4o-mini-tts | gpt-4o-mini-tts-2025-03-20

42```42```

43 43 

44```go44```go

45package main

46 

47import (45import (

46 "context"

47 "fmt"

48 "os"48 "os"

49 49 

50 "github.com/openai/openai-go/v3"50 "github.com/openai/openai-go/v3"

51 "github.com/openai/openai-go/v3/option"51 "github.com/openai/openai-go/v3/option"

52)52)

53 53 

54func main() {54client := openai.NewClient(

55 client := openai.NewClient(

56 option.WithAdminAPIKey(os.Getenv("OPENAI_ADMIN_KEY")),55 option.WithAdminAPIKey(os.Getenv("OPENAI_ADMIN_KEY")),

57 )56)

58 

59 _ = client

60}

61```57```

62 58 

63```java59```java

64import com.openai.client.OpenAIClient;60import com.openai.client.OpenAIClient;

65import com.openai.client.okhttp.OpenAIOkHttpClient;61import com.openai.client.okhttp.OpenAIOkHttpClient;

62import com.openai.models.admin.organization.auditlogs.AuditLogListParams;

66 63 

67OpenAIClient client =64OpenAIClient client =

68 OpenAIOkHttpClient.builder().adminApiKey(System.getenv("OPENAI_ADMIN_KEY")).build();65 OpenAIOkHttpClient.builder().adminApiKey(System.getenv("OPENAI_ADMIN_KEY")).build();

450```447```

451 448 

452```java449```java

453import com.openai.models.admin.organization.auditlogs.AuditLogListParams;

454 

455var page =450var page =

456 client451 client

457 .admin()452 .admin()

174System.out.println(automation);174System.out.println(automation);

175```175```

176 176 

177```csharp

178using OpenAI;

179using OpenAI.Agents;

180#pragma warning disable OPENAI001

181 

182string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

183AgentClient client = new OpenAIClient(key).GetAgentClient();

184AgentAutomation automation = await client.CreateAutomationAsync(

185 new AgentAutomationCreationOptions

186 {

187 Type = AgentAutomationType.Periodic,

188 Name = "Daily session",

189 Expression = "0 10 * * *",

190 Timezone = "America/New_York",

191 Target = new NewSessionAutomationTarget

192 {

193 AgentId = "agt_123",

194 Environment = new EnvironmentParamOpenaiHosted(),

195 Input =

196 [

197 new InputMessageParam(

198 [new InputContentParamInputText("Summarize the current status and next steps.")]

199 ),

200 ],

201 },

202 }

203);

204Console.WriteLine(automation.Id);

205```

206 

207```ruby177```ruby

208require "openai"178require "openai"

209 179 

210client = OpenAI::Client.new180client = OpenAI::Client.new

211automation = client.beta.agents.automations.create(181automation = client.beta.agents.automations.create(

212 body: {182 create_automation_params: {

213 type: "periodic",183 type: "periodic",

214 name: "Daily session",184 name: "Daily session",

215 expression: "0 10 * * *",185 expression: "0 10 * * *",

232 }202 }

233 }203 }

234)204)

235puts automation205puts automation.id

236```206```

237 207 

238```bash208```bash

381System.out.println(session.id());351System.out.println(session.id());

382```352```

383 353 

384```csharp

385using OpenAI;

386using OpenAI.Agents;

387#pragma warning disable OPENAI001

388 

389string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

390AgentClient client = new OpenAIClient(key).GetAgentClient();

391AgentSession session = await client.CreateAgentSessionAsync(

392 new AgentSessionCreationOptions

393 {

394 Agent = new SessionAgentConfigParam

395 {

396 Model = "gpt-6-astra",

397 Instructions = "Use automations to schedule tasks requested by the user. Delegate each scheduled task to a subagent and ask for a concise result. Keep the goal, schedule, and useful summaries in the main session. Adjust or stop schedules when the user asks.",

398 MultiAgent = new MultiAgentConfigParam { Enabled = true },

399 Tools = [new AgentToolConfigParamAutomations()],

400 },

401 Environment = new EnvironmentParamOpenaiHosted(),

402 Input =

403 [

404 new InputMessageParam(

405 [new InputContentParamInputText("Every day at 10 AM in America/New_York, review the goals we discuss here and suggest the next actions I could take.")]

406 ),

407 ],

408 }

409);

410Console.WriteLine(session.Id);

411```

412 

413```ruby354```ruby

414require "openai"355require "openai"

415 356 

512}453}

513```454```

514 455 

515```csharp

516using OpenAI;

517using OpenAI.Agents;

518#pragma warning disable OPENAI001

519 

520string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

521AgentClient client = new OpenAIClient(key).GetAgentClient();

522await foreach (AgentAutomationInvocation invocation in client.GetAutomationInvocationsAsync("auto_123"))

523{

524 Console.WriteLine($"{invocation.Id} {invocation.Status} {invocation.SessionId}");

525}

526```

527 

528```ruby456```ruby

529require "openai"457require "openai"

530 458 

744System.out.println(automation);672System.out.println(automation);

745```673```

746 674 

747```csharp

748using OpenAI;

749using OpenAI.Agents;

750#pragma warning disable OPENAI001

751 

752string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

753AgentClient client = new OpenAIClient(key).GetAgentClient();

754AgentAutomation automation = await client.CreateAutomationAsync(

755 new AgentAutomationCreationOptions

756 {

757 Type = AgentAutomationType.Periodic,

758 Name = "Check restaurant reservations",

759 Expression = "0 */2 * * *",

760 Timezone = "America/New_York",

761 Target = new ExistingSessionAutomationTarget

762 {

763 SessionId = "sess_123",

764 Instructions = "Check restaurant availability for our dinner plans. Compare with earlier checks and report newly available tables.",

765 },

766 }

767);

768Console.WriteLine(automation.Id);

769```

770 

771```ruby675```ruby

772require "openai"676require "openai"

773 677 

774client = OpenAI::Client.new678client = OpenAI::Client.new

775automation = client.beta.agents.automations.create(679automation = client.beta.agents.automations.create(

776 body: {680 create_automation_params: {

777 type: "periodic",681 type: "periodic",

778 name: "Check restaurant reservations",682 name: "Check restaurant reservations",

779 expression: "0 */2 * * *",683 expression: "0 */2 * * *",

785 }689 }

786 }690 }

787)691)

788puts automation692puts automation.id

789```693```

790 694 

791```bash695```bash

952System.out.println(automation);856System.out.println(automation);

953```857```

954 858 

955```csharp

956using OpenAI;

957using OpenAI.Agents;

958#pragma warning disable OPENAI001

959 

960string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

961AgentClient client = new OpenAIClient(key).GetAgentClient();

962AgentAutomation automation = await client.CreateAutomationAsync(

963 new AgentAutomationCreationOptions

964 {

965 Type = AgentAutomationType.Periodic,

966 Name = "Monthly spending review",

967 Expression = "0 9 1 * *",

968 Timezone = "America/New_York",

969 Target = new NewSessionAutomationTarget

970 {

971 AgentId = "agt_123",

972 Environment = new EnvironmentParamOpenaiHosted(),

973 Input =

974 [

975 new InputMessageParam(

976 [new InputContentParamInputText("Review my spending for the previous month. Flag unused subscriptions, price increases, and other potential savings for me to review.")]

977 ),

978 ],

979 },

980 }

981);

982Console.WriteLine(automation.Id);

983```

984 

985```ruby859```ruby

986require "openai"860require "openai"

987 861 

988client = OpenAI::Client.new862client = OpenAI::Client.new

989automation = client.beta.agents.automations.create(863automation = client.beta.agents.automations.create(

990 body: {864 create_automation_params: {

991 type: "periodic",865 type: "periodic",

992 name: "Monthly spending review",866 name: "Monthly spending review",

993 expression: "0 9 1 * *",867 expression: "0 9 1 * *",

1010 }884 }

1011 }885 }

1012)886)

1013puts automation887puts automation.id

1014```888```

1015 889 

1016```bash890```bash

1190System.out.println(automation);1064System.out.println(automation);

1191```1065```

1192 1066 

1193```csharp

1194using OpenAI;

1195using OpenAI.Agents;

1196#pragma warning disable OPENAI001

1197 

1198string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

1199AgentClient client = new OpenAIClient(key).GetAgentClient();

1200AgentAutomation automation = await client.CreateAutomationAsync(

1201 new AgentAutomationCreationOptions

1202 {

1203 Type = AgentAutomationType.Periodic,

1204 Name = "Daily suggestions",

1205 Expression = "0 10 * * *",

1206 Timezone = "America/New_York",

1207 Target = new NewSessionAutomationTarget

1208 {

1209 AgentId = "agt_123",

1210 Environment = new EnvironmentParamOpenaiHosted(),

1211 Input =

1212 [

1213 new InputMessageParam(

1214 [new InputContentParamInputText("Review my calendar, tasks, and recent messages for today. Suggest the most useful actions I could take today, with a short reason for each.")]

1215 ),

1216 ],

1217 },

1218 }

1219);

1220Console.WriteLine(automation.Id);

1221```

1222 

1223```ruby1067```ruby

1224require "openai"1068require "openai"

1225 1069 

1226client = OpenAI::Client.new1070client = OpenAI::Client.new

1227automation = client.beta.agents.automations.create(1071automation = client.beta.agents.automations.create(

1228 body: {1072 create_automation_params: {

1229 type: "periodic",1073 type: "periodic",

1230 name: "Daily suggestions",1074 name: "Daily suggestions",

1231 expression: "0 10 * * *",1075 expression: "0 10 * * *",

1248 }1092 }

1249 }1093 }

1250)1094)

1251puts automation1095puts automation.id

1252```1096```

1253 1097 

1254```bash1098```bash

1466System.out.println(automation);1310System.out.println(automation);

1467```1311```

1468 1312 

1469```csharp

1470using OpenAI;

1471using OpenAI.Agents;

1472#pragma warning disable OPENAI001

1473 

1474string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

1475AgentClient client = new OpenAIClient(key).GetAgentClient();

1476AgentAutomation automation = await client.CreateAutomationAsync(

1477 new AgentAutomationCreationOptions

1478 {

1479 Type = AgentAutomationType.Periodic,

1480 Name = "Daily suggestions",

1481 Expression = "0 10 * * *",

1482 Timezone = "America/New_York",

1483 Target = new NewSessionAutomationTarget

1484 {

1485 AgentId = "agt_123",

1486 Environment = new EnvironmentParamOpenaiHosted(),

1487 Input =

1488 [

1489 new InputMessageParam(

1490 [new InputContentParamInputText("Review my calendar, tasks, and recent messages for today. Suggest the most useful actions I could take today, with a short reason for each.")]

1491 ),

1492 ],

1493 },

1494 }

1495);

1496Console.WriteLine(automation.Id);

1497```

1498 

1499```ruby1313```ruby

1500require "openai"1314require "openai"

1501 1315 

1502client = OpenAI::Client.new1316client = OpenAI::Client.new

1503automation = client.beta.agents.automations.create(1317automation = client.beta.agents.automations.create(

1504 body: {1318 create_automation_params: {

1505 type: "periodic",1319 type: "periodic",

1506 name: "Daily suggestions",1320 name: "Daily suggestions",

1507 expression: "0 10 * * *",1321 expression: "0 10 * * *",

1524 }1338 }

1525 }1339 }

1526)1340)

1527puts automation1341puts automation.id

1528```1342```

1529 1343 

1530```bash1344```bash

1713System.out.println(automation);1527System.out.println(automation);

1714```1528```

1715 1529 

1716```csharp

1717using OpenAI;

1718using OpenAI.Agents;

1719#pragma warning disable OPENAI001

1720 

1721string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

1722AgentClient client = new OpenAIClient(key).GetAgentClient();

1723AgentAutomation automation = await client.CreateAutomationAsync(

1724 new AgentAutomationCreationOptions

1725 {

1726 Type = AgentAutomationType.Periodic,

1727 Name = "Monthly spending review",

1728 Expression = "0 9 1 * *",

1729 Timezone = "America/New_York",

1730 Target = new NewSessionAutomationTarget

1731 {

1732 AgentId = "agt_123",

1733 Environment = new EnvironmentParamOpenaiHosted(),

1734 Input =

1735 [

1736 new InputMessageParam(

1737 [new InputContentParamInputText("Review my spending for the previous month. Flag unused subscriptions, price increases, and other potential savings for me to review.")]

1738 ),

1739 ],

1740 },

1741 }

1742);

1743Console.WriteLine(automation.Id);

1744```

1745 

1746```ruby1530```ruby

1747require "openai"1531require "openai"

1748 1532 

1749client = OpenAI::Client.new1533client = OpenAI::Client.new

1750automation = client.beta.agents.automations.create(1534automation = client.beta.agents.automations.create(

1751 body: {1535 create_automation_params: {

1752 type: "periodic",1536 type: "periodic",

1753 name: "Monthly spending review",1537 name: "Monthly spending review",

1754 expression: "0 9 1 * *",1538 expression: "0 9 1 * *",

1771 }1555 }

1772 }1556 }

1773)1557)

1774puts automation1558puts automation.id

1775```1559```

1776 1560 

1777```bash1561```bash

1934System.out.println(automation);1718System.out.println(automation);

1935```1719```

1936 1720 

1937```csharp

1938using OpenAI;

1939using OpenAI.Agents;

1940#pragma warning disable OPENAI001

1941 

1942string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

1943AgentClient client = new OpenAIClient(key).GetAgentClient();

1944AgentAutomation automation = await client.CreateAutomationAsync(

1945 new AgentAutomationCreationOptions

1946 {

1947 Type = AgentAutomationType.Periodic,

1948 Name = "Check restaurant reservations",

1949 Expression = "0 */2 * * *",

1950 Timezone = "America/New_York",

1951 Target = new ExistingSessionAutomationTarget

1952 {

1953 SessionId = "sess_123",

1954 Instructions = "Check restaurant availability for our dinner plans. Compare with earlier checks and report newly available tables.",

1955 },

1956 }

1957);

1958Console.WriteLine(automation.Id);

1959```

1960 

1961```ruby1721```ruby

1962require "openai"1722require "openai"

1963 1723 

1964client = OpenAI::Client.new1724client = OpenAI::Client.new

1965automation = client.beta.agents.automations.create(1725automation = client.beta.agents.automations.create(

1966 body: {1726 create_automation_params: {

1967 type: "periodic",1727 type: "periodic",

1968 name: "Check restaurant reservations",1728 name: "Check restaurant reservations",

1969 expression: "0 */2 * * *",1729 expression: "0 */2 * * *",

1975 }1735 }

1976 }1736 }

1977)1737)

1978puts automation1738puts automation.id

1979```1739```

1980 1740 

1981```bash1741```bash

2108System.out.println(automation);1868System.out.println(automation);

2109```1869```

2110 1870 

2111```csharp

2112using OpenAI;

2113using OpenAI.Agents;

2114#pragma warning disable OPENAI001

2115 

2116string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

2117AgentClient client = new OpenAIClient(key).GetAgentClient();

2118AgentAutomation automation = await client.CreateAutomationAsync(

2119 new AgentAutomationCreationOptions

2120 {

2121 Type = AgentAutomationType.Once,

2122 Name = "Check restaurant reply",

2123 RunAt = 1798794000,

2124 Target = new ExistingSessionAutomationTarget

2125 {

2126 SessionId = "sess_123",

2127 Instructions = "Check whether the restaurant replied about our booking. Summarize any changes to the dinner plans.",

2128 },

2129 }

2130);

2131Console.WriteLine(automation.Id);

2132```

2133 

2134```ruby1871```ruby

2135require "openai"1872require "openai"

2136 1873 

2137client = OpenAI::Client.new1874client = OpenAI::Client.new

2138automation = client.beta.agents.automations.create(1875automation = client.beta.agents.automations.create(

2139 body: {1876 create_automation_params: {

2140 type: "once",1877 type: "once",

2141 name: "Check restaurant reply",1878 name: "Check restaurant reply",

2142 run_at: 1798794000,1879 run_at: 1798794000,

2147 }1884 }

2148 }1885 }

2149)1886)

2150puts automation1887puts automation.id

2151```1888```

2152 1889 

2153```bash1890```bash

2285System.out.println(session.id());2022System.out.println(session.id());

2286```2023```

2287 2024 

2288```csharp

2289using OpenAI;

2290using OpenAI.Agents;

2291#pragma warning disable OPENAI001

2292 

2293string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

2294AgentClient client = new OpenAIClient(key).GetAgentClient();

2295AgentSession session = await client.CreateAgentSessionAsync(

2296 new AgentSessionCreationOptions

2297 {

2298 Agent = new SessionAgentConfigParam

2299 {

2300 Model = "gpt-6-astra",

2301 Instructions = "Use automations to schedule tasks requested by the user. Delegate each scheduled task to a subagent and ask for a concise result. Keep the goal, schedule, and useful summaries in the main session. Adjust or stop schedules when the user asks.",

2302 MultiAgent = new MultiAgentConfigParam { Enabled = true },

2303 Tools = [new AgentToolConfigParamAutomations()],

2304 },

2305 Environment = new EnvironmentParamOpenaiHosted(),

2306 Input =

2307 [

2308 new InputMessageParam(

2309 [new InputContentParamInputText("Every day at 10 AM in America/New_York, review the goals we discuss here and suggest the next actions I could take.")]

2310 ),

2311 ],

2312 }

2313);

2314Console.WriteLine(session.Id);

2315```

2316 

2317```ruby2025```ruby

2318require "openai"2026require "openai"

2319 2027 

2477System.out.println(automation);2185System.out.println(automation);

2478```2186```

2479 2187 

2480```csharp

2481using OpenAI;

2482using OpenAI.Agents;

2483#pragma warning disable OPENAI001

2484 

2485string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

2486AgentClient client = new OpenAIClient(key).GetAgentClient();

2487AgentAutomation automation = await client.CreateAutomationAsync(

2488 new AgentAutomationCreationOptions

2489 {

2490 Type = AgentAutomationType.Once,

2491 Name = "Onboarding follow-up",

2492 RunAt = DateTimeOffset.UtcNow.AddHours(48).ToUnixTimeSeconds(),

2493 Target = new ExistingSessionAutomationTarget

2494 {

2495 SessionId = "sess_123",

2496 Instructions = "Review onboarding progress and send the next onboarding message if the user has not completed onboarding.",

2497 },

2498 }

2499);

2500Console.WriteLine(automation.Id);

2501```

2502 

2503```ruby2188```ruby

2504require "openai"2189require "openai"

2505 2190 

2506client = OpenAI::Client.new2191client = OpenAI::Client.new

2507automation = client.beta.agents.automations.create(2192automation = client.beta.agents.automations.create(

2508 body: {2193 create_automation_params: {

2509 type: "once",2194 type: "once",

2510 name: "Onboarding follow-up",2195 name: "Onboarding follow-up",

2511 run_at: Time.now.to_i + 48 * 60 * 60,2196 run_at: Time.now.to_i + 48 * 60 * 60,

2516 }2201 }

2517 }2202 }

2518)2203)

2519puts automation2204puts automation.id

2520```2205```

2521 2206 

2522```bash2207```bash

2615}2300}

2616```2301```

2617 2302 

2618```csharp

2619using OpenAI;

2620using OpenAI.Agents;

2621#pragma warning disable OPENAI001

2622 

2623string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

2624AgentClient client = new OpenAIClient(key).GetAgentClient();

2625await foreach (AgentAutomationInvocation invocation in client.GetAutomationInvocationsAsync("auto_123"))

2626{

2627 Console.WriteLine($"{invocation.Id} {invocation.Status} {invocation.SessionId}");

2628}

2629```

2630 

2631```ruby2303```ruby

2632require "openai"2304require "openai"

2633 2305 

2728System.out.println(automation);2400System.out.println(automation);

2729```2401```

2730 2402 

2731```csharp

2732using OpenAI;

2733using OpenAI.Agents;

2734#pragma warning disable OPENAI001

2735 

2736string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

2737AgentClient client = new OpenAIClient(key).GetAgentClient();

2738AgentAutomation automation = await client.UpdateAutomationAsync(

2739 "auto_123",

2740 new AgentAutomationUpdateOptions { Expression = "0 11 * * *" }

2741);

2742Console.WriteLine(automation.Id);

2743```

2744 

2745```ruby2403```ruby

2746require "openai"2404require "openai"

2747 2405 

2750 "auto_123",2408 "auto_123",

2751 expression: "0 11 * * *"2409 expression: "0 11 * * *"

2752)2410)

2753puts automation2411puts automation.id

2754```2412```

2755 2413 

2756```bash2414```bash

196System.out.println("Session ID: " + session.id());196System.out.println("Session ID: " + session.id());

197```197```

198 198 

199```csharp

200using System.ClientModel;

201using System.ClientModel.Primitives;

202using System.Text.Json;

203using OpenAI;

204using OpenAI.Agents;

205#pragma warning disable OPENAI001

206 

207string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

208OpenAIClientOptions options = new() { RetryPolicy = new ClientRetryPolicy(maxRetries: 0) };

209AgentClient client = new OpenAIClient(new ApiKeyCredential(key), options).GetAgentClient();

210AgentSession session = await client.CreateAgentSessionAsync(

211 new AgentSessionCreationOptions

212 {

213 Agent = new SessionAgentConfigParam

214 {

215 Model = "gpt-6-astra",

216 Instructions = "Read public documentation in the browser. Do not sign in or change any website data. Report the page title and URL you find.",

217 Tools = [new AgentToolConfigParamComputerUse { IncludeScreenshots = true }],

218 },

219 Environment = new EnvironmentParamOpenaiHosted

220 {

221 Desktop = new DesktopParam(true),

222 Network = new NetworkPolicyParam(NetworkAccessParam.Enabled),

223 },

224 }

225);

226Console.WriteLine($"Session ID: {session.Id}");

227```

228 

229```ruby199```ruby

230require "base64"200require "base64"

231require "openai"201require "openai"

490}460}

491```461```

492 462 

493```csharp

494static async Task RespondToOriginApprovalAsync(

495 AgentClient client, string sessionId,

496 SessionRequiredActionResourceComputerUseApprovalRequest approval)

497{

498 if (Console.IsInputRedirected)

499 {

500 throw new InvalidOperationException("Run this example in an interactive terminal.");

501 }

502 ComputerUseApprovalResponseParam response;

503 if (approval.Request is ComputerUseApprovalRequestKindResourceBrowserOriginAccess origin)

504 {

505 Console.WriteLine($"Origin: {origin.Origin}");

506 Console.WriteLine($"Reason: {origin.Reason ?? "Not supplied"}");

507 string choice;

508 while (true)

509 {

510 Console.Write("Allow browser access? [approve/deny/cancel; default deny] ");

511 choice = (Console.ReadLine() ?? throw new EndOfStreamException("Approval input closed.")).Trim().ToLowerInvariant();

512 if (choice.Length == 0) choice = "deny";

513 if (choice is "approve" or "deny" or "cancel") break;

514 Console.WriteLine("Enter approve, deny, or cancel.");

515 }

516 BrowserOriginAccessDecisionParam decision = choice switch

517 {

518 "approve" => BrowserOriginAccessDecisionParam.Approve,

519 "cancel" => BrowserOriginAccessDecisionParam.Cancel,

520 _ => BrowserOriginAccessDecisionParam.Deny,

521 };

522 response = new ComputerUseApprovalResponseParamBrowserOriginAccess(decision);

523 }

524 else if (approval.Request is ComputerUseApprovalRequestKindResourceBrowserAuthentication)

525 {

526 Console.WriteLine("Sign-in is outside this public-page task; cancelling the request.");

527 response = new ComputerUseApprovalResponseParamBrowserAuthenticationCancel();

528 }

529 else

530 {

531 throw new InvalidOperationException("Unsupported computer-use approval request.");

532 }

533 await client.CreateAgentSessionEventsAsync(

534 sessionId,

535 new CreateSessionEventsParams(

536 [new SessionInputParamAgentSessionInputComputerUseApprovalRequestResult(approval.RequestId, response)]

537 )

538 );

539}

540```

541 

542```ruby463```ruby

543def respond_to_origin_approval(client, session_id, approval)464def respond_to_origin_approval(client, session_id, approval)

544 request = approval.request465 request = approval.request

970}891}

971```892```

972 893 

973```csharp

974byte[]? lastScreenshot = null;

975HashSet<string> handledRequests = new(StringComparer.Ordinal);

976await using var events = await client.GetAgentSessionEventsAsync(session.Id);

977await client.CreateAgentSessionEventsAsync(

978 session.Id,

979 new CreateSessionEventsParams(

980 [

981 new SessionInputParamAgentSessionInputMessage(

982 [

983 new InputMessageParam(

984 [new InputContentParamInputText("Open https://developers.openai.com in the browser. Find the Agents API quickstart, then report its page title and URL.")]

985 ),

986 ]

987 ),

988 ]

989 )

990);

991bool completed = false;

992await foreach (var message in events)

993{

994 using JsonDocument document = JsonDocument.Parse(message.Data.ToMemory());

995 JsonElement current = document.RootElement;

996 string? type = current.GetProperty("type").GetString();

997 if (type == "agent.session.requires_action")

998 {

999 AgentSession latest = await client.RetrieveAgentSessionAsync(session.Id);

1000 foreach (SessionRequiredActionResource action in latest.RequiredActions)

1001 {

1002 if (action is SessionRequiredActionResourceComputerUseApprovalRequest approval

1003 && !handledRequests.Contains(approval.RequestId))

1004 {

1005 await RespondToOriginApprovalAsync(client, session.Id, approval);

1006 handledRequests.Add(approval.RequestId);

1007 }

1008 }

1009 }

1010 else if (type == "agent.session.turn.item.done")

1011 {

1012 // Preserve streamed screenshots; retrieved history may omit image bytes.

1013 JsonElement item = current.GetProperty("item");

1014 if (item.GetProperty("type").GetString() == "computer_use_call"

1015 && item.TryGetProperty("output", out JsonElement output)

1016 && output.ValueKind == JsonValueKind.Object

1017 && output.GetProperty("type").GetString() == "computer_screenshot")

1018 {

1019 const string prefix = "data:image/jpeg;base64,";

1020 string imageUrl = output.GetProperty("image_url").GetString()!;

1021 if (imageUrl.StartsWith(prefix, StringComparison.Ordinal))

1022 {

1023 lastScreenshot = Convert.FromBase64String(imageUrl[prefix.Length..]);

1024 }

1025 }

1026 }

1027 else if (type == "agent.session.turn.output_text.done")

1028 {

1029 Console.WriteLine(current.GetProperty("text").GetString());

1030 }

1031 else if (type is "agent.session.turn.completed" or "agent.session.turn.failed" or "agent.session.turn.cancelled")

1032 {

1033 JsonElement turn = current.GetProperty("turn");

1034 if (turn.TryGetProperty("subagent_id", out JsonElement subagent)

1035 && subagent.ValueKind != JsonValueKind.Null)

1036 {

1037 continue;

1038 }

1039 if (type != "agent.session.turn.completed")

1040 {

1041 throw new InvalidOperationException($"Browser task ended: {type}");

1042 }

1043 completed = true;

1044 break;

1045 }

1046 else if (type == "error")

1047 {

1048 throw new InvalidOperationException(current.GetProperty("error").GetProperty("message").GetString());

1049 }

1050 else if (type is "agent.session.failed" or "agent.session.environment.failed")

1051 {

1052 throw new InvalidOperationException($"Session failed: {type}");

1053 }

1054}

1055if (!completed)

1056{

1057 throw new InvalidOperationException("Stream closed before the browser task finished.");

1058}

1059```

1060 

1061```ruby894```ruby

1062last_screenshot = String.new(encoding: Encoding::BINARY)895last_screenshot = String.new(encoding: Encoding::BINARY)

1063handled_requests = Set.new896handled_requests = Set.new

1315}1148}

1316```1149```

1317 1150 

1318```csharp

1319await foreach (AgentSessionItem item in client.GetAgentSessionItemsAsync(

1320 session.Id, limit: 100, order: AgentSessionItemCollectionOrder.Ascending))

1321{

1322 if (item is not ComputerUseCallItemResource activity)

1323 {

1324 continue;

1325 }

1326 Console.WriteLine($"{activity.Title ?? "Browser activity"}: {activity.Status}");

1327 

1328}

1329if (lastScreenshot is not null)

1330{

1331 FileStreamOptions fileOptions = new()

1332 {

1333 Mode = FileMode.CreateNew,

1334 Access = FileAccess.Write,

1335 Share = FileShare.None,

1336 };

1337 if (!OperatingSystem.IsWindows())

1338 {

1339 fileOptions.UnixCreateMode = UnixFileMode.UserRead | UnixFileMode.UserWrite;

1340 }

1341 await using FileStream file = new("browser-screenshot.jpg", fileOptions);

1342 if (!OperatingSystem.IsWindows())

1343 {

1344 File.SetUnixFileMode(file.SafeFileHandle, UnixFileMode.UserRead | UnixFileMode.UserWrite);

1345 }

1346 await file.WriteAsync(lastScreenshot);

1347 Console.WriteLine("Saved screenshot: browser-screenshot.jpg");

1348}

1349else

1350{

1351 Console.WriteLine("No screenshot was returned.");

1352}

1353```

1354 

1355```ruby1151```ruby

1356items = client.beta.agents.sessions.items.list(1152items = client.beta.agents.sessions.items.list(

1357 session.id,1153 session.id,

2178}1974}

2179```1975```

2180 1976 

2181```csharp

2182using System.ClientModel;

2183using System.ClientModel.Primitives;

2184using System.Globalization;

2185using System.Text;

2186using System.Text.Json;

2187using OpenAI;

2188using OpenAI.Agents;

2189#pragma warning disable OPENAI001

2190 

2191static string ReadLine(string prompt)

2192{

2193 Console.Write(prompt);

2194 return Console.ReadLine() ?? "cancel";

2195}

2196 

2197static string ReadHidden(string prompt)

2198{

2199 if (Console.IsInputRedirected)

2200 {

2201 throw new InvalidOperationException("Run this sign-in example in a terminal.");

2202 }

2203 Console.Write(prompt);

2204 StringBuilder value = new();

2205 while (true)

2206 {

2207 ConsoleKeyInfo key = Console.ReadKey(intercept: true);

2208 if (key.Key == ConsoleKey.Enter)

2209 {

2210 Console.WriteLine();

2211 return value.ToString();

2212 }

2213 if (key.Key == ConsoleKey.Backspace)

2214 {

2215 if (value.Length > 0)

2216 {

2217 value.Length--;

2218 }

2219 }

2220 else if (!char.IsControl(key.KeyChar))

2221 {

2222 value.Append(key.KeyChar);

2223 }

2224 }

2225}

2226 

2227static async Task RespondToComputerUseApprovalAsync(

2228 AgentClient client, string sessionId,

2229 SessionRequiredActionResourceComputerUseApprovalRequest approval)

2230{

2231 if (Console.IsInputRedirected)

2232 {

2233 throw new InvalidOperationException("Run this example in an interactive terminal.");

2234 }

2235 ComputerUseApprovalResponseParam response;

2236 if (approval.Request is ComputerUseApprovalRequestKindResourceBrowserOriginAccess origin)

2237 {

2238 Console.WriteLine($"Origin: {origin.Origin}");

2239 Console.WriteLine($"Reason: {origin.Reason ?? "Not supplied"}");

2240 string choice;

2241 while (true)

2242 {

2243 Console.Write("Allow browser access? [approve/deny/cancel; default deny] ");

2244 choice = (Console.ReadLine() ?? throw new EndOfStreamException("Approval input closed.")).Trim().ToLowerInvariant();

2245 if (choice.Length == 0) choice = "deny";

2246 if (choice is "approve" or "deny" or "cancel") break;

2247 Console.WriteLine("Enter approve, deny, or cancel.");

2248 }

2249 BrowserOriginAccessDecisionParam decision = choice switch

2250 {

2251 "approve" => BrowserOriginAccessDecisionParam.Approve,

2252 "cancel" => BrowserOriginAccessDecisionParam.Cancel,

2253 _ => BrowserOriginAccessDecisionParam.Deny,

2254 };

2255 response = new ComputerUseApprovalResponseParamBrowserOriginAccess(decision);

2256 }

2257 else if (approval.Request is ComputerUseApprovalRequestKindResourceBrowserAuthentication challenge)

2258 {

2259 async Task CancelAuthenticationAsync()

2260 {

2261 await client.CreateAgentSessionEventsAsync(

2262 sessionId,

2263 new CreateSessionEventsParams(

2264 [new SessionInputParamAgentSessionInputComputerUseApprovalRequestResult(

2265 approval.RequestId, new ComputerUseApprovalResponseParamBrowserAuthenticationCancel())]

2266 )

2267 );

2268 }

2269 

2270 Console.WriteLine(challenge.Reason ?? "The agent needs you to sign in.");

2271 Console.WriteLine($"Credential origin: {challenge.CredentialOrigin ?? "Not supplied"}");

2272 string consent = ReadLine("Have you verified the sign-in destination? [y/N] ").Trim();

2273 if (!consent.Equals("y", StringComparison.OrdinalIgnoreCase)

2274 && !consent.Equals("yes", StringComparison.OrdinalIgnoreCase))

2275 {

2276 await CancelAuthenticationAsync();

2277 return;

2278 }

2279 

2280 ComputerUseApprovalResponseParamBrowserAuthenticationSubmit submission = new([]);

2281 var activeFields = challenge.Fields.ToList();

2282 if (challenge.Options.Count > 0)

2283 {

2284 for (int index = 0; index < challenge.Options.Count; index++)

2285 {

2286 Console.WriteLine($"{index + 1}. {challenge.Options[index].Label}");

2287 }

2288 while (true)

2289 {

2290 string choice = ReadLine("Choose a sign-in method, or enter cancel: ").Trim();

2291 if (choice.Equals("cancel", StringComparison.OrdinalIgnoreCase))

2292 {

2293 await CancelAuthenticationAsync();

2294 return;

2295 }

2296 if (!int.TryParse(choice, NumberStyles.None, CultureInfo.InvariantCulture, out int index)

2297 || index < 1 || index > challenge.Options.Count)

2298 {

2299 Console.WriteLine("Enter a method number from the list, or cancel.");

2300 continue;

2301 }

2302 var option = challenge.Options[index - 1];

2303 submission.SelectedOption = option.Id;

2304 var fieldsById = challenge.Fields.ToDictionary(field => field.Id, StringComparer.Ordinal);

2305 activeFields = option.FieldIds.Select(id => fieldsById[id]).ToList();

2306 break;

2307 }

2308 }

2309 while (true)

2310 {

2311 foreach (var field in activeFields)

2312 {

2313 while (true)

2314 {

2315 string choices = field.Required

2316 ? "enter/cancel; default enter" : "enter/skip/cancel; default skip";

2317 string choice = ReadLine($"{field.Label} [{choices}]: ").Trim().ToLowerInvariant();

2318 if (choice == "cancel")

2319 {

2320 await CancelAuthenticationAsync();

2321 return;

2322 }

2323 if (choice.Length == 0) choice = field.Required ? "enter" : "skip";

2324 if (choice == "skip" && !field.Required) break;

2325 if (choice != "enter")

2326 {

2327 Console.WriteLine("Choose one of the displayed options.");

2328 continue;

2329 }

2330 string value = ReadHidden($"{field.Label}: ");

2331 if (value.Length == 0)

2332 {

2333 if (!field.Required) break;

2334 Console.WriteLine("This field is required.");

2335 continue;

2336 }

2337 submission.Fields.Add(new BrowserAuthenticationFieldValueParam(field.Id, value));

2338 break;

2339 }

2340 }

2341 if (challenge.Options.Count > 0 || activeFields.Count == 0 || submission.Fields.Count > 0) break;

2342 Console.WriteLine("Enter at least one field to submit this form, or cancel.");

2343 }

2344 response = submission;

2345 }

2346 else

2347 {

2348 throw new InvalidOperationException("Unsupported computer-use approval request.");

2349 }

2350 await client.CreateAgentSessionEventsAsync(

2351 sessionId,

2352 new CreateSessionEventsParams(

2353 [new SessionInputParamAgentSessionInputComputerUseApprovalRequestResult(approval.RequestId, response)]

2354 )

2355 );

2356 // Admission does not establish sign-in or navigation success; keep following the session.

2357}

2358```

2359 

2360```ruby1977```ruby

2361require "io/console"1978require "io/console"

2362 1979 

2916}2533}

2917```2534```

2918 2535 

2919```csharp

2920string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;

2921// An uncertain approval must not resend credentials automatically.

2922OpenAIClientOptions options = new() { RetryPolicy = new ClientRetryPolicy(maxRetries: 0) };

2923AgentClient client = new OpenAIClient(new ApiKeyCredential(key), options).GetAgentClient();

2924AgentSession session = await client.CreateAgentSessionAsync(

2925 new AgentSessionCreationOptions

2926 {

2927 Agent = new SessionAgentConfigParam

2928 {

2929 Model = "gpt-6-astra",

2930 Instructions = "Read the requested GitHub issue list in the browser. Request sign-in when needed. Do not create, edit, comment on, or close issues.",

2931 Tools = [new AgentToolConfigParamComputerUse { IncludeScreenshots = false }],

2932 },

2933 Environment = new EnvironmentParamOpenaiHosted

2934 {

2935 Desktop = new DesktopParam(true),

2936 Network = new NetworkPolicyParam(NetworkAccessParam.Enabled),

2937 },

2938 }

2939);

2940Console.WriteLine($"Session ID: {session.Id}");

2941HashSet<string> handledRequests = new(StringComparer.Ordinal);

2942try

2943{

2944 await using var events = await client.GetAgentSessionEventsAsync(session.Id);

2945 await client.CreateAgentSessionEventsAsync(

2946 session.Id,

2947 new CreateSessionEventsParams(

2948 [

2949 new SessionInputParamAgentSessionInputMessage(

2950 [

2951 new InputMessageParam(

2952 // Replace this illustrative URL with your private repository.

2953 [new InputContentParamInputText("Open https://github.com/acme/private-repo/issues in the browser. Sign in if needed, then report the title and URL of the most recently updated open issue. Do not make changes.")]

2954 ),

2955 ]

2956 ),

2957 ]

2958 )

2959 );

2960 bool completed = false;

2961 await foreach (var message in events)

2962 {

2963 using JsonDocument document = JsonDocument.Parse(message.Data.ToMemory());

2964 JsonElement current = document.RootElement;

2965 string? type = current.GetProperty("type").GetString();

2966 if (type == "agent.session.requires_action")

2967 {

2968 AgentSession latest = await client.RetrieveAgentSessionAsync(session.Id);

2969 foreach (SessionRequiredActionResource action in latest.RequiredActions)

2970 {

2971 if (action is SessionRequiredActionResourceComputerUseApprovalRequest approval

2972 && !handledRequests.Contains(approval.RequestId))

2973 {

2974 await RespondToComputerUseApprovalAsync(client, session.Id, approval);

2975 handledRequests.Add(approval.RequestId);

2976 }

2977 }

2978 }

2979 else if (type == "agent.session.turn.output_text.done")

2980 {

2981 Console.WriteLine(current.GetProperty("text").GetString());

2982 }

2983 else if (type is "agent.session.turn.completed" or "agent.session.turn.failed" or "agent.session.turn.cancelled")

2984 {

2985 JsonElement turn = current.GetProperty("turn");

2986 if (turn.TryGetProperty("subagent_id", out JsonElement subagent)

2987 && subagent.ValueKind != JsonValueKind.Null)

2988 {

2989 continue;

2990 }

2991 if (type != "agent.session.turn.completed")

2992 {

2993 throw new InvalidOperationException($"Browser task ended: {type}");

2994 }

2995 completed = true;

2996 break;

2997 }

2998 else if (type == "error")

2999 {

3000 throw new InvalidOperationException(current.GetProperty("error").GetProperty("message").GetString());

3001 }

3002 else if (type is "agent.session.failed" or "agent.session.environment.failed")

3003 {

3004 throw new InvalidOperationException($"Session failed: {type}");

3005 }

3006 }

3007 if (!completed)

3008 {

3009 throw new InvalidOperationException("Stream closed before the browser task finished.");

3010 }

3011}

3012catch

3013{

3014 Console.Error.WriteLine($"Session {session.Id} was kept. Retrieve it and check pending actions before sending anything again.");

3015 throw;

3016}

3017await client.DeleteAgentSessionAsync(session.Id);

3018```

3019 

3020```ruby2536```ruby

3021require "openai"2537require "openai"

3022 2538 

3239client.beta().agents().sessions().delete(session.id());2755client.beta().agents().sessions().delete(session.id());

3240```2756```

3241 2757 

3242```csharp

3243await client.DeleteAgentSessionAsync(session.Id);

3244```

3245 

3246```ruby2758```ruby

3247begin2759begin

3248 client.beta.agents.sessions.delete(session.id) if completed2760 client.beta.agents.sessions.delete(session.id) if completed

1800The JavaScript sample uses `npm install openai@^7.10.0 ws`.1800The JavaScript sample uses `npm install openai@^7.10.0 ws`.

1801The Ruby sample uses `gem install openai async-websocket`.1801The Ruby sample uses `gem install openai async-websocket`.

1802 1802 

1803For Go, run `go get github.com/openai/openai-go/v3@v3.97.0`.1803For Go, run `go get github.com/openai/openai-go/v3@v3.98.0`.

1804For Java, add the Maven dependency `com.openai:openai-java:4.101.0`.1804For Java, add the Maven dependency `com.openai:openai-java:4.101.0`.

1805These Go and Java SDK versions provide native Responses WebSocket support.1805These Go and Java SDK versions provide native Responses WebSocket support.

1806 1806 

749 }749 }

750 ]750 ]

751 },751 },

752 model: "gpt-6-astra"752 model: "gpt-6-astra",

753 sampling_params: { reasoning_effort: :low }

753 }754 }

754)755)

755puts(run.id)756puts(run.id)

40 console](https://platform.openai.com/settings/organization/general) before40 console](https://platform.openai.com/settings/organization/general) before

41 using GPT Image models.41 using GPT Image models.

42 42 

43### GPT Image 2.643### GPT-Image-2.6

44 44 

45GPT Image 2.6 includes [Sunburst](https://developers.openai.com/api/docs/models/gpt-image-2.6-sunburst) for detailed visual work and [Flare](https://developers.openai.com/api/docs/models/gpt-image-2.6-flare) for fast iteration. Both models support complexity control, markup-guided edits, SVG output, and animated GIF output through the Image API. The existing examples below use GPT Image 2.5.45GPT-Image-2.6 includes [Sunburst](https://developers.openai.com/api/docs/models/gpt-image-2.6-sunburst) for detailed visual work and [Flare](https://developers.openai.com/api/docs/models/gpt-image-2.6-flare) for fast iteration. Both models support complexity control, markup-guided edits, SVG output, and animated GIF output through the Image API. The existing examples below use GPT-Image-2.5.

46 46 

47#### Set image complexity47#### Set image complexity

48 48 

2559 2559 

2560### Guide an edit with markup2560### Guide an edit with markup

2561 2561 

2562Use the Image API’s `POST /v1/images/edits` endpoint for markup-guided edits with supported GPT Image 2.5 and 2.6 models. For regional edits with the Responses API, use a [mask](#edit-an-image-using-a-mask). Use an annotation layer to show where a change should happen and describe the change in `prompt`.2562Use the Image API’s `POST /v1/images/edits` endpoint for markup-guided edits with supported GPT-Image-2.5 and GPT-Image-2.6 models. For regional edits with the Responses API, use a [mask](#edit-an-image-using-a-mask). Use an annotation layer to show where a change should happen and describe the change in `prompt`.

2563 2563 

2564For example, download the [kitchen photo](https://developers.openai.com/images/platform/guides/image-prompting/kitchen.webp) and [transparent overlay](https://developers.openai.com/images/platform/guides/image-prompting/markup-vase-overlay-gpt-image-2-6.png) into the same directory. The overlay circles the vase to recolor.2564For example, download the [kitchen photo](https://developers.openai.com/images/platform/guides/image-prompting/kitchen.webp) and [transparent overlay](https://developers.openai.com/images/platform/guides/image-prompting/markup-vase-overlay-gpt-image-2-6.png) into the same directory. The overlay circles the vase to recolor.

2565 2565 

3307 3307 

3308 <figure className="m-0 min-w-0 [&_[data-codex-screenshot-overlay]_img]:bg-surface">3308 <figure className="m-0 min-w-0 [&_[data-codex-screenshot-overlay]_img]:bg-surface">

3309 <figcaption className="mb-2 text-sm font-semibold">3309 <figcaption className="mb-2 text-sm font-semibold">

3310 GPT Image 2.6 Flare3310 GPT-Image-2.6 Flare

3311 </figcaption>3311 </figcaption>

3312 3312

3313 3313 

3317 </figure>3317 </figure>

3318 <figure className="m-0 min-w-0 [&_img]:bg-white">3318 <figure className="m-0 min-w-0 [&_img]:bg-white">

3319 <figcaption className="mb-2 text-sm font-semibold">3319 <figcaption className="mb-2 text-sm font-semibold">

3320 GPT Image 2.6 Sunburst3320 GPT-Image-2.6 Sunburst

3321 </figcaption>3321 </figcaption>

3322 3322

3323 3323 

3623 3623 

3624## Cost and latency3624## Cost and latency

3625 3625 

3626### GPT Image 2.6 costs3626### GPT-Image-2.6 costs

3627 3627 

3628Image output costs $30 per million billable tokens. Use the [calculator](#calculating-costs) to estimate the output cost for one image.3628Image output costs $30 per million billable tokens. Use the [calculator](#calculating-costs) to estimate the output cost for one image.

3629 3629 

3631 3631 

3632Markup-guided edits use the same token rates as other edits, with no extra fee. For SVG output, you pay the image model’s rate for the reference image and the authoring model’s rate for the tokens it uses to produce the SVG. The total depends on how many tokens each model uses.3632Markup-guided edits use the same token rates as other edits, with no extra fee. For SVG output, you pay the image model’s rate for the reference image and the authoring model’s rate for the tokens it uses to produce the SVG. The total depends on how many tokens each model uses.

3633 3633 

3634### GPT Image 2.5 costs3634### GPT-Image-2.5 costs

3635 3635 

3636Responses API requests include the mainline model's token usage in addition to image generation costs.3636Responses API requests include the mainline model's token usage in addition to image generation costs.

3637 3637 

3638Both GPT Image 2.5 models use the same token rates: $8 per million image input tokens, $2 per million cached image input tokens, $30 per million image output tokens, $5 per million text input tokens, and $1.25 per million cached text input tokens. See [pricing](https://developers.openai.com/api/docs/pricing#image-generation).3638Both GPT-Image-2.5 models use the same token rates: $8 per million image input tokens, $2 per million cached image input tokens, $30 per million image output tokens, $5 per million text input tokens, and $1.25 per million cached text input tokens. See [pricing](https://developers.openai.com/api/docs/pricing#image-generation).

3639 3639 

3640Use the response's `usage` to measure token consumption for your prompts, sizes, and quality settings. Equal token rates don't mean equal cost per image: token consumption can differ by model and quality setting. For older-model pricing examples, see [Earlier GPT Image models](#earlier-gpt-image-models).3640Use the response's `usage` to measure token consumption for your prompts, sizes, and quality settings. Equal token rates don't mean equal cost per image: token consumption can differ by model and quality setting. For older-model pricing examples, see [Earlier GPT Image models](#earlier-gpt-image-models).

3641 3641 

3642### Cached input pricing3642### Cached input pricing

3643 3643 

3644For GPT Image 2 and GPT Image 2.5, cached input pricing applies only to the image generation tool in the Responses API. It doesn't apply to direct Images API requests, including `/v1/images/edits`.3644For GPT-Image-2 and GPT-Image-2.5, cached input pricing applies only to the image generation tool in the Responses API. It doesn't apply to direct Images API requests, including `/v1/images/edits`.

3645 3645 

3646Cached image generation inputs are reflected in billing, but their cached token counts aren't included in the Responses API output. The response's `usage` can't verify these cache hits.3646Cached image generation inputs are reflected in billing, but their cached token counts aren't included in the Responses API output. The response's `usage` can't verify these cache hits.

3647 3647 

3654### Calculating costs3654### Calculating costs

3655 3655 

3656Select a model, quality, and size to estimate output tokens and image output cost.3656Select a model, quality, and size to estimate output tokens and image output cost.

3657For GPT Image 2.6 and 2.5 Sunburst and Flare, the quality options are `low`, `medium`, `high`, `xhigh`, and `max`.3657For the Sunburst and Flare models in both GPT-Image-2.6 and GPT-Image-2.5, the quality options are `low`, `medium`, `high`, `xhigh`, and `max`.

3658For `gpt-image-2`, the options are `low`, `medium`, and `high`.3658For `gpt-image-2`, the options are `low`, `medium`, and `high`.

3659The models can use different token counts for the same quality setting and share the same price per image output token.3659The models can use different token counts for the same quality setting and share the same price per image output token.

3660Use explicit quality and size values for this estimate; `auto` depends on the generated image.3660Use explicit quality and size values for this estimate; `auto` depends on the generated image.

3674 3674 

3675## Earlier GPT Image models3675## Earlier GPT Image models

3676 3676 

3677The details below apply to earlier models, not Sunburst or Flare. For new integrations, use one of the GPT Image 2.5 models described above.3677The details below apply to earlier models, not Sunburst or Flare. For new integrations, use [GPT-Image-2.6 Sunburst or Flare](#gpt-image-26).

3678 3678 

3679<details>3679<details>

3680<summary>GPT Image 2 settings and input fidelity</summary>3680<summary>GPT-Image-2 settings and input fidelity</summary>

3681 3681 

3682`gpt-image-2` accepts any resolution in the `size` parameter when it satisfies the constraints below. Square images are typically fastest to generate.3682`gpt-image-2` accepts any resolution in the `size` parameter when it satisfies the constraints below. Square images are typically fastest to generate.

3683 3683 

3800### Historical output costs3800### Historical output costs

3801 3801 

3802`gpt-image-2` supports thousands of valid resolutions; the table below lists the3802`gpt-image-2` supports thousands of valid resolutions; the table below lists the

3803same sizes used for previous GPT Image models for comparison. For GPT Image 1.5,3803same sizes used for previous GPT Image models for comparison. For GPT-Image-1.5,

3804GPT Image 1, and GPT Image 1 Mini, the legacy per-image output pricing table is3804GPT-Image-1, and GPT-Image-1 Mini, the legacy per-image output pricing table is

3805also listed below. You should still account for text and image input tokens when3805also listed below. You should still account for text and image input tokens when

3806estimating the total cost of a request.3806estimating the total cost of a request.

3807 3807 

3829 <tbody>3829 <tbody>

3830 <tr>3830 <tr>

3831 <td rowSpan="3" style={{ padding: "8px", width: "28%" }}>3831 <td rowSpan="3" style={{ padding: "8px", width: "28%" }}>

3832 GPT Image 23832 GPT-Image-2

3833 3833

3834 3834 

3835 3835

3856 3856 

3857 <tr>3857 <tr>

3858 <td rowSpan="3" style={{ padding: "8px", width: "28%" }}>3858 <td rowSpan="3" style={{ padding: "8px", width: "28%" }}>

3859 GPT Image 1.53859 GPT-Image-1.5

3860 </td>3860 </td>

3861 <td style={{ padding: "8px" }}>Low</td>3861 <td style={{ padding: "8px" }}>Low</td>

3862 <td style={{ padding: "8px" }}>$0.009</td>3862 <td style={{ padding: "8px" }}>$0.009</td>

3878 3878 

3879 <tr>3879 <tr>

3880 <td rowSpan="3" style={{ padding: "8px", width: "28%" }}>3880 <td rowSpan="3" style={{ padding: "8px", width: "28%" }}>

3881 GPT Image 13881 GPT-Image-1

3882 </td>3882 </td>

3883 <td style={{ padding: "8px" }}>Low</td>3883 <td style={{ padding: "8px" }}>Low</td>

3884 <td style={{ padding: "8px" }}>$0.011</td>3884 <td style={{ padding: "8px" }}>$0.011</td>

3900 3900 

3901 <tr>3901 <tr>

3902 <td rowSpan="3" style={{ padding: "8px", width: "28%" }}>3902 <td rowSpan="3" style={{ padding: "8px", width: "28%" }}>

3903 GPT Image 1 Mini3903 GPT-Image-1 Mini

3904 </td>3904 </td>

3905 <td style={{ padding: "8px" }}>Low</td>3905 <td style={{ padding: "8px" }}>Low</td>

3906 <td style={{ padding: "8px" }}>$0.005</td>3906 <td style={{ padding: "8px" }}>$0.005</td>

13 id="gpt-image-2.6-guide"13 id="gpt-image-2.6-guide"

14 className="m-0 text-3xl font-semibold text-default"14 className="m-0 text-3xl font-semibold text-default"

15 >15 >

16 {"GPT Image 2.6 prompting guide"}16 {"GPT-Image-2.6 prompting guide"}

17 </h2>17 </h2>

18 18

19 19 

27 27 

28Start with the image you need, then describe the subject, composition, style, and constraints. For edits, identify what should change and what must stay the same. Refine one thing at a time and inspect the result.28Start with the image you need, then describe the subject, composition, style, and constraints. For edits, identify what should change and what must stay the same. Refine one thing at a time and inspect the result.

29 29 

30GPT Image 2.6 Flare is the smaller model for workflows where speed matters most. GPT Image 2.6 Sunburst is the base model for workflows that need more detail or precise edits. Both support image generation, editing, and transparent backgrounds.30GPT-Image-2.6 Flare is the smaller model for workflows where speed matters most. GPT-Image-2.6 Sunburst is the base model for workflows that need more detail or precise edits. Both support image generation, editing, and transparent backgrounds.

31 31 

32For API setup and request examples, see the [image generation guide](https://developers.openai.com/api/docs/guides/image-generation).32For API setup and request examples, see the [image generation guide](https://developers.openai.com/api/docs/guides/image-generation).

33 33 

34## Choose a model34## Choose a model

35 35 

36For a new workflow, start with **GPT Image 2.6 Flare** if response time matters most. Start with **GPT Image 2.6 Sunburst** if the image must meet demanding requirements for detail, layout, or edit accuracy.36For a new workflow, start with **GPT-Image-2.6 Flare** if response time matters most. Start with **GPT-Image-2.6 Sunburst** if the image must meet demanding requirements for detail, layout, or edit accuracy.

37 37 

38| Your current workflow | Start by testing |38| Your current workflow | Start by testing |

39| --------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |39| --------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |

40| Your existing GPT Image 2 workflow meets your quality requirements, or you use GPT Image 2.5 Flare. | `gpt-image-2.6-flare`. Check quality and response time on the prompts you already use. |40| Your existing GPT-Image-2 workflow meets your quality requirements, or you use GPT-Image-2.5 Flare. | `gpt-image-2.6-flare`. Check quality and response time on the prompts you already use. |

41| GPT Image 2 falls short on a complex task, or you use GPT Image 2.5 Sunburst. | `gpt-image-2.6-sunburst`. Check the details that determine whether you can use the image. |41| GPT-Image-2 falls short on a complex task, or you use GPT-Image-2.5 Sunburst. | `gpt-image-2.6-sunburst`. Check the details that determine whether you can use the image. |

42 42 

43If Sunburst meets your requirements, try Flare with the same prompts, reference images, dimensions, and quality setting. Compare the results and response times on your workload.43If Sunburst meets your requirements, try Flare with the same prompts, reference images, dimensions, and quality setting. Compare the results and response times on your workload.

44 44 

46 46 

47Set these fields in the API request. Use the prompt to describe the image you want.47Set these fields in the API request. Use the prompt to describe the image you want.

48 48 

49| Parameter | GPT Image 2.6 settings |49| Parameter | GPT-Image-2.6 settings |

50| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |50| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

51| `model` | Use `gpt-image-2.6-flare` or `gpt-image-2.6-sunburst`. |51| `model` | Use `gpt-image-2.6-flare` or `gpt-image-2.6-sunburst`. |

52| `quality` | Controls how much visual detail the model can render, such as texture or small lettering. Choose `auto`, `low`, `medium`, `high`, `xhigh`, or `max`. |52| `quality` | Controls how much visual detail the model can render, such as texture or small lettering. Choose `auto`, `low`, `medium`, `high`, `xhigh`, or `max`. |

60 60 

61For a custom `size`, use multiples of 16 for both dimensions and an aspect ratio from 1:3 to 3:1. The landscape slide example uses `1536x864`.61For a custom `size`, use multiples of 16 for both dimensions and an aspect ratio from 1:3 to 3:1. The landscape slide example uses `1536x864`.

62 62 

63Omit `input_fidelity` on image edits. GPT Image 2.6 does not support `reasoning.summary`.63Omit `input_fidelity` on image edits. GPT-Image-2.6 does not support `reasoning.summary`.

64 64 

65## Migrate an existing workflow65## Migrate an existing workflow

66 66 

671. **Save a baseline.** Collect representative prompts, reference images, and outputs from your current model. Include difficult edits, exact text, product geometry, and transparent assets where relevant.671. **Save a baseline.** Collect representative prompts, reference images, and outputs from your current model. Include difficult edits, exact text, product geometry, and transparent assets where relevant.

682. **Test the corresponding model.** For a 2.5 Flare workflow, try 2.6 Flare first. For a 2.5 Sunburst workflow, try 2.6 Sunburst first. For a GPT Image 2 workflow, use the [model selection table](#choose-a-model).682. **Test the corresponding model.** For a 2.5 Flare workflow, try 2.6 Flare first. For a 2.5 Sunburst workflow, try 2.6 Sunburst first. For a GPT-Image-2 workflow, use the [model selection table](#choose-a-model).

693. **Keep the first comparison consistent.** Use the same prompt, reference images, size, quality, and output format. Leave complexity at the model default.693. **Keep the first comparison consistent.** Use the same prompt, reference images, size, quality, and output format. Leave complexity at the model default.

704. **Inspect the result.** Check text, layout, identity, and details that should survive an edit. For a sequence of edits, check the final image as well as each intermediate result.704. **Inspect the result.** Check text, layout, identity, and details that should survive an edit. For a sequence of edits, check the final image as well as each intermediate result.

715. **Tune one setting at a time.** Change either quality or complexity. Repeat each request and compare how often the output meets your criteria and how long it takes.715. **Tune one setting at a time.** Change either quality or complexity. Repeat each request and compare how often the output meets your criteria and how long it takes.

726. **Roll out by workflow.** Move a small share of traffic after the new model meets your criteria. Track response time, failures, retries, and cost per accepted image before you expand.726. **Roll out by workflow.** Move a small share of traffic after the new model meets your criteria. Track response time, failures, retries, and cost per accepted image before you expand.

73 73 

74When migrating from GPT Image 1 or 1.5, use its reference tab to check parameter differences and shutdown dates. If part of an image must remain pixel-identical, composite the approved edit into the original.74When migrating from GPT-Image-1 or GPT-Image-1.5, use its reference tab to check parameter differences and shutdown dates. If part of an image must remain pixel-identical, composite the approved edit into the original.

75 75 

76## Prompting fundamentals76## Prompting fundamentals

77 77 

94 94 

95> A premium handcrafted layered paper-cut illustration of a football team celebrating a championship victory inside a packed stadium.95> A premium handcrafted layered paper-cut illustration of a football team celebrating a championship victory inside a packed stadium.

96 96 

97GPT Image 2.6 Sunburst generated one image at each complexity level with the same prompt, `size="1024x1536"`, `quality="medium"`, and PNG output. Compare the trophy and where the word “CHAMPIONS” appears.97GPT-Image-2.6 Sunburst generated one image at each complexity level with the same prompt, `size="1024x1536"`, `quality="medium"`, and PNG output. Compare the trophy and where the word “CHAMPIONS” appears.

98 98 

99 99 

100 100 

146 146 

147 <figure className="m-0 min-w-0 [&_[data-codex-screenshot-overlay]_img]:bg-surface">147 <figure className="m-0 min-w-0 [&_[data-codex-screenshot-overlay]_img]:bg-surface">

148 <figcaption className="mb-2 text-sm font-semibold">148 <figcaption className="mb-2 text-sm font-semibold">

149 GPT Image 2.6 Flare149 GPT-Image-2.6 Flare

150 </figcaption>150 </figcaption>

151 151

152 152 

156 </figure>156 </figure>

157 <figure className="m-0 min-w-0 [&_img]:bg-white">157 <figure className="m-0 min-w-0 [&_img]:bg-white">

158 <figcaption className="mb-2 text-sm font-semibold">158 <figcaption className="mb-2 text-sm font-semibold">

159 GPT Image 2.6 Sunburst159 GPT-Image-2.6 Sunburst

160 </figcaption>160 </figcaption>

161 161

162 162 

201 201 

202 <figure className="m-0 min-w-0">202 <figure className="m-0 min-w-0">

203 <figcaption className="mb-2 min-h-10 text-sm font-semibold">203 <figcaption className="mb-2 min-h-10 text-sm font-semibold">

204 GPT Image 2.6 Flare204 GPT-Image-2.6 Flare

205 </figcaption>205 </figcaption>

206 206

207 207 

208![Photorealistic portrait of a sailor repairing a net — GPT Image 2.6 Flare](<https://developers.openai.com/images/platform/guides/image-prompting/photorealism-gpt-image-2-6-flare.webp>)208![Photorealistic portrait of a sailor repairing a net — GPT-Image-2.6 Flare](<https://developers.openai.com/images/platform/guides/image-prompting/photorealism-gpt-image-2-6-flare.webp>)

209 209 

210 210 

211 </figure>211 </figure>

212 <figure className="m-0 min-w-0">212 <figure className="m-0 min-w-0">

213 <figcaption className="mb-2 min-h-10 text-sm font-semibold">213 <figcaption className="mb-2 min-h-10 text-sm font-semibold">

214 GPT Image 2.6 Sunburst214 GPT-Image-2.6 Sunburst

215 </figcaption>215 </figcaption>

216 216

217 217 

218![Photorealistic portrait of a sailor repairing a net — GPT Image 2.6 Sunburst](<https://developers.openai.com/images/platform/guides/image-prompting/photorealism-gpt-image-2-6-sunburst.webp>)218![Photorealistic portrait of a sailor repairing a net — GPT-Image-2.6 Sunburst](<https://developers.openai.com/images/platform/guides/image-prompting/photorealism-gpt-image-2-6-sunburst.webp>)

219 219 

220 220 

221 </figure>221 </figure>

238 238 

239 <figure className="m-0 min-w-0">239 <figure className="m-0 min-w-0">

240 <figcaption className="mb-2 min-h-10 text-sm font-semibold">240 <figcaption className="mb-2 min-h-10 text-sm font-semibold">

241 GPT Image 2.6 Flare241 GPT-Image-2.6 Flare

242 </figcaption>242 </figcaption>

243 243

244 244 

245![Diagram explaining an automatic coffee machine — GPT Image 2.6 Flare](<https://developers.openai.com/images/platform/guides/image-prompting/infographic-coffee-machine-gpt-image-2-6-flare.webp>)245![Diagram explaining an automatic coffee machine — GPT-Image-2.6 Flare](<https://developers.openai.com/images/platform/guides/image-prompting/infographic-coffee-machine-gpt-image-2-6-flare.webp>)

246 246 

247 247 

248 </figure>248 </figure>

249 <figure className="m-0 min-w-0">249 <figure className="m-0 min-w-0">

250 <figcaption className="mb-2 min-h-10 text-sm font-semibold">250 <figcaption className="mb-2 min-h-10 text-sm font-semibold">

251 GPT Image 2.6 Sunburst251 GPT-Image-2.6 Sunburst

252 </figcaption>252 </figcaption>

253 253

254 254 

255![Diagram explaining an automatic coffee machine — GPT Image 2.6 Sunburst](<https://developers.openai.com/images/platform/guides/image-prompting/infographic-coffee-machine-gpt-image-2-6-sunburst.webp>)255![Diagram explaining an automatic coffee machine — GPT-Image-2.6 Sunburst](<https://developers.openai.com/images/platform/guides/image-prompting/infographic-coffee-machine-gpt-image-2-6-sunburst.webp>)

256 256 

257 257 

258 </figure>258 </figure>

278 278 

279 <figure className="m-0 min-w-0">279 <figure className="m-0 min-w-0">

280 <figcaption className="mb-2 min-h-10 text-sm font-semibold">280 <figcaption className="mb-2 min-h-10 text-sm font-semibold">

281 GPT Image 2.6 Flare281 GPT-Image-2.6 Flare

282 </figcaption>282 </figcaption>

283 283

284 284 

285![Thread streetwear campaign with the requested tagline — GPT Image 2.6 Flare](<https://developers.openai.com/images/platform/guides/image-prompting/thread-ad-gpt-image-2-6-flare.webp>)285![Thread streetwear campaign with the requested tagline — GPT-Image-2.6 Flare](<https://developers.openai.com/images/platform/guides/image-prompting/thread-ad-gpt-image-2-6-flare.webp>)

286 286 

287 287 

288 </figure>288 </figure>

289 <figure className="m-0 min-w-0">289 <figure className="m-0 min-w-0">

290 <figcaption className="mb-2 min-h-10 text-sm font-semibold">290 <figcaption className="mb-2 min-h-10 text-sm font-semibold">

291 GPT Image 2.6 Sunburst291 GPT-Image-2.6 Sunburst

292 </figcaption>292 </figcaption>

293 293

294 294 

295![Thread streetwear campaign with the requested tagline — GPT Image 2.6 Sunburst](<https://developers.openai.com/images/platform/guides/image-prompting/thread-ad-gpt-image-2-6-sunburst.webp>)295![Thread streetwear campaign with the requested tagline — GPT-Image-2.6 Sunburst](<https://developers.openai.com/images/platform/guides/image-prompting/thread-ad-gpt-image-2-6-sunburst.webp>)

296 296 

297 297 

298 </figure>298 </figure>

318 318 

319 <figure className="m-0 min-w-0">319 <figure className="m-0 min-w-0">

320 <figcaption className="mb-2 text-sm font-semibold">320 <figcaption className="mb-2 text-sm font-semibold">

321 GPT Image 2.6 Flare321 GPT-Image-2.6 Flare

322 </figcaption>322 </figcaption>

323 323

324 324 

328 </figure>328 </figure>

329 <figure className="m-0 min-w-0">329 <figure className="m-0 min-w-0">

330 <figcaption className="mb-2 text-sm font-semibold">330 <figcaption className="mb-2 text-sm font-semibold">

331 GPT Image 2.6 Sunburst331 GPT-Image-2.6 Sunburst

332 </figcaption>332 </figcaption>

333 333

334 334 

354 354 

355 <figure className="m-0 min-w-0">355 <figure className="m-0 min-w-0">

356 <figcaption className="mb-2 min-h-10 text-sm font-semibold">356 <figcaption className="mb-2 min-h-10 text-sm font-semibold">

357 GPT Image 2.6 Flare357 GPT-Image-2.6 Flare

358 </figcaption>358 </figcaption>

359 359

360 360 

361![Crowd scene in Bethel, New York, in August 1969 — GPT Image 2.6 Flare](<https://developers.openai.com/images/platform/guides/image-prompting/world-knowledge-gpt-image-2-6-flare.webp>)361![Crowd scene in Bethel, New York, in August 1969 — GPT-Image-2.6 Flare](<https://developers.openai.com/images/platform/guides/image-prompting/world-knowledge-gpt-image-2-6-flare.webp>)

362 362 

363 363 

364 </figure>364 </figure>

365 <figure className="m-0 min-w-0">365 <figure className="m-0 min-w-0">

366 <figcaption className="mb-2 min-h-10 text-sm font-semibold">366 <figcaption className="mb-2 min-h-10 text-sm font-semibold">

367 GPT Image 2.6 Sunburst367 GPT-Image-2.6 Sunburst

368 </figcaption>368 </figcaption>

369 369

370 370 

371![Crowd scene in Bethel, New York, in August 1969 — GPT Image 2.6 Sunburst](<https://developers.openai.com/images/platform/guides/image-prompting/world-knowledge-gpt-image-2-6-sunburst.webp>)371![Crowd scene in Bethel, New York, in August 1969 — GPT-Image-2.6 Sunburst](<https://developers.openai.com/images/platform/guides/image-prompting/world-knowledge-gpt-image-2-6-sunburst.webp>)

372 372 

373 373 

374 </figure>374 </figure>

393 393 

394 <figure className="m-0 min-w-0">394 <figure className="m-0 min-w-0">

395 <figcaption className="mb-2 min-h-10 text-sm font-semibold">395 <figcaption className="mb-2 min-h-10 text-sm font-semibold">

396 GPT Image 2.6 Flare396 GPT-Image-2.6 Flare

397 </figcaption>397 </figcaption>

398 398

399 399 

400![Four-panel comic about a pet at home — GPT Image 2.6 Flare](<https://developers.openai.com/images/platform/guides/image-prompting/comic-reel-gpt-image-2-6-flare.webp>)400![Four-panel comic about a pet at home — GPT-Image-2.6 Flare](<https://developers.openai.com/images/platform/guides/image-prompting/comic-reel-gpt-image-2-6-flare.webp>)

401 401 

402 402 

403 </figure>403 </figure>