JSON Stringify Online

Before & After: Object to String

Here is exactly what JSON.stringify() does to a simple object — note how every internal double quote becomes \" and the whole result is wrapped in outer quotes.

{
  "name": "Alice Chen",
  "age": 30,
  "active": true,
  "note": "line one\nline two"
}

"{"name":"Alice Chen","age":30,"active":true,"note":"line one\\nline two"}"

What Gets Escaped

JSON.stringify must escape certain characters inside string values to produce a valid JSON string literal. Here is every character that is transformed:

Non-ASCII characters (like emoji or accented letters) are not escaped by default — they are included as-is in the output. This is valid per RFC 8259 which mandates UTF-8. You can force Unicode escaping with a custom replacer if you need ASCII-safe output.

The Three Parameters of JSON.stringify()

JSON.stringify(value, replacer, space) — most developers only use the first argument, but the other two are powerful.

// Array replacer — only include these keys
JSON.stringify(user, ['name', 'email'])
// {"name":"Alice","email":"alice@example.com"}

// Function replacer — omit sensitive fields
JSON.stringify(user, (key, val) => {
  if (key === 'password') return undefined; // omit
  return val;                               // keep everything else
})

JSON.stringify(obj)          // compact (minified)
JSON.stringify(obj, null, 2) // 2-space indented (pretty-print)
JSON.stringify(obj, null, 4) // 4-space indented
JSON.stringify(obj, null, '\t') // tab-indented

Edge Cases & Gotchas

JSON.stringify has several non-obvious behaviours that cause bugs. Know them before they hit you in production.

const obj = { name: 'Alice', fn: () => {}, sym: Symbol('x'), val: undefined };
JSON.stringify(obj);
// '{"name":"Alice"}' — fn, sym, val silently omitted

JSON.stringify({ created: new Date('2026-04-26') });
// '{"created":"2026-04-26T00:00:00.000Z"}'
// JSON.parse() gives back a string, NOT a Date object

const a = {};
a.self = a; // circular
JSON.stringify(a);
// TypeError: Converting circular structure to JSON

JSON.stringify({ n: 9007199254740993n });
// TypeError: Do not know how to serialize a BigInt

const obj = {
  value: 42,
  toJSON() { return { serialised: this.value }; }
};
JSON.stringify(obj);
// '{"serialised":42}'

Stringifying Nested Objects & Arrays

Regardless of how deeply nested a JSON object is, JSON.stringify() flattens everything into a single linear string. Every double quote at every nesting level gets escaped — and nesting depth has no effect on the output structure.

{
  "orders": [
    {
      "id": "ord-001",
      "customer": {
        "name": "Alice Chen",
        "email": "alice@example.com"
      },
      "items": [
        { "sku": "WGT-PRO", "qty": 2 }
      ],
      "paid": true
    }
  ],
  "meta": { "page": 1, "total": 1 }
}

"{"orders":[{"id":"ord-001","customer":{"name":"Alice Chen","email":"alice@example.com"},"items":[{"sku":"WGT-PRO","qty":2}],"paid":true}],"meta":{"page":1,"total":1}}"

A key insight: array items are not individually escaped — the entire array structure is preserved as JSON, just with quotes escaped. The array brackets [ and ] do not need escaping (they are not JSON string delimiters), so they pass through as-is.

// Storing nested application state
const appState = {
  user: { id: 4821, name: 'Alice', role: 'admin' },
  prefs: { theme: 'dark', lang: 'en-US', notifications: true },
  cart: [{ id: 'WGT-PRO', qty: 2 }, { id: 'GDG-PLS', qty: 1 }],
};

// Stringify the whole object tree — nesting is preserved
localStorage.setItem('app-state', JSON.stringify(appState));

// Reading back — JSON.parse reconstructs the full nested structure
const stored = localStorage.getItem('app-state');
const state = stored ? JSON.parse(stored) : {};
console.log(state.user.name);   // 'Alice'
console.log(state.cart.length); // 2

JSON.stringify vs JSON.parse — The Complete Round-Trip

Every JSON data lifecycle follows the same pattern: serialise to cross a boundary, deserialise on the other side. Understanding both sides together is essential for writing bug-free data code.

// ── Full round-trip: Client → Server → Client ──────────────────

// 1. CLIENT: Stringify before sending
const payload = { userId: 4821, action: 'activate', meta: { source: 'dashboard' } };
const response = await fetch('/api/users/activate', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify(payload),   // ← serialise
});

// 2. SERVER (Node.js/Express): Parse is automatic via express.json()
app.post('/api/users/activate', (req, res) => {
  const { userId, action } = req.body; // ← already parsed by middleware
  res.json({ ok: true, userId });      // ← express calls JSON.stringify() internally
});

// 3. CLIENT: Parse the response
const result = await response.json(); // ← implicitly calls JSON.parse()
console.log(result.ok);              // true

// ── Reviver: Transform values during parse ──────────────────────
const data = JSON.parse(jsonString, (key, value) => {
  // Convert ISO date strings back to Date objects
  if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T/.test(value)) {
    return new Date(value);
  }
  return value;
});

Real-World JSON.stringify() Patterns

Beyond the basic use case, experienced JavaScript developers use JSON.stringify() in several powerful patterns. Here are the five most useful.

// ✓ Works for objects with JSON-compatible values
const original = { user: { id: 1, prefs: { theme: 'dark' } } };
const clone = JSON.parse(JSON.stringify(original));

clone.user.prefs.theme = 'light'; // does NOT affect original
console.log(original.user.prefs.theme); // 'dark' — deep clone confirmed

// ✗ Limitations — these values are lost in the clone:
// - undefined properties (silently dropped)
// - Functions (dropped)
// - Date objects (become strings)
// - RegExp objects (become {})
// - Circular references (throw)
//
// For complex objects, use structuredClone() (modern browsers/Node 17+)
const betterClone = structuredClone(original);

// API payload with optional fields
const updateUser = (id: number, changes: Partial<User>) => {
  // undefined fields are automatically omitted from the JSON body
  // — no need to manually delete them or use Object.fromEntries filter
  return fetch(`/api/users/${id}`, {
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      name: changes.name,        // included only if not undefined
      email: changes.email,      // included only if not undefined
      role: changes.role,        // included only if not undefined
    }),
  });
};

// JSON.stringify({name: 'Alice', email: undefined, role: undefined})
// → '{"name":"Alice"}'  — clean PATCH payload

const SENSITIVE_KEYS = new Set(['password', 'token', 'secret', 'apiKey', 'ssn']);

function safeStringify(obj: unknown): string {
  return JSON.stringify(obj, (key, value) => {
    if (SENSITIVE_KEYS.has(key)) return '[REDACTED]';
    return value;
  }, 2);
}

const user = {
  id: 4821,
  name: 'Alice Chen',
  password: 's3cr3t!',    // ← sensitive
  token: 'jwt-abc-123',   // ← sensitive
};

console.log(safeStringify(user));
// {
//   "id": 4821,
//   "name": "Alice Chen",
//   "password": "[REDACTED]",
//   "token": "[REDACTED]"
// }

const original = { name: 'Alice', role: 'viewer' };
const current  = { name: 'Alice', role: 'admin'  }; // role changed

const hasChanged = JSON.stringify(original) !== JSON.stringify(current);
console.log(hasChanged); // true

// ✓ Works for: flat objects, nested plain data, arrays
// ✗ Avoid for: objects with non-deterministic key order (use a
//   canonical stringify library like json-stable-stringify instead)

// React: Detect if state actually changed before re-rendering
const prevRef = useRef(JSON.stringify(data));
useEffect(() => {
  const current = JSON.stringify(data);
  if (current !== prevRef.current) {
    prevRef.current = current;
    // only runs when data actually changed
  }
}, [data]);

function asciiSafeStringify(obj: unknown): string {
  return JSON.stringify(obj, (_key, value) => {
    if (typeof value === 'string') {
      // Escape all non-ASCII characters to \uXXXX form
      return value.replace(/[^\x00-\x7F]/g, (ch) => {
        return '\\u' + ch.charCodeAt(0).toString(16).padStart(4, '0');
      });
    }
    return value;
  });
}

asciiSafeStringify({ greeting: 'héllo', name: '张伟', emoji: '🚀' });
// '{"greeting":"h\u00e9llo","name":"\u5f20\u4f1f","emoji":"\ud83d\ude80"}'
// — 100% ASCII, safe for any transport or legacy system

Stringifying in Other Languages

Every language with JSON support has an equivalent to JSON.stringify. The concept is the same: object → JSON string.

import json

user = {"name": "Alice", "age": 30, "active": True}

# Compact (equivalent to JSON.stringify with no spaces)
compact = json.dumps(user, separators=(',', ':'))
# '{"name":"Alice","age":30,"active":true}'

# Pretty-printed
pretty = json.dumps(user, indent=2)
# {
#   "name": "Alice",
#   ...
# }

# Sort keys alphabetically
sorted_json = json.dumps(user, sort_keys=True)

# Ensure ASCII — escapes non-ASCII chars
ascii_safe = json.dumps(user, ensure_ascii=True)

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    Name   string `json:"name"`
    Age    int    `json:"age"`
    Active bool   `json:"active"`
}

func main() {
    user := User{Name: "Alice", Age: 30, Active: true}

    // Compact
    b, _ := json.Marshal(user)
    fmt.Println(string(b))
    // {"name":"Alice","age":30,"active":true}

    // Pretty-printed
    b2, _ := json.MarshalIndent(user, "", "  ")
    fmt.Println(string(b2))
}

using System.Text.Json;

var user = new { Name = "Alice", Age = 30, Active = true };

// Compact (default)
string compact = JsonSerializer.Serialize(user);
// {"Name":"Alice","Age":30,"Active":true}

// Pretty-printed
string pretty = JsonSerializer.Serialize(user,
    new JsonSerializerOptions { WriteIndented = true });

// Newtonsoft.Json
using Newtonsoft.Json;
string njCompact = JsonConvert.SerializeObject(user);
string njPretty  = JsonConvert.SerializeObject(user, Formatting.Indented);

Double-Stringified JSON — JSON Inside JSON

Some APIs and event systems embed a JSON payload as a string value inside an outer JSON object. This requires double-stringification — stringifying a JSON string rather than an object.

{"event":"user.created","userId":4821}

{
  "type": "webhook",
  "body": "{"event":"user.created","userId":4821}"
}

The body field is a string that contains JSON — not an object. To produce it in JavaScript:

const inner = { event: 'user.created', userId: 4821 };
const outer = {
  type: 'webhook',
  body: JSON.stringify(inner), // stringify once → string value
};
JSON.stringify(outer); // stringify again → transmittable JSON

This pattern is common in AWS SQS/SNS messages, Stripe webhook events, Kafka message payloads, and any system where the transport envelope separates metadata from the data payload. Use this tool's Stringify mode to produce the inner string value, then paste it as the field value in your outer JSON.

When to Stringify JSON

Stringification is necessary whenever a JSON object must cross a boundary that only accepts plain strings — storage, transport headers, URL parameters, or nested JSON fields.

Stringify vs Parse vs Formatter

All three deal with JSON — but they serve opposite purposes in the data lifecycle.

Frequently Asked Questions