JSON in Excel konvertieren: Vollständiger Leitfaden mit Tools

# JSON in Excel konvertieren: Vollständiger Leitfaden

Erfahren Sie, wie Sie JSON-Daten effizient in Excel-Tabellen umwandeln.

Warum JSON zu Excel konvertieren?

Vorteile

• 📊 Datenanalyse - Excel bietet mächtige Analysewerkzeuge
• 👥 Zusammenarbeit - Excel ist universell bekannt
• 📈 Visualisierung - Diagramme und Pivot-Tabellen
• 💼 Reporting - Professionelle Berichte erstellen
• 🔢 Berechnungen - Formeln und Funktionen

Methode 1: Online-Konverter

Schritt-für-Schritt mit Big JSON

Besuchen Sie Big JSON Tool

Fügen Sie Ihr JSON ein

Klicken Sie auf "Zu Excel konvertieren"

Laden Sie die Excel-Datei herunter

Beispiel-JSON:

[
  {
    "name": "Max Mustermann",
    "alter": 30,
    "stadt": "Berlin",
    "gehalt": 50000
  },
  {
    "name": "Anna Schmidt",
    "alter": 28,
    "stadt": "München",
    "gehalt": 55000
  }
]

Resultat in Excel:

| name | alter | stadt | gehalt |

|------|-------|-------|--------|

| Max Mustermann | 30 | Berlin | 50000 |

| Anna Schmidt | 28 | München | 55000 |

Methode 2: Excel Power Query

Für Excel 2016 und später

Schritt 1: JSON-Datei vorbereiten

[
  {"produkt": "Laptop", "preis": 899, "lager": 45},
  {"produkt": "Maus", "preis": 29, "lager": 150},
  {"produkt": "Tastatur", "preis": 79, "lager": 80}
]

Schritt 2: In Excel importieren

Öffnen Sie Excel

Gehen Sie zu Daten → Daten abrufen → Aus Datei → Aus JSON

Wählen Sie Ihre JSON-Datei

Power Query Editor öffnet sich

Klicken Sie auf In Tabelle konvertieren

Erweitern Sie die Spalten

Klicken Sie auf Schließen & Laden

Verschachtelte JSON-Daten

JSON mit Verschachtelung:

[
  {
    "name": "Max",
    "adresse": {
      "straße": "Hauptstraße 1",
      "stadt": "Berlin",
      "plz": "10115"
    }
  }
]

In Power Query:

Importieren Sie das JSON

Klicken Sie auf den Erweiterungs-Button neben "adresse"

Wählen Sie die Felder aus: straße, stadt, plz

Resultat: Flache Tabelle mit allen Feldern

Methode 3: Python-Scripts

Einfache Konvertierung mit pandas

import pandas as pd
import json

# JSON-Datei laden
with open('daten.json', 'r', encoding='utf-8') as f:
    data = json.load(f)

# Zu DataFrame konvertieren
df = pd.DataFrame(data)

# Als Excel speichern
df.to_excel('ausgabe.xlsx', index=False, sheet_name='Daten')

print("✅ Excel-Datei erstellt!")

Mit Formatierung

import pandas as pd
import json
from openpyxl import load_workbook
from openpyxl.styles import Font, PatternFill, Alignment

# JSON laden und zu Excel konvertieren
with open('daten.json', 'r', encoding='utf-8') as f:
    data = json.load(f)

df = pd.DataFrame(data)
dateiname = 'formatiert.xlsx'

# Excel schreiben
df.to_excel(dateiname, index=False, sheet_name='Daten')

# Formatierung hinzufügen
wb = load_workbook(dateiname)
ws = wb.active

# Header formatieren
header_fill = PatternFill(start_color="366092", end_color="366092", fill_type="solid")
header_font = Font(color="FFFFFF", bold=True)

for cell in ws[1]:
    cell.fill = header_fill
    cell.font = header_font
    cell.alignment = Alignment(horizontal="center")

# Spaltenbreite anpassen
for column in ws.columns:
    max_length = 0
    column_letter = column[0].column_letter
    for cell in column:
        if cell.value:
            max_length = max(max_length, len(str(cell.value)))
    ws.column_dimensions[column_letter].width = max_length + 2

wb.save(dateiname)
print("✅ Formatierte Excel-Datei erstellt!")

Verschachtelte JSON-Daten normalisieren

import pandas as pd
from pandas import json_normalize

# Verschachtelte JSON-Daten
json_data = '''
[
  {
    "name": "Max",
    "alter": 30,
    "adresse": {
      "stadt": "Berlin",
      "land": "Deutschland"
    },
    "hobbys": ["Programmieren", "Musik"]
  }
]
'''

data = json.loads(json_data)

# Normalisieren (flache Struktur)
df = json_normalize(data)

# Zu Excel
df.to_excel('normalisiert.xlsx', index=False)

# Resultat: Spalten wie 'name', 'alter', 'adresse.stadt', 'adresse.land', 'hobbys'

Mehrere Sheets

import pandas as pd
import json

# JSON mit mehreren Kategorien
with open('daten.json', 'r', encoding='utf-8') as f:
    data = json.load(f)

# Excel-Writer erstellen
with pd.ExcelWriter('multi_sheet.xlsx', engine='openpyxl') as writer:
    # Benutzer-Sheet
    if 'benutzer' in data:
        df_benutzer = pd.DataFrame(data['benutzer'])
        df_benutzer.to_excel(writer, sheet_name='Benutzer', index=False)

    # Produkte-Sheet
    if 'produkte' in data:
        df_produkte = pd.DataFrame(data['produkte'])
        df_produkte.to_excel(writer, sheet_name='Produkte', index=False)

    # Bestellungen-Sheet
    if 'bestellungen' in data:
        df_bestellungen = pd.DataFrame(data['bestellungen'])
        df_bestellungen.to_excel(writer, sheet_name='Bestellungen', index=False)

print("✅ Multi-Sheet Excel erstellt!")

Methode 4: JavaScript/Node.js

Mit xlsx-Bibliothek

const XLSX = require('xlsx');
const fs = require('fs');

// JSON-Datei lesen
const jsonData = JSON.parse(fs.readFileSync('daten.json', 'utf8'));

// Workbook erstellen
const wb = XLSX.utils.book_new();

// JSON zu Worksheet konvertieren
const ws = XLSX.utils.json_to_sheet(jsonData);

// Worksheet zu Workbook hinzufügen
XLSX.utils.book_append_sheet(wb, ws, 'Daten');

// Excel-Datei schreiben
XLSX.writeFile(wb, 'ausgabe.xlsx');

console.log('✅ Excel-Datei erstellt!');

Mit Formatierung

const XLSX = require('xlsx');
const fs = require('fs');

const jsonData = JSON.parse(fs.readFileSync('daten.json', 'utf8'));

// Workbook und Worksheet erstellen
const wb = XLSX.utils.book_new();
const ws = XLSX.utils.json_to_sheet(jsonData);

// Spaltenbreite setzen
const wscols = [
  { wch: 20 }, // Spalte A
  { wch: 10 }, // Spalte B
  { wch: 15 }  // Spalte C
];
ws['!cols'] = wscols;

// Workbook zusammenbauen
XLSX.utils.book_append_sheet(wb, ws, 'Daten');

// Schreiben
XLSX.writeFile(wb, 'formatiert.xlsx');

Verschachtelte Daten flatten

const XLSX = require('xlsx');
const fs = require('fs');

function flattenObject(obj, prefix = '') {
  const flattened = {};

  for (const [key, value] of Object.entries(obj)) {
    const newKey = prefix ? \\${prefix}.\\${key} : key;

    if (value && typeof value === 'object' && !Array.isArray(value)) {
      Object.assign(flattened, flattenObject(value, newKey));
    } else if (Array.isArray(value)) {
      flattened[newKey] = value.join(', ');
    } else {
      flattened[newKey] = value;
    }
  }

  return flattened;
}

// JSON laden
const jsonData = JSON.parse(fs.readFileSync('verschachtelt.json', 'utf8'));

// Flatten
const flatData = jsonData.map(item => flattenObject(item));

// Zu Excel
const wb = XLSX.utils.book_new();
const ws = XLSX.utils.json_to_sheet(flatData);
XLSX.utils.book_append_sheet(wb, ws, 'Daten');
XLSX.writeFile(wb, 'geflattert.xlsx');

Methode 5: CSV als Zwischenschritt

JSON zu CSV zu Excel

import pandas as pd
import json

# JSON laden
with open('daten.json', 'r', encoding='utf-8') as f:
    data = json.load(f)

df = pd.DataFrame(data)

# Zu CSV (für Excel-Import)
df.to_csv('daten.csv', index=False, encoding='utf-8-sig')  # utf-8-sig für Excel

# Oder direkt zu Excel
df.to_excel('daten.xlsx', index=False)

CSV in Excel öffnen

Speichern Sie als CSV

In Excel: Daten → Aus Text/CSV

Wählen Sie die Datei

Trennzeichen: Komma

Laden klicken

Spezielle Fälle

Große JSON-Dateien

import pandas as pd
import json

# Chunked Processing für große Dateien
def json_zu_excel_chunks(json_datei, excel_datei, chunk_size=10000):
    with open(json_datei, 'r', encoding='utf-8') as f:
        data = json.load(f)

    # In Chunks aufteilen
    with pd.ExcelWriter(excel_datei, engine='openpyxl') as writer:
        for i in range(0, len(data), chunk_size):
            chunk = data[i:i + chunk_size]
            df = pd.DataFrame(chunk)

            # Sheet-Name mit Chunk-Nummer
            sheet_name = f'Daten_{i // chunk_size + 1}'
            df.to_excel(writer, sheet_name=sheet_name, index=False)

    print(f"✅ {len(data)} Zeilen in {(len(data) - 1) // chunk_size + 1} Sheets geschrieben")

json_zu_excel_chunks('grosse_datei.json', 'ausgabe.xlsx')

Arrays und Listen

import pandas as pd

# JSON mit Arrays
data = [
    {
        "name": "Max",
        "skills": ["Python", "JavaScript", "Docker"]
    }
]

df = pd.DataFrame(data)

# Arrays als Komma-getrennte Strings
df['skills'] = df['skills'].apply(lambda x: ', '.join(x))

df.to_excel('mit_arrays.xlsx', index=False)

Mehrere verschachtelte Ebenen

import pandas as pd
from pandas import json_normalize

json_data = [
    {
        "firma": "TechCorp",
        "mitarbeiter": [
            {
                "name": "Max",
                "projekte": [
                    {"name": "Projekt A", "status": "aktiv"},
                    {"name": "Projekt B", "status": "abgeschlossen"}
                ]
            }
        ]
    }
]

# Mehrfach normalisieren
df_mitarbeiter = json_normalize(
    json_data,
    record_path=['mitarbeiter'],
    meta=['firma']
)

df_projekte = json_normalize(
    json_data,
    record_path=['mitarbeiter', 'projekte'],
    meta=['firma', ['mitarbeiter', 'name']],
    meta_prefix='mitarbeiter_'
)

# Beide als Sheets speichern
with pd.ExcelWriter('hierarchisch.xlsx') as writer:
    df_mitarbeiter.to_excel(writer, sheet_name='Mitarbeiter', index=False)
    df_projekte.to_excel(writer, sheet_name='Projekte', index=False)

Automatisierung

Batch-Konvertierung

import pandas as pd
import json
from pathlib import Path

def konvertiere_alle_json_zu_excel(quell_ordner, ziel_ordner):
    """Konvertiert alle JSON-Dateien in einem Ordner zu Excel"""
    quell_pfad = Path(quell_ordner)
    ziel_pfad = Path(ziel_ordner)
    ziel_pfad.mkdir(exist_ok=True)

    for json_datei in quell_pfad.glob('*.json'):
        try:
            with open(json_datei, 'r', encoding='utf-8') as f:
                data = json.load(f)

            df = pd.DataFrame(data)

            excel_datei = ziel_pfad / f'{json_datei.stem}.xlsx'
            df.to_excel(excel_datei, index=False)

            print(f'✅ {json_datei.name} → {excel_datei.name}')
        except Exception as e:
            print(f'❌ Fehler bei {json_datei.name}: {e}')

# Verwendung
konvertiere_alle_json_zu_excel('json_dateien', 'excel_dateien')

Mit Kommandozeilen-Script

#!/usr/bin/env python3
import sys
import pandas as pd
import json

def main():
    if len(sys.argv) != 3:
        print("Verwendung: python json_to_excel.py <input.json> <output.xlsx>")
        sys.exit(1)

    input_file = sys.argv[1]
    output_file = sys.argv[2]

    try:
        with open(input_file, 'r', encoding='utf-8') as f:
            data = json.load(f)

        df = pd.DataFrame(data)
        df.to_excel(output_file, index=False)

        print(f"✅ {input_file} → {output_file}")
        print(f"   {len(df)} Zeilen, {len(df.columns)} Spalten")
    except Exception as e:
        print(f"❌ Fehler: {e}")
        sys.exit(1)

if __name__ == '__main__':
    main()

Verwendung:

python json_to_excel.py daten.json ausgabe.xlsx

Qualitätssicherung

Datenvalidierung

import pandas as pd
import json

def validiere_und_konvertiere(json_datei, excel_datei):
    """Validiert JSON-Daten vor der Konvertierung"""
    with open(json_datei, 'r', encoding='utf-8') as f:
        data = json.load(f)

    # Prüfe, ob es eine Liste ist
    if not isinstance(data, list):
        raise ValueError("JSON muss ein Array sein")

    # Prüfe, ob alle Elemente Objekte sind
    if not all(isinstance(item, dict) for item in data):
        raise ValueError("Alle Array-Elemente müssen Objekte sein")

    # Erstelle DataFrame
    df = pd.DataFrame(data)

    # Validierung
    print(f"Zeilen: {len(df)}")
    print(f"Spalten: {len(df.columns)}")
    print(f"Fehlende Werte: {df.isnull().sum().sum()}")

    # Datentypen
    print("\nDatentypen:")
    print(df.dtypes)

    # Zu Excel
    df.to_excel(excel_datei, index=False)
    print(f"\n✅ Excel-Datei erstellt: {excel_datei}")

validiere_und_konvertiere('daten.json', 'validiert.xlsx')

Best Practices

1. Datenstruktur vorbereiten

# ✅ Gut - Flache Array-Struktur
[
  {"name": "Max", "alter": 30, "stadt": "Berlin"},
  {"name": "Anna", "alter": 28, "stadt": "München"}
]

# ⚠️ Schwieriger - Verschachtelt
{
  "benutzer": {
    "aktiv": [
      {"name": "Max", "details": {"alter": 30}}
    ]
  }
}

2. Konsistente Feldnamen

# ✅ Gut - Alle Objekte haben gleiche Felder
[
  {"name": "Max", "alter": 30, "stadt": "Berlin"},
  {"name": "Anna", "alter": 28, "stadt": "München"}
]

# ❌ Schlecht - Inkonsistent
[
  {"name": "Max", "age": 30},
  {"name": "Anna", "alter": 28, "city": "München"}
]

3. Spaltenreihenfolge festlegen

import pandas as pd

df = pd.DataFrame(data)

# Spaltenreihenfolge festlegen
gewuenschte_reihenfolge = ['id', 'name', 'email', 'alter', 'stadt']
df = df[gewuenschte_reihenfolge]

df.to_excel('sortiert.xlsx', index=False)

4. Datentypen erhalten

import pandas as pd
import json

with open('daten.json', 'r') as f:
    data = json.load(f)

df = pd.DataFrame(data)

# Datums-Strings zu Datum konvertieren
if 'datum' in df.columns:
    df['datum'] = pd.to_datetime(df['datum'])

# Zahlen mit Tausendertrennzeichen
if 'gehalt' in df.columns:
    df['gehalt'] = df['gehalt'].apply(lambda x: f'{x:,.2f}')

df.to_excel('typisiert.xlsx', index=False)

Zusammenfassung

Schnellreferenz

| Methode | Vorteile | Nachteile |

|---------|----------|-----------|

| Excel Power Query | Keine Programmierung | Nur für Excel 2016+ |

| Python pandas | Sehr flexibel | Programmierung nötig |

| Node.js xlsx | JavaScript-Umgebung | Setup erforderlich |

| Online-Tools | Schnell & einfach | Größenlimit |

Empfohlene Tools

Kleine Dateien → Online-Konverter

Große Dateien → Python pandas

Automatisierung → Python-Script

Excel-Benutzer → Power Query

Checkliste

✅ JSON-Struktur validieren

✅ Verschachtelung auflösen

✅ Feldnamen konsistent halten

✅ Datentypen prüfen

✅ Große Dateien in Chunks verarbeiten

✅ Formatierung bei Bedarf hinzufügen

Weiterführende Ressourcen

• JSON Online-Tools
• Python und JSON
• Arbeiten mit großen JSON-Dateien
• JSON-Dateien erklärt