Documentation 2026-08-04 22:59 UTC to 2026-08-05 18:01 UTC

36)36)

37```37```

38 38 

39```go

40input, err := os.Open("revenue-forecast.csv")

41if err != nil {

42 panic(err)

43}

44defer input.Close()

45file, err := client.Files.New(context.Background(), openai.FileNewParams{

46 File: input,

47 Purpose: openai.FilePurposeAssistants,

48})

49if err != nil {

50 panic(err)

51}

52```

53 

39```bash54```bash

40curl https://api.openai.com/v1/files \55curl https://api.openai.com/v1/files \

41 -H "Authorization: Bearer $OPENAI_API_KEY" \56 -H "Authorization: Bearer $OPENAI_API_KEY" \

71)86)

72```87```

73 88 

89```go

90assistant, err := client.Beta.Assistants.New(context.Background(), openai.BetaAssistantNewParams{

91 Name: openai.String("Data visualizer"),

92 Description: openai.String("You are great at creating beautiful data visualizations. You analyze data present in .csv files, understand trends, and come up with data visualizations relevant to those trends. You also share a brief text summary of the trends observed."),

93 Model: shared.ChatModelGPT4o,

94 Tools: []openai.AssistantToolUnionParam{{OfCodeInterpreter: &openai.CodeInterpreterToolParam{}}},

95 ToolResources: openai.BetaAssistantNewParamsToolResources{

96 CodeInterpreter: openai.BetaAssistantNewParamsToolResourcesCodeInterpreter{FileIDs: []string{"file-BK7bzQj3FfZFXr7DbL6xJwfo"}},

97 },

98})

99if err != nil {

100 panic(err)

101}

102```

103 

74```bash104```bash

75curl https://api.openai.com/v1/assistants \105curl https://api.openai.com/v1/assistants \

76 -H "Authorization: Bearer $OPENAI_API_KEY" \106 -H "Authorization: Bearer $OPENAI_API_KEY" \

131)161)

132```162```

133 163 

164```go

165thread, err := client.Beta.Threads.New(context.Background(), openai.BetaThreadNewParams{

166 Messages: []openai.BetaThreadNewParamsMessage{{

167 Role: "user",

168 Content: openai.BetaThreadNewParamsMessageContentUnion{

169 OfString: openai.String("Create 3 data visualizations based on the trends in this file."),

170 },

171 Attachments: []openai.BetaThreadNewParamsMessageAttachment{{

172 FileID: openai.String("file-ACq8OjcLQm2eIG0BvRM4z5qX"),

173 Tools: []openai.BetaThreadNewParamsMessageAttachmentToolUnion{{OfCodeInterpreter: &openai.CodeInterpreterToolParam{}}},

174 }},

175 }},

176})

177if err != nil {

178 panic(err)

179}

180```

181 

134```bash182```bash

135curl https://api.openai.com/v1/threads \183curl https://api.openai.com/v1/threads \

136 -H "Authorization: Bearer $OPENAI_API_KEY" \184 -H "Authorization: Bearer $OPENAI_API_KEY" \

217)265)

218```266```

219 267 

268```go

269image, err := os.Open("myimage.png")

270if err != nil {

271 panic(err)

272}

273defer image.Close()

274file, err := client.Files.New(context.Background(), openai.FileNewParams{

275 File: image,

276 Purpose: openai.FilePurposeVision,

277})

278if err != nil {

279 panic(err)

280}

281thread, err := client.Beta.Threads.New(context.Background(), openai.BetaThreadNewParams{

282 Messages: []openai.BetaThreadNewParamsMessage{{

283 Role: "user",

284 Content: openai.BetaThreadNewParamsMessageContentUnion{OfArrayOfContentParts: []openai.MessageContentPartParamUnion{

285 openai.MessageContentPartParamOfText("What is the difference between these images?"),

286 openai.MessageContentPartParamOfImageURL(openai.ImageURLParam{URL: "https://openai-documentation.vercel.app/images/cat_and_otter.png"}),

287 openai.MessageContentPartParamOfImageFile(openai.ImageFileParam{FileID: file.ID}),

288 }},

289 }},

290})

291if err != nil {

292 panic(err)

293}

294```

295 

220```bash296```bash

221# Upload a file with an "vision" purpose297# Upload a file with an "vision" purpose

222curl https://api.openai.com/v1/files \298curl https://api.openai.com/v1/files \

304)380)

305```381```

306 382 

383```go

384thread, err := client.Beta.Threads.New(context.Background(), openai.BetaThreadNewParams{

385 Messages: []openai.BetaThreadNewParamsMessage{{

386 Role: "user",

387 Content: openai.BetaThreadNewParamsMessageContentUnion{OfArrayOfContentParts: []openai.MessageContentPartParamUnion{

388 openai.MessageContentPartParamOfText("What is this an image of?"),

389 openai.MessageContentPartParamOfImageURL(openai.ImageURLParam{

390 URL: "https://openai-documentation.vercel.app/images/cat_and_otter.png",

391 Detail: openai.ImageURLDetailHigh,

392 }),

393 }},

394 }},

395})

396if err != nil {

397 panic(err)

398}

399```

400 

307```bash401```bash

308curl https://api.openai.com/v1/threads \402curl https://api.openai.com/v1/threads \

309 -H "Authorization: Bearer $OPENAI_API_KEY" \403 -H "Authorization: Bearer $OPENAI_API_KEY" \

410message_content.value += "\n" + "\n".join(citations)504message_content.value += "\n" + "\n".join(citations)

411```505```

412 506 

507```go

508message, err := client.Beta.Threads.Messages.Get(context.Background(), "thread_abc123", "msg_abc123")

509if err != nil {

510 panic(err)

511}

512if len(message.Content) == 0 || message.Content[0].Type != "text" {

513 panic("message does not contain text")

514}

515messageContent := message.Content[0].AsText().Text

516citations := make([]string, 0, len(messageContent.Annotations))

517for index, annotation := range messageContent.Annotations {

518 messageContent.Value = strings.ReplaceAll(messageContent.Value, annotation.Text, fmt.Sprintf(" [%d]", index))

519 switch annotation.Type {

520 case "file_citation":

521 citation := annotation.AsFileCitation()

522 file, err := client.Files.Get(context.Background(), citation.FileCitation.FileID)

523 if err != nil {

524 panic(err)

525 }

526 citations = append(citations, fmt.Sprintf("[%d] %s", index, file.Filename))

527 case "file_path":

528 filePath := annotation.AsFilePath()

529 file, err := client.Files.Get(context.Background(), filePath.FilePath.FileID)

530 if err != nil {

531 panic(err)

532 }

533 response, err := client.Files.Content(context.Background(), filePath.FilePath.FileID)

534 if err != nil {

535 panic(err)

536 }

537 defer response.Body.Close()

538 if err := os.MkdirAll("downloads", 0o755); err != nil {

539 panic(err)

540 }

541 outputPath := filepath.Join("downloads", filepath.Base(file.Filename))

542 output, err := os.Create(outputPath)

543 if err != nil {

544 panic(err)

545 }

546 if _, err := io.Copy(output, response.Body); err != nil {

547 output.Close()

548 panic(err)

549 }

550 if err := output.Close(); err != nil {

551 panic(err)

552 }

553 citations = append(citations, fmt.Sprintf("[%d] Downloaded %s", index, outputPath))

554 }

555}

556messageContent.Value += "\n" + strings.Join(citations, "\n")

557fmt.Println(messageContent.Value)

558```

559 

413 560 

414## Runs and Run Steps561## Runs and Run Steps

415 562 

428)575)

429```576```

430 577 

578```go

579_, err := client.Beta.Threads.Runs.New(context.Background(), "thread_abc123", openai.BetaThreadRunNewParams{

580 AssistantID: "asst_ToSF7Gb04YMj8AMMm50ZLLtY",

581})

582if err != nil {

583 panic(err)

584}

585```

586 

431```bash587```bash

432curl https://api.openai.com/v1/threads/THREAD_ID/runs \588curl https://api.openai.com/v1/threads/THREAD_ID/runs \

433 -H "Authorization: Bearer $OPENAI_API_KEY" \589 -H "Authorization: Bearer $OPENAI_API_KEY" \

460)616)

461```617```

462 618 

619```go

620_, err := client.Beta.Threads.Runs.New(context.Background(), "thread_abc123", openai.BetaThreadRunNewParams{

621 AssistantID: "asst_ToSF7Gb04YMj8AMMm50ZLLtY",

622 Model: shared.ChatModelGPT4o,

623 Instructions: openai.String("New instructions that override the Assistant instructions"),

624 Tools: []openai.AssistantToolUnionParam{

625 {OfCodeInterpreter: &openai.CodeInterpreterToolParam{}},

626 {OfFileSearch: &openai.FileSearchToolParam{}},

627 },

628})

629if err != nil {

630 panic(err)

631}

632```

633 

463```bash634```bash

464curl https://api.openai.com/v1/threads/THREAD_ID/runs \635curl https://api.openai.com/v1/threads/THREAD_ID/runs \

465 -H "Authorization: Bearer $OPENAI_API_KEY" \636 -H "Authorization: Bearer $OPENAI_API_KEY" \

81 81 

82### Request example82### Request example

83 83 

84#### Python

85 

86#### Go

87 

84### Response example88### Response example

85 89 

86 90 

124 128 

125### Request example129### Request example

126 130 

131#### Python

132 

133#### Go

134 

127### Response example135### Response example

128 136 

129 137 

35)35)

36```36```

37 37 

38```go

39assistant, err := client.Beta.Assistants.New(context.Background(), openai.BetaAssistantNewParams{

40 Instructions: openai.String("You are a personal math tutor. When asked a math question, write and run code to answer the question."),

41 Model: shared.ChatModelGPT4o,

42 Tools: []openai.AssistantToolUnionParam{{OfCodeInterpreter: &openai.CodeInterpreterToolParam{}}},

43})

44if err != nil {

45 panic(err)

46}

47```

48 

38```bash49```bash

39curl https://api.openai.com/v1/assistants \50curl https://api.openai.com/v1/assistants \

40 -u :$OPENAI_API_KEY \51 -u :$OPENAI_API_KEY \

90)101)

91```102```

92 103 

104```go

105input, err := os.Open("mydata.csv")

106if err != nil {

107 panic(err)

108}

109defer input.Close()

110file, err := client.Files.New(context.Background(), openai.FileNewParams{

111 File: input,

112 Purpose: openai.FilePurposeAssistants,

113})

114if err != nil {

115 panic(err)

116}

117assistant, err := client.Beta.Assistants.New(context.Background(), openai.BetaAssistantNewParams{

118 Instructions: openai.String("You are a personal math tutor. When asked a math question, write and run code to answer the question."),

119 Model: shared.ChatModelGPT4o,

120 Tools: []openai.AssistantToolUnionParam{{OfCodeInterpreter: &openai.CodeInterpreterToolParam{}}},

121 ToolResources: openai.BetaAssistantNewParamsToolResources{

122 CodeInterpreter: openai.BetaAssistantNewParamsToolResourcesCodeInterpreter{FileIDs: []string{file.ID}},

123 },

124})

125if err != nil {

126 panic(err)

127}

128```

129 

93```bash130```bash

94# Upload a file with an "assistants" purpose131# Upload a file with an "assistants" purpose

95curl https://api.openai.com/v1/files \132curl https://api.openai.com/v1/files \

148)185)

149```186```

150 187 

188```go

189thread, err := client.Beta.Threads.New(context.Background(), openai.BetaThreadNewParams{

190 Messages: []openai.BetaThreadNewParamsMessage{{

191 Role: "user",

192 Content: openai.BetaThreadNewParamsMessageContentUnion{OfString: openai.String("I need to solve the equation `3x + 11 = 14`. Can you help me?")},

193 Attachments: []openai.BetaThreadNewParamsMessageAttachment{{

194 FileID: openai.String("file-ACq8OjcLQm2eIG0BvRM4z5qX"),

195 Tools: []openai.BetaThreadNewParamsMessageAttachmentToolUnion{{OfCodeInterpreter: &openai.CodeInterpreterToolParam{}}},

196 }},

197 }},

198})

199if err != nil {

200 panic(err)

201}

202```

203 

151```bash204```bash

152curl https://api.openai.com/v1/threads/thread_abc123/messages \205curl https://api.openai.com/v1/threads/thread_abc123/messages \

153 -u :$OPENAI_API_KEY \206 -u :$OPENAI_API_KEY \

235 file.write(image_data_bytes)288 file.write(image_data_bytes)

236```289```

237 290 

291```go

292response, err := client.Files.Content(context.Background(), "file-abc123")

293if err != nil {

294 panic(err)

295}

296defer response.Body.Close()

297output, err := os.Create("./my-image.png")

298if err != nil {

299 panic(err)

300}

301if _, err := io.Copy(output, response.Body); err != nil {

302 output.Close()

303 panic(err)

304}

305if err := output.Close(); err != nil {

306 panic(err)

307}

308```

309 

238```bash310```bash

239curl https://api.openai.com/v1/files/file-abc123/content \311curl https://api.openai.com/v1/files/file-abc123/content \

240 -H "Authorization: Bearer $OPENAI_API_KEY" \312 -H "Authorization: Bearer $OPENAI_API_KEY" \

291)363)

292```364```

293 365 

366```go

367runSteps, err := client.Beta.Threads.Runs.Steps.List(context.Background(), "thread_abc123", "run_abc123", openai.BetaThreadRunStepListParams{})

368if err != nil {

369 panic(err)

370}

371fmt.Println(runSteps.Data)

372```

373 

294```bash374```bash

295curl https://api.openai.com/v1/threads/thread_abc123/runs/RUN_ID/steps \375curl https://api.openai.com/v1/threads/thread_abc123/runs/RUN_ID/steps \

296 -H "Authorization: Bearer $OPENAI_API_KEY" \376 -H "Authorization: Bearer $OPENAI_API_KEY" \

46)46)

47```47```

48 48 

49```go

50assistant, err := client.Beta.Assistants.New(context.Background(), openai.BetaAssistantNewParams{

51 Name: openai.String("Financial Analyst Assistant"),

52 Instructions: openai.String("You are an expert financial analyst. Use your knowledge base to answer questions about audited financial statements."),

53 Model: shared.ChatModelGPT4o,

54 Tools: []openai.AssistantToolUnionParam{{OfFileSearch: &openai.FileSearchToolParam{}}},

55})

56if err != nil {

57 panic(err)

58}

59```

60 

49```bash61```bash

50curl https://api.openai.com/v1/assistants \62curl https://api.openai.com/v1/assistants \

51-H "Content-Type: application/json" \63-H "Content-Type: application/json" \

126)138)

127```139```

128 140 

141```go

142_, err := client.Beta.Assistants.Update(context.Background(), "asst_abc123", openai.BetaAssistantUpdateParams{

143 ToolResources: openai.BetaAssistantUpdateParamsToolResources{

144 FileSearch: openai.BetaAssistantUpdateParamsToolResourcesFileSearch{

145 VectorStoreIDs: []string{"vs_abc123"},

146 },

147 },

148})

149if err != nil {

150 panic(err)

151}

152```

153 

129 154 

130### Step 4: Create a thread155### Step 4: Create a thread

131 156 

406)431)

407```432```

408 433 

434```go

435vectorStore, err := client.VectorStores.New(context.Background(), openai.VectorStoreNewParams{

436 Name: openai.String("Product Documentation"),

437 FileIDs: []string{"file_1", "file_2", "file_3", "file_4", "file_5"},

438})

439if err != nil {

440 panic(err)

441}

442```

443 

409 444 

410Adding files to vector stores is an async operation. To ensure the operation is complete, we recommend that you use the 'create and poll' helpers in our official SDKs. If you're not using the SDKs, you can retrieve the `vector_store` object and monitor its [`file_counts`](https://developers.openai.com/api/reference/resources/vector_stores#vector-stores/object-file_counts) property to see the result of the file ingestion operation.445Adding files to vector stores is an async operation. To ensure the operation is complete, we recommend that you use the 'create and poll' helpers in our official SDKs. If you're not using the SDKs, you can retrieve the `vector_store` object and monitor its [`file_counts`](https://developers.openai.com/api/reference/resources/vector_stores#vector-stores/object-file_counts) property to see the result of the file ingestion operation.

411 446 

428)463)

429```464```

430 465 

466```go

467_, err := client.VectorStores.Files.NewAndPoll(context.Background(), "vs_abc123", openai.VectorStoreFileNewParams{

468 FileID: "file-abc123",

469}, 1000)

470if err != nil {

471 panic(err)

472}

473```

474 

431 475 

432Alternatively, you can add several files to a vector store by [creating batches](https://developers.openai.com/api/reference/resources/vector_stores/subresources/file_batches/methods/create) of up to 500 files.476Alternatively, you can add several files to a vector store by [creating batches](https://developers.openai.com/api/reference/resources/vector_stores/subresources/file_batches/methods/create) of up to 500 files.

433 477 

476)520)

477```521```

478 522 

523```go

524_, err := client.VectorStores.FileBatches.NewAndPoll(context.Background(), "vs_abc123", openai.VectorStoreFileBatchNewParams{

525 Files: []openai.VectorStoreFileBatchNewParamsFile{

526 {

527 FileID: "file_1",

528 Attributes: map[string]openai.VectorStoreFileBatchNewParamsFileAttributeUnion{

529 "category": {OfString: openai.String("finance")},

530 },

531 },

532 {

533 FileID: "file_2",

534 ChunkingStrategy: openai.FileChunkingStrategyParamUnion{OfStatic: &openai.StaticFileChunkingStrategyObjectParam{

535 Static: openai.StaticFileChunkingStrategyParam{MaxChunkSizeTokens: 1000, ChunkOverlapTokens: 200},

536 }},

537 },

538 },

539}, 1000)

540if err != nil {

541 panic(err)

542}

543```

544 

479 545 

480Similarly, these files can be removed from a vector store by either:546Similarly, these files can be removed from a vector store by either:

481 547 

527)593)

528```594```

529 595 

596```go

597assistant, err := client.Beta.Assistants.New(context.Background(), openai.BetaAssistantNewParams{

598 Instructions: openai.String("You are a helpful product support assistant and you answer questions based on the files provided to you."),

599 Model: shared.ChatModelGPT4o,

600 Tools: []openai.AssistantToolUnionParam{{OfFileSearch: &openai.FileSearchToolParam{}}},

601 ToolResources: openai.BetaAssistantNewParamsToolResources{

602 FileSearch: openai.BetaAssistantNewParamsToolResourcesFileSearch{VectorStoreIDs: []string{"vs_1"}},

603 },

604})

605if err != nil {

606 panic(err)

607}

608thread, err := client.Beta.Threads.New(context.Background(), openai.BetaThreadNewParams{

609 Messages: []openai.BetaThreadNewParamsMessage{{

610 Role: "user",

611 Content: openai.BetaThreadNewParamsMessageContentUnion{OfString: openai.String("How do I cancel my subscription?")},

612 }},

613 ToolResources: openai.BetaThreadNewParamsToolResources{

614 FileSearch: openai.BetaThreadNewParamsToolResourcesFileSearch{VectorStoreIDs: []string{"vs_2"}},

615 },

616})

617if err != nil {

618 panic(err)

619}

620```

621 

530 622 

531You can also attach a vector store to Threads or Assistants after they're created by updating them with the right `tool_resources`.623You can also attach a vector store to Threads or Assistants after they're created by updating them with the right `tool_resources`.

532 624 

600print(run_step)692print(run_step)

601```693```

602 694 

695```go

696runStep, err := client.Beta.Threads.Runs.Steps.Get(

697 context.Background(),

698 "thread_abc123",

699 "run_abc123",

700 "step_abc123",

701 openai.BetaThreadRunStepGetParams{Include: []openai.RunStepInclude{

702 openai.RunStepIncludeStepDetailsToolCallsFileSearchResultsContent,

703 }},

704)

705if err != nil {

706 panic(err)

707}

708fmt.Println(runStep)

709```

710 

603```bash711```bash

604curl -g https://api.openai.com/v1/threads/thread_abc123/runs/run_abc123/steps/step_abc123?include[]=step_details.tool_calls[*].file_search.results[*].content \712curl -g https://api.openai.com/v1/threads/thread_abc123/runs/run_abc123/steps/step_abc123?include[]=step_details.tool_calls[*].file_search.results[*].content \

605-H "Authorization: Bearer $OPENAI_API_KEY" \713-H "Authorization: Bearer $OPENAI_API_KEY" \

662)770)

663```771```

664 772 

773```go

774vectorStore, err := client.VectorStores.New(context.Background(), openai.VectorStoreNewParams{

775 Name: openai.String("Product Documentation"),

776 FileIDs: []string{"file_1", "file_2", "file_3", "file_4", "file_5"},

777 ExpiresAfter: openai.VectorStoreNewParamsExpiresAfter{Days: 7},

778})

779if err != nil {

780 panic(err)

781}

782```

783 

665 784 

666**Thread vector stores have default expiration policies**785**Thread vector stores have default expiration policies**

667 786 

707 )826 )

708```827```

709 828 

829```go

830pager := client.VectorStores.Files.ListAutoPaging(context.Background(), "vs_expired", openai.VectorStoreFileListParams{})

831fileIDs := make([]string, 0)

832for pager.Next() {

833 fileIDs = append(fileIDs, pager.Current().ID)

834}

835if err := pager.Err(); err != nil {

836 panic(err)

837}

838vectorStore, err := client.VectorStores.New(context.Background(), openai.VectorStoreNewParams{

839 Name: openai.String("rag-store"),

840})

841if err != nil {

842 panic(err)

843}

844_, err = client.Beta.Threads.Update(context.Background(), "thread_abc123", openai.BetaThreadUpdateParams{

845 ToolResources: openai.BetaThreadUpdateParamsToolResources{

846 FileSearch: openai.BetaThreadUpdateParamsToolResourcesFileSearch{VectorStoreIDs: []string{vectorStore.ID}},

847 },

848})

849if err != nil {

850 panic(err)

851}

852for start := 0; start < len(fileIDs); start += 100 {

853 end := min(start+100, len(fileIDs))

854 if _, err := client.VectorStores.FileBatches.NewAndPoll(context.Background(), vectorStore.ID, openai.VectorStoreFileBatchNewParams{

855 FileIDs: fileIDs[start:end],

856 }, 1000); err != nil {

857 panic(err)

858 }

859}

860```

861 

710 862 

711## Supported files863## Supported files

712 864 

129)129)

130```130```

131 131 

132```go

133assistant, err := client.Beta.Assistants.New(context.Background(), openai.BetaAssistantNewParams{

134 Model: shared.ChatModelGPT4o,

135 Instructions: openai.String("You are a weather bot. Use the provided functions to answer questions."),

136 Tools: weatherTools(false),

137})

138if err != nil {

139 panic(err)

140}

141 

142func weatherTools(strict bool) []openai.AssistantToolUnionParam {

143 return []openai.AssistantToolUnionParam{

144 openai.AssistantToolParamOfFunction(shared.FunctionDefinitionParam{

145 Name: "get_current_temperature",

146 Description: openai.String("Get the current temperature for a specific location"),

147 Parameters: map[string]any{

148 "type": "object",

149 "properties": map[string]any{

150 "location": map[string]any{"type": "string", "description": "The city and state, e.g., San Francisco, CA"},

151 "unit": map[string]any{"type": "string", "enum": []string{"Celsius", "Fahrenheit"}, "description": "The temperature unit to use. Infer this from the user's location."},

152 },

153 "required": []string{"location", "unit"},

154 },

155 Strict: openai.Bool(strict),

156 }),

157 openai.AssistantToolParamOfFunction(shared.FunctionDefinitionParam{

158 Name: "get_rain_probability",

159 Description: openai.String("Get the probability of rain for a specific location"),

160 Parameters: map[string]any{

161 "type": "object",

162 "properties": map[string]any{

163 "location": map[string]any{"type": "string", "description": "The city and state, e.g., San Francisco, CA"},

164 },

165 "required": []string{"location"},

166 },

167 Strict: openai.Bool(strict),

168 }),

169 }

170}

171```

172 

132 173 

133### Step 2: Create a Thread and add Messages174### Step 2: Create a Thread and add Messages

134 175 

152)193)

153```194```

154 195 

196```go

197thread, err := client.Beta.Threads.New(context.Background(), openai.BetaThreadNewParams{})

198if err != nil {

199 panic(err)

200}

201_, err = client.Beta.Threads.Messages.New(context.Background(), thread.ID, openai.BetaThreadMessageNewParams{

202 Role: "user",

203 Content: openai.BetaThreadMessageNewParamsContentUnion{

204 OfString: openai.String("What's the weather in San Francisco today and the likelihood it'll rain?"),

205 },

206})

207if err != nil {

208 panic(err)

209}

210```

211 

155 212 

156### Step 3: Initiate a Run213### Step 3: Initiate a Run

157 214 

346 403

347 404 

348Runs are asynchronous, which means you'll want to monitor their `status` by polling the Run object until a405Runs are asynchronous, which means you'll want to monitor their `status` by polling the Run object until a

349[terminal status](https://developers.openai.com/api/docs/assistants/deep-dive#runs-and-run-steps) is reached. For convenience, the 'create and poll' SDK helpers assist both in406[terminal status](https://developers.openai.com/api/docs/assistants/deep-dive#runs-and-run-steps) is reached. For convenience, where available, the 'create and poll' SDK helpers assist both in

350creating the run and then polling for its completion. Once the Run completes, you can list the407creating the run and then polling for its completion. The Go tab shows the equivalent workflow with manual polling. Once the Run completes, you can list the

351Messages added to the Thread by the Assistant. Finally, you would retrieve all the `tool_outputs` from408Messages added to the Thread by the Assistant. Finally, you would retrieve all the `tool_outputs` from

352`required_action` and submit them at the same time to the 'submit tool outputs and poll' helper.409`required_action` and submit them at the same time to the 'submit tool outputs and poll' helper.

353 410 

456 print(run.status)513 print(run.status)

457```514```

458 515 

516```go

517run, err := client.Beta.Threads.Runs.New(context.Background(), thread.ID, openai.BetaThreadRunNewParams{

518 AssistantID: assistant.ID,

519})

520if err != nil {

521 panic(err)

522}

523run = pollRun(client, thread.ID, run)

524if run.Status == openai.RunStatusRequiresAction {

525 outputs := make([]openai.BetaThreadRunSubmitToolOutputsParamsToolOutput, 0)

526 for _, toolCall := range run.RequiredAction.SubmitToolOutputs.ToolCalls {

527 switch toolCall.Function.Name {

528 case "get_current_temperature":

529 outputs = append(outputs, openai.BetaThreadRunSubmitToolOutputsParamsToolOutput{

530 ToolCallID: openai.String(toolCall.ID), Output: openai.String("57"),

531 })

532 case "get_rain_probability":

533 outputs = append(outputs, openai.BetaThreadRunSubmitToolOutputsParamsToolOutput{

534 ToolCallID: openai.String(toolCall.ID), Output: openai.String("0.06"),

535 })

536 }

537 }

538 if len(outputs) > 0 {

539 run, err = client.Beta.Threads.Runs.SubmitToolOutputs(

540 context.Background(), thread.ID, run.ID,

541 openai.BetaThreadRunSubmitToolOutputsParams{ToolOutputs: outputs},

542 )

543 if err != nil {

544 panic(err)

545 }

546 run = pollRun(client, thread.ID, run)

547 }

548}

549if run.Status == openai.RunStatusCompleted {

550 messages, err := client.Beta.Threads.Messages.List(context.Background(), thread.ID, openai.BetaThreadMessageListParams{})

551 if err != nil {

552 panic(err)

553 }

554 fmt.Println(messages.Data)

555} else {

556 fmt.Println(run.Status)

557}

558 

559func pollRun(client openai.Client, threadID string, run *openai.Run) *openai.Run {

560 for run.Status == openai.RunStatusQueued || run.Status == openai.RunStatusInProgress {

561 time.Sleep(time.Second)

562 next, err := client.Beta.Threads.Runs.Get(context.Background(), threadID, run.ID)

563 if err != nil {

564 panic(err)

565 }

566 run = next

567 }

568 return run

569}

570```

571 

459 572 

460 573 

461### Using Structured Outputs574### Using Structured Outputs

587 ],700 ],

588)701)

589```702```

703 

704```go

705assistant, err := client.Beta.Assistants.New(context.Background(), openai.BetaAssistantNewParams{

706 Model: shared.ChatModelGPT4o2024_08_06,

707 Instructions: openai.String("You are a weather bot. Use the provided functions to answer questions."),

708 Tools: weatherTools(),

709})

710if err != nil {

711 panic(err)

712}

713 

714func weatherTools() []openai.AssistantToolUnionParam {

715 return []openai.AssistantToolUnionParam{

716 openai.AssistantToolParamOfFunction(shared.FunctionDefinitionParam{

717 Name: "get_current_temperature",

718 Description: openai.String("Get the current temperature for a specific location"),

719 Parameters: map[string]any{

720 "type": "object",

721 "properties": map[string]any{

722 "location": map[string]any{"type": "string", "description": "The city and state, e.g., San Francisco, CA"},

723 "unit": map[string]any{"type": "string", "enum": []string{"Celsius", "Fahrenheit"}, "description": "The temperature unit to use. Infer this from the user's location."},

724 },

725 "required": []string{"location", "unit"},

726 "additionalProperties": false,

727 },

728 Strict: openai.Bool(true),

729 }),

730 openai.AssistantToolParamOfFunction(shared.FunctionDefinitionParam{

731 Name: "get_rain_probability",

732 Description: openai.String("Get the probability of rain for a specific location"),

733 Parameters: map[string]any{

734 "type": "object",

735 "properties": map[string]any{

736 "location": map[string]any{"type": "string", "description": "The city and state, e.g., San Francisco, CA"},

737 },

738 "required": []string{"location"},

739 "additionalProperties": false,

740 },

741 Strict: openai.Bool(true),

742 }),

743 }

744}

745```

153 153 

154| Shutdown date | Model snapshot | Recommended replacement base model |154| Shutdown date | Model snapshot | Recommended replacement base model |

155| ---------------- | ---------------------------- | ---------------------------------- |155| ---------------- | ---------------------------- | ---------------------------------- |

156| October 23, 2026 | `ft-gpt-3.5-turbo` | `gpt-5.4-mini` |156| October 23, 2026 | `ft-gpt-3.5-turbo` | `gpt-5.6-terra` |

157| October 23, 2026 | `ft-gpt-4` | `gpt-5.5` |157| October 23, 2026 | `ft-gpt-4` | `gpt-5.6-sol` |

158| October 23, 2026 | `ft-gpt-4.1-nano-2025-04-14` | `gpt-5.4-nano` |158| October 23, 2026 | `ft-gpt-4.1-nano-2025-04-14` | `gpt-5.6-luna` |

159| October 23, 2026 | `ft-babbage-002` | `gpt-5.4-mini` |159| October 23, 2026 | `ft-babbage-002` | `gpt-5.6-terra` |

160| October 23, 2026 | `ft-davinci-002` | `gpt-5.4-mini` |160| October 23, 2026 | `ft-davinci-002` | `gpt-5.6-terra` |

161 161 

162### 2026-03-24: Sora 2 video generation models and Videos API162### 2026-03-24: Sora 2 video generation models and Videos API

163 163 

177To improve reliability and make it easier for developers to choose the right models, we are deprecating a set of older OpenAI models with declining usage over the next six to twelve months. Access to these models will be shut down on the dates below.177To improve reliability and make it easier for developers to choose the right models, we are deprecating a set of older OpenAI models with declining usage over the next six to twelve months. Access to these models will be shut down on the dates below.

178 178 

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

180| ------------- | ------------------------ | ------------------------------ |180| ------------- | ------------------------ | ----------------------- |

181| 2026-09-28 | `gpt-3.5-turbo-instruct` | `gpt-5.4-mini` or `gpt-5-mini` |181| 2026-09-28 | `gpt-3.5-turbo-instruct` | `gpt-5.6-terra` |

182| 2026-09-28 | `babbage-002` | `gpt-5.4-mini` or `gpt-5-mini` |182| 2026-09-28 | `babbage-002` | `gpt-5.6-terra` |

183| 2026-09-28 | `davinci-002` | `gpt-5.4-mini` or `gpt-5-mini` |183| 2026-09-28 | `davinci-002` | `gpt-5.6-terra` |

184| 2026-09-28 | `gpt-3.5-turbo-1106` | `gpt-5.4-mini` or `gpt-5-mini` |184| 2026-09-28 | `gpt-3.5-turbo-1106` | `gpt-5.6-terra` |

185 185 

186### 2025-08-20: Assistants API186### 2025-08-20: Assistants API

187 187 

204On April 22, 2026, we announced the deprecation of the following older OpenAI models. Access to these models was shut down on July 23, 2026.204On April 22, 2026, we announced the deprecation of the following older OpenAI models. Access to these models was shut down on July 23, 2026.

205 205 

206| Shutdown date | Model snapshot | Substitute model |206| Shutdown date | Model snapshot | Substitute model |

207| ------------- | ------------------------------------------------------------- | ---------------------------- |207| ------------- | ------------------------------------------------------------- | ----------------------- |

208| July 23, 2026 | `computer-use-preview-2025-03-11` \| `computer-use-preview` | `gpt-5.6-terra` |208| July 23, 2026 | `computer-use-preview-2025-03-11` \| `computer-use-preview` | `gpt-5.6-terra` |

209| July 23, 2026 | `gpt-4o-mini-search-preview-2025-03-11` | `gpt-5.6-terra` |209| July 23, 2026 | `gpt-4o-mini-search-preview-2025-03-11` | `gpt-5.6-terra` |

210| July 23, 2026 | `gpt-4o-mini-tts-2025-03-20` | `gpt-4o-mini-tts-2025-12-15` |

211| July 23, 2026 | `gpt-4o-search-preview-2025-03-11` | `gpt-5.6-terra` |210| July 23, 2026 | `gpt-4o-search-preview-2025-03-11` | `gpt-5.6-terra` |

212| July 23, 2026 | `gpt-5-chat-latest` | `gpt-5.6-sol` |211| July 23, 2026 | `gpt-5-chat-latest` | `gpt-5.6-sol` |

213| July 23, 2026 | `gpt-5-codex` | `gpt-5.6-sol` |212| July 23, 2026 | `gpt-5-codex` | `gpt-5.6-sol` |

220| Function calling | Available | Available |220| Function calling | Available | Available |

221| Streaming responses | Available | Available |221| Streaming responses | Available | Available |

222| WebSocket connections | Available | Not available |222| WebSocket connections | Available | Not available |

223| Context window | Model-dependent | 272,000 tokens for GPT-5.4, GPT-5.5, and GPT-5.6 |223| Context window | Model-dependent | 272,000 tokens for GPT-5.4 and GPT-5.5 |

224| Context window | Model-dependent | 1,050,000 tokens for GPT-5.6 Sol, Terra, and Luna |

224| Reasoning effort | Available | Available, including `max` on supported models |225| Reasoning effort | Available | Available, including `max` on supported models |

225| Pro mode | Available on supported models | Not available |226| Pro mode | Available on supported models | Not available |

226| Persisted reasoning | Available on supported models | Available on supported models |227| Persisted reasoning | Available on supported models | Available on supported models |

229| Multi-agent | Beta on supported models | Not available |230| Multi-agent | Beta on supported models | Not available |

230| Custom tools | Available | Available |231| Custom tools | Available | Available |

231| Client-side `tool_search` | Available | Available |232| Client-side `tool_search` | Available | Available |

232| Hosted web search | Available | Not available |233| Hosted web search | Available | Available |

233| Hosted file search | Available | Not available |234| Hosted file search | Available | Not available |

234| Computer use | Available | Not available |235| Computer use | Available | Not available |

235| Shell tool | Available | Not available |236| Shell tool | Available | Not available |

238| Service tiers | Available where supported | On-demand inference only |239| Service tiers | Available where supported | On-demand inference only |

239 240 

240Client-side `tool_search` is distinct from hosted tools and remote MCP server241Client-side `tool_search` is distinct from hosted tools and remote MCP server

241support. Hosted tools run through OpenAI-operated service infrastructure and242support. Hosted web search is available on Amazon Bedrock, but hosted file

242are unavailable on Amazon Bedrock.243search and remote MCP servers are unavailable.

243 244 

244GPT-5.4, GPT-5.5, and GPT-5.6 have a 272,000-token context window on Amazon245GPT-5.4 and GPT-5.5 have a 272,000-token context window on Amazon Bedrock.

245Bedrock. Amazon Bedrock rejects requests that exceed this limit. See the AWS246GPT-5.6 Sol, Terra, and Luna have a 1,050,000-token context window. Amazon

247Bedrock rejects requests that exceed the applicable model limit. See the AWS

246model cards for current model-specific limits.248model cards for current model-specific limits.

247 249 

248Treat feature parity as workload-specific. If your application depends on a250Treat feature parity as workload-specific. If your application depends on a

134 f.write(wav_bytes)134 f.write(wav_bytes)

135```135```

136 136 

137```go

138package main

139 

140import (

141 "context"

142 "encoding/base64"

143 "fmt"

144 "os"

145 

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

147)

148 

149func main() {

150 client := openai.NewClient()

151 response, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{

152 Model: "gpt-audio-1.5",

153 Modalities: []string{"text", "audio"},

154 Audio: openai.ChatCompletionAudioParam{

155 Voice: openai.ChatCompletionAudioParamVoiceUnion{OfString: openai.String("alloy")},

156 Format: openai.ChatCompletionAudioParamFormatWAV,

157 },

158 Messages: []openai.ChatCompletionMessageParamUnion{openai.UserMessage("Is a golden retriever a good family dog?")},

159 })

160 if err != nil {

161 panic(err)

162 }

163 fmt.Println(response.Choices[0])

164 audio, err := base64.StdEncoding.DecodeString(response.Choices[0].Message.Audio.Data)

165 if err != nil {

166 panic(err)

167 }

168 if err := os.WriteFile("dog.wav", audio, 0o600); err != nil {

169 panic(err)

170 }

171}

172```

173 

137```bash174```bash

138curl "https://api.openai.com/v1/chat/completions" \175curl "https://api.openai.com/v1/chat/completions" \

139 -H "Content-Type: application/json" \176 -H "Content-Type: application/json" \

227print(completion.choices[0].message)264print(completion.choices[0].message)

228```265```

229 266 

267```go

268package main

269 

270import (

271 "context"

272 "encoding/base64"

273 "fmt"

274 "os"

275 

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

277)

278 

279func main() {

280 audio, err := os.ReadFile("fixtures/audio.wav")

281 if err != nil {

282 panic(err)

283 }

284 client := openai.NewClient()

285 response, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{

286 Model: "gpt-audio-1.5",

287 Modalities: []string{"text", "audio"},

288 Audio: openai.ChatCompletionAudioParam{

289 Voice: openai.ChatCompletionAudioParamVoiceUnion{OfString: openai.String("alloy")},

290 Format: openai.ChatCompletionAudioParamFormatWAV,

291 },

292 Messages: []openai.ChatCompletionMessageParamUnion{openai.UserMessage([]openai.ChatCompletionContentPartUnionParam{

293 openai.TextContentPart("What is in this recording?"),

294 openai.InputAudioContentPart(openai.ChatCompletionContentPartInputAudioInputAudioParam{

295 Data: base64.StdEncoding.EncodeToString(audio),

296 Format: "wav",

297 }),

298 })},

299 })

300 if err != nil {

301 panic(err)

302 }

303 fmt.Println(response.Choices[0])

304}

305```

306 

230```bash307```bash

231curl "https://api.openai.com/v1/chat/completions" \308curl "https://api.openai.com/v1/chat/completions" \

232 -H "Content-Type: application/json" \309 -H "Content-Type: application/json" \

50print(resp.status)50print(resp.status)

51```51```

52 52 

53```go

54package main

55 

56import (

57 "context"

58 "fmt"

59 

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

61 "github.com/openai/openai-go/v3/responses"

62)

63 

64func main() {

65 client := openai.NewClient()

66 

67 response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

68 Model: "gpt-5.6",

69 Background: openai.Bool(true),

70 Input: responses.ResponseNewParamsInputUnion{

71 OfString: openai.String("Write a very long novel about otters in space."),

72 },

73 })

74 if err != nil {

75 panic(err)

76 }

77 

78 fmt.Println(response.Status)

79}

80```

81 

53 82 

54## Polling background responses83## Polling background responses

55 84 

102print(f"Final status: {resp.status}\nOutput:\n{resp.output_text}")131print(f"Final status: {resp.status}\nOutput:\n{resp.output_text}")

103```132```

104 133 

134```go

135package main

136 

137import (

138 "context"

139 "fmt"

140 "time"

141 

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

143 "github.com/openai/openai-go/v3/responses"

144)

145 

146func main() {

147 client := openai.NewClient()

148 

149 response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

150 Model: "gpt-5.6",

151 Background: openai.Bool(true),

152 Input: responses.ResponseNewParamsInputUnion{

153 OfString: openai.String("Write a very long novel about otters in space."),

154 },

155 })

156 if err != nil {

157 panic(err)

158 }

159 

160 for response.Status == "queued" || response.Status == "in_progress" {

161 fmt.Println("Current status:", response.Status)

162 time.Sleep(2 * time.Second)

163 response, err = client.Responses.Get(context.Background(), response.ID, responses.ResponseGetParams{})

164 if err != nil {

165 panic(err)

166 }

167 }

168 

169 fmt.Printf("Final status: %s\nOutput:\n%s\n", response.Status, response.OutputText())

170}

171```

172 

105 173 

106## Cancelling a background response174## Cancelling a background response

107 175 

137print(resp.status)205print(resp.status)

138```206```

139 207 

208```go

209package main

210 

211import (

212 "context"

213 "fmt"

214 

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

216)

217 

218func main() {

219 client := openai.NewClient()

220 

221 canceled, err := client.Responses.Cancel(context.Background(), "resp_123")

222 if err != nil {

223 panic(err)

224 }

225 

226 fmt.Println(canceled.Status)

227}

228```

229 

140 230 

141Cancelling twice is idempotent - subsequent calls simply return the final `Response` object.231Cancelling twice is idempotent - subsequent calls simply return the final `Response` object.

142 232 

213# print(event)303# print(event)

214```304```

215 305 

306```go

307package main

308 

309import (

310 "context"

311 "fmt"

312 

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

314 "github.com/openai/openai-go/v3/responses"

315)

316 

317func main() {

318 client := openai.NewClient()

319 

320 stream := client.Responses.NewStreaming(context.Background(), responses.ResponseNewParams{

321 Model: "gpt-5.6",

322 Background: openai.Bool(true),

323 Input: responses.ResponseNewParamsInputUnion{

324 OfString: openai.String("Write a very long novel about otters in space."),

325 },

326 })

327 var cursor int64

328 var responseID string

329 for stream.Next() {

330 event := stream.Current()

331 fmt.Println(event.Type)

332 cursor = event.SequenceNumber

333 if event.Response.ID != "" {

334 responseID = event.Response.ID

335 }

336 }

337 if err := stream.Err(); err != nil {

338 panic(err)

339 }

340 fmt.Printf("response %s last cursor %d\n", responseID, cursor)

341 

342 // If the connection drops, resume streaming from the last cursor:

343 // resumed := client.Responses.GetStreaming(

344 // context.Background(),

345 // responseID,

346 // responses.ResponseGetParams{StartingAfter: openai.Int(cursor)},

347 // )

348 // for resumed.Next() {

349 // fmt.Println(resumed.Current().Type)

350 // }

351}

352```

353 

216 354 

217## Limits355## Limits

218 356 

130print(batch_input_file)130print(batch_input_file)

131```131```

132 132 

133```go

134package main

135 

136import (

137 "context"

138 "fmt"

139 "os"

140 

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

142)

143 

144func main() {

145 client := openai.NewClient()

146 file, err := os.Open("batchinput.jsonl")

147 if err != nil {

148 panic(err)

149 }

150 defer file.Close()

151 

152 uploaded, err := client.Files.New(context.Background(), openai.FileNewParams{

153 File: file,

154 Purpose: openai.FilePurposeBatch,

155 })

156 if err != nil {

157 panic(err)

158 }

159 fmt.Println(uploaded.ID)

160}

161```

162 

133```bash163```bash

134curl https://api.openai.com/v1/files \164curl https://api.openai.com/v1/files \

135 -H "Authorization: Bearer $OPENAI_API_KEY" \165 -H "Authorization: Bearer $OPENAI_API_KEY" \

173print(batch)203print(batch)

174```204```

175 205 

206```go

207package main

208 

209import (

210 "context"

211 "fmt"

212 

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

214)

215 

216func main() {

217 client := openai.NewClient()

218 batch, err := client.Batches.New(context.Background(), openai.BatchNewParams{

219 InputFileID: "file-abc123",

220 Endpoint: openai.BatchNewParamsEndpointV1ChatCompletions,

221 CompletionWindow: openai.BatchNewParamsCompletionWindow24h,

222 })

223 if err != nil {

224 panic(err)

225 }

226 fmt.Println(batch.ID)

227}

228```

229 

176```bash230```bash

177curl https://api.openai.com/v1/batches \231curl https://api.openai.com/v1/batches \

178 -H "Authorization: Bearer $OPENAI_API_KEY" \232 -H "Authorization: Bearer $OPENAI_API_KEY" \

239print(batch)293print(batch)

240```294```

241 295 

296```go

297package main

298 

299import (

300 "context"

301 "fmt"

302 

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

304)

305 

306func main() {

307 client := openai.NewClient()

308 batch, err := client.Batches.Get(context.Background(), "batch_abc123")

309 if err != nil {

310 panic(err)

311 }

312 fmt.Println(batch.Status)

313}

314```

315 

242```bash316```bash

243curl https://api.openai.com/v1/batches/batch_abc123 \317curl https://api.openai.com/v1/batches/batch_abc123 \

244 -H "Authorization: Bearer $OPENAI_API_KEY" \318 -H "Authorization: Bearer $OPENAI_API_KEY" \

292print(file_response.text)366print(file_response.text)

293```367```

294 368 

369```go

370package main

371 

372import (

373 "context"

374 "fmt"

375 "io"

376 

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

378)

379 

380func main() {

381 client := openai.NewClient()

382 response, err := client.Files.Content(context.Background(), "file-xyz123")

383 if err != nil {

384 panic(err)

385 }

386 defer response.Body.Close()

387 contents, err := io.ReadAll(response.Body)

388 if err != nil {

389 panic(err)

390 }

391 fmt.Println(string(contents))

392}

393```

394 

295```bash395```bash

296curl https://api.openai.com/v1/files/file-xyz123/content \396curl https://api.openai.com/v1/files/file-xyz123/content \

297 -H "Authorization: Bearer $OPENAI_API_KEY" > batch_output.jsonl397 -H "Authorization: Bearer $OPENAI_API_KEY" > batch_output.jsonl

345client.batches.cancel(batch_id)445client.batches.cancel(batch_id)

346```446```

347 447 

448```go

449package main

450 

451import (

452 "context"

453 "fmt"

454 

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

456)

457 

458func main() {

459 client := openai.NewClient()

460 batch, err := client.Batches.Cancel(context.Background(), "batch_abc123")

461 if err != nil {

462 panic(err)

463 }

464 fmt.Println(batch.Status)

465}

466```

467 

348```bash468```bash

349curl https://api.openai.com/v1/batches/batch_abc123/cancel \469curl https://api.openai.com/v1/batches/batch_abc123/cancel \

350 -H "Authorization: Bearer $OPENAI_API_KEY" \470 -H "Authorization: Bearer $OPENAI_API_KEY" \

383client.batches.list(limit=10)503client.batches.list(limit=10)

384```504```

385 505 

506```go

507package main

508 

509import (

510 "context"

511 "fmt"

512 

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

514)

515 

516func main() {

517 client := openai.NewClient()

518 list := client.Batches.ListAutoPaging(context.Background(), openai.BatchListParams{Limit: openai.Int(10)})

519 for list.Next() {

520 fmt.Println(list.Current().ID)

521 }

522 if err := list.Err(); err != nil {

523 panic(err)

524 }

525}

526```

527 

386```bash528```bash

387curl https://api.openai.com/v1/batches?limit=10 \529curl https://api.openai.com/v1/batches?limit=10 \

388 -H "Authorization: Bearer $OPENAI_API_KEY" \530 -H "Authorization: Bearer $OPENAI_API_KEY" \

68print(result.output_text)68print(result.output_text)

69```69```

70 70 

71```go

72package main

73 

74import (

75 "context"

76 "fmt"

77 

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

79 "github.com/openai/openai-go/v3/responses"

80 "github.com/openai/openai-go/v3/shared"

81)

82 

83func main() {

84 client := openai.NewClient()

85 response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

86 Model: "gpt-5.6",

87 Input: responses.ResponseNewParamsInputUnion{OfString: openai.String(`Find the null pointer exception in this code:

88 

89def display_name(user):

90 return user.profile.name

91 

92print(display_name(None))`)},

93 Reasoning: shared.ReasoningParam{Effort: shared.ReasoningEffortHigh},

94 })

95 if err != nil {

96 panic(err)

97 }

98 fmt.Println(response.OutputText())

99}

100```

101 

71```bash102```bash

72curl https://api.openai.com/v1/responses \103curl https://api.openai.com/v1/responses \

73 -H "Content-Type: application/json" \104 -H "Content-Type: application/json" \

80 )80 )

81```81```

82 82 

83```go

84package main

85 

86import (

87 "bufio"

88 "context"

89 "encoding/json"

90 "fmt"

91 "os"

92 

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

94 "github.com/openai/openai-go/v3/responses"

95)

96 

97func main() {

98 client := openai.NewClient()

99 conversation := []responses.ResponseInputItemUnionParam{

100 responses.ResponseInputItemParamOfMessage("Let's begin a long coding task.", responses.EasyInputMessageRoleUser),

101 }

102 scanner := bufio.NewScanner(os.Stdin)

103 for {

104 response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

105 Model: "gpt-5.3-codex",

106 Store: openai.Bool(false),

107 Input: responses.ResponseNewParamsInputUnion{OfInputItemList: conversation},

108 ContextManagement: []responses.ResponseNewParamsContextManagement{{

109 Type: "compaction", CompactThreshold: openai.Int(200000),

110 }},

111 })

112 if err != nil {

113 panic(err)

114 }

115 conversation = append(conversation, outputAsInput(response.Output)...)

116 fmt.Println(response.OutputText())

117 if !scanner.Scan() {

118 break

119 }

120 conversation = append(conversation,

121 responses.ResponseInputItemParamOfMessage(scanner.Text(), responses.EasyInputMessageRoleUser),

122 )

123 }

124 if err := scanner.Err(); err != nil {

125 panic(err)

126 }

127}

128 

129func outputAsInput(output []responses.ResponseOutputItemUnion) []responses.ResponseInputItemUnionParam {

130 input := make([]responses.ResponseInputItemUnionParam, 0, len(output))

131 for _, item := range output {

132 var converted responses.ResponseInputItemUnion

133 if err := json.Unmarshal([]byte(item.RawJSON()), &converted); err != nil {

134 panic(err)

135 }

136 input = append(input, converted.ToParam())

137 }

138 return input

139}

140```

141 

83 142 

84## Standalone compact endpoint143## Standalone compact endpoint

85 144 

144 store=False, # Keep the flow ZDR-friendly203 store=False, # Keep the flow ZDR-friendly

145)204)

146```205```

206 

207```go

208package main

209 

210import (

211 "bufio"

212 "context"

213 "encoding/json"

214 "fmt"

215 "os"

216 

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

218 "github.com/openai/openai-go/v3/responses"

219)

220 

221func main() {

222 client := openai.NewClient()

223 longInputItems := []responses.ResponseInputItemUnionParam{

224 responses.ResponseInputItemParamOfMessage("Plan a trip to Kyoto.", responses.EasyInputMessageRoleUser),

225 }

226 compacted, err := client.Responses.Compact(context.Background(), responses.ResponseCompactParams{

227 Model: "gpt-5.6",

228 Input: responses.ResponseCompactParamsInputUnion{OfResponseInputItemArray: longInputItems},

229 })

230 if err != nil {

231 panic(err)

232 }

233 scanner := bufio.NewScanner(os.Stdin)

234 if !scanner.Scan() {

235 return

236 }

237 nextInput := append(outputAsInput(compacted.Output),

238 responses.ResponseInputItemParamOfMessage(scanner.Text(), responses.EasyInputMessageRoleUser),

239 )

240 nextResponse, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

241 Model: "gpt-5.6",

242 Store: openai.Bool(false),

243 Input: responses.ResponseNewParamsInputUnion{OfInputItemList: nextInput},

244 })

245 if err != nil {

246 panic(err)

247 }

248 fmt.Println(nextResponse.OutputText())

249}

250 

251func outputAsInput(output []responses.ResponseOutputItemUnion) []responses.ResponseInputItemUnionParam {

252 input := make([]responses.ResponseInputItemUnionParam, 0, len(output))

253 for _, item := range output {

254 var converted responses.ResponseInputItemUnion

255 if err := json.Unmarshal([]byte(item.RawJSON()), &converted); err != nil {

256 panic(err)

257 }

258 input = append(input, converted.ToParam())

259 }

260 return input

261}

262```

23)23)

24```24```

25 25 

26```go

27package main

28 

29import (

30 "context"

31 "fmt"

32 

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

34)

35 

36func main() {

37 client := openai.NewClient()

38 response, err := client.Completions.New(context.Background(), openai.CompletionNewParams{

39 Model: "gpt-3.5-turbo-instruct",

40 Prompt: openai.CompletionNewParamsPromptUnion{OfString: openai.String("Write a tagline for an ice cream shop.")},

41 })

42 if err != nil {

43 panic(err)

44 }

45 fmt.Println(response.Choices[0].Text)

46}

47```

48 

26 49 

27See the full [API reference documentation](https://platform.openai.com/docs/api-reference/completions) to learn more.50See the full [API reference documentation](https://platform.openai.com/docs/api-reference/completions) to learn more.

28 51 

53print(response.output_text)53print(response.output_text)

54```54```

55 55 

56```go

57package main

58 

59import (

60 "context"

61 "fmt"

62 

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

64 "github.com/openai/openai-go/v3/responses"

65)

66 

67func main() {

68 client := openai.NewClient()

69 

70 response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

71 Model: "gpt-5.6",

72 Input: responses.ResponseNewParamsInputUnion{

73 OfInputItemList: responses.ResponseInputParam{

74 responses.ResponseInputItemParamOfMessage("Knock knock.", responses.EasyInputMessageRoleUser),

75 responses.ResponseInputItemParamOfMessage("Who's there?", responses.EasyInputMessageRoleAssistant),

76 responses.ResponseInputItemParamOfMessage("Orange.", responses.EasyInputMessageRoleUser),

77 },

78 },

79 })

80 if err != nil {

81 panic(err)

82 }

83 

84 fmt.Println(response.OutputText())

85}

86```

87 

56 88 

57 89 

58By using alternating `user` and `assistant` messages, you capture the previous state of a conversation in one request to the model.90By using alternating `user` and `assistant` messages, you capture the previous state of a conversation in one request to the model.

135print(second_response.output_text)167print(second_response.output_text)

136```168```

137 169 

170```go

171package main

172 

173import (

174 "context"

175 "encoding/json"

176 "fmt"

177 

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

179 "github.com/openai/openai-go/v3/responses"

180)

181 

182func main() {

183 client := openai.NewClient()

184 history := responses.ResponseInputParam{

185 responses.ResponseInputItemParamOfMessage("tell me a joke", responses.EasyInputMessageRoleUser),

186 }

187 first, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

188 Model: "gpt-5.6",

189 Input: responses.ResponseNewParamsInputUnion{OfInputItemList: history},

190 Store: openai.Bool(false),

191 })

192 if err != nil {

193 panic(err)

194 }

195 fmt.Println(first.OutputText())

196 

197 history = append(history, outputAsInput(first.Output)...)

198 history = append(history, responses.ResponseInputItemParamOfMessage("tell me another", responses.EasyInputMessageRoleUser))

199 second, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

200 Model: "gpt-5.6",

201 Input: responses.ResponseNewParamsInputUnion{OfInputItemList: history},

202 Store: openai.Bool(false),

203 })

204 if err != nil {

205 panic(err)

206 }

207 fmt.Println(second.OutputText())

208}

209 

210func outputAsInput(output []responses.ResponseOutputItemUnion) []responses.ResponseInputItemUnionParam {

211 input := make([]responses.ResponseInputItemUnionParam, 0, len(output))

212 for _, item := range output {

213 var converted responses.ResponseInputItemUnion

214 if err := json.Unmarshal([]byte(item.RawJSON()), &converted); err != nil {

215 panic(err)

216 }

217 input = append(input, converted.ToParam())

218 }

219 return input

220}

221```

222 

138 223 

139 224 

140## OpenAI APIs for conversation state225## OpenAI APIs for conversation state

157conversation = openai.conversations.create()242conversation = openai.conversations.create()

158```243```

159 244 

245```go

246conversation, err := client.Conversations.New(context.Background(), conversations.ConversationNewParams{})

247if err != nil {

248 panic(err)

249}

250```

251 

160 252 

161In a multi-turn interaction, you can pass the `conversation` into subsequent responses to persist state and share context across subsequent responses, rather than having to chain multiple response items together.253In a multi-turn interaction, you can pass the `conversation` into subsequent responses to persist state and share context across subsequent responses, rather than having to chain multiple response items together.

162 254 

170)262)

171```263```

172 264 

265```go

266response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

267 Model: "gpt-5.6",

268 Conversation: responses.ResponseNewParamsConversationUnion{

269 OfString: openai.String(conversation.ID),

270 },

271 Input: responses.ResponseNewParamsInputUnion{

272 OfString: openai.String("What are the five Ds of dodgeball?"),

273 },

274})

275if err != nil {

276 panic(err)

277}

278fmt.Println(response.OutputText())

279```

280 

173 281 

174### Passing context from the previous response282### Passing context from the previous response

175 283 

219print(second_response.output_text)327print(second_response.output_text)

220```328```

221 329 

330```go

331package main

332 

333import (

334 "context"

335 "fmt"

336 

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

338 "github.com/openai/openai-go/v3/responses"

339)

340 

341func main() {

342 client := openai.NewClient()

343 

344 first, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

345 Model: "gpt-5.6",

346 Input: responses.ResponseNewParamsInputUnion{

347 OfString: openai.String("Tell me a joke."),

348 },

349 })

350 if err != nil {

351 panic(err)

352 }

353 fmt.Println(first.OutputText())

354 

355 second, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

356 Model: "gpt-5.6",

357 PreviousResponseID: openai.String(first.ID),

358 Input: responses.ResponseNewParamsInputUnion{

359 OfString: openai.String("Explain why this is funny."),

360 },

361 })

362 if err != nil {

363 panic(err)

364 }

365 fmt.Println(second.OutputText())

366}

367```

368 

222 369 

223In the following example, we ask the model to tell a joke. Separately, we ask the model to explain why it's funny, and the model has all necessary context to deliver a good response.370In the following example, we ask the model to tell a joke. Separately, we ask the model to explain why it's funny, and the model has all necessary context to deliver a good response.

224 371 

267print(second_response.output_text)414print(second_response.output_text)

268```415```

269 416 

417```go

418package main

419 

420import (

421 "context"

422 "fmt"

423 

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

425 "github.com/openai/openai-go/v3/responses"

426)

427 

428func main() {

429 client := openai.NewClient()

430 

431 first, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

432 Model: "gpt-5.6",

433 Input: responses.ResponseNewParamsInputUnion{

434 OfString: openai.String("Tell me a joke."),

435 },

436 })

437 if err != nil {

438 panic(err)

439 }

440 fmt.Println(first.OutputText())

441 

442 second, err := client.Responses.New(context.Background(), responses.ResponseNewParams{

443 Model: "gpt-5.6",

444 PreviousResponseID: openai.String(first.ID),

445 Input: responses.ResponseNewParamsInputUnion{

446 OfString: openai.String("Explain why this is funny."),

447 },

448 })

449 if err != nil {

450 panic(err)

451 }

452 fmt.Println(second.OutputText())

453}

454```

455 

270 456 

271#### `previous_response_id` in WebSocket mode457#### `previous_response_id` in WebSocket mode

272 458 

90print(response.output_text)90print(response.output_text)

91```91```

92 92 

93```go

94package main

95 

96import (

97 "context"

98 "fmt"

99 

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

101 "github.com/openai/openai-go/v3/responses"