JSONLint vs DevOkk JSON Formatter: Validate vs a JSON Toolkit

DevOkk’s JSON Formatter also validates and pretty-prints. The difference is the rest of the hub: a tree viewer, a minifier, a graph, and converters from XML, CSV, and YAML. This is a toolkit comparison, not “whose lint algorithm is more correct.” Valid JSON is valid JSON.

A third bookmark, JSONFormatter.org, is covered in DevOkk vs JSONFormatter.org. Do not mix the three names in a search. This page is JSONLint.

What JSONLint is for

Lint, in this sense, means syntax. Missing commas, single quotes instead of double, trailing garbage after the closing brace, undefined copied from a console, comments that JSON does not allow. JSONLint’s reputation is that it points at the break. For a 40-line config, that is the whole job.

It is not a JSON database. It is not a schema validator against a draft-07 file unless the current UI says so - do not assume. It is not a pretty-printer you will use as a pipeline. People still pretty-print there because the valid output is readable. The identity is the red/green result.

If your workflow is “CI already validates, I just need to un-minify a log line,” you will outgrow lint-only quickly. That is the gap DevOkk fills.

What DevOkk’s JSON pages are for

Formatter. JSON Formatter is the pretty-print and validate step. Use it when a backend dumped one line into a ticket. The how-to is How to format and validate JSON from an API response. Common breaks are How to fix invalid JSON.

Viewer. Syntax-valid JSON can still be unreadable. Nested data.items[3].user.profile is a tree problem. JSON Viewer is for that. JSONLint will tell you the file is valid and leave you scrolling.

Minifier. Production payloads and fixture files that should be compact. JSON Minifier is the reverse of pretty-print. Lint sites are not where you should build that habit if the payload is sensitive; minify locally.

Graph. JSON to Graph Visualizer answers “what points at what.” It is the wrong tool for a missing comma.

Converters. Real-world “JSON” often starts as a spreadsheet or a Spring XML blob. Lint cannot help until it is JSON. Convert first, then format.

The catalog write-up is Best JSON tools for developers.

Privacy: validators still see what you paste

A lint page that runs in JavaScript can still be a bad place for a HAR export that includes Authorization headers. The failure mode is not always “the site uploaded it.” It is:

• You paste a 2 MB customer export because the error was on line 1
• The payload includes emails, tokens, and internal IDs
• You screenshot the result into Slack
• You try a second site when the first one “didn’t work”

DevOkk’s JSON tools are built to process the text in the browser. That is the safer default for anything that might be production-adjacent. It is not a license to paste secrets into a shared kiosk.

JSONLint’s exact processing model can change; read the page you are on. “It is a lint site” is not a DPA.

If the error is in a file on disk, opening it in an editor with a JSON plugin never leaves the machine. Web tools exist for the other case: you have a paste, not a checkout.

Errors both sites will show - and what they will not

Both will choke on:

• Trailing commas (unless you are accidentally in JSON5 land)
• Single-quoted keys
• NaN, Infinity, undefined
• Concatenated objects without an array
• A Python True instead of true

Neither will tell you that user_id should have been userId for your API. That is a schema/product problem. Neither will tell you a number overflowed in JavaScript. Neither will redact secrets for you.

If the paste is huge, the browser tab is the limit on both sites. Split the file. Do not “just upload it to a cloud formatter” as the next idea when the payload is a customer database export.

JSON dialects lint will punish you for

Comments and trailing commas. JSONC / JSON5 / tsconfig.json look like JSON and are not. JSONLint will fail them. That is correct for JSON.parse. It is annoying for a config you copied from TypeScript. Strip comments locally or convert YAML if the source was YAML: YAML to JSON.

Duplicate keys. {"a":1,"a":2} is allowed by some parsers (last key wins) and rejected by others. A linter that says valid may not match your runtime. Do not use a website as the spec for your language’s JSON library.

Big integers. JavaScript cannot represent every 64-bit ID. A formatter that parses via JSON.parse will round. If the ID is a snowflake, keep it a string. Neither JSONLint nor DevOkk will save you from that if you parse first.

NDJSON / concatenated objects. Logs are often one object per line. A linter expects one value. Wrap in an array or lint line by line. JSON Viewer is the wrong first tool until it is a single document.

Python and JS dumps. True, None, trailing commas from a trailing print, single quotes. How to fix invalid JSON is the catalog of those. Lint is how you find the first one; it will not rewrite Python for you.

Pretty-print is not a pipeline

JSONLint’s output is for humans. Shipping minified JSON from a website you pasted production data into is a process smell. Use JSON Minifier on a redacted fixture, or minify in CI. The formatter’s job in a team is “we can read this,” not “this is how artifacts are built.”

If you need a canonical key order or schema validation (AJV, etc.), that is code in the repo. Web lint will not replace it.

JSONLint vs JSONFormatter.org vs DevOkk (names)

Search results mix them. JSONLint: validator identity. JSONFormatter.org: formatter identity (separate DevOkk post). DevOkk: hub. Bookmark the one you mean. Comparing the wrong pair is how you write a useless wiki page.

When JSONLint is the right tab

• Teaching “what is valid JSON”
• A public sample from documentation
• You only need the first syntax error
• Muscle memory: the URL is already typed

Stay. DevOkk does not need to win that click.

When DevOkk is the right tab

• The payload might contain secrets or PII
• You need a tree or a graph after it is valid
• You need to minify, or convert from CSV/XML/YAML
• The next step is a JWT or Base64 on the same site

Open JSON Formatter or the JSON tools hub.

A worked example: one-line API error

The backend returns {"error":"invalid","details":{...40 nested keys...}} as one line in a log. JSONLint will say valid if the quotes are intact. You still cannot find details.user.email.

1. Paste into JSON Formatter. If it fails, fix the syntax using the error - often a truncated log line. Do not paste the rest of the 10 MB log file.
2. If it is valid but unreadable, JSON Viewer and expand details.
3. If you need to see relationships, JSON to Graph Visualizer.
4. If you are putting a fixture in the repo, JSON Minifier after redacting emails.
5. If the “JSON” was actually a CSV export, CSV to JSON first.

JSONLint could have been step 1 only. Steps 2–5 are why a hub exists. If step 1 is all you needed, your bookmark can stay JSONLint.

Redact before any of those steps if the log is production. "email":"[email protected]" is enough to debug shape.

Unicode, BOM, and “it works in the editor”

A UTF-8 BOM at the start of a file will break some strict parsers and look invisible in a web textarea. If JSONLint fails on character 1 with a file that looks fine in VS Code, save as UTF-8 without BOM and try again. DevOkk’s formatter will hit the same bytes; this is not a site war.

Unescaped line breaks inside strings, smart quotes from Word, and non-breaking spaces from Slack are the other “it looks valid” traps. Copy from a terminal, not from a formatted chat, when you can.

Depth limits exist in some libraries. A 10,000-level nested joke payload may crash a tab. That is not a reason to upload it. Shorten the sample.

Numbers as strings vs numbers, null vs missing keys, and empty arrays vs empty objects are valid JSON and still wrong for your API. Lint will never catch those. Write a fixture test. The website is for syntax.

A 200 from your API can still be invalid JSON if a proxy injected HTML or two values were concatenated. Lint the body, not the status code. If the body starts with <, you have an HTML error page. Streaming endpoints are not one document - copy a single event.

JSONLint remains the lint bookmark. DevOkk is what you open when lint is step one of three. If you only ever needed step one, you were never the audience for a toolkit article - and that is fine.