CSV zu JSON: Methoden, Fallstricke und Best Practices

Du hast einen CSV-Export, aber deine API erwartet JSON. Was ist der schnellste Weg, 10.000 Zeilen zu konvertieren, ohne Daten zu verlieren?

Dieser Leitfaden behandelt vier Konvertierungsmethoden (Browser-Tools, JavaScript, Python, CLI), die Gegenrichtung (JSON zu CSV), fünf Fallstricke, die Daten stillschweigend beschädigen, und den Umgang mit Dateien, die zu groß für den Arbeitsspeicher sind.

CSV vs JSON: Wann was verwenden

Beide Formate haben unterschiedliche Stärken:

Dimension	CSV	JSON
Struktur	Flache Tabelle (Zeilen und Spalten)	Verschachtelte Hierarchie (Objekte, Arrays)
Datentypen	Alles ist ein String	string, number, boolean, null
Lesbarkeit	Tabellenkalkulationsfreundlich	Entwicklerfreundlich
Hauptverwendung	Datenexport/-import, Berichte, ETL	APIs, Konfigurationsdateien, NoSQL-Speicher
Dateigröße	Kleiner (keine wiederholten Schlüsselnamen)	Größer (Schlüsselnamen wiederholen sich pro Datensatz)
Schema	Implizit (Kopfzeile)	Explizit (oder JSON Schema verwenden)

Verwende CSV, wenn deine Daten tabellarisch sind und der Konsument eine Tabellenkalkulation oder Datenpipeline ist. Verwende JSON, wenn deine Daten Hierarchie haben oder dein Konsument eine API ist. Die JSON-Ausgabe lässt sich mit einem JSON Formatter validieren.

Wenn dein Projekt entspannte JSON-Formate wie JSON5 oder JSONC für Konfiguration verwendet, lies unseren JSON5- und JSONC-Formatting-Leitfaden für Syntaxunterschiede und Tooling.

4 Wege, CSV zu JSON zu konvertieren

Methode 1 — Browser-basiertes Tool

Für einmalige Konvertierungen ist der Browser-basierte Ansatz der schnellste Weg. Füge dein CSV in einen Online-Konverter ein, erhalte JSON und validiere dann das Ergebnis in einem JSON Formatter, um die Struktur zu bestätigen.

Der Vorteil: Deine Daten verlassen nie deinen Browser. Keine Uploads, keine Server-Verarbeitung, keine Datenschutzbedenken. Das ist wichtig, wenn du mit internen Daten arbeitest, API-Schlüssel in Exporten eingebettet sind oder du etwas hast, das du lieber nicht an einen Drittanbieter-Server senden möchtest.

Am besten für: Kleine Dateien (unter 10 MB), schnelle Einmal-Konvertierungen und nicht-technische Teammitglieder.

Methode 2 — JavaScript / Node.js

Browser (Vanilla JS):

function csvToJson(csv) {
  const lines = csv.trim().split('\n');
  const headers = lines[0].split(',').map(h => h.trim());

  return lines.slice(1).map(line => {
    const values = line.split(',');
    return headers.reduce((obj, header, i) => {
      obj[header] = values[i]?.trim() ?? '';
      return obj;
    }, {});
  });
}

const csv = `name,age,city
Alice,30,New York
Bob,25,London`;

console.log(JSON.stringify(csvToJson(csv), null, 2));

Das funktioniert für einfaches CSV ohne zitierte Felder. Für den Produktionseinsatz mit Kommas in Werten, Zeilenumbrüchen in Feldern oder zitierten Strings verwende einen richtigen Parser.

Node.js (csv-parser + Streams):

import { createReadStream } from 'fs';
import { parse } from 'csv-parse';

const records = [];

createReadStream('data.csv')
  .pipe(parse({ columns: true, trim: true, skip_empty_lines: true }))
  .on('data', (row) => records.push(row))
  .on('end', () => {
    console.log(JSON.stringify(records, null, 2));
  });

Die Option columns: true nutzt die erste Zeile als Schlüssel. Die Option trim entfernt Leerzeichen aus Werten. Dies verarbeitet zitierte Felder, escaped Kommas und mehrzeilige Werte korrekt.

Methode 3 — Python

Standardbibliothek (keine Abhängigkeiten):

import csv
import json

with open('data.csv', encoding='utf-8') as f:
    reader = csv.DictReader(f)
    rows = list(reader)

with open('data.json', 'w', encoding='utf-8') as f:
    json.dump(rows, f, indent=2, ensure_ascii=False)

csv.DictReader ordnet jede Zeile einem Dictionary zu, mit der Kopfzeile als Schlüssel. Das Flag ensure_ascii=False bewahrt Unicode-Zeichen (Chinesisch, Japanisch, Umlaute) statt sie als \uXXXX zu escapen.

Pandas (Einzeiler für Data Scientists):

import pandas as pd

df = pd.read_csv('data.csv')
df.to_json('data.json', orient='records', indent=2, force_ascii=False)

Wann was verwenden:

csv + json: Leichtgewichtige Skripte, Lambda-Funktionen, Container, wo minimale Abhängigkeiten gewünscht sind.
pandas: Wenn du Daten vor der Konvertierung auch bereinigen, filtern oder transformieren musst. Der Overhead des Pandas-Imports lohnt sich, wenn du mehr tust als nur Formatkonvertierung.

Methode 4 — CLI-Tools

Für Shell-Skripte und Automatisierungspipelines:

csvkit:

# Installation: pip install csvkit
csvjson data.csv > data.json

Miller (mlr):

# Installation: brew install miller (macOS) oder apt install miller (Ubuntu)
mlr --csv --json cat data.csv > data.json

Pipe mit jq zum Filtern:

# Konvertieren und filtern in einer Pipeline
csvjson data.csv | jq '[.[] | select(.age | tonumber > 25)]'

Miller ist besonders leistungsfähig, weil es CSV, JSON, TSV und andere Formate nativ verarbeitet. Du kannst Daten während der Konvertierung transformieren:

# CSV zu JSON konvertieren, Feld umbenennen, berechnetes Feld hinzufügen
mlr --csv --json rename name,fullName then put '$age_group = ($age > 30) ? "senior" : "junior"' data.csv

JSON zu CSV: Die Gegenrichtung

Das Konvertieren von JSON zu CSV bringt Herausforderungen mit sich, die in der Vorwärtsrichtung nicht existieren.

Verschachtelte Objekte abflachen

CSV ist von Natur aus flach. Wenn dein JSON verschachtelte Objekte hat, brauchst du eine Abflachungsstrategie:

{
  "name": "Alice",
  "address": {
    "city": "New York",
    "zip": "10001"
  }
}

Wird zu:

name	address.city	address.zip
Alice	New York	10001

Die Punkt-Notation-Konvention (address.city) ist der häufigste Ansatz. In Python:

import pandas as pd

data = [
    {"name": "Alice", "address": {"city": "New York", "zip": "10001"}},
    {"name": "Bob", "address": {"city": "London", "zip": "EC1A"}}
]

df = pd.json_normalize(data)
df.to_csv('output.csv', index=False)
# Spalten: name, address.city, address.zip

Arrays verarbeiten

Array-Felder erfordern eine Entscheidung:

Strategie	Beispieleingabe	CSV-Ausgabe	Am besten für
Als String verbinden	`["admin","editor"]`	`admin;editor`	Einfache Listen, reimportierbar
Zu Spalten erweitern	`["admin","editor"]`	`role_0: admin, role_1: editor`	Arrays fester Länge
Zu Zeilen erweitern	`["admin","editor"]`	Zwei Zeilen, eine pro Rolle	Relationale Analyse

Wähle basierend auf deinem nachgelagerten Konsumenten. Wenn das CSV zurück in eine Datenbank geht, ist das Erweitern zu Zeilen normalerweise am sinnvollsten.

Typinformationsverlust

CSV hat kein Typsystem. Wenn du JSON zu CSV konvertierst:

true wird zum String "true". Ist es ein Boolean oder ein String?
null wird zu einer leeren Zelle, nicht unterscheidbar von einem leeren String ""
42 wird zu "42". Ist es eine Zahl oder ein String?

Wenn Roundtrip-Treue wichtig ist (CSV → Verarbeitung → JSON), dokumentiere deine Typ-Konventionen in einem Header-Kommentar oder einer Begleit-Schemadatei.

5 häufige Fallstricke und wie man sie vermeidet

Diese Probleme beschädigen Daten stillschweigend und fallen oft erst in Produktion auf.

1. Kodierungs-Landminen

Das Problem: Du öffnest ein CSV von einem Kollegen und siehst ÃƒÂ© statt é, oder 锟斤拷 statt chinesischer Zeichen.

Warum es passiert: Die Datei wurde in einer Kodierung gespeichert (Windows-1252, GBK, Shift_JIS), aber dein Parser nimmt UTF-8 an. Excel unter Windows speichert CSV oft als Windows-1252 oder fügt eine UTF-8 BOM (Byte Order Mark, die unsichtbaren \xEF\xBB\xBF am Dateianfang) hinzu.

Die Lösung:

# Kodierung zuerst erkennen
import chardet

with open('data.csv', 'rb') as f:
    result = chardet.detect(f.read(10000))
    print(result)  # {'encoding': 'Windows-1252', 'confidence': 0.73}

# Dann mit der richtigen Kodierung lesen
with open('data.csv', encoding=result['encoding']) as f:
    reader = csv.DictReader(f)
    # ...

In Node.js die BOM explizit entfernen:

import { readFileSync } from 'fs';

let content = readFileSync('data.csv', 'utf-8');
// UTF-8 BOM entfernen, falls vorhanden
if (content.charCodeAt(0) === 0xFEFF) {
  content = content.slice(1);
}

2. Trennzeichen-Verwirrung

Das Problem: Dein Parser erzeugt eine einzige riesige Spalte statt mehrerer Felder.

Warum es passiert: In vielen europäischen Locales (Frankreich, Deutschland, Spanien) verwendet Excel Semikolons (;) als CSV-Trennzeichen, weil Kommas als Dezimaltrennzeichen verwendet werden (z. B. 3,14 statt 3.14). Tab-getrennte Dateien (.tsv) fügen eine weitere Variante hinzu.

Die Lösung: Das Trennzeichen durch Sampling der ersten Zeilen automatisch erkennen:

import csv

with open('data.csv') as f:
    sample = f.read(8192)
    dialect = csv.Sniffer().sniff(sample, delimiters=',;\t|')
    f.seek(0)
    reader = csv.DictReader(f, dialect=dialect)

3. Führende Nullen verschwinden

Das Problem: Postleitzahl 00501 wird zu 501. Produktcode 007 wird zu 7.

Warum es passiert: Der Parser (oder Excel) interpretiert das Feld als Zahl und entfernt führende Nullen. Das ist besonders gefährlich bei Postleitzahlen, Telefonnummern und ID-Codes.

Die Lösung: String-Typisierung erzwingen. In Pandas:

df = pd.read_csv('data.csv', dtype={'zip': str, 'product_code': str})

In JavaScript prüfen, ob der Original-String sich vom numerischen Parse unterscheidet:

function preserveLeadingZeros(value) {
  if (/^0\d+$/.test(value)) return value; // Als String behalten
  const num = Number(value);
  return isNaN(num) ? value : num;
}

4. Präzisionsverlust bei großen Zahlen

Das Problem: ID 9007199254740993 wird zu 9007199254740992 in deinem JSON.

Warum es passiert: JavaScript Number ist ein 64-Bit-Float (IEEE 754). Ganzzahlen über Number.MAX_SAFE_INTEGER (2^53 - 1 = 9007199254740991) verlieren Präzision. Betroffen sind Datenbank-IDs, Snowflake IDs und Twitter/X-Post-IDs.

Die Lösung: Große Zahlen als Strings in JSON behalten, oder BigInt im Verarbeitungscode verwenden:

// Parse mit String-Bewahrung für große Zahlen
function safeParseNumber(value) {
  const num = Number(value);
  if (Number.isInteger(num) && !Number.isSafeInteger(num)) {
    return value; // Als String behalten, um Präzision zu bewahren
  }
  return isNaN(num) ? value : num;
}

5. Leere-Werte-Mehrdeutigkeit

Das Problem: Dein CSV hat leere Zellen. Nach der Konvertierung kannst du nicht unterscheiden, ob der ursprüngliche Wert ein leerer String "", null oder einfach fehlend war.

Warum es passiert: CSV kann nicht zwischen diesen drei Zuständen unterscheiden. Ein leeres Feld zwischen zwei Kommas (Alice,,30) könnte alles davon bedeuten.

Die Lösung: Eine Konvention definieren und konsequent anwenden:

def parse_value(value):
    if value == '':
        return None        # oder '' — wähle eine Konvention
    if value == 'NULL' or value == 'null':
        return None
    return value

Wenn deine Daten Sentinel-Werte wie NULL, N/A oder - verwenden, dokumentiere und behandle sie explizit.

Große Dateien streamen

Wenn dein CSV 100 MB überschreitet, ist das vollständige Laden in den Arbeitsspeicher keine Option. Verwende Streaming.

Node.js (Stream-Pipeline):

import { createReadStream, createWriteStream } from 'fs';
import { parse } from 'csv-parse';
import { Transform } from 'stream';
import { pipeline } from 'stream/promises';

let first = true;
const toJsonArray = new Transform({
  objectMode: true,
  transform(record, encoding, callback) {
    const prefix = first ? '[\n' : ',\n';
    first = false;
    callback(null, prefix + JSON.stringify(record));
  },
  flush(callback) {
    callback(null, '\n]');
  }
});

await pipeline(
  createReadStream('large.csv'),
  parse({ columns: true, trim: true }),
  toJsonArray,
  createWriteStream('large.json')
);

Python (Generator):

import csv
import json

def csv_rows(path):
    with open(path, encoding='utf-8') as f:
        reader = csv.DictReader(f)
        for row in reader:
            yield row

# Stream zu JSON Lines Format (ein JSON-Objekt pro Zeile)
with open('large.jsonl', 'w', encoding='utf-8') as out:
    for row in csv_rows('large.csv'):
        out.write(json.dumps(row, ensure_ascii=False) + '\n')

Für sehr große Dateien erwäge JSON Lines (.jsonl) statt eines einzelnen JSON-Arrays. Jede Zeile ist ein unabhängiges JSON-Objekt, was bedeutet, dass du die Ausgabedatei auch zeilenweise verarbeiten kannst, ohne die gesamte Datei zu parsen.

FAQ

Was ist der Unterschied zwischen CSV und JSON?

CSV (Comma-Separated Values) speichert Daten als flache Tabelle, in der jeder Wert ein String ist. JSON (JavaScript Object Notation) speichert strukturierte Daten mit verschachtelten Objekten, Arrays und typisierten Werten (Strings, Zahlen, Booleans, null). CSV ist kleiner und tabellenkalkulationsfreundlich; JSON ist ausdrucksstärker und API-freundlich.

Wie konvertiere ich CSV zu JSON in JavaScript?

Verwende das csv-parse-Paket in Node.js: Lies die Datei mit createReadStream, leite sie durch parse({ columns: true }) und sammle die Ergebnisse. Für Browser-Nutzung lies die Datei mit FileReader, teile nach Zeilenumbrüchen und ordne Zeilen mithilfe der Kopfzeile als Schlüssel Objekten zu.

Wie konvertiere ich CSV zu JSON in Python?

Verwende csv.DictReader aus der Standardbibliothek, um Zeilen als Dictionaries zu lesen, dann json.dump() zum Schreiben als JSON-Array. Für Datenmanipulation vor der Konvertierung ist pandas.read_csv() gefolgt von df.to_json(orient='records') eine Einzeiler-Alternative.

Kann verschachteltes JSON zu CSV konvertiert werden?

Ja, aber du brauchst eine Abflachungsstrategie. Der häufigste Ansatz nutzt Punkt-Notation: Ein Feld wie address.city wird zu einem Spaltenheader. In Python verarbeitet pandas.json_normalize() das automatisch. Arrays erfordern zusätzliche Entscheidungen: als Strings verbinden, zu Spalten erweitern oder zu Zeilen erweitern.

Warum hat mein CSV nach der Konvertierung unleserliche Zeichen?

Kodierungskonflikte. Die Datei wurde wahrscheinlich in Windows-1252 oder GBK gespeichert, aber dein Parser nimmt UTF-8 an. Verwende eine Erkennungsbibliothek wie chardet (Python), um die Kodierung zu identifizieren, und gib sie dann beim Lesen explizit an. Prüfe auch auf eine UTF-8 BOM, die manche Tools automatisch hinzufügen.

Wie verarbeite ich eine CSV-Datei größer als 100 MB?

Verwende Streaming statt die gesamte Datei in den Arbeitsspeicher zu laden. In Node.js leite durch csv-parse mit Streams. In Python iteriere mit csv.DictReader über einen Generator. Erwäge die Ausgabe im JSON-Lines-Format (.jsonl) statt eines einzelnen JSON-Arrays für einfachere nachgelagerte Verarbeitung.

Wie kann ich verifizieren, dass mein konvertiertes JSON gültig ist?

Füge die Ausgabe in einen Online-JSON Formatter ein, um Syntax, Struktur und Verschachtelung zu prüfen. Für automatisierte Validierung verwende JSON.parse() in JavaScript oder json.loads() in Python. Beide werfen klare Fehler bei ungültiger Eingabe. Für Schema-Validierung definiere ein JSON Schema und validiere programmatisch.

Wichtige Erkenntnisse

Browser-Tools für schnelle Einmalaufgaben, Code für Automatisierung, CLI für Pipelines.
Kodierung immer explizit angeben, statt dich auf Standards zu verlassen.
Führende Nullen, große Ganzzahlen und null-Werte brauchen explizite Behandlung.
Große Dateien streamen statt in den Arbeitsspeicher laden. JSON Lines Format für sehr große Datensätze.
Konvertiertes JSON mit einem JSON Formatter validieren, bevor es in Produktion geht.

CSV zu JSON: Methoden, Fallstricke und Code-Beispiele