Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Ihre erste API-Anfrage

Lektion 5 von 22 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Ihre erste API-Anfrage
  2. Die einfachste Anfrage
  3. Was die Antwort wirklich enthält
  4. Die Parameter, die zählen
  5. Überleitung zu strukturierten Eingaben
  6. Lassen Sie eine Anfrage niemals ungeschützt
  7. Kernaussagen

Lektion aktualisiert am 3. November 2026 basierend auf der OpenAI-Dokumentation: Die Parameter temperature und top_p werden nur mit einem Reasoning-Effort von none akzeptiert, während Modelle der GPT-5.6-Serie standardmäßig mit medium rechnerisch arbeiten. Anfragen, die diese Parameter setzen, müssen daher reasoning={"effort": "none"} (Responses API) oder reasoning_effort="none" (Chat Completions) angeben. Quellen: Verwendung von GPT-6 · GPT-5.6 Terra.

Ihre erste API-Anfrage

Ihre Umgebung ist bereit: wir kommen zur Arbeit. Sie werden Ihre erste Anfrage an die Responses API senden, das Objekt analysieren, das diese zurückgibt, und dann die Parameter manipulieren, die eine generische Antwort von einer nützlichen unterscheiden.

Die einfachste Anfrage

Zwei Parameter sind alles, was Sie benötigen: model, die Kennzeichnung des abzufragenden Modells, und input, Ihre Eingabe – entweder ein Textstring oder eine Liste von Nachrichten, wie wir gleich sehen werden.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Was ist der Unterschied zwischen Python und JavaScript?"
)

print(response.output_text)
# Ergebnis: Python ist eine vielseitige Sprache, die sich auf Datenwissenschaft
# und Backend-Entwicklung konzentriert, während JavaScript primär für
# Frontend- und Backend-Webentwicklung (via Node.js) verwendet wird...

Was die Antwort wirklich enthält

output_text ist lediglich eine Bequemlichkeit. Das response-Objekt enthält zudem seine eindeutige ID – unerlässlich für das Verkettung von Austauschschritten und das Nachschlagen von Aufrufen in Ihren Protokollen –, das tatsächlich verwendete Modell und eine Aufschlüsselung des Token-Verbrauchs. Machen Sie es sich zur Gewohnheit, diese drei Informationen bereits in Ihren ersten Skripten zu protokollieren. Dies wird es Ihnen später ermöglichen, die Frage zu beantworten: „Warum hat sich die Rechnung diesen Monat verdoppelt?”

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Hallo, wie geht es Ihnen?"
)

# Der Antworttext (Abkürzung)
print(response.output_text)

# Die eindeutige ID der Antwort
print(f"ID: {response.id}")

# Das verwendete Modell
print(f"Modell: {response.model}")

# Verwendete Tokens
print(f"Eingabetokens: {response.usage.input_tokens}")
print(f"Ausgabetokens: {response.usage.output_tokens}")
print(f"Gesamttokens: {response.usage.total_tokens}")

# Ergebnis:
# Hallo! Mir geht es sehr gut, danke. Wie kann ich Ihnen helfen?
# ID: resp_abc123xyz
# Modell: gpt-5.6-terra
# Eingabetokens: 14
# Ausgabetokens: 19
# Gesamttokens: 33

Die Parameter, die zählen

temperature steuert die Variabilität der Generierung. Bei 0,0 wählt das Modell systematisch die wahrscheinlichste Fortsetzung: dies ist die Einstellung für faktische Fragen, Datenextraktion und alles, was Sie exakt reproduzieren müssen. Bei 1,0 erkundet es mehr, was Sie für Benennung, kreatives Schreiben oder die Generierung von Varianten wünschen.

# Niedrige Temperatur (0,0) = deterministisch, faktisch
response_factual = client.responses.create(
    model="gpt-5.6-terra",
    reasoning={"effort": "none"},  # temperature erfordert effort none
    input="Was ist die Hauptstadt von Deutschland?",
    temperature=0.0
)
print(response_factual.output_text)
# Ergebnis: Die Hauptstadt von Deutschland ist Berlin.

# Hohe Temperatur (1,0) = kreativ, variabel
response_creative = client.responses.create(
    model="gpt-5.6-terra",
    reasoning={"effort": "none"},  # temperature erfordert effort none
    input="Erfinden Sie einen Namen für ein literarisches Café.",
    temperature=1.0
)
print(response_creative.output_text)
# Ergebnis: "Die wandelnden Seiten" – ein Café, bei dem jeder Tisch
# den Namen eines berühmten Kapitels trägt.

Der Parameter instructions übernimmt die Rolle der alten Systemnachricht: Er definiert die Rolle, den Ton und die Einschränkungen, die das Modell während des gesamten Austauschs einhalten muss, unabhängig von der gestellten Frage. Im folgenden Beispiel würde dieselbe Frage ohne Anweisungen eine Liste allgemeiner Tipps produzieren; mit ihnen werden Rezepte erstellt.

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions="Sie sind ein Experte für französische Küche. "
                 "Antworten Sie immer mit Rezeptvorschlägen.",
    input="Ich weiß nicht, was ich mit Zucchini anfangen soll."
)
print(response.output_text)
# Ergebnis: Hier sind drei Ideen für Ihre Zucchini:
# 1. Zucchini-Graatin mit Ziegenkäse...
# 2. Provenzalische Ratatouille...
# 3. Kalte Zucchini-Velouté mit Minze...

Schließlich begrenzt max_output_tokens die Länge der Antwort. Dies ist eine budgetäre Sicherheitsvorkehrung, keine Schreibweisung: Die Antwort wird abrupt abgeschnitten, sobald das Limit erreicht ist. Wenn Sie eine kurze, gut strukturierte Antwort wünschen, bitten Sie dies auch in der Eingabe.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Erklären Sie die allgemeine Relativitätstheorie.",
    max_output_tokens=100
)
print(response.output_text)
print(f"Verwendete Tokens: {response.usage.output_tokens}")
# Die Antwort wird bei ungefähr 100 Tokens abgeschnitten

Überleitung zu strukturierten Eingaben

Wenn ein einfacher String nicht ausreicht, akzeptiert input eine Liste von Nachrichten. Die minimale Form enthält einen einzigen Durchgang, doch der Nutzen zeigt sich, sobald Sie einen Verlauf bereitstellen: Das Modell hat dann Zugriff darauf, was bereits gesagt wurde, und reagiert entsprechend. Hier wird „Fortschritt” im Kontext von Python verstanden, nicht abstrakt.

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": "Übersetzen Sie ins Englische: Hello world"
        }
    ]
)
print(response.output_text)
# Ergebnis: Hello world

# Mit Gesprächskontext
response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {
            "role": "user",
            "content": "Meine Lieblings-Sprache ist Python."
        },
        {
            "role": "assistant",
            "content": "Python ist eine hervorragende Wahl! Es ist sehr vielseitig."
        },
        {
            "role": "user",
            "content": "Geben Sie mir einen Tipp zur Verbesserung."
        }
    ]
)
print(response.output_text)
# Ergebnis: Um in Python zu verbessern, empfehle ich Ihnen...

Lassen Sie eine Anfrage niemals ungeschützt

Netzwerkanfragen scheitern, und Schlüssel verfallen. Drei Ausnahmen decken die meisten Fälle beim Start ab: AuthenticationError bei fehlendem oder ungültigem Schlüssel, RateLimitError, wenn Sie Ihre erlaubte Durchsatzgrenze überschreiten, und APIError als generischer Sicherheitsnetz. Eine ganze Lektion wird später auf die vollständige Strategie zurückkommen, aber beginnen Sie heute damit, Ihre Anfragen zu umschließen.

from openai import OpenAI, APIError, AuthenticationError, RateLimitError

client = OpenAI()

try:
    response = client.responses.create(
        model="gpt-5.6-terra",
        input="Hallo!"
    )
    print(response.output_text)
except AuthenticationError:
    print("Fehler: Ungültiger oder fehlender API-Schlüssel")
except RateLimitError:
    print("Fehler: Zu viele Anfragen, warten Sie einen Moment")
except APIError as e:
    print(f"API-Fehler: {e.message}")

Um dies alles zu konsolidieren, schreiben Sie ein Skript, das drei Fragen stellt und die verbrauchten Tokens akkumuliert. Sie werden den Aufruf-Loop, eine Temperatur von 0,0 für stabile Antworten und das Lesen von usage kombinieren – die drei grundlegenden Reflexe.

from openai import OpenAI

client = OpenAI()

questions = [
    "Was ist der größte Ozean der Welt?",
    "Wer hat die Mona Lisa gemalt?",
    "Wie viele Planeten gibt es im Sonnensystem?"
]

total_tokens = 0

for question in questions:
    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature erfordert effort none
        input=question,
        temperature=0.0
    )
    tokens = response.usage.total_tokens
    total_tokens += tokens
    print(f"F: {question}")
    print(f"A: {response.output_text}")
    print(f"   ({tokens} Tokens)\n")

print(f"Gesamt: {total_tokens} verbrauchte Tokens")

Kernaussagen

  • Eine grundlegende Anfrage erfordert nur model und input
  • response.output_text liefert den Antworttext
  • response.usage enthält Details zum Token-Verbrauch
  • temperature steuert die Kreativität (0,0 = faktisch, 1,0 = kreativ)
  • instructions ersetzen die Systemnachricht aus Chat Completions
  • Behandeln Sie Fehler immer mit try/except-Blöcken