Escaping encodes the characters that are not legal inside a JSON string — double quotes, backslashes, newlines, tabs and other control characters — exactly as a valid JSON string literal would represent them.

What is the difference between escape here and a JSON string literal?

This tool gives you the escaped body — the part between the outer quotes. If you also need the surrounding double quotes to paste a complete string literal, use the JSON String Escape tool, which wraps the result in quotes.

How accurate is the conversion?

Escaping uses the browser's built-in JSON.stringify and unescaping uses JSON.parse, so the result matches the official JSON specification, including \\uXXXX unicode escapes. Invalid escape sequences are reported as an error rather than guessed.

How is a newline represented?

A literal line break becomes \\n, a tab becomes \\t, a double quote becomes \\" and a backslash becomes \\\\. Decoding reverses each of these back to the original character.

What happens with non-ASCII or emoji characters?

They round-trip correctly. The native serialiser may emit \\uXXXX escapes for some characters; unescaping resolves those escapes back to the original Unicode characters.

Why do I get an error when unescaping?

Unescaping uses JSON.parse, so an invalid escape sequence (for example a lone backslash or a malformed \\u code) is rejected with the parser error rather than guessed at, keeping the result trustworthy.

Is my text uploaded anywhere?

No — all encoding and decoding runs locally in your browser and nothing is sent to a server.

What is the JSON Escape / Unescape?

Free JSON escape and unescape tool — convert raw text into a valid JSON string body (newlines, tabs, quotes, backslashes, unicode) and decode escaped JSON strings back to plain text. Runs entirely in your browser, nothing is uploaded. It runs free in your browser on Gera Tools, with nothing uploaded.

JSON Escape / Unescape

Name: JSON Escape / Unescape
Creator: Gera Tools
License: https://creativecommons.org/licenses/by/4.0/

Get one useful tool a week

Like this tool? Enter your email and we'll send you one genuinely useful Gera tool a week — plus a link to come back to this one. No spam, one-click unsubscribe any time.

JSON escape and unescape

When you need to drop raw text — a multi-line message, a snippet containing quotes, a log line — into a JSON document, every special character has to be escaped first. This tool converts raw text into a valid JSON string body and decodes escaped strings back to plain text, using the browser’s own JSON engine so the result is spec-correct.

How it works

Escaping wraps your text with JSON.stringify and removes the outer quotes, leaving just the escaped body. Unescaping wraps your input in quotes and runs JSON.parse. Because both use the native engine, every rule of the JSON spec is honoured, including \uXXXX unicode escapes.

Character	Escaped as
`"` (double quote)	`\"`
`\` (backslash)	`\\`
newline	`\n`
tab	`\t`
carriage return	`\r`
control / non-ASCII	`\uXXXX` (where needed)

Example

Escaping the two-line text:

Hello "world"
Line two

produces the body:

Hello \"world\"\nLine two

Unescaping that body restores the original two lines exactly. Everything runs in your browser — nothing is uploaded.

When you actually need this

The most common situations where JSON escaping becomes necessary:

Embedding strings in a hand-written JSON payload. If you are constructing a JSON body manually — say, a curl command or a REST client request — and your string value contains double quotes or backslashes, you need to escape those before pasting. Otherwise the JSON becomes invalid and the server rejects it.

Storing multi-line content as a JSON value. JSON strings cannot span multiple lines in source. A code snippet, a SQL query, or a log message that contains real newlines must have them replaced with \n before it can live inside a JSON string.

Decoding an escaped string stored in a database or config file. Systems that store JSON-encoded text will hand you back the escaped body; this tool decodes it so you can read or edit the original content.

The difference between “escape body” and “string literal”

This tool returns the escaped body — the content you would put inside the surrounding double quotes in a JSON document. For example, if the raw text is Say "hello", the escaped body is Say \"hello\".

The companion JSON String Escape tool returns a complete JSON string literal, including the outer double quotes: "Say \"hello\"". Use that version when you want a value you can paste directly as a standalone JSON expression.

Edge cases worth knowing

Unicode and emoji: Characters above the basic ASCII range round-trip correctly. The native serialiser may represent some control characters as \uXXXX sequences; unescaping resolves them back to the original code point.
Lone surrogates: A string containing an unpaired surrogate code point (rare, but valid in JavaScript) may be represented with a \uXXXX escape because JSON technically requires paired surrogates. The tool follows the native engine behaviour.
Invalid escape sequences on unescape: Sequences like \q or a malformed \u code are rejected with a parser error rather than passed through silently, keeping the output trustworthy.