OpenAI API 文件输入

文件输入支持范围取决于端点。Responses以input_file接收下文列出的文件类型；Chat Completions的file内容部分只接受PDF。

非PDF应使用Responses。若要在Chat Completions使用文件文本，可由应用自行读取，再作为text内容发送。

工作原理

Responses按类型处理input_file：

• PDF：对有视觉能力的模型（来源举例GPT-4o及后续模型），同时提取文字和页面图像交给模型。
• 非PDF文档、文本（如DOCX、PPTX、TXT、代码）：只提取文字。
• 表格（如XLSX、CSV、TSV）：使用专门的表格增强流程。

根据任务可选择其他工具：大型文件检索适合文件搜索，无需把整份文件直接放入上下文；大量表格聚合、连接、图表及自定义计算适合托管Shell。

非PDF的图像与图表限制

Responses不会把非PDF中的嵌入图像或图表提取到模型上下文。需要保留图表、示意图视觉细节时，先转换为PDF，再用input_file发送。

表格增强如何工作

XLSX、XLS、CSV、TSV、IIF等文件使用表格专用处理。API不把全部工作表原样传给模型，而是解析每张表前最多1,000行，加上模型生成的摘要和表头元数据，形成较小的结构化视图。这不等于整张工作表均已逐行分析。

PDF细节等级

Responses的input_file.detail可设auto、low或high，控制页面图像处理；默认auto。GPT-5.6及后续模型的auto采用high，较早模型采用low。low减少输入词元，high适合密集图表、小字或示意图。

该设置只影响页面图像，提取文本仍会包含。Chat Completions文件输入不支持detail。

显式高细节请求体示例：

来源示例 1（json）：

{
  "model": "gpt-4.1",
  "input": [
    {
      "role": "user",
      "content": [
        {
          "type": "input_file",
          "filename": "document.pdf",
          "file_data": "data:application/pdf;base64,...",
          "detail": "high"
        },
        {
          "type": "input_text",
          "text": "Summarize this document."
        }
      ]
    }
  ]
}

接受的文件类型

下表是Responses接受的常见类型，完整扩展名和MIME见后文。Chat Completions的file_data与file_id仅支持.pdf（application/pdf）。

文件URL

Responses可通过外部URL提供文件输入。

来源示例 2（javascript）：

// [中文] 用外部file_url要求分析信件并总结要点；此方式用于Responses，不能套到Chat。
import OpenAI from "openai";
const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-6-astra",
  input: [
    {
      role: "user",
      content: [
        {
          type: "input_text",
          text: "Analyze the letter and provide a summary of the key points.",
        },
        {
          type: "input_file",
          file_url: "https://www.berkshirehathaway.com/letters/2024ltr.pdf",
        },
      ],
    },
  ],
});

console.log(response.output_text);

来源示例 3（python）：

## [中文] 用外部file_url要求分析信件并总结要点；此方式用于Responses，不能套到Chat。
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": "Analyze the letter and provide a summary of the key points.",
                },
                {
                    "type": "input_file",
                    "file_url": "https://www.berkshirehathaway.com/letters/2024ltr.pdf",
                },
            ],
        },
    ],
)

print(response.output_text)

来源示例 4（go）：

// [中文] 用外部file_url要求分析信件并总结要点；此方式用于Responses，不能套到Chat。
package main

import (
    "context"
    "fmt"

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

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

    response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
        Model: "gpt-6-astra",
        Input: responses.ResponseNewParamsInputUnion{
            OfInputItemList: responses.ResponseInputParam{
                responses.ResponseInputItemParamOfMessage(
                    responses.ResponseInputMessageContentListParam{
                        responses.ResponseInputContentParamOfInputText(
                            "Analyze the letter and provide a summary of the key points.",
                        ),
                        {
                            OfInputFile: &responses.ResponseInputFileParam{
                                FileURL: openai.String(
                                    "https://www.berkshirehathaway.com/letters/2024ltr.pdf",
                                ),
                            },
                        },
                    },
                    responses.EasyInputMessageRoleUser,
                ),
            },
        },
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(response.OutputText())
}

来源示例 5（java）：

// [中文] 用外部file_url要求分析信件并总结要点；此方式用于Responses，不能套到Chat。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputFile;
import com.openai.models.responses.ResponseInputItem;
import java.util.List;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .inputOfResponse(
            List.of(
                ResponseInputItem.ofMessage(
                    ResponseInputItem.Message.builder()
                        .role(ResponseInputItem.Message.Role.USER)
                        .addInputTextContent(
                            "Analyze the letter and provide a summary of the key points.")
                        .addContent(
                            ResponseInputFile.builder()
                                .fileUrl(
                                    "https://www.berkshirehathaway.com/letters/2024ltr.pdf")
                                .build())
                        .build())))
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

来源示例 6（csharp）：

// [中文] 用外部file_url要求分析信件并总结要点；此方式用于Responses，不能套到Chat。
using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

Uri fileUrl = new(
    "https://www.berkshirehathaway.com/letters/2024ltr.pdf"
);

ResponseResult response = await client.CreateResponseAsync(
    "gpt-6-astra",
    [
        ResponseItem.CreateUserMessageItem(
            [
                ResponseContentPart.CreateInputTextPart(
                    "Analyze the letter and provide a summary of the key points."
                ),
                ResponseContentPart.CreateInputFilePart(fileUrl),
            ]
        ),
    ]
);

Console.WriteLine(response.GetOutputText());

来源示例 7（ruby）：

## [中文] 用外部file_url要求分析信件并总结要点；此方式用于Responses，不能套到Chat。
require "openai"

openai = OpenAI::Client.new

response = openai.responses.create(
  model: "gpt-6-astra",
  input: [
    {
      role: "user",
      content: [
        {
          type: "input_text",
          text: "Analyze the letter and provide a summary of the key points."
        },
        {
          type: "input_file",
          file_url: "https://www.berkshirehathaway.com/letters/2024ltr.pdf"
        }
      ]
    }
  ]
)

puts(response.output_text)

来源示例 8（bash）：

## [中文] 用外部file_url要求分析信件并总结要点；此方式用于Responses，不能套到Chat。
curl "https://api.openai.com/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-6-astra",
        "input": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_text",
                        "text": "Analyze the letter and provide a summary of the key points."
                    },
                    {
                        "type": "input_file",
                        "file_url": "https://www.berkshirehathaway.com/letters/2024ltr.pdf"
                    }
                ]
            }
        ]
    }'

上传文件

先用Files API上传，再在模型请求中引用文件ID。

来源示例 9（javascript）：

// [中文] 上传draconomicon.pdf后用file_id作为模型输入，purpose=user_data；实际需准备本地文件。
import fs from "fs";
import OpenAI from "openai";
const client = new OpenAI();

const file = await client.files.create({
  file: fs.createReadStream("fixtures/draconomicon.pdf"),
  purpose: "user_data",
});

const response = await client.responses.create({
  model: "gpt-6-astra",
  input: [
    {
      role: "user",
      content: [
        {
          type: "input_file",
          file_id: file.id,
        },
        {
          type: "input_text",
          text: "What is the first dragon in the book?",
        },
      ],
    },
  ],
});

console.log(response.output_text);

来源示例 10（python）：

## [中文] 上传draconomicon.pdf后用file_id作为模型输入，purpose=user_data；实际需准备本地文件。
from openai import OpenAI

client = OpenAI()

file = client.files.create(file=open("draconomicon.pdf", "rb"), purpose="user_data")

response = client.responses.create(
    model="gpt-6-astra",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_file",
                    "file_id": file.id,
                },
                {
                    "type": "input_text",
                    "text": "What is the first dragon in the book?",
                },
            ],
        }
    ],
)

print(response.output_text)

来源示例 11（go）：

// [中文] 上传draconomicon.pdf后用file_id作为模型输入，purpose=user_data；实际需准备本地文件。
package main

import (
    "context"
    "fmt"
    "os"

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

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

    file, err := os.Open("draconomicon.pdf")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    uploadedFile, err := client.Files.New(context.Background(), openai.FileNewParams{
        File:    file,
        Purpose: openai.FilePurposeUserData,
    })
    if err != nil {
        panic(err)
    }

    response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
        Model: "gpt-6-astra",
        Input: responses.ResponseNewParamsInputUnion{
            OfInputItemList: responses.ResponseInputParam{
                responses.ResponseInputItemParamOfMessage(
                    responses.ResponseInputMessageContentListParam{
                        {
                            OfInputFile: &responses.ResponseInputFileParam{
                                FileID: openai.String(uploadedFile.ID),
                            },
                        },
                        responses.ResponseInputContentParamOfInputText(
                            "What is the first dragon in the book?",
                        ),
                    },
                    responses.EasyInputMessageRoleUser,
                ),
            },
        },
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(response.OutputText())
}

来源示例 12（java）：

// [中文] 上传draconomicon.pdf后用file_id作为模型输入，purpose=user_data；实际需准备本地文件。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.files.FileCreateParams;
import com.openai.models.files.FilePurpose;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputFile;
import com.openai.models.responses.ResponseInputItem;
import java.nio.file.Path;
import java.util.List;

var file =
    client
        .files()
        .create(
            FileCreateParams.builder()
                .file(Path.of(System.getenv("OPENAI_EXAMPLE_FILE_PATH")))
                .purpose(FilePurpose.USER_DATA)
                .build());

var response =
    client
        .responses()
        .create(
            ResponseCreateParams.builder()
                .model("gpt-6-astra")
                .inputOfResponse(
                    List.of(
                        ResponseInputItem.ofMessage(
                            ResponseInputItem.Message.builder()
                                .role(ResponseInputItem.Message.Role.USER)
                                .addContent(
                                    ResponseInputFile.builder().fileId(file.id()).build())
                                .addInputTextContent("What is the first dragon in the book?")
                                .build())))
                .build());
response.output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

来源示例 13（csharp）：

// [中文] 上传draconomicon.pdf后用file_id作为模型输入，purpose=user_data；实际需准备本地文件。
using OpenAI.Files;
using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

OpenAIFileClient files = new(key);

OpenAIFile file = await files.UploadFileAsync(
    "draconomicon.pdf",
    FileUploadPurpose.UserData
);

ResponseResult response = await client.CreateResponseAsync(
    "gpt-6-astra",
    [
        ResponseItem.CreateUserMessageItem(
            [
                ResponseContentPart.CreateInputFilePart(file.Id),
                ResponseContentPart.CreateInputTextPart(
                    "What is the first dragon in the book?"
                ),
            ]
        ),
    ]
);

Console.WriteLine(response.GetOutputText());

来源示例 14（ruby）：

## [中文] 上传draconomicon.pdf后用file_id作为模型输入，purpose=user_data；实际需准备本地文件。
require "openai"
require "pathname"

openai = OpenAI::Client.new

file = openai.files.create(
  file: Pathname("draconomicon.pdf"),
  purpose: "user_data"
)

response = openai.responses.create(
  model: "gpt-6-astra",
  input: [
    {
      role: "user",
      content: [
        {
          type: "input_file",
          file_id: file.id
        },
        {
          type: "input_text",
          text: "What is the first dragon in the book?"
        }
      ]
    }
  ]
)

puts(response.output_text)

来源示例 15（bash）：

## [中文] 上传draconomicon.pdf后用file_id作为模型输入，purpose=user_data；实际需准备本地文件。
curl https://api.openai.com/v1/files \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -F purpose="user_data" \
    -F file="@draconomicon.pdf"

curl "https://api.openai.com/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-6-astra",
        "input": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_file",
                        "file_id": "file-6F2ksmvXxt4VdoqmHRw6kL"
                    },
                    {
                        "type": "input_text",
                        "text": "What is the first dragon in the book?"
                    }
                ]
            }
        ]
    }'

同页HTML的Chat Completions版本只以PDF演示，其字段结构与Responses不同：

来源示例 23（javascript）：

// [中文] 上传draconomicon.pdf后用file_id作为模型输入，purpose=user_data；实际需准备本地文件。
import fs from "fs";
import OpenAI from "openai";
const client = new OpenAI();

const file = await client.files.create({
  file: fs.createReadStream("fixtures/draconomicon.pdf"),
  purpose: "user_data",
});

const completion = await client.chat.completions.create({
  model: "gpt-6-astra",
  messages: [
    {
      role: "user",
      content: [
        {
          type: "file",
          file: {
            file_id: file.id,
          },
        },
        {
          type: "text",
          text: "What is the first dragon in the book?",
        },
      ],
    },
  ],
});

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

来源示例 24（python）：

## [中文] 上传draconomicon.pdf后用file_id作为模型输入，purpose=user_data；实际需准备本地文件。
from openai import OpenAI

client = OpenAI()

file = client.files.create(file=open("draconomicon.pdf", "rb"), purpose="user_data")

completion = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "file",
                    "file": {
                        "file_id": file.id,
                    },
                },
                {
                    "type": "text",
                    "text": "What is the first dragon in the book?",
                },
            ],
        }
    ],
)

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

来源示例 25（go）：

// [中文] 上传draconomicon.pdf后用file_id作为模型输入，purpose=user_data；实际需准备本地文件。
package main

import (
    "context"
    "fmt"
    "os"

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

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

    file, err := os.Open("draconomicon.pdf")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    uploadedFile, err := client.Files.New(context.Background(), openai.FileNewParams{
        File:    file,
        Purpose: openai.FilePurposeUserData,
    })
    if err != nil {
        panic(err)
    }

    completion, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
        Model: "gpt-6-astra",
        Messages: []openai.ChatCompletionMessageParamUnion{
            openai.UserMessage([]openai.ChatCompletionContentPartUnionParam{
                openai.FileContentPart(openai.ChatCompletionContentPartFileFileParam{
                    FileID: openai.String(uploadedFile.ID),
                }),
                openai.TextContentPart("What is the first dragon in the book?"),
            }),
        },
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(completion.Choices[0].Message.Content)
}

来源示例 26（java）：

// [中文] 上传draconomicon.pdf后用file_id作为模型输入，purpose=user_data；实际需准备本地文件。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionContentPart;
import com.openai.models.chat.completions.ChatCompletionContentPartText;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
import com.openai.models.chat.completions.ChatCompletionUserMessageParam;
import com.openai.models.files.FileCreateParams;
import com.openai.models.files.FilePurpose;
import java.nio.file.Path;
import java.util.List;

var file =
    client
        .files()
        .create(
            FileCreateParams.builder()
                .file(Path.of(System.getenv("OPENAI_EXAMPLE_FILE_PATH")))
                .purpose(FilePurpose.USER_DATA)
                .build());

var filePart =
    ChatCompletionContentPart.ofFile(
        ChatCompletionContentPart.File.builder()
            .file(ChatCompletionContentPart.File.FileObject.builder().fileId(file.id()).build())
            .build());
var textPart =
    ChatCompletionContentPart.ofText(
        ChatCompletionContentPartText.builder().text("Summarize this PDF.").build());
var completion =
    client
        .chat()
        .completions()
        .create(
            ChatCompletionCreateParams.builder()
                .model("gpt-6-astra")
                .addMessage(
                    ChatCompletionUserMessageParam.builder()
                        .contentOfArrayOfContentParts(List.of(filePart, textPart))
                        .build())
                .build());
completion.choices().stream()
    .flatMap(choice -> choice.message().content().stream())
    .forEach(System.out::println);

来源示例 27（csharp）：

// [中文] 上传draconomicon.pdf后用file_id作为模型输入，purpose=user_data；实际需准备本地文件。
using OpenAI.Chat;
using OpenAI.Files;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
string model = "gpt-6-astra";
ChatClient client = new(model, key);

OpenAIFileClient files = new(key);

OpenAIFile file = await files.UploadFileAsync("draconomicon.pdf", FileUploadPurpose.UserData);

ChatCompletion completion = await client.CompleteChatAsync(
    new UserChatMessage(
        [
            ChatMessageContentPart.CreateFilePart(file.Id),
            ChatMessageContentPart.CreateTextPart("What is the first dragon in the book?"),
        ]
    )
);

Console.WriteLine(completion.Content[0].Text);

来源示例 28（ruby）：

## [中文] 上传draconomicon.pdf后用file_id作为模型输入，purpose=user_data；实际需准备本地文件。
require "openai"
require "pathname"

client = OpenAI::Client.new
file = client.files.create(
  file: Pathname("draconomicon.pdf"),
  purpose: :user_data
)
completion = client.chat.completions.create(
  model: "gpt-6-astra",
  messages: [
    {
      role: :user,
      content: [
        {
          type: :file,
          file: { file_id: file.id }
        },
        {
          type: :text,
          text: "Summarize this PDF."
        }
      ]
    }
  ]
)

puts(completion.choices.fetch(0).message.content)

来源示例 29（bash）：

## [中文] 上传draconomicon.pdf后用file_id作为模型输入，purpose=user_data；实际需准备本地文件。
curl https://api.openai.com/v1/files \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -F purpose="user_data" \
    -F file="@draconomicon.pdf"

curl "https://api.openai.com/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-6-astra",
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "file",
                        "file": {
                            "file_id": "file-6F2ksmvXxt4VdoqmHRw6kL"
                        }
                    },
                    {
                        "type": "text",
                        "text": "What is the first dragon in the book?"
                    }
                ]
            }
        ]
    }'

Base64编码文件

也可以直接发送Base64编码的文件数据。

来源示例 16（javascript）：

// [中文] 读取PDF并Base64编码，作为file_data发送；保留来源的Responses或Chat字段层次，勿混用。
import fs from "fs";
import OpenAI from "openai";
const client = new OpenAI();

const data = fs.readFileSync("fixtures/draconomicon.pdf");
const base64String = data.toString("base64");

const response = await client.responses.create({
  model: "gpt-6-astra",
  input: [
    {
      role: "user",
      content: [
        {
          type: "input_file",
          filename: "draconomicon.pdf",
          file_data: `data:application/pdf;base64,${base64String}`,
        },
        {
          type: "input_text",
          text: "What is the first dragon in the book?",
        },
      ],
    },
  ],
});

console.log(response.output_text);

来源示例 17（python）：

## [中文] 读取PDF并Base64编码，作为file_data发送；保留来源的Responses或Chat字段层次，勿混用。
import base64
from openai import OpenAI

client = OpenAI()

with open("draconomicon.pdf", "rb") as f:
    data = f.read()

base64_string = base64.b64encode(data).decode("utf-8")

response = client.responses.create(
    model="gpt-6-astra",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_file",
                    "filename": "draconomicon.pdf",
                    "file_data": f"data:application/pdf;base64,{base64_string}",
                },
                {
                    "type": "input_text",
                    "text": "What is the first dragon in the book?",
                },
            ],
        },
    ],
)

print(response.output_text)

来源示例 18（go）：

// [中文] 读取PDF并Base64编码，作为file_data发送；保留来源的Responses或Chat字段层次，勿混用。
package main

import (
    "context"
    "encoding/base64"
    "fmt"
    "os"

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

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

    data, err := os.ReadFile("draconomicon.pdf")
    if err != nil {
        panic(err)
    }
    fileData := "data:application/pdf;base64," + base64.StdEncoding.EncodeToString(data)

    response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
        Model: "gpt-6-astra",
        Input: responses.ResponseNewParamsInputUnion{
            OfInputItemList: responses.ResponseInputParam{
                responses.ResponseInputItemParamOfMessage(
                    responses.ResponseInputMessageContentListParam{
                        {
                            OfInputFile: &responses.ResponseInputFileParam{
                                Filename: openai.String("draconomicon.pdf"),
                                FileData: openai.String(fileData),
                            },
                        },
                        responses.ResponseInputContentParamOfInputText(
                            "What is the first dragon in the book?",
                        ),
                    },
                    responses.EasyInputMessageRoleUser,
                ),
            },
        },
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(response.OutputText())
}

来源示例 19（java）：

// [中文] 读取PDF并Base64编码，作为file_data发送；保留来源的Responses或Chat字段层次，勿混用。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputFile;
import com.openai.models.responses.ResponseInputItem;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;
import java.util.List;

String pdfData =
    Base64.getEncoder()
        .encodeToString(Files.readAllBytes(Path.of(System.getenv("OPENAI_EXAMPLE_FILE_PATH"))));
ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .inputOfResponse(
            List.of(
                ResponseInputItem.ofMessage(
                    ResponseInputItem.Message.builder()
                        .role(ResponseInputItem.Message.Role.USER)
                        .addContent(
                            ResponseInputFile.builder()
                                .filename("document.pdf")
                                .fileData("data:application/pdf;base64," + pdfData)
                                .build())
                        .addInputTextContent("Summarize this document.")
                        .build())))
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

来源示例 20（csharp）：

// [中文] 读取PDF并Base64编码，作为file_data发送；保留来源的Responses或Chat字段层次，勿混用。
using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

BinaryData fileBytes = BinaryData.FromBytes(await File.ReadAllBytesAsync("draconomicon.pdf"));
ResponseResult response = await client.CreateResponseAsync(
    "gpt-6-astra",
    [
        ResponseItem.CreateUserMessageItem(
            [
                ResponseContentPart.CreateInputFilePart(
                    fileBytes,
                    "application/pdf",
                    "draconomicon.pdf"
                ),
                ResponseContentPart.CreateInputTextPart(
                    "What is the first dragon in the book?"
                ),
            ]
        ),
    ]
);

Console.WriteLine(response.GetOutputText());

来源示例 21（ruby）：

## [中文] 读取PDF并Base64编码，作为file_data发送；保留来源的Responses或Chat字段层次，勿混用。
require "base64"
require "openai"

client = OpenAI::Client.new
pdf_data = Base64.strict_encode64(File.binread("draconomicon.pdf"))
response = client.responses.create(
  model: "gpt-6-astra",
  input: [
    {
      role: :user,
      content: [
        {
          type: :input_file,
          filename: "document.pdf",
          file_data: "data:application/pdf;base64,#{pdf_data}"
        },
        {
          type: :input_text,
          text: "Summarize this document."
        }
      ]
    }
  ]
)

puts(response.output_text)

来源示例 22（bash）：

## [中文] 读取PDF并Base64编码，作为file_data发送；保留来源的Responses或Chat字段层次，勿混用。
curl "https://api.openai.com/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-6-astra",
        "input": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_file",
                        "filename": "draconomicon.pdf",
                        "file_data": "...base64 encoded PDF bytes here..."
                    },
                    {
                        "type": "input_text",
                        "text": "What is the first dragon in the book?"
                    }
                ]
            }
        ]
    }'

Chat Completions的Base64 PDF版本：

来源示例 30（javascript）：

// [中文] 读取PDF并Base64编码，作为file_data发送；保留来源的Responses或Chat字段层次，勿混用。
import fs from "fs";
import OpenAI from "openai";
const client = new OpenAI();

const data = fs.readFileSync("fixtures/draconomicon.pdf");
const base64String = data.toString("base64");

const completion = await client.chat.completions.create({
  model: "gpt-6-astra",
  messages: [
    {
      role: "user",
      content: [
        {
          type: "file",
          file: {
            filename: "draconomicon.pdf",
            file_data: `data:application/pdf;base64,${base64String}`,
          },
        },
        {
          type: "text",
          text: "What is the first dragon in the book?",
        },
      ],
    },
  ],
});

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

来源示例 31（python）：

## [中文] 读取PDF并Base64编码，作为file_data发送；保留来源的Responses或Chat字段层次，勿混用。
import base64
from openai import OpenAI

client = OpenAI()

with open("draconomicon.pdf", "rb") as f:
    data = f.read()

base64_string = base64.b64encode(data).decode("utf-8")

completion = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "file",
                    "file": {
                        "filename": "draconomicon.pdf",
                        "file_data": f"data:application/pdf;base64,{base64_string}",
                    },
                },
                {
                    "type": "text",
                    "text": "What is the first dragon in the book?",
                },
            ],
        },
    ],
)

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

来源示例 32（go）：

// [中文] 读取PDF并Base64编码，作为file_data发送；保留来源的Responses或Chat字段层次，勿混用。
package main

import (
    "context"
    "encoding/base64"
    "fmt"
    "os"

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

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

    data, err := os.ReadFile("draconomicon.pdf")
    if err != nil {
        panic(err)
    }
    fileData := "data:application/pdf;base64," + base64.StdEncoding.EncodeToString(data)

    completion, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
        Model: "gpt-6-astra",
        Messages: []openai.ChatCompletionMessageParamUnion{
            openai.UserMessage([]openai.ChatCompletionContentPartUnionParam{
                openai.FileContentPart(openai.ChatCompletionContentPartFileFileParam{
                    Filename: openai.String("draconomicon.pdf"),
                    FileData: openai.String(fileData),
                }),
                openai.TextContentPart("What is the first dragon in the book?"),
            }),
        },
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(completion.Choices[0].Message.Content)
}

来源示例 33（java）：

// [中文] 读取PDF并Base64编码，作为file_data发送；保留来源的Responses或Chat字段层次，勿混用。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionContentPart;
import com.openai.models.chat.completions.ChatCompletionContentPartText;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
import com.openai.models.chat.completions.ChatCompletionUserMessageParam;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;
import java.util.List;

String encoded =
    Base64.getEncoder()
        .encodeToString(Files.readAllBytes(Path.of(System.getenv("OPENAI_EXAMPLE_FILE_PATH"))));
ChatCompletionContentPart file =
    ChatCompletionContentPart.ofFile(
        ChatCompletionContentPart.File.builder()
            .file(
                ChatCompletionContentPart.File.FileObject.builder()
                    .filename("document.pdf")
                    .fileData("data:application/pdf;base64," + encoded)
                    .build())
            .build());
ChatCompletionContentPart text =
    ChatCompletionContentPart.ofText(
        ChatCompletionContentPartText.builder().text("Summarize this document.").build());

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-6-astra")
        .addMessage(
            ChatCompletionUserMessageParam.builder()
                .contentOfArrayOfContentParts(List.of(file, text))
                .build())
        .build();

client.chat().completions().create(params).choices().stream()
    .flatMap(choice -> choice.message().content().stream())
    .forEach(System.out::println);

来源示例 34（csharp）：

// [中文] 读取PDF并Base64编码，作为file_data发送；保留来源的Responses或Chat字段层次，勿混用。
using OpenAI.Chat;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
string model = "gpt-6-astra";
ChatClient client = new(model, key);

BinaryData fileBytes = BinaryData.FromBytes(await File.ReadAllBytesAsync("draconomicon.pdf"));
ChatCompletion completion = await client.CompleteChatAsync(
    new UserChatMessage(
        [
            ChatMessageContentPart.CreateFilePart(
                fileBytes,
                "application/pdf",
                "draconomicon.pdf"
            ),
            ChatMessageContentPart.CreateTextPart("What is the first dragon in the book?"),
        ]
    )
);

Console.WriteLine(completion.Content[0].Text);

来源示例 35（ruby）：

## [中文] 读取PDF并Base64编码，作为file_data发送；保留来源的Responses或Chat字段层次，勿混用。
require "base64"
require "openai"

client = OpenAI::Client.new
pdf_data = Base64.strict_encode64(File.binread("draconomicon.pdf"))
completion = client.chat.completions.create(
  model: "gpt-6-astra",
  messages: [
    {
      role: :user,
      content: [
        {
          type: :file,
          file: {
            filename: "document.pdf",
            file_data: "data:application/pdf;base64,#{pdf_data}"
          }
        },
        {
          type: :text,
          text: "Summarize this document."
        }
      ]
    }
  ]
)

puts(completion.choices.fetch(0).message.content)

来源示例 36（bash）：

## [中文] 读取PDF并Base64编码，作为file_data发送；保留来源的Responses或Chat字段层次，勿混用。
curl "https://api.openai.com/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
        "model": "gpt-6-astra",
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "file",
                        "file": {
                            "filename": "draconomicon.pdf",
                            "file_data": "...base64 encoded bytes here..."
                        }
                    },
                    {
                        "type": "text",
                        "text": "What is the first dragon in the book?"
                    }
                ]
            }
        ]
    }'

使用注意事项

• 词元用量：PDF文字和页面图像都进入上下文，可能增加用量。Responses用detail控制图像细节；规模化使用前核对价格和词元影响。
• 文件大小：单次可包含多个文件，但每个文件必须小于50MB，所有文件总计也以50MB为限。
• 模型支持：同时解析PDF文字和页面图像需要有视觉能力的模型，来源举例GPT-4o及后续模型；仍须核对具体模型能力。
• 上传用途：可使用受支持的purpose，计划作为模型输入的文件建议用user_data。

完整文件类型列表

本表适用于Responses。Chat Completions通过file_data或file_id仍仅支持PDF。扩展名、MIME标识保留原样，类别与说明译为中文。

后续阅读

• 在Playground试验文件输入。
• 完整Responses API参考。
• 大型资料库文件搜索。
• 托管Shell深入分析表格。