Files

List files

files.list(FileListParams**kwargs) -> SyncCursorPage[FileObject]

get /files

List files

Parameters

after: Optional[str]

A cursor for use in pagination. after is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list.
limit: Optional[int]

A limit on the number of objects to be returned. Limit can range between 1 and 10,000, and the default is 10,000.
order: Optional[Literal["asc", "desc"]]

Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.
- "asc"
- "desc"
purpose: Optional[str]

Only return files with the given purpose.

Returns

class FileObject: …

The File object represents a document that has been uploaded to OpenAI.
- id: str
  
  The file identifier, which can be referenced in the API endpoints.
- bytes: int
  
  The size of the file, in bytes.
- created_at: int
  
  The Unix timestamp (in seconds) for when the file was created.
- filename: str
  
  The name of the file.
- object: Literal["file"]
  
  The object type, which is always file.
  - "file"
- purpose: Literal["assistants", "assistants_output", "batch", 5 more]
  
  The intended purpose of the file. Supported values are assistants, assistants_output, batch, batch_output, fine-tune, fine-tune-results, vision, and user_data.
  - "assistants"
  - "assistants_output"
  - "batch"
  - "batch_output"
  - "fine-tune"
  - "fine-tune-results"
  - "vision"
  - "user_data"
- status: Literal["uploaded", "processed", "error"]
  
  Deprecated. The current status of the file, which can be either uploaded, processed, or error.
  - "uploaded"
  - "processed"
  - "error"
- expires_at: Optional[int]
  
  The Unix timestamp (in seconds) for when the file will expire.
- status_details: Optional[str]
  
  Deprecated. For details on why a fine-tuning training file failed validation, see the error field on fine_tuning.job.

Example

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),  # This is the default and can be omitted
)
page = client.files.list()
page = page.data[0]
print(page)

Response

{
  "data": [
    {
      "id": "id",
      "bytes": 0,
      "created_at": 0,
      "filename": "filename",
      "object": "file",
      "purpose": "assistants",
      "status": "uploaded",
      "expires_at": 0,
      "status_details": "status_details"
    }
  ],
  "first_id": "file-abc123",
  "has_more": false,
  "last_id": "file-abc456",
  "object": "list"
}

Example

from openai import OpenAI
client = OpenAI()

client.files.list()

Response

{
  "object": "list",
  "data": [
    {
      "id": "file-abc123",
      "object": "file",
      "bytes": 175,
      "created_at": 1613677385,
      "expires_at": 1677614202,
      "filename": "salesOverview.pdf",
      "purpose": "assistants",
    },
    {
      "id": "file-abc456",
      "object": "file",
      "bytes": 140,
      "created_at": 1613779121,
      "expires_at": 1677614202,
      "filename": "puppy.jsonl",
      "purpose": "fine-tune",
    }
  ],
  "first_id": "file-abc123",
  "last_id": "file-abc456",
  "has_more": false
}

Upload file

files.create(FileCreateParams**kwargs) -> FileObject

post /files

Upload file

Parameters

file: FileTypes

The File object (not file name) to be uploaded.
purpose: object
expires_after: Optional[ExpiresAfter]

The expiration policy for a file. By default, files with purpose=batch expire after 30 days and all other files are persisted until they are manually deleted.
- anchor: Literal["created_at"]
  
  Anchor timestamp after which the expiration policy applies. Supported anchors: created_at.
  - "created_at"
- seconds: int
  
  The number of seconds after the anchor time that the file will expire. Must be between 3600 (1 hour) and 2592000 (30 days).

Returns

class FileObject: …

The File object represents a document that has been uploaded to OpenAI.
- id: str
  
  The file identifier, which can be referenced in the API endpoints.
- bytes: int
  
  The size of the file, in bytes.
- created_at: int
  
  The Unix timestamp (in seconds) for when the file was created.
- filename: str
  
  The name of the file.
- object: Literal["file"]
  
  The object type, which is always file.
  - "file"
- purpose: Literal["assistants", "assistants_output", "batch", 5 more]
  
  The intended purpose of the file. Supported values are assistants, assistants_output, batch, batch_output, fine-tune, fine-tune-results, vision, and user_data.
  - "assistants"
  - "assistants_output"
  - "batch"
  - "batch_output"
  - "fine-tune"
  - "fine-tune-results"
  - "vision"
  - "user_data"
- status: Literal["uploaded", "processed", "error"]
  
  Deprecated. The current status of the file, which can be either uploaded, processed, or error.
  - "uploaded"
  - "processed"
  - "error"
- expires_at: Optional[int]
  
  The Unix timestamp (in seconds) for when the file will expire.
- status_details: Optional[str]
  
  Deprecated. For details on why a fine-tuning training file failed validation, see the error field on fine_tuning.job.

Example

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),  # This is the default and can be omitted
)
file_object = client.files.create(
    file=b"Example data",
    purpose={},
)
print(file_object.id)

Response

{
  "id": "id",
  "bytes": 0,
  "created_at": 0,
  "filename": "filename",
  "object": "file",
  "purpose": "assistants",
  "status": "uploaded",
  "expires_at": 0,
  "status_details": "status_details"
}

Example

from openai import OpenAI
client = OpenAI()

client.files.create(
  file=open("mydata.jsonl", "rb"),
  purpose="fine-tune",
  expires_after={
    "anchor": "created_at",
    "seconds": 2592000
  }
)

Response

{
  "id": "file-abc123",
  "object": "file",
  "bytes": 120000,
  "created_at": 1677610602,
  "expires_at": 1677614202,
  "filename": "mydata.jsonl",
  "purpose": "fine-tune",
}

Delete file

files.delete(strfile_id) -> FileDeleted

delete /files/{file_id}

Delete file

Parameters

file_id: str

Returns

class FileDeleted: …
- id: str
- deleted: bool
- object: Literal["file"]
  - "file"

Example

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),  # This is the default and can be omitted
)
file_deleted = client.files.delete(
    "file_id",
)
print(file_deleted.id)

Response

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

Example

from openai import OpenAI
client = OpenAI()

client.files.delete("file-abc123")

Response

{
  "id": "file-abc123",
  "object": "file",
  "deleted": true
}

Retrieve file

files.retrieve(strfile_id) -> FileObject

get /files/{file_id}

Retrieve file

Parameters

file_id: str

Returns

class FileObject: …

The File object represents a document that has been uploaded to OpenAI.
- id: str
  
  The file identifier, which can be referenced in the API endpoints.
- bytes: int
  
  The size of the file, in bytes.
- created_at: int
  
  The Unix timestamp (in seconds) for when the file was created.
- filename: str
  
  The name of the file.
- object: Literal["file"]
  
  The object type, which is always file.
  - "file"
- purpose: Literal["assistants", "assistants_output", "batch", 5 more]
  
  The intended purpose of the file. Supported values are assistants, assistants_output, batch, batch_output, fine-tune, fine-tune-results, vision, and user_data.
  - "assistants"
  - "assistants_output"
  - "batch"
  - "batch_output"
  - "fine-tune"
  - "fine-tune-results"
  - "vision"
  - "user_data"
- status: Literal["uploaded", "processed", "error"]
  
  Deprecated. The current status of the file, which can be either uploaded, processed, or error.
  - "uploaded"
  - "processed"
  - "error"
- expires_at: Optional[int]
  
  The Unix timestamp (in seconds) for when the file will expire.
- status_details: Optional[str]
  
  Deprecated. For details on why a fine-tuning training file failed validation, see the error field on fine_tuning.job.

Example

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),  # This is the default and can be omitted
)
file_object = client.files.retrieve(
    "file_id",
)
print(file_object.id)

Response

{
  "id": "id",
  "bytes": 0,
  "created_at": 0,
  "filename": "filename",
  "object": "file",
  "purpose": "assistants",
  "status": "uploaded",
  "expires_at": 0,
  "status_details": "status_details"
}

Example

from openai import OpenAI
client = OpenAI()

client.files.retrieve("file-abc123")

Response

{
  "id": "file-abc123",
  "object": "file",
  "bytes": 120000,
  "created_at": 1677610602,
  "expires_at": 1677614202,
  "filename": "mydata.jsonl",
  "purpose": "fine-tune",
}

Retrieve file content

files.content(strfile_id) -> BinaryResponseContent

get /files/{file_id}/content

Retrieve file content

Parameters

file_id: str

Returns

BinaryResponseContent

Example

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),  # This is the default and can be omitted
)
response = client.files.content(
    "file_id",
)
print(response)
content = response.read()
print(content)

Example

from openai import OpenAI
client = OpenAI()

content = client.files.content("file-abc123")

Retrieve file content

files.retrieve_content(strfile_id) -> FileContent

get /files/{file_id}/content

Retrieve file content

Parameters

file_id: str

Returns

str

Example

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),  # This is the default and can be omitted
)
file_content = client.files.retrieve_content(
    "file_id",
)
print(file_content)

Response

"string"

Example

from openai import OpenAI
client = OpenAI()

content = client.files.content("file-abc123")

Domain Types

File Content

str

File Deleted

class FileDeleted: …
- id: str
- deleted: bool
- object: Literal["file"]
  - "file"

File Object

class FileObject: …

The File object represents a document that has been uploaded to OpenAI.
- id: str
  
  The file identifier, which can be referenced in the API endpoints.
- bytes: int
  
  The size of the file, in bytes.
- created_at: int
  
  The Unix timestamp (in seconds) for when the file was created.
- filename: str
  
  The name of the file.
- object: Literal["file"]
  
  The object type, which is always file.
  - "file"
- purpose: Literal["assistants", "assistants_output", "batch", 5 more]
  
  The intended purpose of the file. Supported values are assistants, assistants_output, batch, batch_output, fine-tune, fine-tune-results, vision, and user_data.
  - "assistants"
  - "assistants_output"
  - "batch"
  - "batch_output"
  - "fine-tune"
  - "fine-tune-results"
  - "vision"
  - "user_data"
- status: Literal["uploaded", "processed", "error"]
  
  Deprecated. The current status of the file, which can be either uploaded, processed, or error.
  - "uploaded"
  - "processed"
  - "error"
- expires_at: Optional[int]
  
  The Unix timestamp (in seconds) for when the file will expire.
- status_details: Optional[str]
  
  Deprecated. For details on why a fine-tuning training file failed validation, see the error field on fine_tuning.job.

File Purpose

object

python/resources/files/index.md +709 −0 created

1# Files

3## List files

5`files.list(FileListParams**kwargs) -> SyncCursorPage[FileObject]`

7**get** `/files`

9List files

11### Parameters

13- `after: Optional[str]`

15 A cursor for use in pagination. `after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list.

17- `limit: Optional[int]`

19 A limit on the number of objects to be returned. Limit can range between 1 and 10,000, and the default is 10,000.

21- `order: Optional[Literal["asc", "desc"]]`

23 Sort order by the `created_at` timestamp of the objects. `asc` for ascending order and `desc` for descending order.

25 - `"asc"`

27 - `"desc"`

29- `purpose: Optional[str]`

31 Only return files with the given purpose.

33### Returns

35- `class FileObject: …`

37 The `File` object represents a document that has been uploaded to OpenAI.

39 - `id: str`

41 The file identifier, which can be referenced in the API endpoints.

43 - `bytes: int`

45 The size of the file, in bytes.

47 - `created_at: int`

49 The Unix timestamp (in seconds) for when the file was created.

51 - `filename: str`

53 The name of the file.

55 - `object: Literal["file"]`

57 The object type, which is always `file`.

59 - `"file"`

61 - `purpose: Literal["assistants", "assistants_output", "batch", 5 more]`

63 The intended purpose of the file. Supported values are `assistants`, `assistants_output`, `batch`, `batch_output`, `fine-tune`, `fine-tune-results`, `vision`, and `user_data`.

65 - `"assistants"`

67 - `"assistants_output"`

69 - `"batch"`

71 - `"batch_output"`

73 - `"fine-tune"`

75 - `"fine-tune-results"`

77 - `"vision"`

79 - `"user_data"`

81 - `status: Literal["uploaded", "processed", "error"]`

83 Deprecated. The current status of the file, which can be either `uploaded`, `processed`, or `error`.

85 - `"uploaded"`

87 - `"processed"`

89 - `"error"`

91 - `expires_at: Optional[int]`

93 The Unix timestamp (in seconds) for when the file will expire.

95 - `status_details: Optional[str]`

97 Deprecated. For details on why a fine-tuning training file failed validation, see the `error` field on `fine_tuning.job`.

99### Example

100

101```python

102import os

103from openai import OpenAI

104

105client = OpenAI(

106 api_key=os.environ.get("OPENAI_API_KEY"), # This is the default and can be omitted

107)

108page = client.files.list()

109page = page.data[0]

110print(page)

111```

112

113#### Response

114

115```json

116{

117 "data": [

118 {

119 "id": "id",

120 "bytes": 0,

121 "created_at": 0,

122 "filename": "filename",

123 "object": "file",

124 "purpose": "assistants",

125 "status": "uploaded",

126 "expires_at": 0,

127 "status_details": "status_details"

128 }

129 ],

130 "first_id": "file-abc123",

131 "has_more": false,

132 "last_id": "file-abc456",

133 "object": "list"

134}

135```

136

137### Example

138

139```python

140from openai import OpenAI

141client = OpenAI()

142

143client.files.list()

144```

145

146#### Response

147

148```json

149{

150 "object": "list",

151 "data": [

152 {

153 "id": "file-abc123",

154 "object": "file",

155 "bytes": 175,

156 "created_at": 1613677385,

157 "expires_at": 1677614202,

158 "filename": "salesOverview.pdf",

159 "purpose": "assistants",

160 },

161 {

162 "id": "file-abc456",

163 "object": "file",

164 "bytes": 140,

165 "created_at": 1613779121,

166 "expires_at": 1677614202,

167 "filename": "puppy.jsonl",

168 "purpose": "fine-tune",

169 }

170 ],

171 "first_id": "file-abc123",

172 "last_id": "file-abc456",

173 "has_more": false

174}

175```

176

177## Upload file

178

179`files.create(FileCreateParams**kwargs) -> FileObject`

180

181**post** `/files`

182

183Upload file

184

185### Parameters

186

187- `file: FileTypes`

188

189 The File object (not file name) to be uploaded.

190

191- `purpose: object`

192

193- `expires_after: Optional[ExpiresAfter]`

194

195 The expiration policy for a file. By default, files with `purpose=batch` expire after 30 days and all other files are persisted until they are manually deleted.

196

197 - `anchor: Literal["created_at"]`

198

199 Anchor timestamp after which the expiration policy applies. Supported anchors: `created_at`.

200

201 - `"created_at"`

202

203 - `seconds: int`

204

205 The number of seconds after the anchor time that the file will expire. Must be between 3600 (1 hour) and 2592000 (30 days).

206

207### Returns

208

209- `class FileObject: …`

210

211 The `File` object represents a document that has been uploaded to OpenAI.

212

213 - `id: str`

214

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

216

217 - `bytes: int`

218

219 The size of the file, in bytes.

220

221 - `created_at: int`

222

223 The Unix timestamp (in seconds) for when the file was created.

224

225 - `filename: str`

226

227 The name of the file.

228

229 - `object: Literal["file"]`

230

231 The object type, which is always `file`.

232

233 - `"file"`

234

235 - `purpose: Literal["assistants", "assistants_output", "batch", 5 more]`

236

237 The intended purpose of the file. Supported values are `assistants`, `assistants_output`, `batch`, `batch_output`, `fine-tune`, `fine-tune-results`, `vision`, and `user_data`.

238

239 - `"assistants"`

240

241 - `"assistants_output"`

242

243 - `"batch"`

244

245 - `"batch_output"`

246

247 - `"fine-tune"`

248

249 - `"fine-tune-results"`

250

251 - `"vision"`

252

253 - `"user_data"`

254

255 - `status: Literal["uploaded", "processed", "error"]`

256

257 Deprecated. The current status of the file, which can be either `uploaded`, `processed`, or `error`.

258

259 - `"uploaded"`

260

261 - `"processed"`

262

263 - `"error"`

264

265 - `expires_at: Optional[int]`

266

267 The Unix timestamp (in seconds) for when the file will expire.

268

269 - `status_details: Optional[str]`

270

271 Deprecated. For details on why a fine-tuning training file failed validation, see the `error` field on `fine_tuning.job`.

272

273### Example

274

275```python

276import os

277from openai import OpenAI

278

279client = OpenAI(

280 api_key=os.environ.get("OPENAI_API_KEY"), # This is the default and can be omitted

281)

282file_object = client.files.create(

283 file=b"Example data",

284 purpose={},

285)

286print(file_object.id)

287```

288

289#### Response

290

291```json

292{

293 "id": "id",

294 "bytes": 0,

295 "created_at": 0,

296 "filename": "filename",

297 "object": "file",

298 "purpose": "assistants",

299 "status": "uploaded",

300 "expires_at": 0,

301 "status_details": "status_details"

302}

303```

304

305### Example

306

307```python

308from openai import OpenAI

309client = OpenAI()

310

311client.files.create(

312 file=open("mydata.jsonl", "rb"),

313 purpose="fine-tune",

314 expires_after={

315 "anchor": "created_at",

316 "seconds": 2592000

317 }

318)

319```

320

321#### Response

322

323```json

324{

325 "id": "file-abc123",

326 "object": "file",

327 "bytes": 120000,

328 "created_at": 1677610602,

329 "expires_at": 1677614202,

330 "filename": "mydata.jsonl",

331 "purpose": "fine-tune",

332}

333```

334

335## Delete file

336

337`files.delete(strfile_id) -> FileDeleted`

338

339**delete** `/files/{file_id}`

340

341Delete file

342

343### Parameters

344

345- `file_id: str`

346

347### Returns

348

349- `class FileDeleted: …`

350

351 - `id: str`

352

353 - `deleted: bool`

354

355 - `object: Literal["file"]`

356

357 - `"file"`

358

359### Example

360

361```python

362import os

363from openai import OpenAI

364

365client = OpenAI(

366 api_key=os.environ.get("OPENAI_API_KEY"), # This is the default and can be omitted

367)

368file_deleted = client.files.delete(

369 "file_id",

370)

371print(file_deleted.id)

372```

373

374#### Response

375

376```json

377{

378 "id": "id",

379 "deleted": true,

380 "object": "file"

381}

382```

383

384### Example

385

386```python

387from openai import OpenAI

388client = OpenAI()

389

390client.files.delete("file-abc123")

391```

392

393#### Response

394

395```json

396{

397 "id": "file-abc123",

398 "object": "file",

399 "deleted": true

400}

401```

402

403## Retrieve file

404

405`files.retrieve(strfile_id) -> FileObject`

406

407**get** `/files/{file_id}`

408

409Retrieve file

410

411### Parameters

412

413- `file_id: str`

414

415### Returns

416

417- `class FileObject: …`

418

419 The `File` object represents a document that has been uploaded to OpenAI.

420

421 - `id: str`

422

423 The file identifier, which can be referenced in the API endpoints.

424

425 - `bytes: int`

426

427 The size of the file, in bytes.

428

429 - `created_at: int`

430

431 The Unix timestamp (in seconds) for when the file was created.

432

433 - `filename: str`

434

435 The name of the file.

436

437 - `object: Literal["file"]`

438

439 The object type, which is always `file`.

440

441 - `"file"`

442

443 - `purpose: Literal["assistants", "assistants_output", "batch", 5 more]`

444

445 The intended purpose of the file. Supported values are `assistants`, `assistants_output`, `batch`, `batch_output`, `fine-tune`, `fine-tune-results`, `vision`, and `user_data`.

446

447 - `"assistants"`

448

449 - `"assistants_output"`

450

451 - `"batch"`

452

453 - `"batch_output"`

454

455 - `"fine-tune"`

456

457 - `"fine-tune-results"`

458

459 - `"vision"`

460

461 - `"user_data"`

462

463 - `status: Literal["uploaded", "processed", "error"]`

464

465 Deprecated. The current status of the file, which can be either `uploaded`, `processed`, or `error`.

466

467 - `"uploaded"`

468

469 - `"processed"`

470

471 - `"error"`

472

473 - `expires_at: Optional[int]`

474

475 The Unix timestamp (in seconds) for when the file will expire.

476

477 - `status_details: Optional[str]`

478

479 Deprecated. For details on why a fine-tuning training file failed validation, see the `error` field on `fine_tuning.job`.

480

481### Example

482

483```python

484import os

485from openai import OpenAI

486

487client = OpenAI(

488 api_key=os.environ.get("OPENAI_API_KEY"), # This is the default and can be omitted

489)

490file_object = client.files.retrieve(

491 "file_id",

492)

493print(file_object.id)

494```

495

496#### Response

497

498```json

499{

500 "id": "id",

501 "bytes": 0,

502 "created_at": 0,

503 "filename": "filename",

504 "object": "file",

505 "purpose": "assistants",

506 "status": "uploaded",

507 "expires_at": 0,

508 "status_details": "status_details"

509}

510```

511

512### Example

513

514```python

515from openai import OpenAI

516client = OpenAI()

517

518client.files.retrieve("file-abc123")

519```

520

521#### Response

522

523```json

524{

525 "id": "file-abc123",

526 "object": "file",

527 "bytes": 120000,

528 "created_at": 1677610602,

529 "expires_at": 1677614202,

530 "filename": "mydata.jsonl",

531 "purpose": "fine-tune",

532}

533```

534

535## Retrieve file content

536

537`files.content(strfile_id) -> BinaryResponseContent`

538

539**get** `/files/{file_id}/content`

540

541Retrieve file content

542

543### Parameters

544

545- `file_id: str`

546

547### Returns

548

549- `BinaryResponseContent`

550

551### Example

552

553```python

554import os

555from openai import OpenAI

556

557client = OpenAI(

558 api_key=os.environ.get("OPENAI_API_KEY"), # This is the default and can be omitted

559)

560response = client.files.content(

561 "file_id",

562)

563print(response)

564content = response.read()

565print(content)

566```

567

568### Example

569

570```python

571from openai import OpenAI

572client = OpenAI()

573

574content = client.files.content("file-abc123")

575```

576

577## Retrieve file content

578

579`files.retrieve_content(strfile_id) -> FileContent`

580

581**get** `/files/{file_id}/content`

582

583Retrieve file content

584

585### Parameters

586

587- `file_id: str`

588

589### Returns

590

591- `str`

592

593### Example

594

595```python

596import os

597from openai import OpenAI

598

599client = OpenAI(

600 api_key=os.environ.get("OPENAI_API_KEY"), # This is the default and can be omitted

601)

602file_content = client.files.retrieve_content(

603 "file_id",

604)

605print(file_content)

606```

607

608#### Response

609

610```json

611"string"

612```

613

614### Example

615

616```python

617from openai import OpenAI

618client = OpenAI()

619

620content = client.files.content("file-abc123")

621```

622

623## Domain Types

624

625### File Content

626

627- `str`

628

629### File Deleted

630

631- `class FileDeleted: …`

632

633 - `id: str`

634

635 - `deleted: bool`

636

637 - `object: Literal["file"]`

638

639 - `"file"`

640

641### File Object

642

643- `class FileObject: …`

644

645 The `File` object represents a document that has been uploaded to OpenAI.

646

647 - `id: str`

648

649 The file identifier, which can be referenced in the API endpoints.

650

651 - `bytes: int`

652

653 The size of the file, in bytes.

654

655 - `created_at: int`

656

657 The Unix timestamp (in seconds) for when the file was created.

658

659 - `filename: str`

660

661 The name of the file.

662

663 - `object: Literal["file"]`

664

665 The object type, which is always `file`.

666

667 - `"file"`

668

669 - `purpose: Literal["assistants", "assistants_output", "batch", 5 more]`

670

671 The intended purpose of the file. Supported values are `assistants`, `assistants_output`, `batch`, `batch_output`, `fine-tune`, `fine-tune-results`, `vision`, and `user_data`.

672

673 - `"assistants"`

674

675 - `"assistants_output"`

676

677 - `"batch"`

678

679 - `"batch_output"`

680

681 - `"fine-tune"`

682

683 - `"fine-tune-results"`

684

685 - `"vision"`

686

687 - `"user_data"`

688

689 - `status: Literal["uploaded", "processed", "error"]`

690

691 Deprecated. The current status of the file, which can be either `uploaded`, `processed`, or `error`.

692

693 - `"uploaded"`

694

695 - `"processed"`

696

697 - `"error"`

698

699 - `expires_at: Optional[int]`

700

701 The Unix timestamp (in seconds) for when the file will expire.

702

703 - `status_details: Optional[str]`

704

705 Deprecated. For details on why a fine-tuning training file failed validation, see the `error` field on `fine_tuning.job`.

706

707### File Purpose

708

709- `object`

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

Files

List files

Parameters

Returns

Example

Response

Example

Response

Upload file

Parameters

Returns

Example

Response

Example

Response

Delete file

Parameters

Returns

Example

Response

Example

Response

Retrieve file

Parameters

Returns

Example

Response

Example

Response

Retrieve file content

Parameters

Returns

Example

Example

Retrieve file content

Parameters

Returns

Example

Response

Example

Domain Types

File Content

File Deleted

File Object

File Purpose