Models

List models

client.Models.List(ctx) (*Page[Model], error)

get /models

List models

Returns

type Model struct{…}

Describes an OpenAI model offering that can be used with the API.
- ID string
  
  The model identifier, which can be referenced in the API endpoints.
- Created int64
  
  The Unix timestamp (in seconds) when the model was created.
- Object Model
  
  The object type, which is always "model".
  - const ModelModel Model = "model"
- OwnedBy string
  
  The organization that owns the model.

Example

package main

import (
  "context"
  "fmt"

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

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  page, err := client.Models.List(context.TODO())
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", page)
}

Response

{
  "data": [
    {
      "id": "id",
      "created": 0,
      "object": "model",
      "owned_by": "owned_by"
    }
  ],
  "object": "list"
}

Retrieve model

client.Models.Get(ctx, model) (*Model, error)

get /models/{model}

Retrieve model

Parameters

model string

Returns

type Model struct{…}

Describes an OpenAI model offering that can be used with the API.
- ID string
  
  The model identifier, which can be referenced in the API endpoints.
- Created int64
  
  The Unix timestamp (in seconds) when the model was created.
- Object Model
  
  The object type, which is always "model".
  - const ModelModel Model = "model"
- OwnedBy string
  
  The organization that owns the model.

Example

package main

import (
  "context"
  "fmt"

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

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  model, err := client.Models.Get(context.TODO(), "gpt-4o-mini")
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", model.ID)
}

Response

{
  "id": "id",
  "created": 0,
  "object": "model",
  "owned_by": "owned_by"
}

Delete a fine-tuned model

client.Models.Delete(ctx, model) (*ModelDeleted, error)

delete /models/{model}

Delete a fine-tuned model

Parameters

model string

Returns

type ModelDeleted struct{…}
- ID string
- Deleted bool
- Object string

Example

package main

import (
  "context"
  "fmt"

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

func main() {
  client := openai.NewClient(
    option.WithAPIKey("My API Key"),
  )
  modelDeleted, err := client.Models.Delete(context.TODO(), "ft:gpt-4o-mini:acemeco:suffix:abc123")
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", modelDeleted.ID)
}

Response

{
  "id": "id",
  "deleted": true,
  "object": "object"
}

Domain Types

Model

type Model struct{…}

Describes an OpenAI model offering that can be used with the API.
- ID string
  
  The model identifier, which can be referenced in the API endpoints.
- Created int64
  
  The Unix timestamp (in seconds) when the model was created.
- Object Model
  
  The object type, which is always "model".
  - const ModelModel Model = "model"
- OwnedBy string
  
  The organization that owns the model.

Model Deleted

type ModelDeleted struct{…}
- ID string
- Deleted bool
- Object string

go/resources/models/index.md +239 −0 created

1# Models

3## List models

5`client.Models.List(ctx) (*Page[Model], error)`

7**get** `/models`

9List models

11### Returns

13- `type Model struct{…}`

15 Describes an OpenAI model offering that can be used with the API.

17 - `ID string`

19 The model identifier, which can be referenced in the API endpoints.

21 - `Created int64`

23 The Unix timestamp (in seconds) when the model was created.

25 - `Object Model`

27 The object type, which is always "model".

29 - `const ModelModel Model = "model"`

31 - `OwnedBy string`

33 The organization that owns the model.

35### Example

37```go

38package main

40import (

41 "context"

42 "fmt"

44 "github.com/openai/openai-go"

45 "github.com/openai/openai-go/option"

46)

48func main() {

49 client := openai.NewClient(

50 option.WithAPIKey("My API Key"),

51 )

52 page, err := client.Models.List(context.TODO())

53 if err != nil {

54 panic(err.Error())

55 }

56 fmt.Printf("%+v\n", page)

57}

58```

60#### Response

62```json

63{

64 "data": [

65 {

66 "id": "id",

67 "created": 0,

68 "object": "model",

69 "owned_by": "owned_by"

70 }

71 ],

72 "object": "list"

73}

74```

76## Retrieve model

78`client.Models.Get(ctx, model) (*Model, error)`

80**get** `/models/{model}`

82Retrieve model

84### Parameters

86- `model string`

88### Returns

90- `type Model struct{…}`

92 Describes an OpenAI model offering that can be used with the API.

94 - `ID string`

96 The model identifier, which can be referenced in the API endpoints.

98 - `Created int64`

100 The Unix timestamp (in seconds) when the model was created.

101

102 - `Object Model`

103

104 The object type, which is always "model".

105

106 - `const ModelModel Model = "model"`

107

108 - `OwnedBy string`

109

110 The organization that owns the model.

111

112### Example

113

114```go

115package main

116

117import (

118 "context"

119 "fmt"

120

121 "github.com/openai/openai-go"

122 "github.com/openai/openai-go/option"

123)

124

125func main() {

126 client := openai.NewClient(

127 option.WithAPIKey("My API Key"),

128 )

129 model, err := client.Models.Get(context.TODO(), "gpt-4o-mini")

130 if err != nil {

131 panic(err.Error())

132 }

133 fmt.Printf("%+v\n", model.ID)

134}

135```

136

137#### Response

138

139```json

140{

141 "id": "id",

142 "created": 0,

143 "object": "model",

144 "owned_by": "owned_by"

145}

146```

147

148## Delete a fine-tuned model

149

150`client.Models.Delete(ctx, model) (*ModelDeleted, error)`

151

152**delete** `/models/{model}`

153

154Delete a fine-tuned model

155

156### Parameters

157

158- `model string`

159

160### Returns

161

162- `type ModelDeleted struct{…}`

163

164 - `ID string`

165

166 - `Deleted bool`

167

168 - `Object string`

169

170### Example

171

172```go

173package main

174

175import (

176 "context"

177 "fmt"

178

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

180 "github.com/openai/openai-go/option"

181)

182

183func main() {

184 client := openai.NewClient(

185 option.WithAPIKey("My API Key"),

186 )

187 modelDeleted, err := client.Models.Delete(context.TODO(), "ft:gpt-4o-mini:acemeco:suffix:abc123")

188 if err != nil {

189 panic(err.Error())

190 }

191 fmt.Printf("%+v\n", modelDeleted.ID)

192}

193```

194

195#### Response

196

197```json

198{

199 "id": "id",

200 "deleted": true,

201 "object": "object"

202}

203```

204

205## Domain Types

206

207### Model

208

209- `type Model struct{…}`

210

211 Describes an OpenAI model offering that can be used with the API.

212

213 - `ID string`

214

215 The model identifier, which can be referenced in the API endpoints.

216

217 - `Created int64`

218

219 The Unix timestamp (in seconds) when the model was created.

220

221 - `Object Model`

222

223 The object type, which is always "model".

224

225 - `const ModelModel Model = "model"`

226

227 - `OwnedBy string`

228

229 The organization that owns the model.

230

231### Model Deleted

232

233- `type ModelDeleted struct{…}`

234

235 - `ID string`

236

237 - `Deleted bool`

238

239 - `Object string`

go/resources/models/index.md 2026-07-07 08:02 UTC to 2026-07-09 20:58 UTC

Models

List models

Returns

Example

Response

Retrieve model

Parameters

Returns

Example

Response

Delete a fine-tuned model

Parameters

Returns

Example

Response

Domain Types

Model

Model Deleted