Skip to content

JSON Lint & Validator

In-browser only Finds duplicate keys Every issue at once

Which tool?Format make it readableMinify smallest sizeLint syntax check, strict rules and duplicate keys

Result
The result appears here once you enter JSON.
Runs entirely in your browser — your JSON never leaves this page.
Related tools View all

Overview

Catch the problems a parser stays quiet about

List every strictness problem at once — duplicate keys, trailing commas, comments, single quotes, and unquoted keys — each with its line and column.

  • Finds duplicate keys that parsers silently drop
  • Flags trailing commas, comments, single quotes, and unquoted keys
  • Lists every issue at once with its line and column
  • Separates errors from warnings
  • Copy the full issue list
  • All processing runs entirely in your browser
  • Your JSON data is never uploaded to any server
  • Nothing is stored — the page holds no state between sessions
  • Works the moment the page loads — nothing to install
  • Inspect the network tab to confirm zero outbound requests
  • Catch lossy duplicate keys
  • Flag trailing commas, comments, or single quotes
  • Clean JSON5 or JSONC for a strict parser
  • Spot structural issues a formatter hides
  • Enforce strict-JSON hygiene

Guide

How to use

  1. 1
    Paste your JSON

    Type, paste, or use the Paste button to pull JSON from your clipboard. The Sample button loads a small example to try.

  2. 2
    Read the issue list

    Every problem is listed with its line and column. Errors stop the JSON from parsing; warnings parse but usually hide a bug.

  3. 3
    Fix from the top

    Work down the list — the results update as you type until the page says No issues found.

  4. 4
    Copy the list

    Use Copy to put the full issue list on your clipboard, for a ticket or a code review.

Reference

What JSON Lint checks

JSON lint issues and what they mean
IssueWhat it means
Duplicate keyTwo properties in one object share a key — parsers keep only one value.
Trailing commaA comma before a closing bracket or brace — not allowed in strict JSON.
Comment// or /* */ comments — valid in JSON5/JSONC but rejected by JSON.
Single-quoted stringStrings or keys in single quotes — JSON requires double quotes.
Unquoted keyAn object key without quotes — JSON requires every key to be double-quoted.
Byte-order markA hidden BOM character at the start of the input that can confuse parsers.

Pitfalls

Common JSON mistakes

  • Trailing commas

    A comma after the last item in an array or object is fine in JavaScript but invalid in JSON. Remove the comma before the closing bracket or brace.

  • Single quotes

    JSON requires double quotes for every string and key. Single quotes are a JavaScript habit — Lint flags each one so you can swap them.

  • Unquoted keys

    JavaScript object literals allow bare keys like {name: "x"}, but JSON needs {"name": "x"}. Every key must be wrapped in double quotes.

  • Comments

    JSON has no comment syntax. // and /* */ comments are valid in JSON5 and JSONC but a standard parser will reject them — strip them before parsing.

Frequently asked questions

Does JSON Lint also validate syntax?
Yes. Invalid JSON is reported first, with the exact line and column of the error and a plain-language explanation. Only once the input parses does the linter run its strictness checks. The former JSON Validator page now redirects here.
What does JSON Lint check?
Duplicate keys, trailing commas, line comments (//), block comments (/* */), single-quoted strings, unquoted keys, a leading byte-order mark (BOM), and any syntax error that stops the JSON from parsing.
Why are duplicate keys a problem?
When an object has two properties with the same key, JSON parsers silently keep just one — usually the last. The other value is lost without warning, which often masks a copy-paste bug in an API payload or config file.
Are trailing commas and comments allowed in JSON?
No. Strict JSON does not allow trailing commas or comments. They are valid in JSON5 and JSONC (used by some editors) but a standard JSON parser will reject them.
My JSON parses fine — why does Lint still flag it?
Some issues, like duplicate keys, produce valid-but-lossy JSON: the parser accepts it but quietly drops data. Lint surfaces these so you can fix the source rather than ship a hidden bug.