JSON-Text einrücken
Machen Sie aus einer gedrängten Datenzeile sauber eingerückten Text: Das Beispiel mit 53 Byte kommt als 79 lesbare Byte zurück, mit zwei Leerzeichen pro Ebene. Jeder Fehler wird mit seiner genauen Position gemeldet, statt dass geraten wird. Kostenlos in Ihrem Browser.
- Kostenlos
- Läuft in Ihrem Browser
- Ohne Anmeldung
- Ihre Daten bleiben auf Ihrem Gerät
Im Browser ausführen – kostenlos
Rechenbeispiel
- Text
- {"name":"Ada","skills":["math","code"],"active":true}
- Einzug
- 2
- Eingabe-Bytes
- 53
- Ausgabe-Bytes
- 79
Einrückung und Parse-Fehlerposition
Warum vor dem Einrücken geprüft wird
Ein Werkzeug, das nur Zeilenumbrüche einfügt, weiß nicht, ob die Daten in Ordnung sind. Dieses liest zuerst den gesamten Text mit der Strenge eines Programms und schreibt ihn erst danach mit einer festen Zahl von Leerzeichen pro Ebene neu. Genau dieses Lesen stellt sicher, dass jede geschweifte Klammer ihr Gegenstück hat, jeder Text in Anführungszeichen geschlossen ist, alle Zahlen gültig sind und kein Komma am Ende einer Liste übrig bleibt. Schlägt etwas fehl, erhalten Sie die Position des Zeichens, an dem das Lesen abbrach, und springen direkt zum falschen Komma, Anführungszeichen oder Rest, statt eine endlose Zeile mit den Augen abzusuchen.
Lesen, prüfen oder verdichten
Zwei oder vier Leerzeichen sind üblich, wenn ein Mensch das Ergebnis liest, etwa bei einer Code-Durchsicht, in einer Supportanfrage oder in einem Protokollauszug. Mit null Leerzeichen geschieht das Gegenteil: Besteht der Text die Prüfung, kommt alles in einer einzigen kompakten Zeile zurück, sodass Sie in einem Schritt prüfen und verkleinern. Das Werkzeug repariert nie kaputte Daten und sortiert nichts um: Was gültig hineingeht, kommt mit demselben Inhalt und nur mit neuen Abständen heraus. Wenn Sie gewöhnlichen Text in dieses Format umwandeln möchten, ist das die Aufgabe eines anderen Werkzeugs.
Im Gegensatz zu einem rein visuellen Formatierer, der nur Zeilenumbrüche einfügt ohne die Struktur zu verstehen, muss ein echter Pretty-Printer zuerst parsen: erst dann kann er garantieren, dass Klammern passen, Zeichenketten geschlossen sind, Zahlen gültig sind und abschließende Kommas abgelehnt werden. Indent null ergibt nach erfolgreichem Parse eine kompakte einzeilige Serialisierung—nützlich, wenn Sie Validierung und Minifizierung in einem Schritt wollen. Zwei oder vier Leerzeichen sind die üblichen Wahlen für menschliche Prüfung.
Byte-Zählungen für Ein- und Ausgabe sind enthalten, damit Pipelines Expansionsverhältnisse protokollieren können, wenn große minifizierte Blobs zu mehrzeiligen Dokumenten werden.
Häufige Fragen
Was bewirkt indent 0?
Die Zeichenkette wird zuerst vollständig geparst, daher schlägt ungültige Eingabe weiterhin mit einer Position fehl.
Warum meldet das Werkzeug, dass mein Text ungültig ist?
Weil das strenge Lesen an einem bestimmten Zeichen abgebrochen ist und Ihnen das Werkzeug dessen Position nennt. Meist ist es ein überzähliges Komma am Ende einer Liste, ein nicht geschlossenes Anführungszeichen oder eine Klammer ohne Gegenstück. Korrigieren Sie die Stelle und versuchen Sie es erneut.
Sind zwei oder vier Leerzeichen Einrückung besser?
Beides sind die üblichen Werte, wenn ein Mensch das Ergebnis prüft. Ohne Angabe verwendet das Werkzeug zwei Leerzeichen pro Ebene, und Sie können jeden Wert von 0 bis 8 wählen.
Ändert die Formatierung die Reihenfolge oder den Inhalt meiner Daten?
Nein. Es ändern sich nur Leerzeichen und Zeilenumbrüche. Das Werkzeug sortiert keine Namen um, repariert nichts Kaputtes und holt nichts von außerhalb Ihres Textes, der Inhalt bleibt also identisch.
Um wie viel wächst der Text durch das Einrücken?
Das Werkzeug zeigt die Größe vorher und nachher in Byte. Im Beispiel werden aus 53 Byte mit zwei Leerzeichen pro Ebene 79 Byte: Den Unterschied machen die Zeilenumbrüche und die Einrückung aus.
Verwandte Tools
Für Entwickler — API-Zugang
Alles auf dieser Seite ist auch per API verfügbar. Dieser Abschnitt richtet sich an Teams, die es in ihre eigenen Systeme einbinden möchten; alle anderen nutzen einfach das Tool oben.
Endpunkt
Authentifizierung per Bearer-Token. Ein einziger POST stellt die Aufgabe in die Warteschlange; das Ergebnis erhalten Sie per Webhook oder über einen signierten Link.
Aufruf aus Ihrem Stack
curl -X POST https://api.kit.forhosting.com/text/json-pretty-print \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"{\"name\":\"Ada\",\"skills\":[\"math\",\"code\"],\"active\":true}"}'const res = await fetch("https://api.kit.forhosting.com/text/json-pretty-print", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "{\"name\":\"Ada\",\"skills\":[\"math\",\"code\"],\"active\":true}"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/text/json-pretty-print",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "{\"name\":\"Ada\",\"skills\":[\"math\",\"code\"],\"active\":true}"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/json-pretty-print", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"{\\"name\\":\\"Ada\\",\\"skills\\":[\\"math\\",\\"code\\"],\\"active\\":true}"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"{\"name\":\"Ada\",\"skills\":[\"math\",\"code\"],\"active\":true}"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/json-pretty-print", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Beispiel-Anfrage
{
"text": "{\"name\":\"Ada\",\"skills\":[\"math\",\"code\"],\"active\":true}"
}Beispiel-Antwort
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "text.json_pretty_print",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}Die API arbeitet asynchron: Sie erhalten sofort eine task_id. Polling ist mit 1 Anfrage pro Sekunde erlaubt.
Preis
Der Preis steht auf der Seite – keine Tokens, keine Credits. Fehlgeschlagene Aufgaben werden nicht berechnet.
Limits
max_tokens | 20000 |
Fehler
| HTTP | Code | Bedeutung |
|---|---|---|
401 | unauthorized | Der API-Schlüssel fehlt oder ist ungültig – prüfen Sie den Authorization-Header (Bearer). |
402 | insufficient_balance | Ihr Guthaben reicht für diese Aufgabe nicht aus – Aufladungen verfallen nicht. |
404 | unknown_type | Unbekannter Aufgabentyp – prüfen Sie das Feld „type“ gegen den Katalog. |
429 | rate_limited | Zu viele Anfragen – warten Sie kurz; Polling ist mit 1 Anfrage pro Sekunde erlaubt. |
Technische Hinweise
Minifizierter, einzeiliger oder uneinheitlich eingerückter JSON-Text ist in Code-Reviews, Support-Tickets und Log-Dumps schwer lesbar. Dieses Werkzeug zum Pretty-Print von JSON-Text nimmt eine rohe JSON-Zeichenkette entgegen, validiert sie mit striktem Parsing und serialisiert den Wert mit konsistenter Leerzeichen-Einrückung neu, damit verschachtelte Objekte und Arrays vorhersehbar ausgerichtet sind. Ist die Nutzlast ungültig, schlägt die Aufgabe mit invalid_input fehl und meldet die Zeichenposition des Parse-Fehlers, damit Sie direkt zum falschen Komma, Anführungszeichen oder Restfragment springen können. Keine Schlüssel-Umsortierung jenseits der Standard-JSON-Serialisierung, keine Netzwerkrundreisen und keine Modell-Tokens—nur deterministisches Parse und Stringify zum veröffentlichten Basispreis $0.002 pro erfolgreichem Aufruf.
Was Pretty-Printing einer JSON-Zeichenkette tatsächlich leistet
JSON-Text hübsch zu formatieren bedeutet, eine Zeichenkette, die JSON sein will, in einen Wert zu parsen und diesen Wert mit einer festen Anzahl Leerzeichen pro Verschachtelungsebene wieder auszugeben. Diese Fähigkeit nimmt Ihr text-Feld als Quellzeichenkette, führt ein strikt JSON-Parse aus und liefert ein neues text-Feld mit konsistenter Einrückung, gesteuert durch den optionalen Parameter indent (Ganzzahl von null bis acht, Standard zwei Leerzeichen). Der Algorithmus holt keine fernen Schemas, repariert kein defektes JSON und ordnet Objektschlüssel nicht um jenseits der natürlichen Serialisierungsreihenfolge der Engine über dem geparsten Objekt. Diese Zurückhaltung hält den Vertrag einfach: gültig rein, hübsch raus; ungültig rein, klarer Fehler mit Position.
Eingabevertrag, Antwortfelder und Parse-Fehlerpositionen
Optional senden Sie indent als Ganzzahl zwischen null und acht; lassen Sie es weg, um zwei Leerzeichen zu nutzen. Schlägt das Parse fehl, enthält die Fehlermeldung immer eine Zeichenposition: Engines, die „at position N“ melden, werden mit diesem N widergespiegelt, unvollständige Eingabe wird auf das Ende der Zeichenkette abgebildet, und andere Fehler defaulten auf Position null, damit Clients stets ein Cursor-Ziel haben. Koppeln Sie diesen Endpunkt mit Editor oder Log-Viewer, indem Sie zum gemeldeten Offset springen; ein zweiter Validierungsaufruf ist nicht nötig. Senden Sie per POST einen JSON-Körper mit einer erforderlichen text-Zeichenkette, die das zu formatierende Dokument enthält. Leerer text, Nicht-String und indent außerhalb des Bereichs scheitern mit invalid_input und werden nicht abgerechnet. Bei Erfolg enthält die Antwort text (das formatierte Dokument), indent (die tatsächlich genutzte Einrückung), bytes_in (UTF-8-Länge der Quellzeichenkette) und bytes_out (UTF-8-Länge des formatierten Ergebnisses). Beispiel: text gleich einem minifizierten Objekt mit verschachtelten Arrays und indent gleich zwei liefert mehrzeiliges JSON mit Zwei-Leerzeichen-Schritten und passenden Klammern. Fehlerbeispiel: ein abgeschnittenes Objekt ohne schließende Klammer ergibt invalid_input mit Position nahe dem Ende des Fragments.
Wo Pretty-Print von JSON-Text seinen Nutzen zeigt
CI-Jobs können Konfigurationsdateien ablehnen oder umschreiben, die minifiziert von Upstream-Generatoren kommen, und schnell mit einer Parse-Position scheitern, wenn ein Release-Artefakt mitten im Upload abgeschnitten wird. Fehlgeschlagene Validierung wird nicht abgerechnet. Entwickler fügen API-Antworten in Chats und Tickets ein; Pretty-Print von JSON-Text verwandelt undurchsichtige Einzeiler in prüfbare Bäume, ohne einen Desktop-Formatierer zu installieren. Support-Tools zeigen Kunden den genauen Offset eines fehlerhaften Webhook-Körpers statt eines generischen Banners „ungültiges JSON“. Weil die Implementierung reines Parse der Stufe A ist, kostet jeder erfolgreiche Aufruf den veröffentlichten Basispreis $0.002 ohne Modell-Tokens und ohne ausgehendes Netz. Bevorzugen Sie diesen Text-ein, Text-aus-Vertrag, wenn Ihre Pipeline JSON bereits als Zeichenkette hält—Logs, Dateiinhalte, Nachrichtenkörper—statt als vorgeparstes Objekt.
Integrationsbeispiele
Lesbare API- und Webhook-Dumps
Wandeln Sie minifizierte Anfrage- oder Antwortkörper in eingerücktes JSON für Tickets, Chats und Post-mortems um, mit Parse-Position wenn der Dump abgeschnitten ist.
CI-Config- und Fixture-Prüfungen
Validieren und formatieren Sie JSON-Fixtures in Pipelines; lassen Sie den Job mit invalid_input und einem Zeichen-Offset scheitern, wenn ein Generator kaputte Syntax liefert.
Support und Sprung zum Fehler im Editor
Zeigen Sie Support-Agenten und Nutzern die exakte Zeichenposition eines JSON-Syntaxfehlers, damit Kommas, Anführungszeichen oder fehlende Klammern schnell behoben werden.
Technische Fragen
Wie formatiere ich eine JSON-Zeichenkette hübsch?
Senden Sie das JSON im Feld text und setzen Sie optional indent (0–8, Standard 2). Bei Erfolg erhalten Sie eingerückten text sowie bytes_in und bytes_out.
Was passiert, wenn das JSON ungültig ist?
Die Aufgabe schlägt mit invalid_input fehl und die Meldung enthält die Zeichenposition des Parse-Fehlers, damit Sie das falsche Token finden. Ungültige Eingabe wird nicht abgerechnet.
Sortiert Pretty-Print von JSON-Text Objektschlüssel?
Nein. Schlüssel behalten die natürliche Reihenfolge der Engine nach dem Parse. Das Werkzeug fokussiert Einrückung und Validierung, nicht deterministische Schlüsselsortierung.
Was kostet die API zum Pretty-Print von JSON-Text?
Das Browser-Werkzeug ist kostenlos. API-Anfragen nutzen vorausbezahltes KIT-Guthaben zu $0.002 pro erfolgreichem Aufruf; ungültige Eingabe wird nicht abgerechnet.