JSON Herstelhulpmiddel

Herstel automatisch kapotte of verkeerd opgemaakte JSON—veilig, snel en gratis.

Deze tool repareert kapotte of ongeldige JSON met geautomatiseerde foutenherstel. Het richt zich op de meest voorkomende syntaxproblemen die voorkomen in geëxporteerde data, logbestanden of handmatig bewerkte bestanden — zoals ontbrekende aanhalingstekens, overbodige komma’s of niet-overeenkomende haken — en genereert geldige, parseerbare JSON als resultaat.

Repareer je JSON hieronder

Hoe JSON Reparatie Werkt

Het hulpmiddel controleert uw invoer op veelvoorkomende JSON-syntaxisproblemen en past gerichte correcties toe, zodat er waar mogelijk geldige JSON wordt geproduceerd.

  1. Analyseert de invoer en detecteert veelvoorkomende syntaxfouten, waaronder ongeldige tekens, verkeerd geplaatste haakjes en onjuiste aanhalingstekens voor strings.
  2. Brengt correcties aan voor veelvoorkomende fouten—zoals ontbrekende aanhalingstekens toevoegen, overbodige komma's verwijderen of haakjes corrigeren.
  3. Geeft de gerepareerde JSON weer. In de meeste gevallen is het resultaat direct klaar om te parseren of te gebruiken.
  4. Als de structuur niet automatisch kan worden hersteld, wordt een duidelijke foutmelding weergegeven zodat je je invoer kunt aanpassen.

Veelvoorkomende JSON-fouten en hoe deze op te lossen

Hier zijn veelvoorkomende JSON-fouten die deze tool kan herstellen, met voorbeelden voor elk:

Niet-geverifieerde sleutels

Sleutels moeten tussen dubbele aanhalingstekens staan.

Before:
{ naam: "Bob" }
After:
{ "name": "Bob" }

Opgelost: Voegt dubbele aanhalingstekens toe rond alle ongeciteerde objectsleutels.

Enkele aanhalingstekens gebruikt

JSON accepteert alleen dubbele aanhalingstekens voor strings.

Before:
{ 'rol': 'beheerder' }
After:
{ "rol": "beheerder" }

Opgelost: Vervangt enkele aanhalingstekens door dubbele aanhalingstekens in alle tekststrings.

Achtervoegende komma's

Er mag geen komma staan na het laatste item.

Before:
{ "a": 1, "b": 2, }
After:
{ "a": 1, "b": 2 }

Opgelost: verwijdert eventuele overbodige komma's aan het einde.

Niet-overeenkomende of niet-afgesloten haakjes

Alle haakjes en accolades moeten correct gesloten zijn.

Before:
[1, 2, 3
After:
[1, 2, 3]

Oplossing: Voegt ontbrekende sluitende haakjes of accolades toe.

Ontbrekende of Overbodige Komma's

Array- en objectitems moeten worden gescheiden door een enkele komma.

Before:
{ "a": 1 "b": 2 }
After:
{ "a": 1, "b": 2 }

Oplossing: Voegt ontbrekende komma's toe of verwijdert dubbele.

Aanwezige kommentaarregels

Standaard JSON staat geen opmerkingen toe (zoals // of /* ... */).

Before:
{ "id": 1, // gebruikers-ID
 "active": true }
After:
{ "id": 1, "actief": true }

Oplossen: Verwijdert commentaarregels uit de invoer.

Ongeldige Nummerformaten

Alleen gewone decimale getallen zijn geldig (geen NaN, oneindig of hexadecimaal).

Before:
{ "val": NaN }
After:
{ "val": null }

Oplossing: Vervangt ongeldige nummers door null.

Niet-ontsnapte besturingskarakters

Tekens zoals nieuwe regels in tekst moeten worden ontsnapt.

Before:
{ "msg": "Regel1
Regel2" }
After:
{ "msg": "Regel1\nRegel2" }

Opgelost: Escapes van besturingskarakters correct verwerkt.

Dubbele sleutels in object

Dubbele sleutels in hetzelfde object zorgen voor onduidelijkheid.

Before:
{ "name": "A", "name": "B" }
After:
{ "name": "B" }

Oplossing: Bewaart alleen de laatste waarde bij dubbele sleutels.

Verkeerd Opgezette Arrays

Arrays moeten haken en komma's tussen de items bevatten.

Before:
[ 1 2 3 ]
After:
[ 1, 2, 3 ]

Opgelost: voegt ontbrekende komma's toe tussen array-elementen.

Lege invoer of alleen spaties

JSON mag niet leeg zijn.

Before:
After:
nul
Opgelost: Geeft null terug bij lege invoer.
Voorbeeld: Van kapotte JSON naar een geldige reparatie
Verkeerd gevormde JSON-invoer
{ gebruiker: 'alice', id: 42, rollen: [beheerder, 'redacteur',] // extra komma
 actief: waar }
Gerepareerde JSON-uitvoer
{
  "user": "alice",
  "id": 42,
  "roles": [
    "beheerder",
    "redacteur"
  ],
  "active": true
}
Hoe Deze JSON Hersteltool Te Gebruiken
  1. Plak of typ je kapotte JSON in de onderstaande editor.
  2. Klik op 'Repareren' om automatische detectie en oplossing van veelvoorkomende syntaxisfouten uit te voeren.
  3. Bekijk de gerepareerde uitvoer en kopieer uw aangepaste JSON.
Controleer altijd de herstelde JSON voordat je deze gebruikt voor kritieke gegevens—handmatige aanpassingen kunnen nodig zijn bij complexe of zwaar beschadigde invoer.
Codevoorbeelden voor JSON-reparatie
Zie hoe je JSON kunt repareren in diverse programmeertalen.
JavaScript (Node.js) with jsonrepair
Install: npm install jsonrepair
const { jsonrepair } = require('jsonrepair');
const broken = '{ name: "Bob", age: 42, }';
const fixed = jsonrepair(broken);
console.log(fixed); // Now valid JSON!
JavaScript (Node.js) simple fix (not for production)
Install: Standard library
let broken = "{ name: 'Bob', age: 42 }";
broken = broken.replace(/(['"])?:([\s]*)([^\s,\{\}\[\]":']+)/g, '"$1$3":');
try {
  let obj = JSON.parse(broken);
  console.log(obj);
} catch (e) {
  console.error('Still broken:', e.message);
}
Python with dirtyjson
Install: pip install dirtyjson
import dirtyjson
broken = "{ name: 'Bob', age: 42 }"
obj = dirtyjson.loads(broken)
print(obj)
Python with demjson3
Install: pip install demjson3
import demjson3
broken = "{ name: 'Bob', age: 42 }"
obj = demjson3.decode(broken)
print(obj)
Go (using otto for JS-like object parsing)
Install: go get github.com/robertkrimen/otto
package main
import (
  "fmt"
  "github.com/robertkrimen/otto"
)
func main() {
  vm := otto.New()
  broken := "{ name: 'Bob', age: 42 }"
  value, err := vm.Run("(" + broken + ")")
  if err != nil {
    fmt.Println("Cannot repair:", err)
  } else {
    obj, _ := value.Export()
    fmt.Println(obj)
  }
}
Java with org.json (manual fix for single quotes)
Install: org.json:json
import org.json.JSONObject;
public class Main {
  public static void main(String[] args) {
    String broken = "{'name': 'Bob', 'age': 42}".replace(''', '"');
    JSONObject obj = new JSONObject(broken);
    System.out.println(obj);
  }
}
C# with Newtonsoft.Json (try-catch, manual fix)
Install: Newtonsoft.Json
using System;
using Newtonsoft.Json;
class Program {
  static void Main() {
    var broken = "{ name: 'Bob', age: 42 }".Replace("'", "\"");
    try {
      var obj = JsonConvert.DeserializeObject(broken);
      Console.WriteLine(obj);
    } catch (Exception ex) {
      Console.WriteLine("Broken JSON: " + ex.Message);
    }
  }
}
PHP (manual fix for single quotes/unquoted keys)
Install: Standard library
<?php
$broken = "{ name: 'Bob', age: 42 }";
$fixed = preg_replace("/'([^"]*)'/", '"$1"', $broken);
$fixed = preg_replace('/([a-zA-Z0-9_]+):/', '"$1":', $fixed);
$obj = json_decode($fixed);
var_dump($obj);
Ruby with json-repair (via gem or shell call)
Install: gem install json-repair or use npx jsonrepair
# Using system call to npx jsonrepair
require 'open3'
broken = "{ name: 'Bob', age: 42 }"
fixed, _ = Open3.capture2("echo #{broken.inspect} | npx jsonrepair")
puts fixed
Bash (npx jsonrepair CLI)
Install: npm install -g jsonrepair
echo "{ name: 'Bob', age: 42 }" | npx jsonrepair
Rust (suggest manual pre-processing)
Install: Standard libraries
// Rust does not have a json repair crate yet. Pre-process string with regex to fix simple cases, then use serde_json.
Kotlin (manual fix, like Java)
Install: org.json:json
import org.json.JSONObject
fun main() {
  var broken = "{ name: 'Bob', age: 42 }".replace("'", "\"")
  broken = Regex("([a-zA-Z0-9_]+):").replace(broken, ""$1":")
  val obj = JSONObject(broken)
  println(obj)
}
TypeScript (Node.js) with jsonrepair
Install: npm install jsonrepair
import { jsonrepair } from 'jsonrepair';
const broken = '{ name: "Bob", age: 42 }';
const fixed = jsonrepair(broken);
console.log(fixed);
Dart (manual string fixes)
Install: Standard library
var broken = "{ name: 'Bob', age: 42 }";
var fixed = broken.replaceAll("'", '"').replaceAllMapped(
  RegExp(r'([a-zA-Z0-9_]+):'),
  (m) => '"${m[ 1 ]}":',
);
print(fixed);
Elixir (manual fix with Regex)
Install: Standard library
broken = "{ name: 'Bob', age: 42 }"
fixed = Regex.replace(~r/'/, broken, """)
fixed = Regex.replace(~r/(\w+):/, fixed, ""\\1":")
IO.puts(fixed)