JSON Escape

What is JSON Escaping?

// Input text
She said "hi"
then left.

// Escaped (Wrap on) — identical to JSON.stringify(input)
"She said \"hi\"\nthen left."

// Escaped (Wrap off) — just the body, for hand-built JSON
She said \"hi\"\nthen left.

// JSON-in-JSON
{"a":1}  ->  "{\"a\":1}"  ->  {"payload": "{\"a\":1}"}

Key Features

Examples

{"event":"signup","user":{"id":42,"name":"Alice"}}

function greet(name) {
  return `Hello, ${name}!`;
}

She said "hello"	then left.

Price: 9.99€ — café société

How to Use

1. 1

   Paste your text or JSON

   Enter or paste anything into the input field — a JSON object, a code snippet, a log line, or plain text. The escaped result appears instantly. Click 'Load example' to try a sample like a JSON-in-JSON payload or a multi-line function.

2. 2

   Choose escaping options

   Keep 'Wrap in double quotes' on for a complete JSON string literal (same as JSON.stringify), or off to get just the escaped body. Toggle 'Escape non-ASCII' for pure-ASCII \uXXXX output, and 'Escape forward slash' when inlining JSON into an HTML <script> tag.

3. 3

   Copy the escaped string

   Click Copy to grab the result, ready to paste into a JSON document, REST request body, or config file. Click Swap direction to flip into unescape mode and verify a lossless round-trip.

Common Escaping Pitfalls

Input already escaped: line1\nline2
Escaped again -> line1\\nline2  (literal backslash-n)

Raw input: line1
line2
Escaped once -> line1\nline2  (real newline encoded)

{"msg": hello \"world\"}
// Missing quotes around the value -> invalid JSON

{"msg": "hello \"world\""}
// Wrap on supplies the quotes -> valid JSON

café  ->  caf\u00e9   (no downstream need; just noise)

café  ->  café         (valid JSON, readable, smaller)

Common Use Cases

JSON-in-JSON Webhook Payloads

Escape a request body so it can be stored as a string field inside a webhook envelope, Kafka message, or audit log. Keep Wrap on and the output is ready to assign to a key in the outer document.

Multi-line Snippets in Config

Turn a multi-line shell script, SQL query, or code snippet into a single JSON string value. Every newline becomes \n so the JSON config file stays valid on one line.

Hand-Built REST Request Bodies

Escape a JSON string before dropping it into a curl --data argument or an HTTP client, so quotes and newlines survive the shell and the wire without breaking the request.

Log-Safe String Encoding

Escape user-supplied content before writing it to a structured log line, preventing injected quotes or newlines from corrupting the log format or a downstream JSON log parser.

ASCII-Only Legacy Integrations

Produce pure-ASCII \uXXXX output for SOAP gateways, email headers, or older systems that mangle UTF-8 in transit, while staying fully decodable by any modern JSON parser.

Inlining JSON into HTML

Escape forward slashes so a JSON blob can be embedded directly inside a <script> tag for server-rendered pages, without </script> inside the data closing the tag early.

Technical Details

Escaping Algorithm

The tool serializes your input with the JSON specification's string rules: U+0022 (") → \", U+005C (\) → \\, U+0008 → \b, U+000C → \f, U+000A → \n, U+000D → \r, U+0009 → \t, and any other character below U+0020 → \u00XX. With Wrap on, the surrounding double quotes are included; with it off, they are stripped. This matches the output of a compliant serializer exactly, guaranteeing lossless round-trips.

Unicode and Surrogate Pairs

By default, characters above U+007F are emitted as literal UTF-8, which JSON permits. With Escape non-ASCII on, each such character is converted to \uXXXX using its UTF-16 code unit; characters outside the Basic Multilingual Plane (emoji, rare scripts) are encoded as a surrogate pair of two \uXXXX escapes — for example 😀 (U+1F600) becomes \ud83d\ude00, the same representation a JSON serializer produces.

Forward-Slash and HTML Context

JSON does not require escaping /, so it is preserved by default. When Escape forward slash is enabled, every / becomes \/. The only practical reason to do this is HTML embedding: inside a <script> tag, the literal substring </script> closes the tag regardless of JSON context, so escaping the slash to <\/script> keeps the inlined JSON intact while remaining spec-valid.

Best Practices

Keep Wrap On for Complete Literals

When you need a value to assign in code or paste after a colon in JSON, keep Wrap in double quotes on — the output is a complete, parseable JSON string identical to JSON.stringify. Turn it off only when you are hand-typing the surrounding quotes yourself.

Leave Unicode Escaping Off Unless Required

Raw UTF-8 is valid JSON and far more readable. Enable Escape non-ASCII only for a specific downstream system that mishandles UTF-8 (legacy SOAP, some log pipelines, ASCII-only source files). Escaping everything by default just makes the output noisier.

Only Escape Slashes for HTML Embedding

The forward-slash escape matters in exactly one place: JSON inlined in an HTML <script> tag. Outside that context it adds clutter with no benefit, so leave it off for REST bodies, config files, and message payloads.

Verify Round-Trips with Swap

Before shipping escaped data into a pipeline, click Swap direction to unescape it and confirm you get the original text back. This catches accidental double-escaping — a frequent source of \\n showing up where \n was intended. Reverse anytime with our JSON Unescape tool.

Frequently Asked Questions