JSON String Escaper & Unescaper
Escape JSON for embedding inside Java, C#, Python, SQL, and JS string literals, or unescape escaped strings back to JSON.
Unlike conventional calculator sites that send your financial numbers, payload data, or code snippets across remote web servers, Affi-Chain processes all mathematical derivations, algorithms, and data parsing 100% locally within your browser sandbox. No tracking cookies, no server-side retention, and zero transmission lag.
What is JSON String Escaping?
JSON String Escaping is the standardization process dictated by the IETF RFC 8259 and ECMA-404 specifications that serializes string literals safely across diverse runtime boundaries. In JavaScript Object Notation (JSON), strings are defined as sequences of zero or more Unicode characters wrapped inside double quotation marks (").
Because double quotation marks delimit the start and end of strings, and backslashes (\) denote escape signals, including these characters directly inside a string literal breaks parser lexical state machines. Furthermore, ASCII control characters (code points U+0000 through U+001F, such as newlines, carriage returns, and tabs) are strictly forbidden as unescaped raw characters inside valid JSON strings.
When developers embed JSON payloads inside programming language string literals (such as Java, C#, Python, SQL queries, or Bash commands) or transport serialized data between microservices, unescaped characters trigger fatal parsing exceptions (SyntaxError: Unexpected token, Unterminated string literal).
The Affi-Chain JSON String Escape & Unescape Tool performs instant, 100% in-browser transformation, allowing engineers to toggle between raw unescaped multi-line text and clean, single-line or multi-line escaped string literals compliant with RFC 8259.
The Complete RFC 8259 JSON Escape Sequences Matrix
The JSON grammar reserves two-character escape sequences for the most common control codes, while providing a six-character hexadecimal notation (\uXXXX) for any arbitrary Unicode code point:
| Escape Sequence | Character Name | Unicode Code Point | Hex / Decimal Value | Structural Purpose & Context |
|---|---|---|---|---|
\" | Quotation Mark | U+0022 | 0x22 / 34 | Prevents premature string termination in JSON keys and values |
\\ | Reverse Solidus (Backslash) | U+005C | 0x5C / 92 | Escapes the escape character itself; mandatory for Windows file paths |
\/ | Solidus (Forward Slash) | U+002F | 0x2F / 47 | Optional in JSON; essential to prevent </script> tag injection in HTML |
\b | Backspace | U+0008 | 0x08 / 8 | Terminal control sequence; rarely used in modern text serialization |
\f | Form Feed | U+000C | 0x0C / 12 | Legacy page break control character |
\n | Line Feed (LF) | U+000A | 0x0A / 10 | Standard Unix newline character; mandatory escape in JSON strings |
\r | Carriage Return (CR) | U+000D | 0x0D / 13 | Classic Mac / Windows newline component (\r\n); mandatory escape |
\t | Horizontal Tab | U+0009 | 0x09 / 9 | Tabular indentation token; must be escaped inside JSON strings |
\uXXXX | Unicode Hex Sequence | U+0000–U+FFFF | 4 Hex Digits | Encodes any basic multilingual plane character (e.g., \u00a9 for ©) |
Step-by-Step Practical Transformation Example
Let us examine how a multi-line SQL query configuration object with nested quotes and Windows file paths is transformed into an escaped string for programmatic injection.
Raw Human-Readable Text:
SELECT * FROM "users"
WHERE profile_path = "C:\Users\Administrator\Documents"
AND status = 'ACTIVE';
Escaped JSON String Literal:
"SELECT * FROM \"users\" \nWHERE profile_path = \"C:\\Users\\Administrator\\Documents\" \nAND status = 'ACTIVE';"
Ready for Embedding in Java / C# / Python Source Code:
// In C# or Java, double quotes and backslashes require escaping:
string jsonConfig = "{\"query\":\"SELECT * FROM \\\"users\\\" \\nWHERE profile_path = \\\"C:\\\\Users\\\\Administrator\\\\Documents\\\" \\nAND status = 'ACTIVE';\"}";
Programmatic Implementation Across Core Languages
1. JavaScript / TypeScript (Node.js & Modern Browser Runtimes)
JavaScript provides native serialization through JSON.stringify(), but fine-grained control is often necessary when manipulating raw string fragments:
/**
* Safely escapes a raw text string for insertion into a JSON value.
* @param {string} raw - The raw text input.
* @returns {string} Escaped string content (without outer quotes).
*/
function escapeJsonString(raw) {
if (typeof raw !== 'string') return '';
// JSON.stringify handles quotes, control chars, and newlines
const serialized = JSON.stringify(raw);
// Strip enclosing quotation marks for embedding
return serialized.slice(1, -1);
}
/**
* Reverses escaping, restoring original newlines, quotes, and backslashes.
* @param {string} escaped - The escaped JSON string content.
* @returns {string} Unescaped human-readable text.
*/
function unescapeJsonString(escaped) {
if (typeof escaped !== 'string') return '';
try {
// Wrap with quotes and parse via standard engine
return JSON.parse(`"${escaped}"`);
} catch (err) {
// Fallback manual replacement if string contains broken sequences
return escaped
.replace(/\\"/g, '"')
.replace(/\\\\/g, '\\')
.replace(/\\n/g, '\n')
.replace(/\\r/g, '\r')
.replace(/\\t/g, '\t');
}
}
// Verification:
const rawInput = 'Path: C:\\work\nAction: "Run"';
const escaped = escapeJsonString(rawInput);
console.log('Escaped:', escaped);
// Escaped: Path: C:\\work\nAction: \"Run\"
const restored = unescapeJsonString(escaped);
console.assert(rawInput === restored, 'Round-trip lossless verification passed');
2. Python 3 Backend Implementations
Python handles JSON escaping through its standard json module:
import json
payload = {
"command": "sh -c 'echo \"Hello World\" >> /var/log/app.log'",
"regex": r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b"
}
# Serializes dictionary into strict RFC 8259 JSON
json_string = json.dumps(payload, indent=2)
print("Serialized JSON:\n", json_string)
# Deserialization validates and restores raw strings
parsed_dict = json.loads(json_string)
assert parsed_dict["command"] == payload["command"]
Comparison Matrix: JSON Escaping vs Other Serialization Formats
| Encoding Domain | Double Quote (") | Backslash (\) | Newline (\n) | Single Quote (') | Primary Protocol / Use Case |
|---|---|---|---|---|---|
| JSON Escaping (RFC 8259) | \" | \\ | \n | Left unescaped (') | REST APIs, microservices, config files |
| SQL String Escaping | " (or "") | Platform dependent | Literal newline allowed | '' (doubled single quote) | Relational database queries |
| URL Percent-Encoding | %22 | %5C | %0A | %27 | Query strings, URI parameters |
| HTML Entity Encoding | " | Left unescaped (\) | Literal newline allowed | ' / ' | DOM tree rendering, web views |
| CSV RFC 4180 Escaping | "" (doubled) | Left unescaped (\) | Wrapped in double quotes | Left unescaped (') | Tabular data exports, spreadsheet parsing |
Critical Edge Cases & Common Pitfalls
1. The Windows File Path Bug (\U and \P Traps)
The single most frequent JSON syntax error occurs when Windows paths are pasted directly into JSON files:
// INVALID JSON - Will trigger SyntaxError: Bad escaped character
{
"directory": "C:\Users\Project\node_modules"
}
In JSON, \U or \P is not a valid escape sequence. The backslash must be doubled:
// VALID JSON
{
"directory": "C:\\Users\\Project\\node_modules"
}
2. The </script> Tag Breakout in Server-Side Rendering (SSR)
When Next.js, Nuxt, or Express serializes server data directly into inline <script> tags for client hydration:
<!-- DANGEROUS! Browsers terminate the script tag upon encountering </script> -->
<script>
window.__INITIAL_DATA__ = {"title": "</script><script>alert('XSS')</script>"};
</script>
Standard JSON.stringify() does NOT escape forward slashes (/). HTML parsers prioritize closing </script> tags over JavaScript string boundaries.
Solution: Escape forward slashes as \/ or Unicode \u002F, or replace < with \u003C:
const safeJson = JSON.stringify(data).replace(/</g, '\\u003c');
3. Unicode Surrogate Pairs in JSON
Characters outside the Basic Multilingual Plane (such as emojis or mathematical alphanumeric symbols, code points above U+FFFF) cannot be represented by a single \uXXXX escape. In JSON, they must be encoded as a UTF-16 surrogate pair:
- Rocket glyph (
🚀, code pointU+1F680):- High surrogate:
\uD83D - Low surrogate:
\uDE80 - JSON representation:
"\uD83D\uDE80"Modern parsers handle surrogate pairs automatically, but manual regex string scrapers often corrupt split surrogate bytes.
- High surrogate: