OpenAI API Tutorial: Erste Schritte mit GPT in Python

Die OpenAI API ermoeglicht den programmatischen Zugang zu GPT-4, DALL-E und anderen leistungsstarken KI-Modellen. In diesem Tutorial lernen Sie die Grundlagen der API-Nutzung mit Python - von der Einrichtung bis zu fortgeschrittenen Techniken wie Streaming und Function Calling.

Einrichtung und API-Key

Bevor Sie die API nutzen koennen, benoetigen Sie einen OpenAI-Account und einen API-Key.

Account erstellen

1. Registrierung: Besuchen Sie platform.openai.com und erstellen Sie einen Account
2. Verifizierung: Bestaetigen Sie Ihre E-Mail-Adresse
3. Zahlungsmethode: Hinterlegen Sie eine Kreditkarte fuer die Abrechnung
4. API-Key: Erstellen Sie unter "API Keys" einen neuen Schluessel

Python-Bibliothek installieren

Installieren Sie die offizielle OpenAI-Bibliothek ueber pip:

pip install openai

API-Key konfigurieren

Setzen Sie den API-Key als Umgebungsvariable:

# Linux/Mac
export OPENAI_API_KEY="sk-..."

# Windows (PowerShell)
$env:OPENAI_API_KEY="sk-..."

Die erste API-Anfrage

Beginnen wir mit einer einfachen Chat-Completion-Anfrage:

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Du bist ein hilfreicher Assistent."},
        {"role": "user", "content": "Was ist Python?"}
    ]
)

print(response.choices[0].message.content)

Die Nachrichtenstruktur verstehen

Die API arbeitet mit einem Nachrichten-Array, das den Konversationsverlauf enthält. Das Verständnis dieser Struktur ist entscheidend für den Aufbau professioneller Anwendungen:

• system: Definiert das Verhalten des Assistenten
• user: Nachrichten des Nutzers
• assistant: Vorherige Antworten des Modells

Wichtige Parameter

Die API bietet verschiedene Parameter zur Steuerung der Ausgabe:

Temperature

Steuert die Kreativitaet der Antworten (0-2):

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[...],
    temperature=0.7  # Standard: 1.0
)

• 0: Deterministisch, immer die wahrscheinlichste Antwort
• 0.7: Gute Balance fuer die meisten Anwendungen
• 1.5+: Kreativ, aber moeglicherweise inkonsistent

Max Tokens

Begrenzt die Laenge der Antwort:

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[...],
    max_tokens=500  # Maximale Antwortlaenge
)

Modellauswahl

OpenAI bietet verschiedene Modelle mit unterschiedlichen Staerken:

• gpt-4o: Flaggschiff-Modell, beste Qualitaet
• gpt-4o-mini: Schneller und guenstiger, gut fuer einfache Aufgaben
• gpt-4-turbo: Groesseres Kontextfenster, gut fuer lange Dokumente

Einen Chatbot bauen

Fuer einen echten Chatbot muessen Sie den Konversationsverlauf speichern:

from openai import OpenAI

client = OpenAI()

def chat():
    messages = [
        {"role": "system", "content": "Du bist ein freundlicher Assistent."}
    ]

    print("Chatbot gestartet. 'quit' zum Beenden.")

    while True:
        user_input = input("Sie: ")
        if user_input.lower() == 'quit':
            break

        messages.append({"role": "user", "content": user_input})

        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages
        )

        assistant_message = response.choices[0].message.content
        messages.append({"role": "assistant", "content": assistant_message})

        print(f"Bot: {assistant_message}\n")

chat()

Streaming-Antworten

Fuer eine bessere User Experience koennen Sie Antworten Token fuer Token streamen:

from openai import OpenAI

client = OpenAI()

stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "Erklaere Machine Learning in 3 Saetzen."}
    ],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Function Calling

Eine der maechtigsten Funktionen: Das Modell kann erkennen, wann es externe Funktionen aufrufen soll:

from openai import OpenAI
import json

client = OpenAI()

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Ruft das aktuelle Wetter fuer einen Ort ab",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Stadt, z.B. Berlin"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "Wie ist das Wetter in Berlin?"}
    ],
    tools=tools,
    tool_choice="auto"
)

# Pruefen, ob das Modell eine Funktion aufrufen moechte
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    function_name = tool_call.function.name
    arguments = json.loads(tool_call.function.arguments)
    print(f"Modell moechte {function_name} mit {arguments} aufrufen")

Kosten und Optimierung

Die API rechnet nach Token ab. Ein Token entspricht etwa 4 Zeichen in Englisch, weniger in Deutsch.

Aktuelle Preise (Stand Januar 2026)

• GPT-4o: ~$2.50 pro 1M Input-Token, ~$10 pro 1M Output-Token
• GPT-4o-mini: ~$0.15 pro 1M Input-Token, ~$0.60 pro 1M Output-Token

Kosten optimieren

Die API-Kosten können bei intensiver Nutzung schnell steigen. Mit diesen Strategien halten Sie die Kosten unter Kontrolle:

• Passendes Modell wählen: Nicht immer ist GPT-4o nötig. GPT-4o-mini reicht für Klassifikation, Zusammenfassungen und einfache Textgenerierung
• System-Prompts kurz halten: Jedes Token zählt. Ein präziser System-Prompt mit 100 Token ist besser als ein ausführlicher mit 500 Token
• Max Tokens begrenzen: Verhindert unnötig lange Antworten und hält die Kosten planbar
• Caching: Häufige Anfragen mit identischem Input zwischenspeichern. Bei Kundensupport-Bots sind oft 20-30% der Anfragen identisch oder sehr ähnlich
• Batch Processing: Sammeln Sie nicht zeitkritische Anfragen und verarbeiten Sie sie in Batches zu günstigeren Konditionen

Fehlerbehandlung

Robuste Anwendungen muessen mit API-Fehlern umgehen:

from openai import OpenAI, RateLimitError, APIError
import time

client = OpenAI()

def make_request_with_retry(messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="gpt-4o-mini",
                messages=messages
            )
            return response.choices[0].message.content
        except RateLimitError:
            wait_time = 2 ** attempt
            print(f"Rate limit erreicht. Warte {wait_time}s...")
            time.sleep(wait_time)
        except APIError as e:
            print(f"API-Fehler: {e}")
            raise
    raise Exception("Max retries erreicht")

Structured Output und JSON Mode

Für Unternehmensanwendungen ist es oft wichtig, strukturierte Daten statt Freitext zu erhalten. Die OpenAI API bietet dafür den JSON-Modus:

response = client.chat.completions.create(
    model="gpt-4o",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Extrahiere die Daten als JSON."},
        {"role": "user", "content": "Firma: Muster GmbH, Umsatz: 2.5 Mio, Branche: IT"}
    ]
)

import json
daten = json.loads(response.choices[0].message.content)
print(daten)
# {"firma": "Muster GmbH", "umsatz": 2500000, "branche": "IT"}

Structured Output ist besonders wertvoll für die automatisierte Verarbeitung von Dokumenten, die Extraktion von Informationen aus E-Mails oder die Integration mit bestehenden Datenbanksystemen. Unternehmen nutzen dies etwa für die automatische Rechnungserfassung oder die Analyse von Kundenanfragen.

Best Practices für den Unternehmenseinsatz

Der Schritt von einem Prototyp zu einer produktiven Unternehmensanwendung erfordert besondere Sorgfalt. Folgende Aspekte sind entscheidend:

Architektur und Skalierung

• Asynchrone Verarbeitung - Nutzen Sie asyncio für parallele API-Aufrufe und bessere Auslastung
• Caching-Strategien - Speichern Sie häufige Antworten in Redis oder einer Datenbank, um Kosten und Latenz zu reduzieren
• Rate Limiting - Implementieren Sie eigenes Rate Limiting, um die API-Limits nicht zu überschreiten
• Fallback-Strategien - Bei API-Ausfällen auf günstigere Modelle oder lokale Alternativen wechseln

Sicherheit und Compliance

Für den Unternehmenseinsatz müssen Sie sicherstellen, dass keine sensiblen Daten ungeschützt an die API übermittelt werden. Implementieren Sie Input-Filter, die vertrauliche Informationen wie Kundennamen oder Finanzdaten anonymisieren, bevor sie an die API gesendet werden. Für maximale Datensicherheit bieten On-Premise-Lösungen mit Open-Source-Modellen wie Llama oder Mistral eine vollständig datenschutzkonforme Alternative.

Nächste Schritte

Mit diesen Grundlagen können Sie bereits beeindruckende Anwendungen bauen. Hier einige Ideen für die Weiterentwicklung:

• RAG implementieren: Verbinden Sie GPT mit Ihrer Wissensdatenbank für domänenspezifische Antworten
• Embeddings nutzen: Für semantische Suche und Clustering von Dokumenten
• Vision API: Bilder analysieren mit GPT-4 Vision - ideal für Qualitätskontrolle oder Dokumentenverarbeitung
• Fine-Tuning: Modelle auf Ihre Domäne anpassen für bessere Ergebnisse bei spezifischen Aufgaben

Häufig gestellte Fragen

Was kostet die OpenAI API pro Monat?

Die Kosten hängen stark von der Nutzung ab. GPT-4o kostet etwa $2.50 pro Million Input-Token und $10 pro Million Output-Token. GPT-4o-mini ist mit $0.15/$0.60 deutlich günstiger. Für ein typisches Chatbot-Projekt mit 1.000 Anfragen pro Tag sollten Sie mit 50-200 Euro pro Monat rechnen. Nutzen Sie den KI-Vergleichsrechner für eine individuelle Kostenschätzung.

Ist die OpenAI API DSGVO-konform nutzbar?

OpenAI bietet einen Data Processing Agreement (DPA) an und verspricht, API-Daten nicht für das Modelltraining zu nutzen. Dennoch werden Daten an US-Server übermittelt, was datenschutzrechtliche Fragen aufwirft. Für sensible Unternehmensdaten empfehlen wir On-Premise-Lösungen mit Open-Source-Modellen, die vollständig auf eigener Infrastruktur laufen.

Was ist Function Calling bei der OpenAI API?

Function Calling ermöglicht es dem Modell, strukturierte Funktionsaufrufe zu generieren. Sie definieren verfügbare Funktionen mit Parametern, und das Modell erkennt automatisch, wann welche Funktion aufgerufen werden soll. Das ist ideal für die Integration von GPT in bestehende Systeme - etwa zur Datenbankabfrage, für API-Aufrufe oder zur Aufgabenautomatisierung.

Welches OpenAI-Modell soll ich wählen?

GPT-4o ist das leistungsstärkste Modell für komplexe Aufgaben wie Code-Generierung und Analyse. GPT-4o-mini bietet ein gutes Preis-Leistungs-Verhältnis für einfachere Anwendungen wie Klassifikation oder Zusammenfassungen. Testen Sie verschiedene Modelle mit Ihren konkreten Aufgaben und wählen Sie das kosteneffizienteste Modell, das Ihre Qualitätsanforderungen erfüllt.