GPT-5开发者入门指南：API新功能、参数详解与代码示例

GPT-5 模型的最新版本为开发者带来了尖端的 AI 能力，并在编码、推理和创造力方面取得了显著进步。GPT-5 模型新增了一些 API 功能，使开发者能够创建可精细控制的输出。本入门指南在 API 的背景下介绍了 GPT-5，总结了其差异，并解释了如何将其应用于代码和自动化任务。

GPT-5 专为开发者打造。新版 GPT-5 使用的工具可让您控制详细程度、推理深度和输出格式。在本指南中，您将学习如何开始使用 GPT-5，了解它的一些独特参数，并查看 OpenAI Cookbook 中的代码示例，这些示例展示了比先前版本模型提供更多功能的流程。

GPT-5有哪些新功能？

GPT-5 更智能、更可控，更适合处理复杂工作。它非常擅长代码生成、推理和工具使用。该模型在工程基准测试中展现出顶尖性能，能够编写精美的前端 UI，良好地遵循指令，并能够在完成多步骤任务时自主执行。该模型旨在让您感觉自己正在与真正的协作者互动。其主要功能包括：

突破性能力

• 在 SWE-bench (74.9%) 和 Aider (88%) 上均表现出色
• 能够生成复杂、响应迅速的 UI 代码，同时展现设计感
• 能够修复棘手的 bug 并理解大型代码库
• 能够像真正的 AI 代理一样规划任务，因为它能够精准地使用 API，并能够从工具故障中正确恢复。

更智能的推理，更少的幻觉

• 更少的事实错误和幻觉
• 更好地理解和执行用户指令
• 代理行为和工具集成
• 能够执行多步骤、多工具的工作流程

为什么通过API使用GPT-5？

GPT-5 专为开发者打造，在实际编码和数据任务中实现了专家级性能。它拥有强大的 API，能够实现自动化、精准度和控制力。无论您是调试还是构建完整的应用程序，GPT-5 都能轻松与您的工作流程集成，帮助您在极低负载的情况下提升生产力和可靠性。

• 开发者专属：专为编码工作流程构建，因此易于集成到开发工具和 IDE 中。
• 久经验证的性能：SOTA 实际任务（例如错误修复、代码编辑），包含必要的错误和标记。
• 细粒度控制：通过对详细程度、推理和蓝图工具调用等新参数​​进行控制，您可以调整输出并开发自动化流水线。

入门指南

要在您的应用程序中开始使用 GPT-5，您需要配置对 API 的访问权限，了解可用的不同端点，并根据您的需求选择合适的模型变体。本节将指导您如何配置 API 凭据、选择哪个端点进行聊天或响应，以及如何浏览 GPT-5 模型，以便您充分发挥其潜力。

1. 访问 GPT-5 API

首先，设置您的 API 凭据：如果您想使用 OPENAI_API_KEY 作为环境变量。然后安装或升级 OpenAI SDK 以使用 GPT-5。之后，您可以像调用任何其他模型一样通过 API 调用 GPT-5 模型（gpt-5、gpt-5-mini、gpt-5-nano）。创建一个 .env 文件并将 API 密钥保存为：

OPENAI_API_KEY=sk-abc1234567890—

2. API 密钥和身份验证

要进行任何 GPT-5 API 调用，您需要一个有效的 OpenAI API 密钥。您可以设置环境变量 OPENAI_API_KEY，或将密钥直接传递给客户端。请务必妥善保管您的密钥，因为它将用于验证您的请求。

import os
from openai import OpenAI
client = OpenAI(
   api_key=os.environ.get("OPENAI_API_KEY")
)

3. 选择正确的端点

GPT-5 提供 Responses API，作为与模型交互的统一端点，通过同一接口提供推理跟踪、工具调用和高级控制，使其成为最佳选择。OpenAI 建议所有新部署都使用此 API。

from openai import OpenAI
import os
client = OpenAI()
response = client.responses.create(
   model="gpt‑5",
   input=[{"role": "user", "content": "Tell me a one-sentence bedtime story about a unicorn."}]
)
print(response.output_text)

模型变体

GPT-5 版本

以编程方式使用GPT-5

要访问 GPT-5，我们可以使用 OpenAI SDK 来调用 GPT-5。例如，如果您使用 Python：

from openai import OpenAI
client = OpenAI()

然后使用 client.responses.create 提交包含 GPT-5 消息和参数的请求。SDK 将自动使用您的 API 密钥对请求进行身份验证。

API请求结构

典型的 GPT-5 API 请求包含以下字段：

• model：GPT-5 变体（GPT-5、GPT-5-mini 或 GPT-5-nano）。
• input/messages:
  • 对于响应 API：使用包含消息列表的输入字段（每条消息都具有角色和内容）。
  • 对于聊天完成 API：使用具有相同结构的 messages 字段。
• text：这是一个可选参数，包含一个输出样式参数字典，例如：
  • verbosity：“low”、“medium”或“high”，用于控制详细程度。
• reasoning：这是一个可选参数，包含一个字典，用于控制模型应用的推理工作量，例如：
  • effort：“minimal”，用于更快、更轻量的任务。
• tools：这是一个可选参数，包含一个自定义工具定义列表，例如用于函数调用或语法约束。
• 关键参数：verbosity、reasoning_effort、max_tokens

与 GPT-5 交互时，各种参数允许您自定义模型的响应方式。这种感知使您能够更好地控制与收到的响应相关的质量、性能和成本。

• verbosity：管理模型响应中提供的详细程度。可接受的系列（值）：低、中或高
  • “low”通常在尚未显示的文本区域中显示，并提供简短、切中要点的答案
  • “high”提供全面、详细的解释和答案
• reasoning_effort：指模型在响应之前进行的内部推理量。可接受的系列（值）：最小、低、中、高。
  • 设置为“minimal”通常会返回最快的答案，且几乎不包含任何解释。
  • 设置为“high”可以为模型的输出提供更多空间进行更深入的分析，因此，相对于之前的设置，输出可能更加完善。
• max_tokens：设置模型响应中令牌数量的上限。最大令牌数有助于控制成本或限制预期答案的长度。

API调用示例

这是一个使用 OpenAI 库调用 GPT-5 的 Python 示例。它接收并发送用户提示，然后打印模型的响应：

from openai import OpenAI
client = OpenAI()
response = client.responses.create(
   model="gpt-5",
   input=[{"role": "user", "content": "Hello GPT-5, what can you do?"}],
   text={"verbosity": "medium"},
   reasoning={"effort": "minimal"}
)
print(response.output)

输出：

高级功能

在下一节中，我们将测试 GPT-5 API 的 4 项新功能。

详细程度控制

详细程度参数允许您指示 GPT-5 应该简洁还是详细。您可以将详细程度设置为“低”、“中”或“高”。详细程度越高，模型的输出就越长、越详细。相反，低详细程度使模型专注于提供更简短的答案。

示例：编码用例：斐波那契数列

from openai import OpenAI
client = OpenAI(api_key="sk-proj---")
prompt = "Output a Python program for fibonacci series"
def ask_with_verbosity(verbosity: str, question: str):
   response = client.responses.create(
       model="gpt-5-mini",
       input=question,
       text={
           "verbosity": verbosity
       }
   )
   # Extract assistant's text output
   output_text = ""
   for item in response.output:
       if hasattr(item, "content"):
           for content in item.content:
               if hasattr(content, "text"):
                   output_text += content.text
   # Token usage details
   usage = response.usage
   print("--------------------------------")
   print(f"Verbosity: {verbosity}")
   print("Output:")
   print(output_text)
   print("Tokens => input: {} | output: {}".format(
       usage.input_tokens, usage.output_tokens
   ))

此用例包含不同详细程度的代码生成。

1. Low：生成最少的代码，且仅包含极少的解释。

ask_with_verbosity("low", prompt)

响应：

Verbosity: low

Output:

```python

def fibonacci(n):

   a, b = 0, 1

   for _ in range(n):

       yield a

       a, b = b, a + b

def main():

   try:

       n = int(input("Enter how many Fibonacci numbers to print: "))

       if n <= 0:

           print("Please enter a positive integer.")

           return

   except ValueError:

       print("Invalid input.")

       return

   print(*fibonacci(n))

if __name__ == "__main__":

   main()

```

Tokens => input: 13 | output: 375

2. Medium：生成带有内联注释和一些结构元素的代码。

ask_with_verbosity("medium", prompt)

响应：

Verbosity: medium

Output:

Here's a simple Python program that prints the first N Fibonacci numbers (starting with 0, 1). It validates input and uses an efficient iterative approach:

```python

def fib_series(n):

   """Return a list with the first n Fibonacci numbers (0, 1, 1, 2, ...)."""

   if n <= 0:

       return []

   if n == 1:

       return [0]

   series = [0, 1]

   for _ in range(2, n):

       series.append(series[-1] + series[-2])

   return series

def main():

   try:

       n = int(input("Enter number of Fibonacci terms to generate: ").strip())

   except ValueError:

       print("Please enter a valid integer.")

       return

   if n <= 0:

       print("Enter a positive integer.")

       return

   series = fib_series(n)

   print("Fibonacci series (first {} terms):".format(n))

   print(", ".join(map(str, series)))

if __name__ == "__main__":

   main()

```

If you want other variants (e.g., recursive version, generator that yields values indefinitely, or printing up to a maximum value instead of a count), tell me which and I can provide it.

Tokens => input: 13 | output: 590

3. High：生成带有参数、验证和详细注释的完整生产脚本。

ask_with_verbosity("high", prompt)

响应：

Verbosity: high

Output:

Below are several Python programs/functions for generating Fibonacci numbers and the Fibonacci series. I include a short explanation for each, examples of how to use them, and notes about performance so you can choose the one that best fits your needs.

Note: the usual convention shown here is F0 = 0, F1 = 1, Fn = Fn-1 + Fn-2.

1) Simple iterative version — recommended for generating a sequence (O(n) time, O(1) extra space)

```python

def fibonacci_list(n):

   """Return a list with the first n Fibonacci numbers: F0 .. F(n-1).

   n must be a non-negative integer."""

   if n < 0:

       raise ValueError("n must be non-negative")

   if n == 0:

       return []

   if n == 1:

       return [0]

   seq = [0, 1]

   for _ in range(2, n):

       seq.append(seq[-1] + seq[-2])

   return seq

# Example usage:

if __name__ == "__main__":

   k = int(input("Which Fibonacci index (n)? "))

   print(f"F_{k} =", fibonacci_n(k))

```

2) Generator style — iterate lazily over the sequence

```python

def fib_generator():

   """Infinite Fibonacci generator: yields 0, 1, 1, 2, 3, ..."""

   a, b = 0, 1

   while True:

       yield a

       a, b = b, a + b

# Example: print first 10 Fibonacci numbers

if __name__ == "__main__":

   import itertools

   for x in itertools.islice(fib_generator(), 10):

       print(x, end=" ")

   print()

```

```

3) Recursive with memoization (fast and simple)

```python

from functools import lru_cache

@lru_cache(maxsize=None)

def fib_memo(n):

   if n < 0:

       raise ValueError("n must be non-negative")

   if n < 2:

       return n

   return fib_memo(n-1) + fib_memo(n-2)

# Example:

if __name__ == "__main__":

   print(fib_memo(100))  # works quickly thanks to memoization

```

```

Which one should you use?

- For typical use (print the first N Fibonacci numbers or compute F_n for moderate n), use the simple iterative fibonacci_list or fibonacci_n.

- For very large n (e.g., thousands or millions of digits), use the fast doubling method (fib_fast_doubling) — it computes F_n in O(log n) arithmetic operations using Python's big integers.

- Avoid the naive recursion except for teaching/demonstration.

- Use memoized recursion for convenience if you want recursive style but still need speed.

If you tell me which variant you want (print series vs return nth value, starting indices, how you want input, or limits like very large n), I can provide a single small script tailored to that use-case.

Tokens => input: 13 | output: 1708

自由格式函数调用

GPT-5 现在可以使用新的工具“type”: “custom”将原始文本有效负载（从 Python 脚本到 SQL 查询的任何内容）发送到您的自定义工具，而无需将数据包装成 JSON。这与传统的结构化函数调用不同，让您在与外部运行时交互时拥有更大的灵活性，例如：

• 带有沙盒的 code_exec（Python、C++、Java 等）
• SQL 数据库
• Shell 环境
• 配置生成器

请注意，自定义工具类型不支持并行工具调用。

为了说明自由格式工具调用的用法，我们将要求 GPT-5 执行以下任务：

• 生成用于计算两个 5×5 矩阵乘法的 Python、C++ 和 Java 代码。
• 仅打印代码中每次迭代所用的时间（以毫秒为单位）。
• 调用所有三个函数，然后停止

from openai import OpenAI
from typing import List, Optional
MODEL_NAME = "gpt-5-mini"
# Tools that will be passed to every model invocation
TOOLS = [
   {
       "type": "custom",
       "name": "code_exec_python",
       "description": "Executes python code",
   },
   {
       "type": "custom",
       "name": "code_exec_cpp",
       "description": "Executes c++ code",
   },
   {
       "type": "custom",
       "name": "code_exec_java",
       "description": "Executes java code",
   },
]
client = OpenAI(api_key="ADD-YOUR-API-KEY")
def create_response(
   input_messages: List[dict],
   previous_response_id: Optional[str] = None,
):
   """Wrapper around client.responses.create."""
   kwargs = {
       "model": MODEL_NAME,
       "input": input_messages,
       "text": {"format": {"type": "text"}},
       "tools": TOOLS,
   }
   if previous_response_id:
       kwargs["previous_response_id"] = previous_response_id
   return client.responses.create(**kwargs)
def run_conversation(
   input_messages: List[dict],
   previous_response_id: Optional[str] = None,
):
   """Recursive function to handle tool calls and continue conversation."""
   response = create_response(input_messages, previous_response_id)
   # Check for tool calls in the response
   tool_calls = [output for output in response.output if output.type == "custom_tool_call"]
   if tool_calls:
       # Handle all tool calls in this response
       for tool_call in tool_calls:
           print("--- tool name ---")
           print(tool_call.name)
           print("--- tool call argument (generated code) ---")
           print(tool_call.input)
           print()  # Add spacing
           # Add synthetic tool result to continue the conversation
           input_messages.append({
               "type": "function_call_output",
               "call_id": tool_call.call_id,
               "output": "done",
           })
       # Continue the conversation recursively
       return run_conversation(input_messages, previous_response_id=response.id)
   else:
       # No more tool calls - check for final response
       if response.output and len(response.output) > 0:
           message_content = response.output[0].content
           if message_content:
               print("--- final model response ---")
               print(message_content)
           else:
               print("--- conversation completed (no final message) ---")
       return response
# Your prompt
prompt = """
Write code to multiply two 5x5 matrices in three languages: C++, Python, and Java using code_exec functions. Each language should multiply the matrices 10 times and measure the time taken for each iteration.
ALWAYS CALL THESE THREE FUNCTIONS EXACTLY ONCE: code_exec_python, code_exec_cpp, and code_exec_java tools to perform the matrix multiplication in each language once.
Print only the time it takes to multiply the matrices (in milliseconds) per iteration.
"""
# Initial developer message
messages = [
   {
       "role": "developer",
       "content": prompt,
   }
]
# Start the conversation
run_conversation(messages)

三种语言的答复：

--- tool name ---

code_exec_python

--- tool call argument (generated code) ---

import time

N = 5

A = [[i + j for j in range(N)] for i in range(N)]

B = [[i * j for j in range(N)] for i in range(N)]

def matmul(A, B):

   N = len(A)

   C = [[0] * N for _ in range(N)]

   for i in range(N):

       for j in range(N):

           s = 0

           for k in range(N):

               s += A[i][k] * B[k][j]

           C[i][j] = s

   return C

for _ in range(10):

   t1 = time.perf_counter()

   C = matmul(A, B)

   t2 = time.perf_counter()

   ms = (t2 - t1) * 1000.0

   # Print only the time in milliseconds per iteration

   print(ms)

--- tool name ---

code_exec_cpp

--- tool call argument (generated code) ---

#include <bits/stdc++.h>

using namespace std;

int main() {

   const int N = 5;

   double A[N][N], B[N][N], C[N][N];

   for (int i = 0; i < N; ++i)

       for (int j = 0; j < N; ++j) {

           A[i][j] = i + j;

           B[i][j] = i * j;

       }

   for (int it = 0; it < 10; ++it) {

       for (int i = 0; i < N; ++i)

           for (int j = 0; j < N; ++j)

               C[i][j] = 0.0;

       auto t1 = chrono::high_resolution_clock::now();

       for (int i = 0; i < N; ++i) {

           for (int j = 0; j < N; ++j) {

               double s = 0.0;

               for (int k = 0; k < N; ++k)

                   s += A[i][k] * B[k][j];

               C[i][j] = s;

           }

       }

       auto t2 = chrono::high_resolution_clock::now();

       double ms = chrono::duration<double, milli>(t2 - t1).count();

       cout << ms << endl;

   }

   return 0;

}

--- tool name ---

code_exec_java

--- tool call argument (generated code) ---

public class Main {

   public static void main(String[] args) {

       int N = 5;

       double[][] A = new double[N][N];

       double[][] B = new double[N][N];

       double[][] C = new double[N][N];

       for (int i = 0; i < N; i++)

           for (int j = 0; j < N; j++) {

               A[i][j] = i + j;

               B[i][j] = i * j;

           }

       for (int it = 0; it < 10; it++) {

           for (int i = 0; i < N; i++)

               for (int j = 0; j < N; j++)

                   C[i][j] = 0.0;

           long t1 = System.nanoTime();

           for (int i = 0; i < N; i++) {

               for (int j = 0; j < N; j++) {

                   double s = 0.0;

                   for (int k = 0; k < N; k++)

                       s += A[i][k] * B[k][j];

                   C[i][j] = s;

               }

           }

           long t2 = System.nanoTime();

           double ms = (t2 - t1) / 1_000_000.0;

           System.out.println(ms);

       }

   }

}

上下文无关语法 (CFG) 强制执行

GPT-5 的上下文无关语法 (CFG) 强制执行功能使开发者能够将输出约束为严格的结构，这在格式非常精确的情况下非常理想，例如 SQL 或正则表达式。例如，可以为 MS SQL (TOP) 和 PostgreSQL (LIMIT) 设置单独的语法，并确保 GPT-5 为这两个数据库生成语法有效的查询。

mssql_grammar 指定了有效的 SQL Server 查询的确切结构，包括 SELECT TOP、过滤、排序和语法。它将模型限制为：

• 返回固定数量的行（TOP N）
• 根据 total_amount 和 order_date 进行过滤
• 使用正确的语法，例如 ORDER BY … DESC 和分号
• 仅使用具有固定列、关键字和值格式的安全只读查询

PostgreSQL 语法

• postgres_grammar 与 mssql_grammar 类似，但其设计旨在通过使用 LIMIT 而不是 TOP 来匹配 PostgreSQL 的语法。它将模型限制为：
• 使用 LIMIT N 限制结果大小
• 使用相同的过滤和排序规则
• 验证标识符、数字和日期格式
• 通过限制 SQL 结构来限制不安全/不受支持的 SQL 操作。

import textwrap
# ----------------- grammars for MS SQL dialect -----------------
mssql_grammar = textwrap.dedent(r"""
           // ---------- Punctuation & operators ----------
           SP: " "
           COMMA: ","
           GT: ">"
           EQ: "="
           SEMI: ";"
           // ---------- Start ----------
           start: "SELECT" SP "TOP" SP NUMBER SP select_list SP "FROM" SP table SP "WHERE" SP amount_filter SP "AND" SP date_filter SP "ORDER" SP "BY" SP sort_cols SEMI
           // ---------- Projections ----------
           select_list: column (COMMA SP column)*
           column: IDENTIFIER
           // ---------- Tables ----------
           table: IDENTIFIER
           // ---------- Filters ----------
           amount_filter: "total_amount" SP GT SP NUMBER
           date_filter: "order_date" SP GT SP DATE
           // ---------- Sorting ----------
           sort_cols: "order_date" SP "DESC"
           // ---------- Terminals ----------
           IDENTIFIER: /[A-Za-z_][A-Za-z0-9_]*/
           NUMBER: /[0-9]+/
           DATE: /'[0-9]{4}-[0-9]{2}-[0-9]{2}'/
   """)
# ----------------- grammars for PostgreSQL dialect -----------------
postgres_grammar = textwrap.dedent(r"""
           // ---------- Punctuation & operators ----------
           SP: " "
           COMMA: ","
           GT: ">"
           EQ: "="
           SEMI: ";"
           // ---------- Start ----------
           start: "SELECT" SP select_list SP "FROM" SP table SP "WHERE" SP amount_filter SP "AND" SP date_filter SP "ORDER" SP "BY" SP sort_cols SP "LIMIT" SP NUMBER SEMI
           // ---------- Projections ----------
           select_list: column (COMMA SP column)*
           column: IDENTIFIER
           // ---------- Tables ----------
           table: IDENTIFIER
           // ---------- Filters ----------
           amount_filter: "total_amount" SP GT SP NUMBER
           date_filter: "order_date" SP GT SP DATE
           // ---------- Sorting ----------
           sort_cols: "order_date" SP "DESC"
           // ---------- Terminals ----------
           IDENTIFIER: /[A-Za-z_][A-Za-z0-9_]*/
           NUMBER: /[0-9]+/
           DATE: /'[0-9]{4}-[0-9]{2}-[0-9]{2}'/
   """)

该示例使用 GPT-5 和自定义 mssql_grammar 工具生成一个 SQL Server 查询，该查询返回客户最近下达的高价值订单。mssql_grammar 创建了语法规则来强制执行 SQL Server 语法，并生成了正确的 SELECT TOP 语法以返回有限的结果。

from openai import OpenAI
client = OpenAI()
sql_prompt_mssql = (
   "Call the mssql_grammar to generate a query for Microsoft SQL Server that retrieve the "
   "five most recent orders per customer, showing customer_id, order_id, order_date, and total_amount, "
   "where total_amount > 500 and order_date is after '2025-01-01'. "
)
response_mssql = client.responses.create(
   model="gpt-5",
   input=sql_prompt_mssql,
   text={"format": {"type": "text"}},
   tools=[
       {
           "type": "custom",
           "name": "mssql_grammar",
           "description": "Executes read-only Microsoft SQL Server queries limited to SELECT statements with TOP and basic WHERE/ORDER BY. YOU MUST REASON HEAVILY ABOUT THE QUERY AND MAKE SURE IT OBEYS THE GRAMMAR.",
           "format": {
               "type": "grammar",
               "syntax": "lark",
               "definition": mssql_grammar
           }
       },
   ],
   parallel_tool_calls=False
)
print("--- MS SQL Query ---")
print(response_mssql.output[1].input)

响应：

--- MS SQL Query ---

SELECT TOP 5 customer_id, order_id, order_date, total_amount FROM orders

WHERE total_amount > 500 AND order_date > '2025-01-01'

ORDER BY order_date DESC;

此版本以 PostgreSQL 为目标平台，并使用 postgres_grammar 工具帮助 GPT-5 生成兼容的查询。它遵循与上一个示例相同的逻辑，但使用 LIMIT 作为返回结果的限制，以演示兼容的 PostgreSQL 语法。

sql_prompt_pg = (
   "Call the postgres_grammar to generate a query for PostgreSQL that retrieve the "
   "five most recent orders per customer, showing customer_id, order_id, order_date, and total_amount, "
   "where total_amount > 500 and order_date is after '2025-01-01'. "
)
response_pg = client.responses.create(
   model="gpt-5",
   input=sql_prompt_pg,
   text={"format": {"type": "text"}},
   tools=[
       {
           "type": "custom",
           "name": "postgres_grammar",
           "description": "Executes read-only PostgreSQL queries limited to SELECT statements with LIMIT and basic WHERE/ORDER BY. YOU MUST REASON HEAVILY ABOUT THE QUERY AND MAKE SURE IT OBEYS THE GRAMMAR.",
           "format": {
               "type": "grammar",
               "syntax": "lark",
               "definition": postgres_grammar
           }
       },
   ],
   parallel_tool_calls=False,
)
print("--- PG SQL Query ---")
print(response_pg.output[1].input)

响应：

--- PG SQL Query ---

SELECT customer_id, order_id, order_date, total_amount FROM orders

WHERE total_amount > 500 AND order_date > '2025-01-01'

ORDER BY order_date DESC LIMIT 5;

最小推理工作量

GPT-5 现在支持新的最小推理工作量。使用最小推理工作量时，模型将输出很少甚至不输出推理标记。这适用于开发者希望快速生成首个用户可见标记的用例。

注意：如果未提供推理工作量，则默认值为中等。

from openai import OpenAI
client = OpenAI()
prompt = "Translate the following sentence to Spanish. Return only the translated text."
response = client.responses.create(
   model="gpt-5",
   input=[
       { 'role': 'developer', 'content': prompt },
       { 'role': 'user', 'content': 'Where is the nearest train station?' }
   ],
   reasoning={ "effort": "minimal" } 
)
# Extract model's text output
output_text = ""
for item in response.output:
   if hasattr(item, "content"):
       for content in item.content:
           if hasattr(content, "text"):
               output_text += content.text
# Token usage details
usage = response.usage
print("--------------------------------")
print("Output:")
print(output_text)

响应：

--------------------------------Output:¿Dónde está la estación de tren más cercana?

定价

OpenAI 提供不同级别的 GPT-5 模型，以满足各种性能和预算需求。GPT-5 适用于复杂任务。GPT-5-mini 任务完成速度快且成本更低，而 GPT-5-nano 则适用于实时或轻量级用例。短期对话中重复使用的代币可享受 90% 的折扣，从而大幅降低多轮交互的成本。

小结

GPT-5 为开发者开启了 AI 的新纪元。它通过 API 将顶级编码智能与更强大的控制能力相结合。您可以使用其功能，例如控制冗长程度、启用自定义工具调用、强制语法以及执行极简推理。借助这些功能，您可以构建更智能、更可靠的应用程序。

从自动化复杂的工作流程到加速日常工作流程，GPT-5 的设计具有极高的灵活性和性能，可帮助开发者进行创作。在您的项目中，探索并探索 GPT-5 的特性和功能，以充分利用其优势。

参考：OpenAI Cookbook