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.
Hauptnavigation
Design

MCP-Server

Verbinde Modelle mit Remote-MCP-Servern oder über Secure MCP Tunnel mit lokalen Servern.

Neben den Tools, die du einem Modell über Funktionsaufrufe bereitstellst, kannst du seinen Funktionsumfang mit Remote-MCP-Servern oder Secure MCP Tunnel erweitern. Mit diesen Tools kann sich das Modell bei Bedarf mit externen Diensten verbinden und sie steuern, um auf einen Prompt zu antworten. Bei der Entwicklung legst du fest, ob diese Tool-Aufrufe automatisch zulässig sind oder deine ausdrückliche Genehmigung erfordern.

  • Remote-MCP-Server können beliebige öffentlich im Internet erreichbare Server sein, die das Model Context Protocol (MCP) für den Remote-Zugriff implementieren.

  • Secure MCP Tunnel bindet einen lokalen oder privaten MCP-Server an, ohne ihn öffentlich im Internet zugänglich zu machen.

Dieser Leitfaden zeigt dir, wie du MCP-Tools mit der Responses API verwendest. Bestehende Modelle unterstützen weiterhin integrierte Konnektoren. Im Abschnitt Bisherige Konnektoren erfährst du, für welche Modelle sie als veraltet gelten, und findest Beispiele für kompatible Modelle. Wie du in Sitzungen der Agents API Verbindungen vom verwalteten Dienst oder von deiner Sandbox aus herstellst, erfährst du im Leitfaden zu MCP-Verbindungen.

Secure MCP Tunnel

Wenn dein MCP-Server privat ist, in deiner eigenen Infrastruktur läuft oder sich hinter einer Firewall befindet, kannst du ihn über Secure MCP Tunnel mit unterstützten OpenAI-Produkten verbinden, ohne ihn öffentlich im Internet zugänglich zu machen. Lade die aktuelle öffentliche Version von openai/tunnel-client herunter.

Schnellstart

Verwende den Tool-Typ mcp in der Responses API. Gib für einen Remote-MCP-Server server_url an. Verwende tunnel_id, wenn du einen lokalen MCP-Server über Secure MCP Tunnel anbindest. Je nach Server musst du außerdem ein OAuth-Zugriffstoken im Parameter authorization angeben.

Das folgende Beispiel nutzt den öffentlichen MCP-Server für die OpenAI-Dokumentation, um Dokumentation zum Streaming von Ausgaben der Responses API zu finden. Dieser Server bietet Dokumentationstools ohne Schreibzugriff und erfordert keine Authentifizierung. Das Beispiel überspringt die Genehmigungen für Tool-Aufrufe, da es öffentliche Dokumentation abfragt. Verlange eine Genehmigung, wenn du sensible Daten weitergibst.

Einen Remote-MCP-Server in der Responses API verwenden
curl https://api.openai.com/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
  "model": "gpt-6-astra",
    "tools": [
      {
        "type": "mcp",
        "server_label": "openai_docs",
        "server_description": "Search and read the public OpenAI documentation.",
        "server_url": "https://developers.openai.com/mcp",
        "require_approval": "never"
      }
    ],
    "input": "Search the OpenAI docs for Responses API streaming and return the relevant links."
  }'

Verwende mit der Responses API nur Remote-MCP-Server, denen du vertraust. Ein bösartiger Server kann sensible Daten aus allen Inhalten abgreifen, die in den Kontext des Modells gelangen. Lies den Abschnitt Risiken und Sicherheit weiter unten sorgfältig durch, bevor du dieses Tool verwendest.

Die API gibt neue Elemente im Array output der Modellantwort zurück. Entscheidet sich das Modell für einen MCP-Server, fragt es zunächst beim Server die Liste der verfügbaren Tools ab. Dabei entsteht ein Ausgabeelement vom Typ mcp_list_tools. Die folgende Beispielausgabe zeigt nur das Suchtool mit einer gekürzten Beschreibung. Der Server stellt weitere Dokumentationstools bereit.

{
  "id": "mcpl_68a6102a4968819c8177b05584dd627b0679e572a900e618",
  "type": "mcp_list_tools",
  "server_label": "openai_docs",
  "tools": [
    {
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false
      },
      "description": "Search the public OpenAI documentation.",
      "input_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "type": "object",
        "properties": {
          "query": {
            "type": "string",
            "minLength": 1
          },
          "limit": {
            "type": "integer",
            "minimum": 1,
            "maximum": 50
          },
          "cursor": {
            "type": "string"
          }
        },
        "required": ["query"]
      },
      "name": "search_openai_docs"
    }
  ]
}

Ruft das Modell eines der verfügbaren Tools auf dem MCP-Server auf, enthält die Ausgabe außerdem ein Element vom Typ mcp_call. Es zeigt, was das Modell an das MCP-Tool gesendet und was das Tool zurückgegeben hat.

{
  "id": "mcp_68a6102d8948819c9b1490d36d5ffa4a0679e572a900e618",
  "type": "mcp_call",
  "approval_request_id": null,
  "arguments": "{\"query\":\"Responses API streaming\",\"limit\":1}",
  "error": null,
  "name": "search_openai_docs",
  "output": "{\"hits\":[{\"url\":\"https://developers.openai.com/api/docs/guides/streaming-responses\"}]}",
  "server_label": "openai_docs"
}

Im Folgenden erfährst du, wie das MCP-Tool funktioniert, wie du die verfügbaren Tools filterst und wie du Genehmigungsanfragen für Tool-Aufrufe bearbeitest.

Funktionsweise

Die meisten neueren Modelle unterstützen das MCP-Tool in der Responses API. Ob dein Modell das MCP-Tool unterstützt, erfährst du in der Modellübersicht. Bei der Nutzung des MCP-Tools zahlst du nur für die Token, die beim Import von Tool-Definitionen oder bei Tool-Aufrufen anfallen. Für einzelne Tool-Aufrufe fallen keine zusätzlichen Gebühren an.

Beim Aufruf eines MCP-Tools führt die API die folgenden Schritte aus.

Schritt 1: Verfügbare Tools auflisten

Wenn du einen Remote-MCP-Server im Parameter tools angibst, versucht die API, die Liste der Tools vom Server abzurufen. Die Responses API funktioniert mit Remote-MCP-Servern, die eines der Transportprotokolle Streamable HTTP oder HTTP/SSE unterstützen.

Ruft die API die Tool-Liste erfolgreich ab, erscheint in der Ausgabe der Modellantwort ein neues Element vom Typ mcp_list_tools. Die Eigenschaft tools dieses Objekts enthält die erfolgreich importierten Tools. Der folgende Beispielauszug zeigt nur das Suchtool mit einer gekürzten Beschreibung.

{
  "id": "mcpl_68a6102a4968819c8177b05584dd627b0679e572a900e618",
  "type": "mcp_list_tools",
  "server_label": "openai_docs",
  "tools": [
    {
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false
      },
      "description": "Search the public OpenAI documentation.",
      "input_schema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "type": "object",
        "properties": {
          "query": {
            "type": "string",
            "minLength": 1
          },
          "limit": {
            "type": "integer",
            "minimum": 1,
            "maximum": 50
          },
          "cursor": {
            "type": "string"
          }
        },
        "required": ["query"]
      },
      "name": "search_openai_docs"
    }
  ]
}

Solange das Element mcp_list_tools im Kontext einer API-Anfrage enthalten ist, ruft die API die Tool-Liste des MCP-Servers nicht bei jedem Schritt einer Unterhaltung erneut ab. Wir empfehlen, das Element während jeder Unterhaltung und bei jeder Ausführung eines Workflows im Modellkontext zu behalten, um die Latenz zu verringern.

Tools filtern

Manche MCP-Server bieten Dutzende von Tools an. Wenn du dem Modell viele Tools bereitstellst, kann das Kosten und Latenz erhöhen. Benötigst du nur einen Teil der Tools eines MCP-Servers, kannst du mit dem Parameter allowed_tools den Import auf diese Tools beschränken. Dieses Beispiel importiert nur search_openai_docs, um Links zur Dokumentation zu finden.

Zulässige Tools einschränken
curl https://api.openai.com/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
    "model": "gpt-6-astra",
    "tools": [
      {
        "type": "mcp",
        "server_label": "openai_docs",
        "server_description": "Search and read the public OpenAI documentation.",
        "server_url": "https://developers.openai.com/mcp",
        "require_approval": "never",
        "allowed_tools": ["search_openai_docs"]
      }
    ],
    "input": "Search the OpenAI docs for Responses API streaming and return the relevant links."
  }'

Schritt 2: Tools aufrufen

Sobald das Modell Zugriff auf die Tool-Definitionen hat, kann es anhand seines Kontexts entscheiden, welche Tools es aufruft. Entscheidet sich das Modell für ein MCP-Tool, sendet die API eine Anfrage an den Remote-MCP-Server, um das Tool aufzurufen. Die API übernimmt die Ausgabe des Tools in den Modellkontext. Dabei entsteht ein Element vom Typ mcp_call. Die folgende Beispielausgabe lässt die Metadaten der Suchergebnisse der Übersichtlichkeit halber weg.

{
  "id": "mcp_68a6102d8948819c9b1490d36d5ffa4a0679e572a900e618",
  "type": "mcp_call",
  "approval_request_id": null,
  "arguments": "{\"query\":\"Responses API streaming\",\"limit\":1}",
  "error": null,
  "name": "search_openai_docs",
  "output": "{\"hits\":[{\"url\":\"https://developers.openai.com/api/docs/guides/streaming-responses\"}]}",
  "server_label": "openai_docs"
}

Dieses Element enthält die Argumente, die das Modell für den Tool-Aufruf gewählt hat. Das Feld output enthält die Ausgabe des Remote-MCP-Servers. Alle Modelle können mehrere MCP-Tool-Aufrufe ausführen. Deshalb kann eine einzelne API-Anfrage mehrere solcher Elemente erzeugen.

Schlägt ein Tool-Aufruf fehl, enthält das Fehlerfeld des Elements einen MCP-Protokollfehler, einen Fehler bei der Ausführung des MCP-Tools oder einen allgemeinen Verbindungsfehler. Die MCP-Fehler sind in der MCP-Spezifikation dokumentiert.

Genehmigungen

Standardmäßig fordert OpenAI deine Genehmigung an, bevor Daten an einen Konnektor oder Remote-MCP-Server übermittelt werden. So siehst du, welche Daten an einen MCP-Server gehen, und kannst die Übermittlung steuern. Wir empfehlen dir dringend, alle Daten, die an einen Remote-MCP-Server gehen, sorgfältig zu prüfen und bei Bedarf zu protokollieren. Um den Genehmigungsablauf auszuprobieren, setze require_approval auf "always" statt auf "never" und führe das Schnellstartbeispiel aus. Fordert die API eine Genehmigung für einen MCP-Tool-Aufruf an, enthält die Ausgabe des Response-Objekts ein Element vom Typ mcp_approval_request. Das folgende Beispiel zeigt eine solche Anfrage.

{
  "id": "mcpr_682d498e3bd4819196a0ce1664f8e77b04ad1e533afccbfa",
  "type": "mcp_approval_request",
  "arguments": "{\"query\":\"Responses API streaming\",\"limit\":1}",
  "name": "search_openai_docs",
  "server_label": "openai_docs"
}

Prüfe das angeforderte Tool und seine Argumente, bevor du den Aufruf genehmigst. Erstelle für deine Antwort ein neues Response-Objekt und füge ihm ein Element vom Typ mcp_approval_response hinzu. Ersetze in den folgenden Beispielen die IDs der Antwort und der Genehmigungsanfrage durch die IDs, die deine Anfrage zurückgibt. Das .NET-Beispiel entnimmt diese IDs der ersten Antwort. Jede Genehmigung gilt für einen einzelnen Tool-Aufruf. Bearbeite weitere Genehmigungsanfragen auf dieselbe Weise.

Tool-Aufrufe in einer API-Anfrage genehmigen
curl https://api.openai.com/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
    "model": "gpt-6-astra",
    "tools": [
      {
        "type": "mcp",
        "server_label": "openai_docs",
        "server_description": "Search and read the public OpenAI documentation.",
        "server_url": "https://developers.openai.com/mcp",
        "require_approval": "always"
      }
    ],
    "previous_response_id": "resp_682d498bdefc81918b4a6aa477bfafd904ad1e533afccbfa",
    "input": [{
      "type": "mcp_approval_response",
      "approve": true,
      "approval_request_id": "mcpr_682d498e3bd4819196a0ce1664f8e77b04ad1e533afccbfa"
    }]
  }'

Hier verknüpft der Parameter previous_response_id das neue Response-Objekt mit dem vorherigen, das die Genehmigungsanfrage erzeugt hat. Du kannst auch die Ausgaben einer Antwort als Eingaben für die nächste übergeben. So bestimmst du genau, was in den Modellkontext gelangt.

Wenn du einem Remote-MCP-Server vertraust, kannst du Genehmigungen überspringen, um die Latenz zu verringern. Setze dazu den Parameter require_approval des MCP-Tools wie im folgenden Beispiel auf ein Objekt, das nur die Tools auflistet, für die du Genehmigungen überspringen möchtest. Mit dem Wert 'never' überspringst du Genehmigungen für alle Tools dieses Remote-MCP-Servers.

Für bestimmte Tools nie eine Genehmigung anfordern
curl https://api.openai.com/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
    "model": "gpt-6-astra",
    "tools": [
      {
        "type": "mcp",
        "server_label": "deepwiki",
        "server_url": "https://mcp.deepwiki.com/mcp",
        "require_approval": {
          "never": {
            "tool_names": ["ask_question", "read_wiki_structure"]
          }
        }
      }
    ],
    "input": "What transport protocols does the 2025-03-26 version of the MCP spec (modelcontextprotocol/modelcontextprotocol) support?"
  }'

Authentifizierung

Der MCP-Server für die OpenAI-Dokumentation erfordert keine Authentifizierung. Andere MCP-Server können eine Authentifizierung verlangen. Am häufigsten kommt dabei ein OAuth-Zugriffstoken zum Einsatz. Übergib dieses Token im Feld authorization des MCP-Tools.

Das MCP-Tool von Stripe verwenden
curl https://api.openai.com/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
    "model": "gpt-6-astra",
    "input": "Create a payment link for $20",
    "tools": [
      {
        "type": "mcp",
        "server_label": "stripe",
        "server_url": "https://mcp.stripe.com",
        "authorization": "$STRIPE_OAUTH_ACCESS_TOKEN"
      }
    ]
  }'

Damit sensible Token nicht unbefugt bekannt werden, speichert die Responses API den Wert aus dem Feld authorization nicht. Auch im erstellten Response-Objekt ist er nicht sichtbar. Deshalb musst du den Wert für authorization bei jeder Anfrage zum Erstellen eines Response-Objekts erneut mitsenden.

Bisherige Konnektoren

Für Modelle, die nach dem 1. September 2026 veröffentlicht wurden, gilt connector_id als veraltet. Verwende server_url für die Verbindung zu einem Remote-MCP-Server oder tunnel_id für die Verbindung zu einem lokalen MCP-Server über Secure MCP Tunnel. Bestehende Modelle unterstützen Konnektoren weiterhin. Die Beispiele in diesem Abschnitt verwenden gpt-5.2, das vor dem Stichtag veröffentlicht wurde.

Die Responses API unterstützt eine begrenzte Auswahl integrierter Konnektoren für Dienste von Drittanbietern. Über diese Konnektoren kannst du Kontext aus verbreiteten Anwendungen wie Dropbox und Gmail abrufen, damit das Modell mit diesen Diensten interagieren kann.

Konnektoren verwendest du genauso wie Remote-MCP-Server. Beide ermöglichen einem OpenAI-Modell, in einer API-Anfrage auf zusätzliche Tools von Drittanbietern zuzugreifen. Beim Aufruf eines Remote-MCP-Servers übergibst du server_url. Für einen Konnektor übergibst du stattdessen connector_id. Dieser Wert identifiziert den in der API verfügbaren Konnektor eindeutig.

Konnektoren erfordern ein OAuth-Zugriffstoken, das deine Anwendung im Parameter authorization übergibt.

Einen bisherigen Konnektor mit GPT-5.2 verwenden
curl https://api.openai.com/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
    "model": "gpt-5.2",
    "tools": [
      {
        "type": "mcp",
        "server_label": "Dropbox",
        "connector_id": "connector_dropbox",
        "authorization": "<oauth access token>",
        "require_approval": "never"
      }
    ],
    "input": "Summarize the Q2 earnings report."
  }'

Verfügbare Konnektoren

  • Dropbox: connector_dropbox
  • Gmail: connector_gmail
  • Google Kalender: connector_googlecalendar
  • Google Drive: connector_googledrive
  • Microsoft Teams: connector_microsoftteams
  • Outlook-Kalender: connector_outlookcalendar
  • Outlook-E-Mail: connector_outlookemail
  • SharePoint: connector_sharepoint

Wir haben Dienste bevorzugt, die keine offiziellen Remote-MCP-Server anbieten. GitHub hat beispielsweise einen offiziellen MCP-Server. Um dich mit ihm zu verbinden, übergib https://api.githubcopilot.com/mcp/ im Feld server_url des MCP-Tools.

Einen Konnektor autorisieren

Übergib im Feld authorization ein OAuth-Zugriffstoken. Deine Anwendung muss die Registrierung des OAuth-Clients und die Autorisierung separat übernehmen.

Für Tests kannst du im OAuth 2.0 Playground von Google temporäre Zugriffstoken für API-Anfragen generieren.

Um die Konnektoren der API mit dem Playground zu testen, gib zunächst den folgenden Berechtigungsbereich ein.

https://www.googleapis.com/auth/calendar.events

Gib diesen Berechtigungsbereich unter „Step 1: Select and authorize APIs“ ein, damit die API Termine aus Google Kalender lesen kann.

Nachdem du die Anwendung mit deinem Google-Konto autorisiert hast, gelangst du zu „Step 2: Exchange authorization code for tokens“. Tausche dort den Autorisierungscode gegen ein Zugriffstoken ein, das du für eine API-Anfrage mit dem Konnektor für Google Kalender verwenden kannst.

Den Konnektor für Google Kalender verwenden
curl https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-5.2",
    "tools": [
      {
        "type": "mcp",
        "server_label": "google_calendar",
        "connector_id": "connector_googlecalendar",
        "authorization": "ya29.A0AS3H6...",
        "require_approval": "never"
      }
    ],
    "input": "What is on my Google Calendar for today?"
  }'

Ein MCP-Tool-Aufruf über einen Konnektor sieht genauso aus wie ein Aufruf über einen Remote-MCP-Server. Beide verwenden den Ausgabeelementtyp mcp_call. In diesem Beispiel sind sowohl die Argumente für den Konnektor als auch seine Antwort JSON-Zeichenfolgen.

{
  "id": "mcp_68a62ae1c93c81a2b98c29340aa3ed8800e9b63986850588",
  "type": "mcp_call",
  "approval_request_id": null,
  "arguments": "{\"time_min\":\"2025-08-20T00:00:00\",\"time_max\":\"2025-08-21T00:00:00\",\"timezone_str\":null,\"max_results\":50,\"query\":null,\"calendar_id\":null,\"next_page_token\":null}",
  "error": null,
  "name": "search_events",
  "output": "{\"events\": [{\"id\": \"2n8ni54ani58pc3ii6soelupcs_20250820\", \"summary\": \"Home\", \"location\": null, \"start\": \"2025-08-20T00:00:00\", \"end\": \"2025-08-21T00:00:00\", \"url\": \"https://www.google.com/calendar/event?eid=Mm44bmk1NGFuaTU4cGMzaWk2c29lbHVwY3NfMjAyNTA4MjAga3doaW5uZXJ5QG9wZW5haS5jb20&ctz=America/Los_Angeles\", \"description\": \"\\n\\n\", \"transparency\": \"transparent\", \"display_url\": \"https://www.google.com/calendar/event?eid=Mm44bmk1NGFuaTU4cGMzaWk2c29lbHVwY3NfMjAyNTA4MjAga3doaW5uZXJ5QG9wZW5haS5jb20&ctz=America/Los_Angeles\", \"display_title\": \"Home\"}], \"next_page_token\": null}",
  "server_label": "Google_Calendar"
}

Verfügbare Tools je Konnektor

Welche Tools verfügbar sind, hängt von den Berechtigungsbereichen deines OAuth-Tokens ab. Klappe die Tabellen auf, um zu sehen, welche Tools du mit der jeweiligen Anwendung verwenden kannst.

Tools eines MCP-Servers bei Bedarf laden

Wenn du die Tool-Suche verwendest, kannst du die Funktionen eines MCP-Servers erst dann laden, wenn das Modell sie benötigt. Setze dazu in der Tool-Definition des MCP-Servers defer_loading: true.

Auch beim verzögerten Laden kann das Modell anhand der Bezeichnung und Beschreibung des MCP-Servers entscheiden, wann es dort nach Tools sucht. Die einzelnen Funktionsdefinitionen werden erst bei Bedarf geladen. Das kann den Tokenverbrauch insgesamt senken und ist besonders bei MCP-Servern mit vielen Funktionen sinnvoll.

{
    "type": "mcp",
    "server_label": "openai_docs",
    "server_description": "Search and read the public OpenAI documentation.",
    "server_url": "https://developers.openai.com/mcp",
    "defer_loading": true,
    "require_approval": "never"
}

Risiken und Sicherheit

Mit dem MCP-Tool kannst du OpenAI-Modelle mit externen Diensten verbinden. Die weitreichenden Zugriffsmöglichkeiten bringen Risiken mit sich.

Bei Konnektoren besteht das Risiko, dass sensible Daten an OpenAI gesendet werden oder Modelle Lesezugriff auf potenziell sensible Daten in den angebundenen Diensten erhalten.

Bei Remote-MCP-Servern bestehen dieselben Risiken. Zudem hat OpenAI diese Server nicht überprüft. Über sie können Modelle auf Daten zugreifen, Daten senden und empfangen sowie Aktionen in den angebundenen Diensten ausführen. Alle MCP-Server sind Dienste von Drittanbietern, für die jeweils eigene Geschäftsbedingungen gelten.

Wenn du auf einen bösartigen MCP-Server stößt, melde ihn an security@openai.com.

Beachte beim Einbinden von Konnektoren und Remote-MCP-Servern die folgenden Empfehlungen.

Prompt Injection

Prompt Injection ist ein wichtiges Sicherheitsrisiko für jede LLM-Anwendung. Das gilt besonders, wenn du dem Modell Zugriff auf MCP-Server und Konnektoren gibst, die sensible Daten abrufen oder Aktionen ausführen können. Wenn der Prompt Benutzereingaben enthält, setze diese Tools mit entsprechender Vorsicht und geeigneten Schutzmaßnahmen ein.

Eine Webseite könnte das Modell beispielsweise anweisen, in deinem CRM-System nach einem Kundenkontakt zu suchen und dessen E-Mail-Adresse in eine URL einzufügen. Schon der Abruf dieser URL würde die E-Mail-Adresse offenlegen, selbst wenn das CRM-Tool ohne Schreibzugriff arbeitet.

Wenn du eine öffentliche Unternehmensmitteilung mit privaten CRM-Datensätzen vergleichen möchtest, sammle die öffentlich verfügbaren Fakten in einer Anfrage, für die nur die Websuche aktiviert ist. Übergib die relevanten Fakten an eine zweite Anfrage, die ausschließlich auf dein internes CRM-Suchtool zugreifen kann. So gelangen keine Kundendaten aus dem CRM in Websuchanfragen oder URLs.

Für sensible Aktionen immer eine Genehmigung verlangen

Konfiguriere die Parameter require_approval und allowed_tools so, dass jede sensible Aktion eine Genehmigung erfordert.

URLs in MCP-Tool-Aufrufen und deren Ausgaben

Es kann gefährlich sein, URLs aus den Ausgaben von Tool-Aufrufen abzurufen oder Bild-URLs aus solchen Ausgaben einzubetten. Das gilt für Konnektoren ebenso wie für Remote-MCP-Server. Vergewissere dich, dass du den Domains und Diensten vertraust, von denen die URLs stammen, bevor du sie in deinem Anwendungscode einbettest oder anderweitig verwendest.

Verbindungen zu vertrauenswürdigen Servern herstellen

Wähle offizielle Server, die der jeweilige Dienstanbieter selbst hostet. Für Stripe empfehlen wir beispielsweise den von Stripe gehosteten Server unter mcp.stripe.com anstelle eines Stripe-MCP-Servers, den ein Drittanbieter hostet. Da es derzeit nur wenige offizielle Remote-MCP-Server gibt, kommt für dich vielleicht ein MCP-Server infrage, den eine andere Organisation hostet. Diese Organisation betreibt den eigentlichen Dienst nicht selbst, sondern leitet Anfragen über deine API an ihn weiter. Wenn du auf einen solchen „Aggregator“ angewiesen bist, prüfe besonders gründlich, ob er vertrauenswürdig ist und wie er deine Daten verwendet.

Daten protokollieren und prüfen, die an MCP-Server von Drittanbietern gehen

MCP-Server legen ihre Tool-Definitionen selbst fest. Sie können daher Daten anfordern, die du dem jeweiligen Serverbetreiber möglicherweise nicht anvertrauen möchtest. Deshalb verlangt das MCP-Tool in der Responses API standardmäßig für jeden MCP-Tool-Aufruf eine Genehmigung. Prüfe bei der Entwicklung deiner Anwendung gründlich und systematisch, welche Arten von Daten sie an diese MCP-Server weitergibt. Sobald du dem jeweiligen MCP-Server vertraust, kannst du die Genehmigungen überspringen, um die Latenz bei der Ausführung zu verringern.

Wir empfehlen außerdem, alle Daten zu protokollieren, die an MCP-Server gesendet werden. Wenn du die Responses API mit store=true verwendest, protokolliert die API diese Daten bereits für 30 Tage, sofern für deine Organisation nicht die Option „Keine Datenaufbewahrung“ aktiviert ist. Du kannst die Daten zusätzlich in deinen eigenen Systemen protokollieren und regelmäßig prüfen, ob deine Anwendung die Daten wie vorgesehen weitergibt.

Bösartige MCP-Server können versteckte Anweisungen (Prompt Injections) enthalten, die OpenAI-Modelle gezielt zu unerwartetem Verhalten verleiten sollen. OpenAI hat Schutzmechanismen integriert, die helfen, solche Bedrohungen zu erkennen und zu blockieren. Prüfe dennoch Ein- und Ausgaben sorgfältig und stelle sicher, dass deine Anwendung nur Verbindungen zu vertrauenswürdigen Servern herstellt.

MCP-Server können die Funktionsweise ihrer Tools unerwartet ändern. Das kann unbeabsichtigtes oder bösartiges Verhalten zur Folge haben.

Auswirkungen auf die Vorgabe „Keine Datenaufbewahrung“ und auf die Datenresidenz

Das MCP-Tool ist mit der Vorgabe „Keine Datenaufbewahrung“ und mit Anforderungen an die Datenresidenz kompatibel. MCP-Server sind jedoch Dienste von Drittanbietern. Für Daten, die du an einen MCP-Server sendest, gelten die Richtlinien des jeweiligen Anbieters zur Datenaufbewahrung und Datenresidenz.

Gilt für deine Organisation Datenresidenz in Europa, beschränkt OpenAI die Inferenz und die Speicherung von Kundeninhalten auf Europa. Das gilt bis zu dem Punkt, an dem Nachrichten oder Daten an den MCP-Server gesendet werden. Du bist dafür verantwortlich, dass auch der MCP-Server deine jeweiligen Anforderungen an die Datenaufbewahrung („Keine Datenaufbewahrung“) und die Datenresidenz erfüllt. Weitere Informationen zu diesen Vorgaben findest du im Leitfaden zum Umgang mit deinen Daten.

Hinweise zur Nutzung

API-VerfügbarkeitRatenlimitsHinweise

Build
1.000 RPM

Launch und Grow
2.000 RPM

Preise
Keine Datenaufbewahrung (ZDR) und Datenresidenz