JSON String Escape

What is JSON String Escaping?

JSON string escaping is the process of converting special characters inside a string into escape sequences that JSON parsers can read without breaking the structure. The JSON specification (ECMA-404 / RFC 8259) requires that certain characters inside string values be preceded by a backslash. Without proper escaping, a literal double quote or newline inside a string would terminate the string early and produce a parse error.

Every JSON string is delimited by double quotes. When the string itself contains a double quote, a backslash, or a control character (U+0000 through U+001F), the character must be replaced by its escape sequence. For example, a literal newline becomes \n, a tab becomes \t, and a double quote becomes \". Any Unicode code point can also be represented as \uXXXX, where XXXX is the four-digit hexadecimal value.

Unescaping (the reverse operation) converts those backslash sequences back into the original characters. Use it when you receive a JSON payload where string values are double-escaped, or when you need to extract raw text from a JSON log entry for display in a UI or terminal. Log aggregation pipelines hit this constantly: when a JSON-encoded message is stored as a string value inside another JSON document, every backslash in the inner string arrives doubled.

Why Use a JSON Escape Tool?

Manually adding or removing backslashes is tedious and error-prone, especially when dealing with multi-line text, file paths, or embedded code snippets. A dedicated escape tool catches edge cases that hand-editing misses.

JSON String Escape Use Cases

JSON Escape Sequence Reference

The JSON specification defines exactly two required escapes (double quote and backslash) and six short escape sequences for common control characters. All other control characters (U+0000 through U+001F) must use the \uXXXX form. Characters above U+FFFF (like emoji) can be represented as a UTF-16 surrogate pair: \uD83D\uDE00.

JSON Escaping vs. JSON Encoding

Developers sometimes confuse escaping a string with encoding a full JSON document.

Code Examples

Every major language has built-in functions for this. Examples in JavaScript, Python, Go, and jq:

// JSON.stringify escapes a value and wraps it in quotes
JSON.stringify('Line 1\nLine 2')       // → '"Line 1\\nLine 2"'

// To get just the inner escaped string (no surrounding quotes):
const escaped = JSON.stringify('She said "hello"').slice(1, -1)
// → 'She said \\"hello\\"'

// Parsing reverses the escaping
JSON.parse('"tabs\\tand\\nnewlines"')  // → 'tabs\tand\nnewlines'

// Handling Unicode: emoji in JSON
JSON.stringify('Price: 5\u20ac')       // → '"Price: 5\u20ac"' (raw euro sign)

import json

# json.dumps escapes and quotes a string
json.dumps('Line 1\nLine 2')           # → '"Line 1\\nLine 2"'

# Ensure ASCII: replace non-ASCII with \uXXXX sequences
json.dumps('Caf\u00e9', ensure_ascii=True)   # → '"Caf\\u00e9"'

# Keep UTF-8 characters as-is (default in Python 3)
json.dumps('Caf\u00e9', ensure_ascii=False)  # → '"Caf\u00e9"'

# Unescape by round-tripping through json.loads
json.loads('"She said \\"hello\\""')      # → 'She said "hello"'

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	// json.Marshal escapes a Go string for JSON
	raw := "Line 1\nLine 2\tindented"
	b, _ := json.Marshal(raw)
	fmt.Println(string(b))
	// → "Line 1\nLine 2\tindented"

	// Unescape with json.Unmarshal
	var out string
	json.Unmarshal([]byte(`"She said \"hello\""`), &out)
	fmt.Println(out)
	// → She said "hello"
}

# Escape a raw string into a JSON-safe value
echo 'Line 1
Line 2	with tab' | jq -Rs '.'
# → "Line 1\nLine 2\twith tab\n"

# Unescape a JSON string back to raw text
echo '"She said \"hello\""' | jq -r '.'
# → She said "hello"

Frequently Asked Questions