Unescape JSON

Convert escaped characters in JSON back to actual characters.

Input (Escaped JSON)

Tool Options

Prettify JSON

Prettify Output JSON

Format the output JSON by adding indentation.

Use Spaces as Indentation

Use tabs as Indentation

Output (Unescaped JSON)

What It Does

The JSON Unescape tool converts escaped JSON strings back into their original, human-readable format by systematically reversing all standard escape sequences. When JSON data travels through APIs, gets stored in databases, or is embedded inside other strings, special characters like quotes, backslashes, newlines, and tabs get replaced with their escaped equivalents — sequences like \" , \\, \n, and \t. While this escaping is necessary for data integrity during transmission, it makes the content nearly impossible to read or debug at a glance. This tool reverses that process instantly, restoring the original characters so you can clearly see the underlying JSON structure. It handles single-level escaping as well as double-escaped strings — a common scenario when JSON is serialized inside another JSON value or passed through multiple encoding layers. Whether you're a developer inspecting API payloads, a data engineer troubleshooting pipeline outputs, or a QA engineer validating configuration files, this tool saves you from manually decoding escape sequences by hand. Simply paste your escaped string and get clean, readable JSON output in seconds. It also validates the resulting JSON structure after unescaping, so you can immediately confirm whether the data is well-formed before using it in your application.

How It Works

The Unescape JSON applies its selected transformation logic to your input and produces output based on the options you choose.

It applies a fixed set of transformation rules to your input, so the output is stable and easy to verify.

All processing happens in your browser, so your input stays on your device during the transformation.

Common Use Cases

Decoding escaped JSON strings copied from server-side log files to quickly identify what data was actually sent or received during an API call.
Restoring double-escaped JSON that was serialized as a string value inside another JSON object, a common pattern in microservices and message queues.
Debugging API responses that return JSON as a quoted, escaped string rather than a native JSON object, making them difficult to parse visually.
Converting escaped configuration strings stored in environment variables or secrets managers back into readable JSON for review or editing.
Cleaning up escaped JSON embedded in SQL query results or NoSQL document stores where the data was stored as a serialized string.
Inspecting webhook payloads that arrive as escaped strings in logging dashboards like Datadog, Splunk, or CloudWatch.
Preparing escaped JSON samples for documentation or code reviews where the raw, readable format is needed for clarity.

How to Use

Locate your escaped JSON string — this might come from a log file, an API response body, a database field, or a copied value from your IDE's debugger.
Paste the full escaped string into the input field. Include the surrounding quotes if present; the tool will handle them correctly.
The unescaping process runs automatically as you paste, instantly reversing all escape sequences including \", \\, \n, \r, \t, and Unicode escapes like \uXXXX.
Review the restored JSON output in the result panel. The tool displays the content with proper formatting so the structure is immediately visible.
If the unescaped result is valid JSON, use the copy button to grab the clean output and paste it into your editor, API client, or documentation.
For double-escaped strings, run the tool a second time on the output if you still see escape sequences remaining — each pass removes one layer of escaping.

Features

Reverses all standard JSON escape sequences including backslash, quote, newline, carriage return, tab, form feed, and Unicode code point escapes.
Handles multi-level (double-escaped) JSON strings, making it possible to recover data that has been serialized through multiple encoding layers.
Automatically detects and strips surrounding quotation marks when the input is a quoted JSON string value rather than a raw escaped block.
Validates the resulting JSON structure after unescaping and clearly indicates whether the output is well-formed, saving an extra step with a separate validator.
Preserves Unicode characters correctly, including emoji, non-Latin scripts, and special symbols encoded as \uXXXX sequences.
Processes large escaped payloads quickly without truncation, making it suitable for full API response bodies or large configuration blobs.
Provides a clean, syntax-highlighted output view so the restored JSON structure is immediately readable without additional formatting steps.

Examples

Below is a representative input and output so you can see the transformation clearly.

Input

{\"path\":\"C:\\\\temp\\\\file.txt\"}

Output

{"path":"C:\\temp\\file.txt"}

Edge Cases

Very large inputs may take a few seconds to process in the browser. If performance slows, split the input into smaller batches.
Mixed formatting (tabs, line breaks, or inconsistent delimiters) can affect output. Normalize spacing first if needed.
Unescape JSON follows the selected options strictly. If the output looks unexpected, re-check option settings and input format.

Troubleshooting

Output looks unchanged: confirm the input contains the pattern this tool modifies and that the correct options are selected.
Output differs from a previous run: confirm that the input and every option match, because deterministic tools should repeat when the settings are identical.
Unexpected characters: check for hidden whitespace or encoding issues in the input and try normalizing first.
Slow processing: reduce input size or try a modern browser with more available memory.

Tips

If your unescaped output still contains escape sequences, you are likely dealing with a double-escaped string — simply run the tool again on the output to remove the second layer. When copying escaped JSON from browser developer tools or log aggregators, make sure you copy the raw string value rather than the formatted display, as some tools add extra escaping for their own display purposes. For JSON embedded inside JavaScript string literals, remove the outer single or double quotes before pasting to get the cleanest result. If the tool reports invalid JSON after unescaping, look for truncated strings or missing brackets — this often indicates the original source only captured part of the payload.

Understanding JSON Escaping: Why It Exists and When You Need to Reverse It JSON (JavaScript Object Notation) is the dominant data interchange format on the modern web, and for good reason — it is lightweight, human-readable, and natively supported by virtually every programming language. But JSON has a fundamental rule: certain characters inside string values must be escaped with a backslash to avoid breaking the structure of the document. The characters that require escaping include the double quote ("), the backslash itself (\), and control characters like newline (\n), carriage return (\r), horizontal tab (\t), and form feed (\f). Unicode characters outside the basic ASCII range can also be escaped using the \uXXXX notation. This escaping system works perfectly when JSON is being parsed by a machine. The problem arises when JSON gets serialized as a string value inside another JSON document. Imagine a web service that logs its request and response bodies as string fields inside a JSON log entry. The inner JSON has to be escaped so it doesn't break the outer JSON's syntax — every double quote becomes \", every backslash becomes \\, and every newline becomes \n. The result is technically valid JSON, but visually it is a dense wall of backslashes and escape codes that is extremely difficult for a human to read or debug. This pattern — JSON inside JSON — is surprisingly common. Message queue systems like Kafka and RabbitMQ often carry serialized JSON payloads as string fields. AWS Lambda and API Gateway log request bodies as escaped strings in CloudWatch. Webhook platforms serialize event payloads as string values in their delivery logs. Configuration management tools store structured settings as escaped JSON strings in environment variables. In each of these cases, developers regularly need to reverse the escaping to inspect the actual data. Double escaping adds another layer of complexity. When an already-escaped string gets passed through a second serialization step, you end up with sequences like \\\" representing a single literal quote character. Manually decoding this by eye is error-prone and tedious — a dedicated unescape tool eliminates the guesswork entirely. JSON Unescaping vs. JSON Parsing It is worth distinguishing between unescaping a JSON string and actually parsing JSON. Parsing means interpreting the full JSON syntax and producing a data structure (an object, array, or primitive). Unescaping is a lower-level text operation that simply replaces escape sequences with their literal character equivalents. When you receive a string like "{\"name\":\"Alice\"}" and want to see {"name":"Alice"}, you are unescaping — not parsing. Parsing would go one step further and give you an actual object with a name property. Both operations are useful, but unescaping is often the first step needed when the data arrives as a quoted string rather than a native JSON type. Related operations include URL decoding (reversing percent-encoding used in query strings), HTML entity decoding (replacing & and < with their literal characters), and Base64 decoding (converting encoded binary or text back to its original form). If your JSON payload has been URL-encoded or Base64-encoded on top of being JSON-escaped, you may need to apply those decode steps first before JSON unescaping will produce the expected result. Understanding the encoding chain is key to successfully recovering the original data.

Frequently Asked Questions

What is JSON escaping and why does it happen?

JSON escaping is the process of replacing special characters inside a JSON string value with backslash sequences so they don't break the surrounding JSON syntax. For example, a double quote inside a string must be written as \" because an unescaped quote would signal the end of the string. Escaping happens automatically when a programming language serializes data to JSON format. It is a required part of the JSON specification, not a bug or an error.

What does it mean to unescape JSON?

Unescaping JSON means reversing the escape sequences back to their original characters. So \" becomes ", \n becomes an actual newline character, \\ becomes a single backslash, and \uXXXX becomes the corresponding Unicode character. This is useful when you have a JSON string that was escaped for transmission or storage and you need to read the original content. The unescaped result is the literal text that the string was intended to represent.

What is double-escaped JSON and how do I fix it?

Double-escaped JSON occurs when a JSON string has been serialized to JSON a second time, causing each escape sequence to be escaped again. For example, a single backslash (\) becomes \\\\ in a double-escaped string. This commonly happens when a JSON payload is stored as a string field inside another JSON document, or when data passes through two serialization layers in a pipeline. To fix it, run the unescape tool twice — each pass removes one layer of escaping — until the output looks like normal, readable JSON.

Why do API responses sometimes return JSON as an escaped string instead of a native object?

Some APIs and logging systems serialize their response bodies as string values rather than embedding them as native JSON objects. This can happen because the outer document has a fixed schema where the payload field is typed as a string, or because the system was designed before structured logging became standard practice. It also occurs when an API response is relayed through an intermediary that wraps it in an additional JSON envelope. The result is valid JSON at the outer level, but the inner content requires unescaping before it can be read or re-parsed.

How is JSON unescaping different from JSON formatting or beautifying?

JSON formatting (also called beautifying or pretty-printing) takes valid, compact JSON and adds indentation and line breaks to make its structure visually clear. JSON unescaping, by contrast, operates on a raw string and removes escape sequences to reveal the literal characters. The two operations are complementary: you typically unescape first to recover the original JSON text, and then format it to make it easy to read. Some tools combine both steps, but they are technically distinct operations.

Can I use this tool on JSON that contains Unicode escape sequences like \u0041?

Yes. The tool fully supports Unicode escape sequences in the \uXXXX format, converting them to their actual Unicode characters. So \u0041 becomes the letter A, \u00E9 becomes é, and emoji represented as surrogate pairs (😀) are correctly reassembled into their single Unicode code points. This makes the tool useful for JSON strings that originated from systems that encode all non-ASCII characters as Unicode escapes for safe transmission.