Den vollständigen Index der Dokumentation findest du in llms.txt. Die Markdown-Version einer Dokumentationsseite erhältst du, indem du
.md an die URL der Seite anhängst.
Ermögliche Modellen, vor dem Antworten im Web nach aktuellen Informationen zu suchen.
Responses
Mit der Websuche können Modelle aktuelle Informationen aus dem Internet abrufen und ihre Antworten mit Quellen belegen. Verwende dazu das Tool für die Websuche in der Responses API oder, in bestimmten Fällen, in Chat Completions.
Wähle das Suchverfahren passend zu der Frage, die du beantworten möchtest.
Wenn du schnell etwas nachschlagen möchtest, bitte ein Modell, gezielt nach der Information zu suchen und die Quelle anzugeben.
Wenn du für eine Frage mehrere Quellen brauchst, verwende ein Reasoning-Modell wie gpt-6-astra. Es kann seine Suchanfragen anhand der bisherigen Ergebnisse verfeinern. Verwende den Hintergrundmodus, wenn die Bearbeitung einer Anfrage mehrere Minuten dauern könnte.
Integration auswählen
Anwendungsfall
Empfehlung
Hinweise
Neue Integration der Websuche
Responses API mit web_search und gpt-6-astra
Unterstützt Filter, Quellenlisten, die Steuerung des Livezugriffs und längere Recherchen mit der gehosteten Websuche
Bestehende Suchintegration mit Chat Completions
Chat Completions mit gpt-5-search-api
Verwende diese Variante nur, wenn du eine Integration mit Chat Completions beibehalten musst
Mehrstufige Recherche oder zeitaufwendige Berichte
gpt-6-astra mit einem Reasoning-Aufwand von high oder xhigh
Verwende den Hintergrundmodus für Berichte, deren Erstellung mehrere Minuten dauern kann
In der Responses API aktivierst du die Websuche, indem du sie im tools-Array der API-Anfrage zur Inhaltserstellung konfigurierst. Wie bei anderen Tools entscheidet das Modell anhand des Prompts, ob es das Web durchsucht.
Verwende für neue Integrationen mit der Responses API { "type": "web_search" }. Das ältere Tool web_search_preview ist für bestehende Integrationen weiterhin verfügbar. Es unterstützt jedoch keine neueren Parameter wie filters, external_web_access und return_token_budget.
Beispiel für das Tool zur Websuche
TypeScript
1
2
3
4
5
6
7
8
9
10import OpenAI from"openai";constclient=newOpenAI();constresponse=await client.responses.create({ model: "gpt-6-astra", tools: [{ type: "web_search" }], input: "What was a positive news story from today?",});console.log(response.output_text);
1
2
3
4
5
6
7
8
9
10
11from openai import OpenAIclient = OpenAI()response = client.responses.create( model="gpt-6-astra", tools=[{"type": "web_search"}], input="What was a positive news story from today?",)print(response.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15using OpenAI.Responses;#pragma warning disable OPENAI001string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;ResponsesClient client = new(key);CreateResponseOptions options = new() { Model = "gpt-6-astra" };options.Tools.Add(ResponseTool.CreateWebSearchTool());options.InputItems.Add( ResponseItem.CreateUserMessageItem("What was a positive news story from today?"));ResponseResult response = await client.CreateResponseAsync(options);Console.WriteLine(response.GetOutputText());
1
2
3
4
5
6
7
8
9
10
11require "openai"openai = OpenAI::Client.newresponse = openai.responses.create( model: "gpt-6-astra", tools: [{ type: "web_search" }], input: "What was a positive news story from today?")puts(response.output_text)
1
2
3
4
5
6
7
8curl "https://api.openai.com/v1/responses" \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -d '{ "model": "gpt-6-astra", "tools": [{"type": "web_search"}], "input": "what was a positive news story from today?"}'
1
2
3
4
5
6
7
8openai responses create \ --model gpt-6-astra \ --raw-output \ --transform 'output.#(type=="message").content.0.text' <<'YAML'tools: - type: web_searchinput: What was a positive news story from today?YAML
Ausgabe und Quellenverweise
Wenn das Modell das Tool für die Websuche verwendet, enthält seine Antwort zwei Teile:
Ein Ausgabeelement vom Typ web_search_call mit der ID des Suchaufrufs. In web_search_call.action steht, welche Aktion ausgeführt wurde. Folgende Aktionen sind möglich:
search steht für eine Websuche. Die Aktion enthält in der Regel, aber nicht immer, die verwendeten Suchanfragen in queries. Für Suchaktionen fallen Kosten pro Toolaufruf an (siehe Preise).
open_page steht für das Öffnen einer Seite. Reasoning-Modelle unterstützen diese Aktion.
find_in_page steht für die Suche innerhalb einer Seite. Reasoning-Modelle unterstützen diese Aktion.
Ein Ausgabeelement vom Typ message mit folgenden Inhalten:
Der Antworttext in message.content[0].text
Die Annotationen in message.content[0].annotations für die zitierten URLs
Standardmäßig verweist das Modell direkt im Antworttext auf URLs aus den Suchergebnissen. Das Annotationsobjekt url_citation enthält außerdem die URL und den Titel der Quelle sowie die Position des Verweises im Text.
Wenn deine Benutzeroberfläche Suchergebnisse aus dem Web oder Informationen daraus anzeigt, musst du die Quellenverweise direkt im Text als deutlich sichtbare, anklickbare Links darstellen.
Über die Chat Completions API kannst du direkt auf die feinabgestimmten Modelle und das Tool zugreifen, die bei der Suche in ChatGPT zum Einsatz kommen.
Bei Chat Completions ruft das Modell immer Informationen aus dem Web ab, bevor es deine Anfrage beantwortet. Soll das Modell selbst entscheiden, ob es sucht, wechsle zur Responses API und verwende das Tool web_search.
Verwende derzeit für die Websuche in Chat Completions folgendes Modell:
gpt-5-search-api
Beispiel für einen Parameter der Websuche
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15import OpenAI from"openai";constclient=newOpenAI();constcompletion=await client.chat.completions.create({ model: "gpt-5-search-api", web_search_options: {}, messages: [ { role: "user", content: "What was a positive news story from today?", }, ],});console.log(completion.choices[0].message.content);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16from openai import OpenAIclient = OpenAI()completion = client.chat.completions.create( model="gpt-5-search-api", web_search_options={}, messages=[ { "role": "user", "content": "What was a positive news story from today?", } ],)print(completion.choices[0].message.content)
1
2
3
4
5
6
7
8
9
10
11curl -X POST "https://api.openai.com/v1/chat/completions" \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -H "Content-type: application/json" \ -d '{ "model": "gpt-5-search-api", "web_search_options": {}, "messages": [{ "role": "user", "content": "What was a positive news story from today?" }] }'
Ausgabe und Quellenverweise
Das Element im choices-Array der API-Antwort enthält:
message.content mit dem Antworttext des Modells und allen darin enthaltenen Quellenverweisen
annotations mit einer Liste der zitierten URLs
Standardmäßig verweist das Modell direkt im Antworttext auf URLs aus den Suchergebnissen. Das Annotationsobjekt url_citation enthält außerdem die URL und den Titel der Quelle. Die Werte für Start- und Endindex geben an, an welchen Zeichenpositionen in der Modellantwort die zugehörige Textstelle beginnt und endet.
Wenn deine Benutzeroberfläche Suchergebnisse aus dem Web oder Informationen daraus anzeigt, musst du die Quellenverweise direkt im Text als deutlich sichtbare, anklickbare Links darstellen.
web_search unterstützt neuere Parameter wie filters, external_web_access und return_token_budget
gpt-4o-search-preview oder gpt-4o-mini-search-preview
Wechsle zu web_search in der Responses API oder verwende gpt-5-search-api, wenn du bei Chat Completions bleiben musst
Die Vorschaumodelle für die Suche sind veraltet und wurden am 23. Juli 2026 abgeschaltet
Suchintegrationen mit Chat Completions
Verwende gpt-5-search-api oder wechsle zu web_search in der Responses API, wenn du mehr Einstellungen für das Tool brauchst oder die Suche optional sein soll
Die Suchmodelle in Chat Completions führen vor jeder Antwort eine Suche aus. In der Responses API steht die Suche als Tool zur Verfügung
o4-mini in der Responses API
Wechsle zu einem unterstützten Reasoning-Modell mit web_search
Wenn deine Integration noch gpt-5 verwendet, musst du für die Websuche einen höheren Reasoning-Aufwand als minimal einstellen.
Größe des Suchkontexts
Mit search_context_size legst du fest, wie viel Kontext aus den Suchergebnissen dem Modell zur Verfügung steht, bevor es antwortet. Verwende low, wenn du nur wenige Details nachschlagen möchtest, medium als ausgewogenen Standardwert und high, wenn die Antwort mehr Details aus den Suchergebnissen erfordern könnte. Diese Einstellung legt keine genaue Anzahl von Token fest und garantiert keine bestimmte Anzahl von Quellen oder Quellenverweisen.
Größe des Suchkontexts festlegen
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14import OpenAI from"openai";constopenai=newOpenAI();constresponse=await openai.responses.create({ model: "gpt-6-astra", tools: [ { type: "web_search", search_context_size: "low", }, ], input: "What movie won best picture in 2025?",});console.log(response.output_text);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16from openai import OpenAIclient = OpenAI()response = client.responses.create( model="gpt-6-astra", tools=[ { "type": "web_search", "search_context_size": "low", } ], input="What movie won best picture in 2025?",)print(response.output_text)
Mit return_token_budget legst du fest, wie viel Inhalt aus den Suchergebnissen das Tool bei einer Websuche mit Reasoning-Modellen ab GPT-5 über die Responses API zurückgeben kann. Behalte für die meisten Anfragen den Standardwert bei. Setze den Parameter nur dann auf unlimited, wenn für eine aufwendige Recherche oder Evaluation viele Seiten ausgewertet werden müssen und die Suche sonst beim Erreichen des üblichen Token-Limits für zurückgegebene Ergebnisse abbrechen könnte.
Verwende unlimited gezielt, da die Suche länger dauern und höhere Kosten verursachen kann. Nutze für längere Aufgaben mit mehreren Suchvorgängen den Hintergrundmodus (background: true). So läuft die Anfrage asynchron weiter und du kannst die fertige Antwort später abrufen.
Wert
Verhalten
default
Für die zurückgegebenen Suchergebnisse gilt das standardmäßige Token-Budget. Dasselbe gilt, wenn du return_token_budget weglässt.
unlimited
Hebt das standardmäßige Token-Budget für die Ergebnisse dieses Suchlaufs auf.
Dieser Parameter gilt nur für das gehostete Tool web_search der Responses API, wenn du die Websuche mit Reasoning-Modellen ab GPT-5 verwendest. Er ändert das Kontextfenster der Suche nicht. Für die Websuche ohne Reasoning, ältere Zugriffswege über die Search API, die Websuche in Containern, Suchmodelle in Chat Completions und web_search_preview gilt er nicht. Zulässig sind nur default und unlimited. Die API lehnt null, Zahlen und andere Zeichenfolgen ab.
Längere Websuchen ausführen
curl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45import OpenAI from "openai";import { Agent } from "undici";// Allow long research runs without automatic request retries.const timeout = 15 * 60 * 1000;const dispatcher = new Agent({ headersTimeout: timeout, bodyTimeout: timeout,});const client = new OpenAI({ timeout, maxRetries: 0, fetchOptions: { dispatcher },});try { const stream = client.responses.stream({ model: "gpt-6-astra", reasoning: { effort: "xhigh" }, tools: [ { type: "web_search", return_token_budget: "unlimited", }, ], input: [ "Research the economic impact of semaglutide on global healthcare systems.", "", "Do:", "- Include specific figures, trends, statistics, and measurable outcomes.", "- Prioritize reliable, up-to-date sources: peer-reviewed research, health organizations (e.g., WHO, CDC), regulatory agencies, or pharmaceutical earnings reports.", "- Include inline citations and return all source metadata.", "", "Be analytical, avoid generalities, and ensure that each section supports data-backed reasoning that could inform healthcare policy or financial modeling.", ].join("\n"), }); const response = await stream.finalResponse(); if (response.status !== "completed") { throw new Error(`Research response ended with status ${response.status}`); } console.log(response.output_text);} finally { await dispatcher.close();}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24from openai import OpenAIclient = OpenAI()response = client.responses.create( model="gpt-6-astra", reasoning={"effort": "xhigh"}, tools=[ { "type": "web_search", "return_token_budget": "unlimited", } ], input="""Research the economic impact of semaglutide on global healthcare systems.Do:- Include specific figures, trends, statistics, and measurable outcomes.- Prioritize reliable, up-to-date sources: peer-reviewed research, health organizations (e.g., WHO, CDC), regulatory agencies, or pharmaceutical earnings reports.- Include inline citations and return all source metadata.Be analytical, avoid generalities, and ensure that each section supports data-backed reasoning that could inform healthcare policy or financial modeling.""",)print(response.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37package mainimport ( "context" "fmt" "strings" "github.com/openai/openai-go/v3" "github.com/openai/openai-go/v3/responses" "github.com/openai/openai-go/v3/shared")func main() { client := openai.NewClient() tool := responses.ToolParamOfWebSearch(responses.WebSearchToolTypeWebSearch) tool.OfWebSearch.SetExtraFields(map[string]any{"return_token_budget": "unlimited"}) input := strings.Join([]string{ "Research the economic impact of semaglutide on global healthcare systems.", "", "Do:", "- Include specific figures, trends, statistics, and measurable outcomes.", "- Prioritize reliable, up-to-date sources: peer-reviewed research, health organizations, regulatory agencies, or pharmaceutical earnings reports.", "- Include inline citations and return all source metadata.", "", "Be analytical, avoid generalities, and ensure that each section supports data-backed reasoning that could inform healthcare policy or financial modeling.", }, "\n") response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{ Model: "gpt-6-astra", Reasoning: shared.ReasoningParam{Effort: shared.ReasoningEffortXhigh}, Tools: []responses.ToolUnionParam{tool}, Input: responses.ResponseNewParamsInputUnion{OfString: openai.String(input)}, }) if err != nil { panic(err) } fmt.Println(response.OutputText())}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16require "openai"client = OpenAI::Client.newresponse = client.responses.create( model: "gpt-6-astra", input: "Research the economic impact of semaglutide on global healthcare systems. Include current figures and citations.", reasoning: { effort: :xhigh }, tools: [ { type: :web_search, return_token_budget: :unlimited } ])puts(response.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14curl"https://api.openai.com/v1/responses"\-H"Content-Type: application/json"\-H"Authorization: Bearer $OPENAI_API_KEY"\-d'{ "model": "gpt-6-astra", "reasoning": { "effort": "xhigh" }, "tools": [ { "type": "web_search", "return_token_budget": "unlimited" } ], "input": "Research the economic impact of semaglutide on global healthcare systems.\n\nDo:\n- Include specific figures, trends, statistics, and measurable outcomes.\n- Prioritize reliable, up-to-date sources: peer-reviewed research, health organizations (e.g., WHO, CDC), regulatory agencies, or pharmaceutical earnings reports.\n- Include inline citations and return all source metadata.\n\nBe analytical, avoid generalities, and ensure that each section supports data-backed reasoning that could inform healthcare policy or financial modeling." }'
Nach Domain filtern
Mit Domainfiltern kannst du die Ergebnisse der Websuche auf bestimmte Domains beschränken. Über den Parameter filters kannst du bis zu 100 Einträge für allowed_domains oder bis zu 100 Einträge für blocked_domains angeben. Lass bei den Domains das HTTP- oder HTTPS-Präfix weg. Verwende zum Beispiel openai.com statt https://openai.com/. Der Filter erfasst auch die Subdomains der angegebenen Domains. Domainfilter sind nur in der Responses API mit dem Tool web_search verfügbar.
Quellen
Im Feld sources findest du alle URLs, die während einer Websuche abgerufen wurden. Die Quellenverweise im Text nennen nur die relevantesten Belege. Das Feld sources liefert dagegen die vollständige Liste der URLs, die das Modell für seine Antwort herangezogen hat.
Oft gibt es mehr Quellen als Quellenverweise. Hier erscheinen auch Echtzeitfeeds von Drittanbietern mit den Kennzeichnungen oai-sports, oai-weather oder oai-finance. Das Feld sources ist bei beiden Tools verfügbar, sowohl bei web_search als auch bei web_search_preview.
Quellen auflisten
curl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31import OpenAI from "openai";const client = new OpenAI();const tools: OpenAI.Responses.Tool[] = [ { type: "web_search", filters: { allowed_domains: [ "pubmed.ncbi.nlm.nih.gov", "clinicaltrials.gov", "www.who.int", "www.cdc.gov", "www.fda.gov", ], // @ts-expect-error The published SDK omits this documented API filter. blocked_domains: ["reddit.com", "quora.com", "wikipedia.org"], }, },];const response = await client.responses.create({ model: "gpt-6-astra", reasoning: { effort: "low" }, tools, tool_choice: "auto", include: ["web_search_call.action.sources"], input: "Please perform a web search on how semaglutide is used in the treatment of diabetes.",});console.log(response.output_text);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32from openai import OpenAIclient = OpenAI()response = client.responses.create( model="gpt-6-astra", reasoning={"effort": "low"}, tools=[ { "type": "web_search", "filters": { "allowed_domains": [ "pubmed.ncbi.nlm.nih.gov", "clinicaltrials.gov", "www.who.int", "www.cdc.gov", "www.fda.gov", ], "blocked_domains": [ "reddit.com", "quora.com", "wikipedia.org", ], }, } ], tool_choice="auto", include=["web_search_call.action.sources"], input="Please perform a web search on how semaglutide is used in the treatment of diabetes.",)print(response.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30package mainimport ( "context" "fmt" "github.com/openai/openai-go/v3" "github.com/openai/openai-go/v3/responses" "github.com/openai/openai-go/v3/shared")func main() { client := openai.NewClient() tool := responses.ToolParamOfWebSearch(responses.WebSearchToolTypeWebSearch) tool.OfWebSearch.Filters = responses.WebSearchToolFiltersParam{ AllowedDomains: []string{"pubmed.ncbi.nlm.nih.gov", "clinicaltrials.gov", "www.who.int", "www.cdc.gov", "www.fda.gov"}, } tool.OfWebSearch.Filters.SetExtraFields(map[string]any{"blocked_domains": []string{"reddit.com", "quora.com", "wikipedia.org"}}) response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{ Model: "gpt-6-astra", Reasoning: shared.ReasoningParam{Effort: shared.ReasoningEffortLow}, Tools: []responses.ToolUnionParam{tool}, Include: []responses.ResponseIncludable{responses.ResponseIncludableWebSearchCallActionSources}, Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Please perform a web search on how semaglutide is used in the treatment of diabetes.")}, }) if err != nil { panic(err) } fmt.Println(response.OutputText())}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29curl"https://api.openai.com/v1/responses"\-H"Content-Type: application/json"\-H"Authorization: Bearer $OPENAI_API_KEY"\-d'{ "model": "gpt-6-astra", "reasoning": { "effort": "low" }, "tools": [ { "type": "web_search", "filters": { "allowed_domains": [ "pubmed.ncbi.nlm.nih.gov", "clinicaltrials.gov", "www.who.int", "www.cdc.gov", "www.fda.gov" ], "blocked_domains": [ "reddit.com", "quora.com", "wikipedia.org" ] } } ], "tool_choice": "auto", "include": ["web_search_call.action.sources"], "input": "Please perform a web search on how semaglutide is used in the treatment of diabetes." }'
Ergebnisse der Bildersuche
Die Websuche kann neben Texttreffern auch Bilder liefern. Nutze die Bildersuche, wenn deine Anwendung aktuelle Bilder oder Bildmaterial aus dem Web benötigt, etwa Produktfotos, Aufnahmen von Sehenswürdigkeiten, Orten oder Veranstaltungen oder visuelle Referenzen.
Für die Bildersuche muss search_content_types den Wert image enthalten. Ergänze text, wenn du auch Texttreffer benötigst, die dem Modell helfen, die gefundenen Bilder zusammenzufassen, zu ordnen oder zu erläutern.
Mit image_settings steuerst du die Bildersuche:
max_results: Gib die gewünschte Anzahl der Bildtreffer als positive Zahl an.
caption: Fordere kurze Bildbeschreibungen an, sofern sie verfügbar sind.
Um die Rohdaten der Bildtreffer einzusehen, gib web_search_call.results in der Anfrage an und lies web_search_call.results[] aus der Antwort aus. Die API liefert Bildtreffer getrennt von der Nachricht des Assistenten. Lies das Element web_search_call daher direkt aus, wenn deine Anwendung die URLs oder Metadaten benötigt.
Nach Bildern suchen
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25import OpenAI from"openai";constclient=newOpenAI();consttools:OpenAI.Responses.Tool[] = [ { type: "web_search",// @ts-expect-error The published SDK omits the documented image-search options. search_content_types: ["image", "text"], image_settings: { max_results: 3, caption: true, }, },];constresponse=await client.responses.create({ model: "gpt-6-astra", reasoning: { effort: "low" }, tools, include: ["web_search_call.results"], input:"Search for recent images and supporting text sources about the Golden Gate Bridge at sunset.",});console.log(response.output);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22from openai import OpenAIclient = OpenAI()response = client.responses.create( model="gpt-6-astra", reasoning={"effort": "low"}, tools=[ { "type": "web_search", "search_content_types": ["image", "text"], "image_settings": { "max_results": 3, "caption": True, }, } ], include=["web_search_call.results"], input="Search for recent images and supporting text sources about the Golden Gate Bridge at sunset.",)print(response.output)
Für geografisch passendere Suchergebnisse kannst du den ungefähren Standort der suchenden Person angeben. Verwende dazu eine oder mehrere Angaben zu Land, Stadt, Region und Zeitzone.
Die Felder city und region akzeptieren Freitext, zum Beispiel Minneapolis für die Stadt und Minnesota für die Region.
Das Feld country erwartet einen ISO-Ländercode aus zwei Buchstaben, zum Beispiel US.
Das Feld timezone erwartet eine IANA-Zeitzone wie America/Chicago.
In der Responses API kannst du steuern, ob das Tool für die Websuche Inhalte live abruft oder ausschließlich zwischengespeicherte oder indexierte Ergebnisse verwendet.
Setze external_web_access: false beim Tool web_search, um die Suche offline ausschließlich mit zwischengespeicherten Ergebnissen auszuführen.
Ohne diese Einstellung gilt der Standardwert true (Livezugriff).
Vorschauvarianten (web_search_preview) ignorieren diesen Parameter und verhalten sich so, als wäre external_web_access auf true gesetzt.
Livezugriff auf das Internet steuern
curl
1
2
3
4
5
6
7
8
9
10
11curl"https://api.openai.com/v1/responses"\-H"Content-Type: application/json"\-H"Authorization: Bearer $OPENAI_API_KEY"\-d'{ "model": "gpt-6-astra", "tools": [ { "type": "web_search", "external_web_access": false } ], "tool_choice": "auto", "input": "Find when the Eiffel Tower opened to the public and cite the source." }'
1
2
3
4
5
6
7
8
9
10
11import OpenAI from "openai";const client = new OpenAI();const response = await client.responses.create({ model: "gpt-6-astra", tools: [{ type: "web_search", external_web_access: false }], tool_choice: "auto", input: "Find when the Eiffel Tower opened to the public and cite the source.",});console.log(response.output_text);
1
2
3
4
5
6
7
8
9
10
11from openai import OpenAIclient = OpenAI()resp = client.responses.create( model="gpt-6-astra", tools=[{"type": "web_search", "external_web_access": False}], tool_choice="auto", input="Find when the Eiffel Tower opened to the public and cite the source.",)print(resp.output_text)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24package mainimport ( "context" "fmt" "github.com/openai/openai-go/v3" "github.com/openai/openai-go/v3/responses")func main() { client := openai.NewClient() tool := responses.ToolParamOfWebSearch(responses.WebSearchToolTypeWebSearch) tool.OfWebSearch.SetExtraFields(map[string]any{"external_web_access": false}) response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{ Model: "gpt-6-astra", Tools: []responses.ToolUnionParam{tool}, Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Find when the Eiffel Tower opened to the public and cite the source.")}, }) if err != nil { panic(err) } fmt.Println(response.OutputText())}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import com.openai.client.OpenAIClient;import com.openai.client.okhttp.OpenAIOkHttpClient;import com.openai.core.JsonValue;import com.openai.models.responses.ResponseCreateParams;import com.openai.models.responses.WebSearchTool;ResponseCreateParams params = ResponseCreateParams.builder() .model("gpt-6-astra") .input("Find when the Eiffel Tower opened to the public and cite the source.") .addTool( WebSearchTool.builder() .type(WebSearchTool.Type.WEB_SEARCH) .putAdditionalProperty("external_web_access", JsonValue.from(false)) .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()));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16require "openai"client = OpenAI::Client.newresponse = client.responses.create( model: "gpt-6-astra", input: "Find when the Eiffel Tower opened to the public and cite the source.", tools: [ { type: :web_search, external_web_access: false } ])puts(response.output_text)
Einschränkungen
Chat Completions API
Die Chat Completions API unterstützt für die Websuche ausschließlich spezialisierte Suchmodelle. Diese Modelle unterstützen keine Funktionen des Tools web_search der Responses API wie Domainfilter, vollständige Quellenlisten oder die Steuerung des Livezugriffs und des Token-Budgets für zurückgegebene Ergebnisse.
Modell
Kontextfenster
Einschränkung
gpt-5-search-api
200.000
Nutzt die Suche über Chat Completions
Responses API
Verwende das gehostete Tool web_search. Die Responses API akzeptiert für ältere Integrationen weiterhin web_search_preview. Verwende für neue Integrationen web_search.
Das Kontextfenster der Websuche ist auf 128.000 Token begrenzt, auch wenn das zugrunde liegende Modell ein größeres Kontextfenster hat. Wie groß das Kontextfenster von gpt-6-astra oder einem anderen unterstützten Modell ist, erfährst du auf der jeweiligen Modellseite.
gpt-5.4 kann bei einem Reasoning-Aufwand von none Ergebnisse geringerer Qualität liefern.
Für die Websuche in der Responses API gelten die gestaffelten Ratenlimits des zugrunde liegenden Modells.
web_search_preview unterstützt weder filters noch return_token_budget und ignoriert external_web_access.
Mit tool_choice: "auto" ist die Suche optional. Wenn eine Suche erforderlich ist, verwende tool_choice: "required" oder wähle das Tool für die Websuche ausdrücklich aus.