OpenAI 词元计数

词元计数可在发送生成请求前确定输入词元量，用于让提示词符合窗口限制、估算费用、按大小路由到合适模型，以及避免用字符数猜测图像和文件的用量。

输入词元计数端点接受与Responses创建请求相同的输入格式，可传文本、消息、图像、文件、工具或会话，返回模型将接收的输入计数。

计数含角色、消息边界等结构格式词元，这些可能不出现在可见文字或本地分词字段中。

为什么使用词元计数API

tiktoken等本地工具适合纯文本，但无法完整处理图像与文件；字符数/4并不可靠。工具和模式有额外词元，模型的推理、缓存等特定处理也会影响统计。计数API可用与responses.create一致的载荷，在消息校验或成本预估流程中取得准确输入量。

基础消息计数

简单文本输入：

来源示例 1（javascript）：

// [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 示例文本为“讲一个笑话”。
import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.inputTokens.count({
  model: "gpt-6-astra",
  input: "Tell me a joke.",
});

console.log(response.input_tokens);

来源示例 2（python）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 示例文本为“讲一个笑话”。
from openai import OpenAI

client = OpenAI()

response = client.responses.input_tokens.count(
    model="gpt-6-astra", input="Tell me a joke."
)
print(response.input_tokens)

来源示例 3（go）：

// [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 示例文本为“讲一个笑话”。
package main

import (
    "context"
    "fmt"

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

func main() {
    client := openai.NewClient()
    count, err := client.Responses.InputTokens.Count(context.Background(), responses.InputTokenCountParams{
        Model: openai.String("gpt-6-astra"),
        Input: responses.InputTokenCountParamsInputUnion{OfString: openai.String("Tell me a joke.")},
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(count.InputTokens)
}

来源示例 4（java）：

// [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 示例文本为“讲一个笑话”。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.inputtokens.InputTokenCountParams;

var count =
    client
        .responses()
        .inputTokens()
        .count(
            InputTokenCountParams.builder()
                .model("gpt-6-astra")
                .input("Tell me a joke.")
                .build());

System.out.println(count.inputTokens());

来源示例 5（ruby）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 示例文本为“讲一个笑话”。
require "openai"

client = OpenAI::Client.new

count = client.responses.input_tokens.count(
  model: "gpt-6-astra",
  input: "Tell me a joke."
)

puts(count.input_tokens)

来源示例 6（bash）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 示例文本为“讲一个笑话”。
curl https://api.openai.com/v1/responses/input_tokens \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "input": "Tell me a joke."
  }'

来源示例 7（bash）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 示例文本为“讲一个笑话”。
openai responses:input-tokens count \
  --model gpt-6-astra \
  --input "Tell me a joke." \
  --raw-output \
  --transform input_tokens

会话计数

多轮对话：

来源示例 8（javascript）：

// [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 示例历史为2+2等于4，然后问3+3。
import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.inputTokens.count({
  model: "gpt-6-astra",
  input: [
    { role: "user", content: "What is 2 + 2?" },
    { role: "assistant", content: "2 + 2 equals 4." },
    { role: "user", content: "What about 3 + 3?" },
  ],
});

console.log(response.input_tokens);

来源示例 9（python）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 示例历史为2+2等于4，然后问3+3。
from openai import OpenAI

client = OpenAI()

response = client.responses.input_tokens.count(
    model="gpt-6-astra",
    input=[
        {"role": "user", "content": "What is 2 + 2?"},
        {"role": "assistant", "content": "2 + 2 equals 4."},
        {"role": "user", "content": "What about 3 + 3?"},
    ],
)
print(response.input_tokens)

来源示例 10（go）：

// [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 示例历史为2+2等于4，然后问3+3。
package main

import (
    "context"
    "fmt"

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

func main() {
    client := openai.NewClient()
    input := []responses.ResponseInputItemUnionParam{
        responses.ResponseInputItemParamOfMessage("What is 2 + 2?", responses.EasyInputMessageRoleUser),
        responses.ResponseInputItemParamOfMessage("2 + 2 equals 4.", responses.EasyInputMessageRoleAssistant),
        responses.ResponseInputItemParamOfMessage("What about 3 + 3?", responses.EasyInputMessageRoleUser),
    }
    count, err := client.Responses.InputTokens.Count(context.Background(), responses.InputTokenCountParams{
        Model: openai.String("gpt-6-astra"),
        Input: responses.InputTokenCountParamsInputUnion{OfResponseInputItemArray: input},
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(count.InputTokens)
}

来源示例 11（java）：

// [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 示例历史为2+2等于4，然后问3+3。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.EasyInputMessage;
import com.openai.models.responses.ResponseInputItem;
import com.openai.models.responses.inputtokens.InputTokenCountParams;
import java.util.List;

var count =
    client
        .responses()
        .inputTokens()
        .count(
            InputTokenCountParams.builder()
                .model("gpt-6-astra")
                .inputOfResponseInputItems(
                    List.of(
                        ResponseInputItem.ofEasyInputMessage(
                            EasyInputMessage.builder()
                                .role(EasyInputMessage.Role.USER)
                                .content("What is 2 + 2?")
                                .build()),
                        ResponseInputItem.ofEasyInputMessage(
                            EasyInputMessage.builder()
                                .role(EasyInputMessage.Role.ASSISTANT)
                                .content("2 + 2 equals 4.")
                                .build()),
                        ResponseInputItem.ofEasyInputMessage(
                            EasyInputMessage.builder()
                                .role(EasyInputMessage.Role.USER)
                                .content("What about 3 + 3?")
                                .build())))
                .build());

System.out.println(count.inputTokens());

来源示例 12（ruby）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 示例历史为2+2等于4，然后问3+3。
require "openai"

client = OpenAI::Client.new
conversation = [
  {
    role: :user,
    content: "What is 2 + 2?"
  },
  {
    role: :assistant,
    content: "2 + 2 equals 4."
  },
  {
    role: :user,
    content: "What about 3 + 3?"
  }
]

count = client.responses.input_tokens.count(
  model: "gpt-6-astra",
  input: conversation
)

puts(count.input_tokens)

来源示例 13（bash）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 示例历史为2+2等于4，然后问3+3。
curl https://api.openai.com/v1/responses/input_tokens \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "input": [
      {"role": "user", "content": "What is 2 + 2?"},
      {"role": "assistant", "content": "2 + 2 equals 4."},
      {"role": "user", "content": "What about 3 + 3?"}
    ]
  }'

来源示例 14（bash）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 示例历史为2+2等于4，然后问3+3。
openai responses:input-tokens count \
  --raw-output \
  --transform input_tokens <<'YAML'
model: gpt-6-astra
input:
  - role: user
    content: What is 2 + 2?
  - role: assistant
    content: 2 + 2 equals 4.
  - role: user
    content: What about 3 + 3?
YAML

带指令计数

包含系统指令的输入：

来源示例 15（javascript）：

// [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 指令是简单解释概念，要求用一句话解释量子计算。
import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.inputTokens.count({
  model: "gpt-6-astra",
  instructions: "You are a helpful assistant that explains concepts simply.",
  input: "Explain quantum computing in one sentence.",
});

console.log(response.input_tokens);

来源示例 16（python）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 指令是简单解释概念，要求用一句话解释量子计算。
from openai import OpenAI

client = OpenAI()

response = client.responses.input_tokens.count(
    model="gpt-6-astra",
    instructions="You are a helpful assistant that explains concepts simply.",
    input="Explain quantum computing in one sentence.",
)
print(response.input_tokens)

来源示例 17（go）：

// [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 指令是简单解释概念，要求用一句话解释量子计算。
package main

import (
    "context"
    "fmt"

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

func main() {
    client := openai.NewClient()
    count, err := client.Responses.InputTokens.Count(context.Background(), responses.InputTokenCountParams{
        Model:        openai.String("gpt-6-astra"),
        Instructions: openai.String("You are a helpful assistant that explains concepts simply."),
        Input:        responses.InputTokenCountParamsInputUnion{OfString: openai.String("Explain quantum computing in one sentence.")},
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(count.InputTokens)
}

来源示例 18（java）：

// [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 指令是简单解释概念，要求用一句话解释量子计算。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.inputtokens.InputTokenCountParams;

var count =
    client
        .responses()
        .inputTokens()
        .count(
            InputTokenCountParams.builder()
                .model("gpt-6-astra")
                .input("Explain quantum computing in one sentence.")
                .instructions("You are a helpful assistant that explains concepts simply.")
                .build());

System.out.println(count.inputTokens());

来源示例 19（ruby）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 指令是简单解释概念，要求用一句话解释量子计算。
require "openai"

client = OpenAI::Client.new

count = client.responses.input_tokens.count(
  model: "gpt-6-astra",
  instructions: "You are a helpful assistant that explains concepts simply.",
  input: "Explain quantum computing in one sentence."
)

puts(count.input_tokens)

来源示例 20（bash）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 指令是简单解释概念，要求用一句话解释量子计算。
curl https://api.openai.com/v1/responses/input_tokens \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "instructions": "You are a helpful assistant that explains concepts simply.",
    "input": "Explain quantum computing in one sentence."
  }'

来源示例 21（bash）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 指令是简单解释概念，要求用一句话解释量子计算。
openai responses:input-tokens count \
  --raw-output \
  --transform input_tokens <<'YAML'
model: gpt-6-astra
instructions: You are a helpful assistant that explains concepts simply.
input: Explain quantum computing in one sentence.
YAML

带图像计数

图像按尺寸和细节等级占用词元，可用API计数：

来源示例 22（javascript）：

// [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 图像URL为占位示例，实际需可访问图像或文件ID。
import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.inputTokens.count({
  model: "gpt-6-astra",
  input: [
    {
      role: "user",
      content: [
        {
          type: "input_image",
          image_url: "https://example.com/chart.png",
          detail: "auto",
        },
        { type: "input_text", text: "Summarize this chart." },
      ],
    },
  ],
});

console.log(response.input_tokens);

来源示例 23（python）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 图像URL为占位示例，实际需可访问图像或文件ID。
from openai import OpenAI

client = OpenAI()

## Use file_id from uploaded file, or image_url for a URL
response = client.responses.input_tokens.count(
    model="gpt-6-astra",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_image",
                    "image_url": "https://example.com/chart.png",
                },
                {"type": "input_text", "text": "Summarize this chart."},
            ],
        }
    ],
)
print(response.input_tokens)

来源示例 24（go）：

// [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 图像URL为占位示例，实际需可访问图像或文件ID。
package main

import (
    "context"
    "fmt"

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

func main() {
    client := openai.NewClient()
    input := []responses.ResponseInputItemUnionParam{
        responses.ResponseInputItemParamOfMessage(
            responses.ResponseInputMessageContentListParam{
                {OfInputImage: &responses.ResponseInputImageParam{ImageURL: openai.String("https://example.com/chart.png"), Detail: responses.ResponseInputImageDetailAuto}},
                {OfInputText: &responses.ResponseInputTextParam{Text: "Summarize this chart."}},
            },
            responses.EasyInputMessageRoleUser,
        ),
    }
    count, err := client.Responses.InputTokens.Count(context.Background(), responses.InputTokenCountParams{
        Model: openai.String("gpt-6-astra"),
        Input: responses.InputTokenCountParamsInputUnion{OfResponseInputItemArray: input},
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(count.InputTokens)
}

来源示例 25（java）：

// [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 保留来源的api.nga.gov具体IIIF图像地址；运行前需检查可访问性，本次未验证该地址。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseInputImage;
import com.openai.models.responses.ResponseInputItem;
import com.openai.models.responses.inputtokens.InputTokenCountParams;
import java.util.List;

var count =
    client
        .responses()
        .inputTokens()
        .count(
            InputTokenCountParams.builder()
                .model("gpt-6-astra")
                .inputOfResponseInputItems(
                    List.of(
                        ResponseInputItem.ofMessage(
                            ResponseInputItem.Message.builder()
                                .role(ResponseInputItem.Message.Role.USER)
                                .addContent(
                                    ResponseInputImage.builder()
                                        .detail(ResponseInputImage.Detail.AUTO)
                                        .imageUrl(
                                            "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg")
                                        .build())
                                .addInputTextContent("Summarize this chart.")
                                .build())))
                .build());

System.out.println(count.inputTokens());

来源示例 26（ruby）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 保留来源的api.nga.gov具体IIIF图像地址；运行前需检查可访问性，本次未验证该地址。
require "openai"

client = OpenAI::Client.new

count = client.responses.input_tokens.count(
  model: "gpt-6-astra",
  input: [
    {
      role: :user,
      content: [
        {
          type: :input_image,
          image_url: "https://api.nga.gov/iiif/a2e6da57-3cd1-4235-b20e-95dcaefed6c8/full/!800,800/0/default.jpg",
          detail: :auto
        },
        {
          type: :input_text,
          text: "Summarize this chart."
        }
      ]
    }
  ]
)

puts(count.input_tokens)

来源示例 27（bash）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 图像URL为占位示例，实际需可访问图像或文件ID。
curl https://api.openai.com/v1/responses/input_tokens \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "input": [{
      "role": "user",
      "content": [
        {"type": "input_image", "image_url": "https://example.com/chart.png"},
        {"type": "input_text", "text": "Summarize this chart."}
      ]
    }]
  }'

来源示例 28（bash）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 图像URL为占位示例，实际需可访问图像或文件ID。
openai responses:input-tokens count \
  --raw-output \
  --transform input_tokens <<'YAML'
model: gpt-6-astra
input:
  - role: user
    content:
      - type: input_image
        image_url: https://example.com/chart.png
      - type: input_text
        text: Summarize this chart.
YAML

可用Files API的file_id，也可用image_url（URL或Base64数据URL），详见图像与视觉。

带工具计数

函数模式、MCP服务器等工具定义也进入上下文，应与输入一起计算：

来源示例 29（javascript）：

// [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 一并计入get_weather函数的定义和模式，函数含义为获取指定位置天气。
import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.inputTokens.count({
  model: "gpt-6-astra",
  tools: [
    {
      type: "function",
      name: "get_weather",
      description: "Get the current weather in a location",
      strict: true,
      parameters: {
        type: "object",
        properties: { location: { type: "string" } },
        required: ["location"],
        additionalProperties: false,
      },
    },
  ],
  input: "What is the weather in San Francisco?",
});

console.log(response.input_tokens);

来源示例 30（python）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 一并计入get_weather函数的定义和模式，函数含义为获取指定位置天气。
from openai import OpenAI

client = OpenAI()

response = client.responses.input_tokens.count(
    model="gpt-6-astra",
    tools=[
        {
            "type": "function",
            "name": "get_weather",
            "description": "Get the current weather in a location",
            "parameters": {
                "type": "object",
                "properties": {"location": {"type": "string"}},
                "required": ["location"],
            },
        }
    ],
    input="What is the weather in San Francisco?",
)
print(response.input_tokens)

来源示例 31（go）：

// [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 一并计入get_weather函数的定义和模式，函数含义为获取指定位置天气。
package main

import (
    "context"
    "fmt"

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

func main() {
    client := openai.NewClient()
    parameters := map[string]any{
        "type": "object",
        "properties": map[string]any{
            "location": map[string]any{"type": "string"},
        },
        "required":             []string{"location"},
        "additionalProperties": false,
    }
    tool := responses.ToolParamOfFunction("get_weather", parameters, true)
    tool.OfFunction.Description = openai.String("Get the current weather in a location")
    count, err := client.Responses.InputTokens.Count(context.Background(), responses.InputTokenCountParams{
        Model: openai.String("gpt-6-astra"),
        Input: responses.InputTokenCountParamsInputUnion{OfString: openai.String("What is the weather in San Francisco?")},
        Tools: []responses.ToolUnionParam{tool},
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(count.InputTokens)
}

来源示例 32（java）：

// [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 一并计入get_weather函数的定义和模式，函数含义为获取指定位置天气。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.JsonValue;
import com.openai.models.responses.FunctionTool;
import com.openai.models.responses.inputtokens.InputTokenCountParams;
import java.util.List;
import java.util.Map;

var count =
    client
        .responses()
        .inputTokens()
        .count(
            InputTokenCountParams.builder()
                .model("gpt-6-astra")
                .input("What is the weather in San Francisco?")
                .addTool(
                    FunctionTool.builder()
                        .name("get_weather")
                        .description("Get the current weather in a location")
                        .strict(true)
                        .parameters(
                            FunctionTool.Parameters.builder()
                                .putAdditionalProperty("type", JsonValue.from("object"))
                                .putAdditionalProperty(
                                    "properties",
                                    JsonValue.from(
                                        Map.of("location", Map.of("type", "string"))))
                                .putAdditionalProperty(
                                    "required", JsonValue.from(List.of("location")))
                                .putAdditionalProperty(
                                    "additionalProperties", JsonValue.from(false))
                                .build())
                        .build())
                .build());

System.out.println(count.inputTokens());

来源示例 33（ruby）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 一并计入get_weather函数的定义和模式，函数含义为获取指定位置天气。
require "openai"

client = OpenAI::Client.new

count = client.responses.input_tokens.count(
  model: "gpt-6-astra",
  input: "What is the weather in San Francisco?",
  tools: [
    {
      type: :function,
      name: "get_weather",
      description: "Get the current weather in a location",
      strict: true,
      parameters: {
        type: "object",
        properties: { location: { type: "string" } },
        required: ["location"],
        additionalProperties: false
      }
    }
  ]
)

puts(count.input_tokens)

来源示例 34（bash）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 一并计入get_weather函数的定义和模式，函数含义为获取指定位置天气。
curl https://api.openai.com/v1/responses/input_tokens \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "tools": [{
      "type": "function",
      "name": "get_weather",
      "description": "Get the current weather in a location",
      "parameters": {
        "type": "object",
        "properties": {"location": {"type": "string"}},
        "required": ["location"]
      }
    }],
    "input": "What is the weather in San Francisco?"
  }'

来源示例 35（bash）：

## [中文] 调用input_tokens.count统计输入，不是运行生成；返回包含消息格式开销的输入量。 一并计入get_weather函数的定义和模式，函数含义为获取指定位置天气。
openai responses:input-tokens count \
  --raw-output \
  --transform input_tokens <<'YAML'
model: gpt-6-astra
tools:
  - type: function
    name: get_weather
    description: Get the current weather in a location
    parameters:
      type: object
      properties:
        location:
          type: string
      required:
        - location
input: What is the weather in San Francisco?
YAML

带文件计数

来源计数指南将文件输入范围注明为“目前PDF”。按创建响应的方式传file_id、file_url或file_data，返回模型完整处理后输入的计数。文件输入指南的通用类型列表更广，不能据此自行扩张计数端点已验证的文件范围。

理解输出词元计数

输出用量涵盖模型生成的全部词元，不只是可见回答。Responses称output_tokens，Chat Completions称completion_tokens。

包括GPT-5在内的某些模型会生成用于响应通道、工具调用和消息结构的格式或分隔词元。它们不出现在消息内容或logprobs中，也未必单独列项。因此即使reasoning_tokens=0，报告的输出或补全词元仍可能多于可见或logprobs中的词元。

max_output_tokens与max_completion_tokens限制所有生成词元，包括不可见部分。差额随模型和响应形态变化，不应假定固定值；需要一定可见长度时，应留足余量。

API参考

参数及响应形态见输入计数接口。端点为：

来源示例 36（）：

POST /v1/responses/input_tokens

返回input_tokens整数及object:"response.input_tokens"。