Escape / Unescape — Free Online Tool

What is JSON String Escape/Unescape (Quote, Newline, Unicode, Backslash)?

JSON escape tool converts text to JSON-safe string format by escaping special characters: " → \", newline → \n, tab → \t, backslash → \\. Reverse: unescape \n → actual newline. Handles: double quotes (" required in JSON strings), control characters (\n, \r, \t), backslashes (single \ → double \\), Unicode (\u0041 = A), forward slashes (/ → \/, optional). Use cases: embed text in JSON (API payloads, config files), debug JSON strings (see escaped characters), fix syntax errors (unescaped quotes break JSON), generate JSON programmatically (escape user input before inserting). Features: bidirectional (escape ↔ unescape), Unicode support (escape non-ASCII: © → \u00A9), validation (shows errors in input).

• JSON string escaping: Text with special chars → JSON-safe string. Example: Hello "World"\nNew line → Hello \"World\"\nNew line (quotes escaped: \", newline: \n). Required: JSON strings can't contain raw newlines, unescaped quotes.
• Escape sequences: \" (double quote), \\ (backslash), \n (newline), \r (carriage return), \t (tab), \b (backspace), \f (form feed). Unicode: \uXXXX (4 hex digits). Example: © → \u00A9, 😀 → \uD83D\uDE00 (surrogate pair).
• Unescape (decode): Escaped JSON string → readable text. \"Hello\nWorld\" → "Hello (newline) World". View actual content (escaped strings hard to read). Debug: API response with escaped text.
• Bidirectional conversion: Escape: plain text → JSON string. Unescape: JSON string → plain text. Switch modes. Example: escape Hello\nWorld → Hello\\nWorld (double backslash). Unescape reverses.
• Unicode handling: Non-ASCII characters → Unicode escapes. © → \u00A9, ñ → \u00F1, 中 → \u4E2D. Or keep as-is (UTF-8 JSON supports raw Unicode). Option: escape all non-ASCII (compatibility) or only special chars (compact).

Why use json escape?

Prevent JSON syntax errors (unescaped quotes, newlines break JSON). Safely embed any text in JSON strings.

• Fix JSON syntax errors: JSON: {"message": "He said "Hello""} (syntax error: unescaped quotes). Escaped: {"message": "He said \"Hello\""}. Quotes inside string must be escaped (\" not ").
• Embed multiline text in JSON: Error message (3 lines): Line 1\nLine 2\nLine 3. JSON string: "Line 1\nLine 2\nLine 3" (\n = newline escape). Can't use actual newlines in JSON strings (breaks syntax).
• API request payloads: POST API with user input: {"comment": "User said: \"Great!\"\nThanks"}. User input has quotes/newlines → escape before JSON. Prevents injection (malformed JSON breaks API).
• Generate JSON from code: JavaScript: const msg = 'He said "Hi"'; const json = `{"message": "${escape(msg)}"}`; Without escaping: {"message": "He said "Hi""} (invalid JSON). With escaping: valid.
• Debug escaped strings: API returns: {"error": "File not found:\nC:\\Users\\file.txt"}. Hard to read: \n and \\ mixed. Unescape: File not found: (newline) C:\Users\file.txt (clear message).
• Config files (JSON): Store text with special chars: {"license": "MIT License\nCopyright (c) 2024"}. Newline in license text → escape as \n. JSON parser converts \n back to newline (when reading).

When to use json escape

Use when working with JSON strings containing special characters.

• Creating JSON payloads (API requests with text containing quotes/newlines).
• Fixing JSON syntax errors (unescaped quotes or newlines).
• Debugging JSON responses (unescape to see actual text).
• Generating JSON programmatically (escape variables before inserting).
• Embedding multiline text in JSON (escape newlines as \n).
• Storing config with special chars (JSON config files).
• Testing JSON parsers (check handling of escape sequences).
• Converting between escaped/unescaped formats (data transformation).

How to use json escape

Enter text, choose escape or unescape, copy result.

1. Escape text to JSON string: Mode: Escape. Enter: He said "Hello"\nNew line (quotes, backslash, text 'New line'). Output: He said \"Hello\"\\nNew line (" → \", \ → \\, \n stays \n). Copy result.
2. Unescape JSON string: Mode: Unescape. Enter: Hello\nWorld\t\"Quote\" (escaped string). Output: Hello (newline) World (tab) "Quote" (actual newline/tab/quotes). View readable text.
3. Handle Unicode: Enter: © 2024. Escape (Unicode mode): \u00A9 2024 (© → Unicode escape). Or escape (minimal): © 2024 (keep as UTF-8). Option: escape all non-ASCII or only special chars.
4. Copy for use in JSON: Escaped result: He said \"Hello\". Use in JSON: {"message": "He said \"Hello\""}. Or code: const json = '{"message": "' + escaped + '"}';
5. Validate result: After escaping: paste in JSON validator. Example: {"text": "escaped result"}. Validates: escaping correct (no syntax errors). Or test in JSON.parse('{"text": "..."}').
6. Common scenarios: Newlines: \n (line feed), \r\n (Windows CRLF). Tabs: \t. Backslash: \\ (double). Quotes: \". Example: path C:\\Users → C:\\\\Users (each \ → \\).

Key features

• Escape special characters: Converts to JSON-safe: " → \", \ → \\, \n → \\n (literal backslash-n), newline → \n (escape). Tab → \t, carriage return → \r. Ensures valid JSON strings.
• Unescape (decode): Reverses escaping: \" → ", \\ → \, \n → newline, \t → tab. Input: escaped JSON string. Output: readable text. See actual content (not escape sequences).
• Unicode escape/unescape: Escape: © → \u00A9, ñ → \u00F1, 😀 → \uD83D\uDE00 (surrogate pair for emoji). Unescape: \u00A9 → ©. Supports 4-digit hex (\uXXXX). Compatibility: some parsers require ASCII-only.
• Bidirectional conversion: Toggle: Escape mode ↔ Unescape mode. Input changes: escape takes plain text, unescape takes escaped string. Output updates (real-time). Test both directions.
• Forward slash handling: Optional: escape / → \/. JSON spec allows both (/ and \/). Most parsers accept /. Some require \/ (HTML script tags: </script> → <\/script> to avoid closing tag). Option to enable/disable.
• Error detection: Invalid escape sequences flagged: \x (not valid JSON, should be \uXXXX), \' (single quote, not required in JSON), unterminated \u (\u00 missing 2 digits). Helps fix malformed escaped strings.
• Real-time conversion: Type in input → output updates instantly. No submit button. See escaped/unescaped result as you type. Immediate feedback (test different inputs).

Common use cases

• API POST request with quotes: POST /comment with body: {"text": "User said: \"Great job!\""}. User input: User said: "Great job!". Escape quotes: \" → valid JSON. Without escaping: {"text": "User said: "Great job!""} (syntax error).
• Multiline error messages: API error: Validation failed: (newline) - Name required (newline) - Email invalid. JSON: {"error": "Validation failed:\n- Name required\n- Email invalid"}. Newlines → \n (JSON string format).
• Config file with paths: Windows path: C:\Users\Admin\file.txt. JSON config: {"path": "C:\\Users\\Admin\\file.txt"}. Each backslash doubled (\\). Parser reads \\ as single \.
• Debugging API responses: API returns: {"message": "Error:\nFile not found"}. Unescape: Error: (actual newline) File not found. Easier to read than \n in middle of text.
• Embedding JSON in JSON: Store JSON as string: {"config": "{\"key\": \"value\"}"}. Inner JSON escaped: { → {, " → \". Parser reads: config = string "{\"key\": \"value\"}", parse again to get object.
• Unicode in JSON: Product name: Café Münchën. JSON: {"name": "Café Münchën"} (UTF-8, valid). Or escaped: {"name": "Caf\u00E9 M\u00FCnch\u00EBn"} (ASCII-only, wider compatibility). Tool converts between both.

Examples

Common JSON escape/unescape scenarios.

He said "Hello"

Escaped: He said \"Hello\"
JSON: {"message": "He said \"Hello\""}

Line 1
Line 2
Line 3

Escaped: Line 1\nLine 2\nLine 3
JSON: {"text": "Line 1\nLine 2\nLine 3"}

C:\Users\Admin

Escaped: C:\\Users\\Admin
JSON: {"path": "C:\\Users\\Admin"}

Hello\nWorld\t\"Quote\"

Unescaped: Hello
World	"Quote"

© 2024 Café

Escaped (Unicode): \u00A9 2024 Caf\u00E9
Escaped (minimal): © 2024 Café

Technical reference

JSON string escape sequence specifications:

Required escapes

Double quote (\"), backslash (\\). JSON strings delimited by ". Quote inside string must be escaped: \" (or string ends early). Backslash is escape char → must escape itself: \\.

Control characters

Newline: \n (U+000A). Carriage return: \r (U+000D). Tab: \t (U+0009). Backspace: \b (U+0008). Form feed: \f (U+000C). Must be escaped (can't use raw control chars in JSON strings).

Unicode escapes

\uXXXX (4 hex digits). Example: \u0041 = A, \u00A9 = ©, \u4E2D = 中. Emoji (outside BMP): surrogate pairs. 😀 (U+1F600) → \uD83D\uDE00 (high surrogate D83D + low DE00).

Forward slash

/ can be escaped as \/ (optional). Reason: <\/script> in HTML (avoid closing script tag). JSON parsers accept both / and \/. Escaping not required (unlike \" and \\).

Not required escapes

Single quote (') doesn't need escaping in JSON (only " required). Spaces, letters, numbers: no escaping. Example: "Hello World" valid (no escaping needed). Only special chars/control chars escaped.

Escape in JSON vs JavaScript

JSON: only \" required for quotes (strings use double quotes). JavaScript: \" in double-quoted strings (""), \' in single-quoted (''). Template literals (`): no escaping quotes. Different rules.

Invalid escapes

\x (hex escape, not valid JSON). \0 (null, not valid JSON, use \u0000). \' (single quote, unnecessary). \v (vertical tab, not in JSON spec). Only listed escapes valid: \", \\, \/, \n, \r, \t, \b, \f, \uXXXX.

UTF-8 vs escaped Unicode

JSON allows UTF-8: {"text": "©"} valid (© as raw UTF-8 byte sequence). Or escaped: {"text": "\u00A9"}. Both equivalent. UTF-8: compact (1-4 bytes). Escaped: ASCII-only (6 bytes: \u00A9), wider compatibility.

Escaping backslash

Single \ → double \\. Example: C:\Users → C:\\Users. Literal \n (backslash + n, not newline) → \\n (escaped backslash + n). Newline (actual) → \n (escape sequence).

Order of escaping

Escape backslashes first (prevent double escaping). Example: text has \n (literal backslash-n). 1) Escape \: \\n. 2) Don't escape n (already part of \\n). Wrong order: escape n to \n → escape \ → \\\n (incorrect).

Common mistakes to avoid

Not escaping quotes in JSON strings (syntax error)

Why it happens: {"message": "He said "Hi""} (unescaped quotes → string ends at 2nd ", "Hi"" is invalid syntax). Parser error: unexpected token after string.

How to avoid it: Escape quotes: {"message": "He said \"Hi\""}. Use tool: enter 'He said "Hi"' → copy escaped: He said \"Hi\" → insert in JSON string.

Using raw newlines in JSON strings

Why it happens: {"text": "Line 1 (actual newline) Line 2"} (raw newline breaks JSON syntax). JSON strings must be on single line (or use \n for newlines). Parser error: unterminated string.

How to avoid it: Escape newlines: {"text": "Line 1\nLine 2"}. Tool converts actual newline → \n (escape sequence). Parser reads \n as newline character (when used).

Single backslash in paths (C:\Users → invalid escape \U)

Why it happens: {"path": "C:\Users"} (\U not valid escape sequence). Parser error: invalid escape. Or misinterpreted: \t (tab), \n (newline) in C:\temp\new.

How to avoid it: Double backslashes: {"path": "C:\\Users\\"}. Tool: input C:\Users → escaped: C:\\Users. Each \ → \\. Parser reads \\ as single \.

Forgetting to unescape when displaying (shows \n instead of newline)

Why it happens: API response: {"error": "Error:\nDetails"}. Display as-is: Error:\nDetails (user sees \n text, not newline). Confusing (looks like error message has literal backslash-n).

How to avoid it: Unescape before displaying: Error:\nDetails → Error: (newline) Details. Use tool or parser (JSON.parse() auto-unescapes). User sees formatted message (newline = line break).

Escaping already-escaped strings (double escaping)

Why it happens: String: He said \"Hi\". Escape again: He said \\\"Hi\\\". Result: {"message": "He said \\\"Hi\\\""} (too many backslashes). Parser reads: He said \"Hi\" (not He said "Hi").

How to avoid it: Check if already escaped. If string has \" (escaped quote), don't escape again. Or unescape first → re-escape (if needed). Tool: paste → see if output looks correct.

Frequently asked questions

What's the difference between \n and \\n in JSON?

\n = newline character (escape sequence, becomes line break when parsed). \\n = literal backslash + n (two chars: \ and n, no line break). {"text": "\n"} → newline. {"text": "\\n"} → \n text.

Do I need to escape single quotes in JSON?

No. JSON strings use double quotes (""). Single quote (') doesn't need escaping. Example: {"text": "It's fine"} valid (no escaping needed). Only \" required for double quotes inside string.

How do I escape a backslash in JSON?

Single \ → double \\. Example: C:\Users → C:\\Users in JSON: {"path": "C:\\Users"}. Parser reads \\ as one \. Reason: \ is escape character (must escape itself).

Can JSON strings contain Unicode characters directly?

Yes (if UTF-8). {"text": "©"} valid (© as raw UTF-8). Or escaped: {"text": "\u00A9"}. Both work. UTF-8: compact. Escaped Unicode: ASCII-only (wider compatibility, some old parsers).

Why does my JSON have \/ for forward slashes?

/ can be escaped as \/ (optional, not required). Reason: <\/script> in HTML (prevent closing script tag early). JSON allows both / and \/. Most tools don't escape / (unnecessary unless in HTML).

How do I fix 'invalid escape sequence' error?

Check escape: \x, \', \v invalid in JSON (not in spec). Valid: \", \\, \/, \n, \r, \t, \b, \f, \uXXXX. Example: \x41 → \u0041 (hex escape: use \u). Or literal: \\x41 (backslash-x-4-1).

Do I need to escape spaces, letters, numbers?

No. Only escape: special chars (", \, /), control chars (\n, \t, \r, \b, \f), non-ASCII (optional: Unicode). Spaces, letters (a-z), numbers (0-9): no escaping. Example: "Hello 123" valid as-is.

References

• JSON Specification (RFC 8259)
• JSON String Escaping
• Unicode Escape Sequences
• MDN: JSON.parse (JavaScript)