Docuboxer
By ··Updated: ·6 min read

The Privacy Risk of Online JSON Formatters

What sensitive data a real JSON payload carries, a 2025 case of exposed credentials, and how to check in the Network tab that nothing is uploaded.

A JSON formatter that works on a server receives everything you paste. One that works in your browser has no reason to send anything, and you can check that yourself in the Network tab of your developer tools. This article covers what a real JSON payload tends to carry, what happened in 2025 with two popular formatters, and how to run that check with the Docuboxer JSON formatter.

What is actually in the JSON you paste

What goes into a formatter is rarely test data. It is the response that just came back wrong from an API, and that response is rarely clean. This example, with made-up data, is typical of what ends up on the clipboard:

{
  "user": { "id": 48213, "email": "[email protected]", "phone": "+1 555 0100" },
  "session": { "access_token": "eyJhbGciOiJIUzI1NiJ9...", "expires_in": 3600 },
  "billing": { "card_last4": "4242", "customer": "cus_0000" },
  "config": { "db_host": "db-prod.internal", "db_password": "********" }
}

One object mixes personal data, a session token, payment references and a database credential. The OWASP Logging Cheat Sheet says to keep almost exactly that list out of your own logs: access tokens, session identifiers, passwords, connection strings, encryption keys, sensitive personal data and cardholder data. If it does not belong in your own log, it does not belong in the memory of a service you know nothing about.

What happens to your JSON in a server-side formatter

If the formatter posts your input to its backend, parses it there and returns the result, your data travels to infrastructure you do not control. Whether the service keeps it, where and for how long depends on its policy and configuration, and from outside there is no way to tell. A server that logs request bodies is enough to leave your JSON in a log file.

None of this needs bad intent. The one thing you can say for certain is that the JSON left your machine.

A real case: JSONFormatter and CodeBeautify in 2025

In November 2025 the security firm watchTowr Labs published research on two popular formatters, JSONFormatter and CodeBeautify. Both let you save what you paste and get a shareable link, and both have a recent-links page that lists those saves. The researchers collected more than 80,000 saved submissions, covering five years of JSONFormatter data and one year of CodeBeautify data, and found credentials, keys and personal data.

They also ran a test: they saved fake keys with a canary token, which alerts them if someone uses them. According to the report, the first sign that someone was trying them came 48 hours after the save.

The scope matters. What was exposed was the JSON that users saved with that feature, not any text pasted into any formatter. Even so, it shows the concrete risk of sending real data to a service that keeps it and makes it reachable.

The alternative: formatting in the browser

The Docuboxer JSON formatter parses and formats the text with the JavaScript engine already running in your tab, so the JSON never becomes a network request. It does three things: it formats with a 2-space, 4-space or tab indent, it minifies, and it validates syntax, pointing at the line and column of an error. It does not validate against a JSON Schema.

What it does not cover: formatting locally keeps a third-party server from receiving your data, but it does not protect you from a malicious browser extension or from someone looking at your screen. And if a real secret is not needed to debug, replace it with a fake value before pasting.

How to check in the Network tab that nothing is uploaded

You do not have to trust this page or any other. In Chrome, Edge or Firefox:

  1. Open the formatter and press F12 to open developer tools.
  2. Go to the Network tab and clear it with the trash icon, so you start from zero.
  3. Paste your JSON into the editor.
  4. Read the list. What should not appear is a POST or PUT request whose body (the Payload tab in Chrome, Request in Firefox) contains what you pasted, or any other request whose size is comparable to your JSON. Requests that load files or send analytics from the page itself (this site loads Google Analytics) are normal.

A common mix-up: a page can make requests of its own, such as loading files or sending analytics, without uploading your text. What matters is whether any of them carries your content. A simpler second test: with the page already loaded, switch the network off and format again. A local formatter keeps working; a server-based one fails. The Chrome DevTools and Firefox Network Monitor documentation explain the tab in more detail.

When a local formatter is always the better choice

  • When the JSON carries tokens, API keys or passwords.
  • When it contains customer or user data.
  • When it is a production response and you do not control what it includes.
  • When your company limits which external services may receive work data.

If you already pasted a secret into someone else's website, the guide to what to do after leaking an API key applies as is: revoke and rotate. The same reasoning covers other formats, so see XML structure and validation and CSV to JSON or JSON to CSV.

Frequently asked questions

Is it safe to paste JSON into an online formatter?

It depends on where the formatting happens. If the tool sends your JSON to a server, it has left your machine and you are relying on what that service does with it, which you cannot check from outside. If the tool formats in the browser, nothing is sent. For JSON with tokens or customer data, pick the second kind and verify it in the Network tab.

Which data in a JSON payload is sensitive?

Access and session tokens, passwords, database connection strings, encryption and API keys, personal data such as emails and phone numbers, and payment details. The OWASP Logging Cheat Sheet uses nearly the same list for what should never be written to a log.

How can I tell if a formatter runs locally?

Open developer tools (F12), go to the Network tab, clear it and paste your JSON. A POST or PUT request with a body the size of what you pasted means it is being sent. If you only see page-load or analytics requests, and the tool keeps working with the network switched off, the formatting is local.

I pasted a key or token into a website. What now?

Treat it as exposed: revoke or rotate it at the service that issued it and create a new one. Deleting the entry on the website does not guarantee nobody copied it first. The guide on what to do after pushing an API key to GitHub follows the same steps.

Does the JSON formatter validate against a schema?

No. It checks that the syntax is valid JSON and points at the line and column of the error, but it does not verify that fields have the names or types your application expects. That needs a JSON Schema validator.

Format JSON without sending it anywhere

Paste, format, and check the Network tab yourself to see what leaves.

Open JSON formatter →

Related tools

Sources