Excel mit Python und ChatGPT übersetzen (Anleitung 2026)

Zuletzt aktualisiert: Juni 2026 — getestet mit dem OpenAI Python SDK v1.x und der Chat-Completions-API.

Diese Anleitung verwendet die Chat-Completions-API, weil sie einfach und weit verbreitet ist. Für neue Anwendungen können Sie außerdem die Responses-API von OpenAI und strukturierte Ausgaben in Betracht ziehen.

Zwei Wege, eine Excel-Datei zu übersetzen

Bevor Sie auch nur eine Zeile Code schreiben, lohnt es sich, ehrlich zu prüfen, welcher Ansatz wirklich zu Ihnen passt:

Ein Python-Skript schreiben (diese Anleitung). Ideal, wenn Sie die Übersetzung vieler Dateien automatisieren, sie zeitgesteuert ausführen oder in eine größere Pipeline einbauen möchten. Sie benötigen einen OpenAI-API-Schlüssel und grundlegende Python-Kenntnisse.
Ein fertiges Tool nutzen. Wenn Sie einfach nur jetzt sofort eine einzige Tabelle übersetzen müssen — mit automatisch erhaltenen Diagrammen, Formeln und Formatierungen —, geht das Hochladen in den Excel-Übersetzer von Doc2Lang schneller und kommt ganz ohne Code aus.

Diese Anleitung konzentriert sich auf den Python-Ansatz und liefert Ihnen vollständigen, lauffähigen Code. Wir zeigen außerdem genau auf, wo der Eigenbau heikel wird, damit Sie mit offenen Augen entscheiden können. Gegen Ende finden Sie einen ausführlichen Vergleich.

Voraussetzungen

Bevor wir loslegen, brauchen Sie ein paar Dinge:

Python-Grundkenntnisse. Dieser Artikel enthält Code. Etwas Python zu kennen hilft, aber wir erklären jeden Schritt.
Python installiert. Falls noch nicht vorhanden, laden Sie es von der offiziellen Website herunter.
pip. Damit installieren Sie Python-Bibliotheken. Wenn Sie Python 3 haben, ist pip mit ziemlicher Sicherheit bereits dabei.
Einen OpenAI-API-Schlüssel. Erstellen Sie ihn im Dashboard Ihres OpenAI-Kontos. Derselbe Schlüssel funktioniert mit allen aktuellen Modellen (gpt-4o, gpt-4o-mini und so weiter).
Ihre Excel-Datei. Halten Sie die .xlsx-Datei bereit, die Sie übersetzen möchten.

Legen Sie Ihren API-Schlüssel als Umgebungsvariable an, damit er nie in Ihrem Code landet:

macOS / Linux:

export OPENAI_API_KEY="your_api_key_here"

Windows PowerShell:

$env:OPENAI_API_KEY="your_api_key_here"

Wie eine .xlsx-Datei aufgebaut ist (optionaler Hintergrund)

Wenn Sie eine Tabelle als .xlsx speichern, packen Sie in Wirklichkeit mehrere Dateien in ein einziges Archiv. Das Format heißt OpenXML. Wenn Sie neugierig sind, können Sie die Datei in .zip umbenennen, entpacken und hineinschauen:

xl/worksheets/ — eine XML-Datei pro Blatt (sheet1.xml, sheet2.xml, …). Hier liegen tatsächlich Ihre Zeilen, Spalten und Zelldaten.
xl/styles.xml — jeder Stil in der Arbeitsmappe: welche Zellen fett sind, welche blau, welche Zahlen als Währung formatiert werden und so weiter.
xl/sharedStrings.xml — um Platz zu sparen, speichert Excel jede eindeutige Zeichenkette nur einmal hier und verweist überall darauf, wo sie verwendet wird. Wenn „Summe“ 1.000-mal vorkommt, wird sie nur einmal gespeichert.
xl/workbook.xml — das Inhaltsverzeichnis: welche Blätter es gibt, ihre Reihenfolge und Eigenschaften wie der Blattschutz.

Bibliotheken wie openpyxl verbergen das meiste davon vor Ihnen, aber das Verständnis der Struktur hilft, wenn Sie fortgeschrittene Operationen brauchen oder Fehler beheben müssen.

Windows-Explorer mit dem Inhalt einer entpackten report.xlsx-Datei

Eine entpackte report.xlsx: Arbeitsblätter, gemeinsame Zeichenketten, Stile und Arbeitsmappenstruktur sind einfach XML-Dateien in einem ZIP-Archiv.

Excel-Dateien mit openpyxl lesen und schreiben

openpyxl ist eine Python-Bibliothek, die speziell zum Lesen und Schreiben von Excel-Dateien (.xlsx, .xlsm, .xltx, .xltm) entwickelt wurde. Damit arbeiten Sie direkt mit Blättern und Zellen.

Eines sollte vorab klar sein: openpyxl ist hervorragend für die Arbeit auf Zellebene, aber es ist keine vollwertige Layout-Engine für Excel. Formen, manche Bilder, Diagramme, Makros und Rich Text innerhalb einer einzelnen Zelle bleiben beim Öffnen und erneuten Speichern einer Datei möglicherweise nicht erhalten. Makrofähige .xlsm-Dateien laden Sie mit load_workbook(..., keep_vba=True) und speichern sie wieder als .xlsm, sonst gehen die Makros eventuell verloren. Auf diese Grenzen kommen wir am Ende zurück.

1. openpyxl installieren

pip install openpyxl

2. Grundlegende Konzepte

Ein paar Konzepte lassen sich direkt auf openpyxl übertragen:

Workbook (Arbeitsmappe) — eine Excel-Datei als Ganzes.

from openpyxl import load_workbook
 
workbook = load_workbook(filename="sample.xlsx")

Sheet (Blatt) — eine Arbeitsmappe enthält ein oder mehrere Blätter.

sheet = workbook.active          # das aktive Blatt
another_sheet = workbook["Sheet2"]  # ein Blatt über seinen Namen

Cell (Zelle) — der Schnittpunkt von Zeile und Spalte. Hier liegen die Daten.

cell_value = sheet["A1"].value   # lesen
sheet["B1"] = "Hello, Excel!"    # schreiben

Zeilen und Spalten — lassen sich leicht durchlaufen:

for row in sheet.iter_rows(values_only=True):
    for value in row:
        print(value)

Text mit der OpenAI-API übersetzen

Nachdem Sie Ihre Daten mit openpyxl geladen haben, ist der nächste Schritt die Übersetzung mit der OpenAI-API.

1. Die OpenAI-Python-Bibliothek installieren

pip install openai

2. Eine moderne Übersetzungsfunktion (2026)

import os
from openai import OpenAI
 
# Den Schlüssel aus einer Umgebungsvariable lesen — niemals fest im Skript hinterlegen.
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
 
def translate_text(text, target_lang="German"):
    response = client.chat.completions.create(
        model="gpt-4o-mini",  # schnell und kosteneffizient; für beste Qualität "gpt-4o" verwenden
        messages=[
            {
                "role": "system",
                "content": (
                    f"You are a professional translator. Translate the user's text "
                    f"into {target_lang}. Return only the translation, with no extra commentary."
                ),
            },
            {"role": "user", "content": text},
        ],
    )
    return response.choices[0].message.content.strip()

Achtung: Viele ältere Tutorials verwenden openai.ChatCompletion.create() mit model="gpt-4". Diese Syntax stammt aus dem SDK vor Version 1.0 und funktioniert nicht mehr mit openai>=1.0. Der obige Code nutzt die aktuelle Schnittstelle client.chat.completions.create(). Wählen Sie gpt-4o-mini für niedrige Kosten und hohe Geschwindigkeit oder gpt-4o, wenn Sie maximale Übersetzungsqualität brauchen.

3. Ein naiver erster Versuch

Der häufigste Tutorial-Ansatz ist, über jede Zelle zu iterieren und sie zu überschreiben:

from openpyxl import load_workbook
 
workbook = load_workbook(filename="your_file.xlsx")
 
for sheet in workbook.worksheets:
    for row in sheet.iter_rows():
        for cell in row:
            if isinstance(cell.value, str):
                cell.value = translate_text(cell.value)
 
workbook.save("your_translated_file.xlsx")

In einer Demo funktioniert das, doch bei echten Tabellen treten echte Probleme auf: Es wird ein API-Aufruf pro Zelle gesendet (langsam und teuer), Formeln werden übersetzt und damit zerstört, und es gibt keinen Schutz gegen Rate-Limits. Lösen wir das alles.

Produktionsreif machen

1. Keine Formeln übersetzen

Wenn eine Zelle eine Formel wie =SUM(A1:A10) enthält, beschädigt das Übersetzen die Tabelle. Überspringen Sie Formeln, leere Zellen und Nicht-Text-Werte:

def is_translatable(cell):
    # Leere Zellen, Zahlen und Formelzellen überspringen.
    value = cell.value
    return (
        isinstance(value, str)
        and value.strip() != ""
        and cell.data_type != "f"   # "f" = formula
    )

openpyxl überschreibt nur cell.value, daher bleiben Zahlenformate, Schriftarten, Füllungen und die meisten Formatierungen erhalten, solange Sie Nicht-Text-Zellen unangetastet lassen.

2. Wiederholte Zeichenketten zwischenspeichern, um Kosten zu senken

Tabellen wiederholen ständig dieselben Beschriftungen („Summe“, „Datum“, ein Abteilungsname). Übersetzen Sie jede eindeutige Zeichenkette nur einmal:

cache = {}
 
def translate_cached(text, target_lang="German"):
    if text not in cache:
        cache[text] = translate_text(text, target_lang)
    return cache[text]

Bei einem typischen Bericht kann das allein Ihre API-Aufrufe — und Ihre Rechnung — deutlich reduzieren.

3. Zellen zu einer einzigen Anfrage bündeln

Ein API-Aufruf pro Zelle ist die größte Bremse. Senden Sie stattdessen viele Zeichenketten in einer einzigen Anfrage und lassen Sie das Modell JSON zurückgeben, damit Sie die Ergebnisse zuverlässig zuordnen können:

import json
 
def translate_batch(texts, target_lang="German"):
    numbered = {str(i): t for i, t in enumerate(texts)}
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "system",
                "content": (
                    f"You are a professional translator. Translate each value in the "
                    f"JSON object into {target_lang}. Keep the same keys. "
                    f"Return only a JSON object."
                ),
            },
            {"role": "user", "content": json.dumps(numbered, ensure_ascii=False)},
        ],
        response_format={"type": "json_object"},
    )
    result = json.loads(response.choices[0].message.content)
    return [result[str(i)] for i in range(len(texts))]

4. Bei Rate-Limits erneut versuchen (exponentielles Backoff)

Wenn Sie an ein Rate-Limit stoßen, brechen Sie nicht ab — warten Sie und versuchen Sie es erneut, wobei Sie die Wartezeit jedes Mal verdoppeln:

import time
 
def with_retry(func, *args, retries=5, **kwargs):
    for attempt in range(retries):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            wait = 2 ** attempt
            print(f"Error: {e}. Retrying in {wait}s...")
            time.sleep(wait)
    raise RuntimeError("Translation failed after several retries.")

5. Nicht vertrauenswürdige Dateien sicher verarbeiten

Wenn Sie Excel-Dateien verarbeiten, die andere hochgeladen haben, schützen Sie sich vor bösartigem XML. Installieren Sie defusedxml, das openpyxl automatisch verwendet, sobald es vorhanden ist, und prüfen Sie Größe und Typ der Datei, bevor Sie sie laden:

pip install defusedxml

Für Ihre eigenen Dateien ist das optional, aber für jede Datei, die Sie nicht selbst erstellt haben, dringend zu empfehlen.

Vollständiges, lauffähiges Skript

Hier ist alles zu einem Skript zusammengeführt, das Sie kopieren und ausführen können. Es sammelt eindeutige Zeichenketten, übersetzt sie in Batches mit Wiederholungsversuchen, speichert die Ergebnisse zwischen, überspringt Formeln und speichert in eine neue Datei, damit Ihr Original sicher bleibt.

import json
import os
import time
from openai import OpenAI
from openpyxl import load_workbook
 
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
 
TARGET_LANG = "German"
MODEL = "gpt-4o-mini"   # für höhere Qualität "gpt-4o" verwenden
BATCH_SIZE = 40
 
 
def is_translatable(cell):
    value = cell.value
    return (
        isinstance(value, str)
        and value.strip() != ""
        and cell.data_type != "f"   # "f" = formula
    )
 
 
def translate_batch(texts, target_lang=TARGET_LANG, retries=5):
    numbered = {str(i): t for i, t in enumerate(texts)}
    system = (
        f"You are a professional translator. Translate each value in the JSON object "
        f"into {target_lang}. Keep the same keys. Return only a JSON object."
    )
    for attempt in range(retries):
        try:
            response = client.chat.completions.create(
                model=MODEL,
                messages=[
                    {"role": "system", "content": system},
                    {"role": "user", "content": json.dumps(numbered, ensure_ascii=False)},
                ],
                response_format={"type": "json_object"},
            )
            result = json.loads(response.choices[0].message.content)
            return [result[str(i)] for i in range(len(texts))]
        except Exception as e:
            wait = 2 ** attempt
            print(f"Error: {e}. Retrying in {wait}s...")
            time.sleep(wait)
    raise RuntimeError("Translation failed after several retries.")
 
 
# 1. Arbeitsmappe laden
workbook = load_workbook(filename="your_file.xlsx")
 
# 2. Jede eindeutige, übersetzbare Zeichenkette sammeln
unique_texts = set()
for sheet in workbook.worksheets:
    for row in sheet.iter_rows():
        for cell in row:
            if is_translatable(cell):
                unique_texts.add(cell.value)
unique_texts = list(unique_texts)
 
# 3. In Batches übersetzen und einen Cache {Original: Übersetzung} aufbauen
cache = {}
for start in range(0, len(unique_texts), BATCH_SIZE):
    chunk = unique_texts[start:start + BATCH_SIZE]
    cache.update(dict(zip(chunk, translate_batch(chunk))))
 
# 4. Übersetzungen zurückschreiben, Formeln und Formatierungen unangetastet lassen
for sheet in workbook.worksheets:
    for row in sheet.iter_rows():
        for cell in row:
            if is_translatable(cell):
                cell.value = cache[cell.value]
 
# 5. In eine neue Datei speichern
workbook.save("your_translated_file.xlsx")
print("Done!")

Das ist ein vollständiger, praxistauglicher Übersetzer in deutlich unter 100 Zeilen — schnell, formelsicher und weit günstiger als die Variante, die Zelle für Zelle vorgeht.

Optional: Härtung für echte Arbeitslasten

Das obige Skript ist bereits praxistauglich. Für größere oder wiederkehrende Aufgaben helfen drei weitere Vorkehrungen.

Nicht jede Ausnahme verschlucken. Bei jeder Ausnahme erneut zu versuchen bedeutet, dass auch ein ungültiger API-Schlüssel oder ein falscher Modellname fünfmal wiederholt wird. Versuchen Sie es nur bei Rate-Limits erneut und scheitern Sie bei allem anderen sofort:

from openai import RateLimitError
 
def translate_batch(texts, target_lang=TARGET_LANG, retries=5):
    numbered = {str(i): t for i, t in enumerate(texts)}
    system = (
        f"You are a professional translator. Translate each value in the JSON object "
        f"into {target_lang}. Keep the same keys. Return only a JSON object."
    )
    for attempt in range(retries):
        try:
            response = client.chat.completions.create(
                model=MODEL,
                messages=[
                    {"role": "system", "content": system},
                    {"role": "user", "content": json.dumps(numbered, ensure_ascii=False)},
                ],
                response_format={"type": "json_object"},
            )
            result = json.loads(response.choices[0].message.content)
            missing = [str(i) for i in range(len(texts)) if str(i) not in result]
            if missing:
                raise ValueError(f"Missing translations for keys: {missing}")
            return [result[str(i)] for i in range(len(texts))]
        except RateLimitError:
            wait = 2 ** attempt
            print(f"Rate limited. Retrying in {wait}s...")
            time.sleep(wait)
    raise RuntimeError("Translation failed after several retries.")

Diese Version prüft außerdem, dass das Modell jeden übergebenen Schlüssel zurückgeliefert hat, sodass eine abgeschnittene oder fehlerhafte Antwort laut scheitert, statt stillschweigend Zellen zu verlieren.

Reihenfolge beim Entfernen von Duplikaten beibehalten. Nutzen Sie eine geordnete Duplikatentfernung statt eines Sets, damit Logs und Fehlermeldungen vorhersehbar bleiben:

# vorher: unique_texts = list(unique_texts)  mit einem set()
unique_texts = list(dict.fromkeys(collected_texts))

Python-Skript vs. Doc2Lang: Was sollten Sie nutzen?

Ein eigenes Skript zu schreiben ist mächtig, hat aber echte Grenzen. Hier ein ehrlicher Vergleich:

	Python (Eigenbau)	Doc2Lang
Formatierung & Diagramme	Müssen Sie selbst handhaben; leicht zerstört	Automatisch erhalten
Formeln	Eigene Bedingungen zum Überspringen schreiben	Automatisch übersprungen
Was Sie brauchen	OpenAI-API-Schlüssel + Programmierung	Nur die Datei hochladen
Am besten für	Entwickler, die Massen- oder wiederkehrende Aufgaben automatisieren	Alle, die jetzt eine Datei übersetzt brauchen

Von Doc2Lang aus dem Englischen ins Deutsche übersetzter Finanzbericht mit erhaltenen Diagrammen und Formatierung

Ein englischer Finanzbericht, von Doc2Lang ins Deutsche übersetzt: Säulen- und Liniendiagramme, Formeln, Zahlenformate und Spaltenbreiten bleiben alle erhalten (die Namen der Blattregister bleiben in der Originalsprache und werden nicht übersetzt).

→ Den Excel-Übersetzer ausprobieren — kein API-Schlüssel, kein Code.

Die Faustregel: Wenn Sie wiederkehrende Übersetzungsaufgaben automatisieren möchten, bauen Sie das obige Skript. Wenn Sie nur jetzt sofort eine Tabelle ohne Programmierung übersetzen müssen, nutzen Sie den Excel-Übersetzer — hochladen, übersetzen, herunterladen, mit erhaltener Formatierung.

Häufig gestellte Fragen

Was tun bei einem Rate-Limit-Fehler?
OpenAI legt Rate-Limits anhand Ihrer Konto-Stufe fest. Verwenden Sie das oben gezeigte Retry mit exponentiellem Backoff, verringern Sie Ihre Batch-Größe oder heben Sie Ihre Konto-Stufe an, wenn Sie große Mengen verarbeiten.

Wie übersetze ich in mehrere Sprachen gleichzeitig?
Iterieren Sie über eine Liste von Zielsprachen und führen Sie den gesamten Prozess einmal pro Sprache aus, wobei Sie jedes Ergebnis in eine eigene Datei speichern (zum Beispiel report_ja.xlsx, report_de.xlsx).

Kostet die Nutzung der OpenAI-API Geld?
Ja. Sie zahlen pro verwendetem Token. Das Zwischenspeichern wiederholter Zeichenketten und das Bündeln von Anfragen (beides oben gezeigt) halten die Kosten niedrig. gpt-4o-mini ist für alltägliche Übersetzungen dramatisch günstiger als die größeren Modelle.

Bleiben meine Formatierungen und Formeln erhalten?
Das Skript ändert nur die Werte von Textzellen, daher bleiben grundlegende Zellstile — Schriftarten, Füllungen, Rahmen, Ausrichtung und Zahlenformate — in der Regel erhalten, und Formeln werden übersprungen. openpyxl ist allerdings keine vollwertige Layout-Engine für Excel. Makros, Formen, Diagramme, Bilder, Rich Text innerhalb einer einzelnen Zelle und komplexe Arbeitsmappenfunktionen bleiben möglicherweise nicht perfekt erhalten. Bei .xlsm-Dateien laden Sie mit keep_vba=True und speichern wieder als .xlsm. Wenn ein pixelgenaues Layout wichtiger ist als die Automatisierung, übernimmt ein spezialisiertes Tool diese Fälle automatisch.

Fazit

Mit openpyxl und der OpenAI-API können Sie in deutlich unter 100 Codezeilen einen schnellen, formelsicheren Excel-Übersetzer bauen — ideal, wenn Sie Übersetzungen im großen Maßstab automatisieren müssen.

Wenn Ihre Priorität die Erhaltung des Layouts statt der Automatisierung ist, ist ein spezialisiertes Excel-Übersetzungstool womöglich die bessere Wahl — es bewältigt Diagramme, Formen und Formatierungen, die openpyxl nicht kann.

→ Eine Excel-Datei ohne Code übersetzen