Tool Usage FAQ: Data, Files, and Export

Bottom line: parsing, formatting, diffing and querying run entirely in your browser and keep working offline; clear the localStorage history after handling sensitive data; and switch to command-line streaming tools above 10 MB rather than pasting the file into the browser.

Before pasting a sensitive payload into an online tool, know where it goes. This article covers only the runtime behavior of the tool, not syntax.

1. Data and privacy

Does the online JSON formatter upload my data to a server?

No. Parsing, formatting, minifying, diffing, and querying all happen in the browser, and the page never sends anything you paste to an application server.

You do not need to read a privacy statement to tell whether an online tool uploads data; the browser's network panel is enough:

1. Open developer tools, switch to the Network panel, and enable log persistence;
2. Paste some JSON and click "Format";
3. Watch whether a new XHR or fetch request appears, and whether its body contains your content.

For a genuinely local tool, this step shows only static asset requests. Conversely, if a single format action produces POST /api/format whose body is your original text, then the data has already left the browser no matter what the page claims.

Every tool on this site is a pure front-end implementation, and the build output contains no server API. After going offline, a refresh that hits the cache still works, which is also the most direct way to tell whether something is "fully local".

Can I still use it offline?

Yes, provided the page has been loaded once.

The site's assets are downloaded into the browser cache on first visit, so even without a network afterwards, formatting, minifying, JSON5 conversion, and JSONPath queries keep working. Only network-dependent features fail, such as checking for a new version or downloading the desktop installer.

The offline test is likewise a good way to verify that "data never leaves": if everything breaks the moment you disconnect, every action was talking to a server.

Is any data stored locally? How do I clear it?

Yes, but only in the current browser's localStorage, and only history and UI settings.

• History: the last 100 processed entries in reverse chronological order, used to recall the previously pasted data;
• UI settings: theme, language, indentation preferences, and so on;
• Not stored: the file itself, upload records, or anything carrying an identity.

There are three ways to clear it, from narrowest to broadest:

When handling production data on a shared computer, clear the history when you finish instead of just closing the tab — localStorage does not disappear when a tab closes.

Why did Chinese characters turn into \u4e2d\u6587?

Because the "escape" feature converts non-ASCII characters into Unicode escape sequences. This is deliberate behavior, not mojibake.

\u4e2d is the code point of the character 中 (U+4E2D). The two forms are semantically identical in JSON and parse into the same string:

复制{
  "escaped": "\u4e2d\u6587",
  "plain": "中文"
}

When is escaping needed? When embedding JSON into an old system that only accepts ASCII, writing it into an HTTP header, or nesting it inside another string. When is it not needed? Most API transport and file storage do not need it; storing Chinese directly as UTF-8 saves bytes — one Chinese character is 3 bytes, and 6 bytes once escaped.

If you see Chinese turn into \u4e2d, first check whether you clicked the "Escape" button rather than suspecting that the encoding is broken.

2. Files and size

What file size is supported?

There is no hard limit on the browser side; the real limits come from three places:

In other words, a file of tens of MB "can be parsed" but is "not usable". When you genuinely need to process such data, the right move is not to find a stronger online tool, but to switch to streaming (see Performance and Security FAQ).

Rule of thumb: under 2 MB an online tool stays smooth; 2–10 MB means accepting a lag or two; above 10 MB, prefer a local script.

The browser freezes after I paste. What now?

Do not refresh first — refreshing loses the content and you have to paste again. Rescue it in this order:

1. Wait 10–30 seconds. In most cases the main thread is parsing or rendering and will recover on its own;
2. Once it recovers, immediately switch to the "Minify" view or collapse the tree to reduce DOM nodes;
3. Copy the content into a local file and switch to the command line:

复制# Look at the structure of the first 100 lines only, to avoid loading everything
head -c 200000 data.json | jq . | head -n 100

# Count entries with a streaming tool, without loading them into memory
jq -c '.items[]' data.json | wc -l

Next time you hit a large file, run wc -c first to see the byte count, then decide whether to paste it into a browser.

Why is the formatting unchanged after I paste?

Three common causes, ordered by frequency:

1. The input is already minified and has no syntax errors: formatting only adjusts indentation, so if the original really is two lines, it will still be two lines afterwards — newlines inside strings are not expanded;
2. The content is not JSON: for example you pasted a JavaScript object literal (unquoted keys, single quotes), and the parser reports an error instead of formatting;
3. You clicked the wrong button: minify and format go in opposite directions, and minify strips all indentation.

How to tell: look at the character count in the top-right corner of the output area. After formatting the count should increase (extra indentation and newlines); if it decreased instead, you ran minify.

3. Input and output

How do I export the result to a file?

Three ways, ordered by reliability:

The downloaded file is UTF-8 encoded without a BOM by default. This matters: JSON with a BOM breaks outright in many parsers (see the section on BOM in Syntax and Format FAQ).

Are JSON5 and JSONC supported?

Yes, but distinguish "parsing" from "output".

• On the input side you can paste JSON5 (single quotes, unquoted keys, comments, trailing commas, hexadecimal numbers) or JSONC (comments only);
• On the output side you can convert to standard JSON, or convert standard JSON back into JSON5 to make manual editing easier.

Always emit standard JSON when crossing systems. JSON5 is a dialect for humans writing configuration; a request body with Content-Type: application/json that contains comments or trailing commas will usually be rejected by the server.

4. Environment and compatibility

Does it work on a phone?

Yes. The interface reflows into a single column, and formatting, minifying, diffing, and JSONPath are all retained.

But handling large files on a phone is a poor experience: the soft keyboard covers content, selecting text is hard, and the browser may discard the page when you switch apps, losing your content. Acceptable as an emergency, but do it on a desktop day to day.

Why does the same file open in Chrome but error in Safari?

Usually it is not a browser difference but an encoding difference. Debug in this order:

1. BOM: UTF-8 saved by Windows Notepad includes a BOM, which some parsers do not tolerate;
2. Line endings: mixing CRLF and LF does not affect JSON itself, but it shifts the reported error line numbers, so it looks like "the error position is wrong";
3. Invisible characters: text copied from a web page may contain zero-width spaces (U+200B), invisible to the eye but enough to break key matching.

One command sees through it:

复制# Look at the hex of the first 16 bytes; a leading EF BB BF means a BOM is present
head -c 16 data.json | xxd

5. Quick reference