JSON Object to String in JavaScript: A Practical stringify Guide

Learn how to convert a JavaScript object to a JSON string with JSON.stringify, handle replacers, formatting, and parsing back with JSON.parse. Practical examples for aspiring developers and frontend pros.

JavaScripting Team

April 2, 2026·5 min read

JavaScript Tutorials Learn JavaScript Objects Syntax

Quick AnswerDefinition

A JSON object can be converted to a string in JavaScript using JSON.stringify. This serializes your object into a JSON-formatted text, which is useful for storage or network transmission. You can pass a replacer function or an indent argument to customize output. Note that functions, undefined, or symbol properties are handled specially and may be omitted.

Understanding JSON and JavaScript objects

JSON is a text-based data interchange format that represents structured data. In JavaScript, objects and arrays map naturally to JSON values, and the bridge between them is the stringify operation. The primary API you’ll use is JSON.stringify, which takes a value and returns a JSON-formatted string. If you stringify an object that contains a Date, it will be converted to an ISO string via the toJSON method. This block demonstrates a simple object and its serialized form.

JavaScript

const user = {
  id: 101,
  name: "Alex",
  preferences: { theme: "dark", locale: "en-US" },
  joined: new Date("2024-08-15T08:00:00Z")
};
const jsonText = JSON.stringify(user);
console.log(jsonText);

// Output // {"id":101,"name":"Alex","preferences":{"theme":"dark","locale":"en-US"},"joined":"2024-08-15T08:00:00.000Z"}

Why this matters: JSON.stringify converts JavaScript values to a string representation suitable for storage or transmission. It only serializes data that is valid in JSON, and functions or undefined values are omitted.

Basic usage: JSON.stringify

The most common usage of JSON.stringify is to serialize an object with optional formatting. You can pass a replacer to filter keys, or a space argument to pretty-print. The following example shows both a simple conversion and a pretty-printed output for readability.

JavaScript

const data = { a: 1, b: [2, 3], c: { d: 4 } };
const compact = JSON.stringify(data);
const pretty = JSON.stringify(data, null, 2);
console.log("compact:\n", compact);
console.log("\npretty:\n", pretty);

// Output // compact: // {"a":1,"b":[2,3],"c":{"d":4}} // // pretty: // { // "a": 1, // "b": [ // 2, // 3 // ], // "c": { // "d": 4 // } // }

Why use the space argument? It improves readability for logs, debugging, and human review, while the compact form minimizes payload size for network transmission.

Handling special values and data types

JSON.stringify handles data types differently. Numbers, strings, booleans, and null serialize as expected. Undefined, functions, and symbols are either omitted or converted in special ways. You can also customize serialization with a toJSON method on objects. The examples below illustrate common outcomes and how to influence them.

JavaScript

const tricky = {
  a: undefined,
  b: function() { return "hi"; },
  c: Symbol("id"),
  d: null
};
console.log(JSON.stringify(tricky)); // {"d":null}

const obj = {
  id: 1,
  name: "Sam"
};
obj.toJSON = function() {
  // Custom serialization
  return { id: this.id, name: this.name };
};
console.log(JSON.stringify(obj)); // {"id":1,"name":"Sam"}

Tip: If you need custom behavior, implement a toJSON method on your object. It will be invoked by JSON.stringify to determine how to represent the instance.

Handling circular references

Circular references cause JSON.stringify to throw. To serialize complex graphs, use a replacer that tracks seen objects and omits them when encountered again. The pattern below demonstrates a safe serializer that breaks cycles.

JavaScript

const a = { name: "A" };
const b = { a };
a.b = b; // circular reference

const seen = new WeakSet();
const safeStringify = (key, value) => {
  if (value && typeof value === "object") {
    if (seen.has(value)) return undefined; // drop circular reference
    seen.add(value);
  }
  return value;
};
const json = JSON.stringify(a, safeStringify, 2);
console.log(json);

// Output // { // "name": "A", // "b": { // "a": {} // } // }

Alternatives: Use libraries like cycle.js or a robust replacer for complex graphs. Always validate the resulting JSON before sending over the network.

Parsing back: JSON.parse and reviver

Converting a string back into an object is done with JSON.parse. You can supply a reviver to transform values during parsing, such as turning date strings back into Date objects or converting numeric strings to numbers. This reduces post-processing code in your app.

JavaScript

const s = '{"name":"Alex","date":"2026-04-01T12:34:56.000Z"}';
const obj = JSON.parse(s, (k, v) => {
  if (typeof v === 'string' && /^\d{4}-\d{2}-\d{2}T/.test(v)) {
    return new Date(v);
  }
  return v;
});
console.log(obj.name, obj.date instanceof Date);

// Output // Alex true

Note: Revivers are powerful for restoring types but make the parsing logic slightly more complex. Use them when you need precise type restoration after deserialization.

Practical examples: Storing user data and network transfer

In real apps, you often stringify before sending data to an API or saving to disk. This example demonstrates a practical pattern: stringify a user object and POST it to an endpoint. It includes nested data, arrays, and a Date field that becomes an ISO string in JSON.

JavaScript

const user = {
  id: 42,
  name: "Jordan",
  roles: ["admin","editor"],
  prefs: { theme: "dark", notifications: true },
  lastSeen: new Date()
};
const payload = JSON.stringify(user);
// In a browser environment:
fetch("/api/saveUser", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: payload
})
  .then(res => res.json())
  .then(data => console.log(data))
  .catch(console.error);

Takeaway: JSON.stringify enables compact transport formats. When receiving data back, use JSON.parse (with a reviver if needed) to restore usable JavaScript objects in your app.

Bonus patterns: validating and transforming large payloads

When working with large data sets, streaming or chunked payloads may be desirable. While JSON.stringify operates on entire structures in one go, you can implement chunked processing by breaking the data into smaller pieces and serializing each piece separately. This reduces peak memory usage and improves responsiveness in UI-heavy apps.

JavaScript

function* chunkify(obj, maxKeys = 5) {
  const keys = Object.keys(obj);
  for (let i = 0; i < keys.length; i += maxKeys) {
    const chunkKeys = keys.slice(i, i + maxKeys);
    const chunk = {};
    for (const k of chunkKeys) chunk[k] = obj[k];
    yield JSON.stringify(chunk);
  }
}
const largeObj = { /* many keys */ };
for (const piece of chunkify(largeObj)) {
  console.log(piece);
}

This pattern keeps memory usage predictable while still producing valid JSON strings.

Summary of serialization choices and best practices

Prefer JSON.stringify for object-to-string conversion and JSON.parse for parsing back to objects.
Use replacer and space arguments to control output shape and readability.
Be mindful of data types that do not serialize (functions, undefined, symbols).
Handle circular references with a replacer or dedicated libraries.
Use toJSON on objects when you need custom serialization behavior.
Validate the serialized string before network transmission or persistence.

prerequisitesSectionExcludedForClarity

Steps

Estimated time: 20-40 minutes

1
Define data to stringify
Declare the JavaScript object you intend to serialize. Include nested objects and arrays to reflect real data structures.
Tip: Keep data shaped similarly to how you’ll consume it after parsing.
2
Call JSON.stringify with options
Invoke JSON.stringify(value, replacer, space) to control which keys serialize and how the string looks.
Tip: Use space for readability in development; avoid it in production payloads.
3
Handle serialization edge cases
Account for undefined, functions, and symbols. Use toJSON if you need custom serialization behavior.
Tip: If you must serialize dates, rely on toJSON or a reviver on parse.
4
Parse back with JSON.parse
Convert the string back into a JavaScript object. Optionally use a reviver to restore types.
Tip: Validate the resulting object before use.
5
Persist or transmit
Send the string over the network or store it. Use proper content-type headers and validation.
Tip: Always validate JSON compatibility on both ends.
6
Extend with custom serialization
Leverage a toJSON method or a replacer function for advanced scenarios.
Tip: Document custom serialization rules for future maintainers.

Pro Tip: Prefer JSON.stringify for stable object-to-string without side effects.

Warning: Functions, undefined, and symbols do not serialize by default.

Note: Indentation (space) improves readability; trim in production.

Pro Tip: Use a reviver in JSON.parse to restore Date objects and other types.

Warning: Original object structure may not be preserved if you rely on non-JSON data.

Prerequisites

Required

Node.js 14+ (LTS) or a modern browser environment↗
Required
Basic knowledge of JavaScript objects and arrays
Required
JSON basics (format, syntax)
Required

Optional

Code editor (e.g., VS Code)↗
Optional
Familiarity with console output for debugging
Optional

Commands

Action	Command
Run a quick stringify in Node.jsShows pretty-printed JSON in terminal	—
Write to file and stringifySaves pretty JSON to disk	—
Parse a JSON string back to objectConverts string back to JS object	—
Inline stringify demoDate becomes ISO string in JSON	—

Questions & Answers

What happens to undefined values, functions, or symbols when stringified?

Undefined values, functions, and symbols are typically omitted or replaced during serialization. You can customize behavior with toJSON or a replacer function to control what gets serialized.

How do I stringify circular references without throwing an error?

Use a replacer that tracks seen objects (a Set or WeakSet) and omit values that create cycles. Libraries also provide robust cycle handling.

Can I serialize Date objects and restore them later?

Date objects serialize to ISO strings by default. Use a reviver in JSON.parse to convert those strings back into Date objects.

What is the difference between JSON.stringify and toJSON?

JSON.stringify uses your object's toJSON method if present. Defining toJSON allows custom serialization, producing tailored JSON output.

Is it safe to parse JSON from an untrusted source?

Parsing untrusted JSON can raise security concerns; validate schema, limit input size, and avoid evaluating code during parsing. Consider using a strict parser or schema validation.

How can I pretty-print JSON for debugging?

Pass a non-null space argument to JSON.stringify to generate indented, human-readable JSON. This is excellent for debugging and logging.

What to Remember

Use JSON.stringify to convert objects to strings
Indent with space for readability in development
Avoid serializing non-JSON data like functions
Parse with JSON.parse and optional revivers to restore types

← More in JavaScript Objects

Understanding JSON and JavaScript objects

Basic usage: JSON.stringify

Handling special values and data types

Handling circular references

Parsing back: JSON.parse and reviver

Practical examples: Storing user data and network transfer

Bonus patterns: validating and transforming large payloads

Summary of serialization choices and best practices

Steps

Define data to stringify

Call JSON.stringify with options

Handle serialization edge cases

Parse back with JSON.parse

Persist or transmit

Extend with custom serialization

Prerequisites

Commands

Questions & Answers

What to Remember

Related Articles