How do I convert a JavaScript object to a JSON string?

Call JSON.stringify(object) to get a compact JSON string. For readable output, use JSON.stringify(object, null, 2) to add two-space indentation. To filter which fields are included, pass an array of key names as the second argument: JSON.stringify(object, ["id", "name"], 2) outputs only the id and name fields. For conditional transforms, pass a replacer function as the second argument. The result is always a string. If you need to send it over HTTP, that string goes in the request body with Content-Type: application/json.

How do I convert a JavaScript class instance to JSON?

JSON.stringify serializes the enumerable own properties of a class instance, which is usually a subset of the full object. Private fields (#field syntax) and methods are not included. To get full control over serialization, add a toJSON() method to your class. JSON.stringify calls toJSON() automatically and serializes whatever it returns. For example: toJSON() { return { id: this.id, name: this.name } } ensures only those fields appear in the output, regardless of what else the instance contains. This pattern is also useful for omitting sensitive fields before serialization.

What is the toJSON method and when should I use it?

toJSON() is a method you can define on any object. When JSON.stringify encounters an object with a toJSON() method, it calls that method and serializes the returned value instead of the object itself. Date objects use this mechanism to produce ISO strings. You should add toJSON() when you need to control the serialization of class instances, strip sensitive or non-serializable fields, convert non-JSON-compatible types like Map or Set to plain objects, or produce a stable wire format that is decoupled from your internal data model. The method receives the current key as its argument.

JavaScript Object to JSON: Complete Conversion Guide

Q: Which JavaScript values cannot be serialized to JSON?

Several JavaScript values have no JSON representation. undefined, functions, and symbols are omitted when they appear as object property values, and become null when they appear as array elements. NaN, Infinity, and -Infinity become null. BigInt values throw a TypeError. Map and Set do not serialize as useful JSON by default — a Map becomes {} and a Set becomes []. Class instances serialize only their enumerable own properties, which is often incomplete. Date objects do serialize, but as ISO strings, not as Date objects. Circular references throw a TypeError.

Q: What happens to functions in JSON.stringify?

Functions are silently dropped when they appear as object property values. JSON.stringify({name: "Alice", greet: function() {}}) produces {"name":"Alice"} — the greet property is omitted entirely. When a function appears as an array element, it becomes null to preserve the array length. This is intentional: JSON is a data interchange format and executable code cannot be represented or safely transmitted as JSON. If you need to serialize logic, consider storing the function name as a string and mapping it back to a function after parsing.

Last updated: May 11, 2026

JSON.stringify(value, replacer, space) converts any JavaScript object to a JSON string. Pass an array of key names as the replacer to whitelist fields; pass 2 as the space argument for 2-space pretty-printing. Three value types are silently dropped from object properties: undefined, functions, and Symbol-keyed properties; the same types become null inside arrays. NaN and Infinity also serialize to null; BigInt and circular references both throw a TypeError. This guide covers the 3-argument signature, handling undefined and functions, fixing circular references with a custom replacer, Date serialization, and the toJSON() method for controlling class instance output.

Convert an object to a JSON string

Pass the object to JSON.stringify. The result is a string that can be sent over HTTP, saved to localStorage, written to a file, or pasted into another tool.

const user = {
  id: 42,
  name: 'Alice',
  active: true,
  roles: ['admin', 'editor']
}

const json = JSON.stringify(user)

console.log(typeof json)
// string

console.log(json)
// {"id":42,"name":"Alice","active":true,"roles":["admin","editor"]}

To turn that string back into runtime data, use JSON to JavaScript object.

Pretty print the JSON output

Add a third argument to create readable JSON. This is the most common form for debugging, config files, and examples in docs.

const pretty = JSON.stringify(user, null, 2)

// {
//   "id": 42,
//   "name": "Alice",
//   "active": true,
//   "roles": [
//     "admin",
//     "editor"
//   ]
// }

There is also a dedicated guide for pretty printing JSON in JavaScript.

Convert only selected properties

Use a replacer array when you want an allowlist of keys. This is useful for small exports, examples, and log output.

const account = {
  id: 42,
  name: 'Alice',
  email: 'alice@example.com',
  passwordHash: 'do-not-export'
}

JSON.stringify(account, ['id', 'name'], 2)

// {
//   "id": 42,
//   "name": "Alice"
// }

For security-sensitive fields, filter data before serialization too. A replacer is useful, but it should not be the only guard that protects secrets.

Transform values while converting

A replacer function can omit, normalize, or convert fields as JSON is created.

const json = JSON.stringify(account, (key, value) => {
  if (key === 'passwordHash') return undefined
  if (value instanceof Date) return value.toISOString()
  if (typeof value === 'bigint') return value.toString()
  return value
}, 2)

This pattern is useful for API payloads, logs, and exports where you want a stable wire format.

Values that do not survive object to JSON conversion

undefined, functions, and symbols are omitted from objects.
NaN, Infinity, and -Infinity become null.
Date objects become ISO strings.
Map and Set do not serialize as useful JSON by default.
BigInt throws unless converted first.
Circular references throw TypeError.

Prepare objects before stringifying

If the object contains Maps, Sets, class instances, or database records, normalize it to plain JSON-compatible data first.

const settings = new Map([
  ['theme', 'dark'],
  ['density', 'compact']
])

const payload = {
  settings: Object.fromEntries(settings),
  exportedAt: new Date().toISOString()
}

JSON.stringify(payload, null, 2)

Check the JSON before using it

Paste your generated JSON into Jsonic's JSON Formatter to validate syntax, inspect nesting, or minify the final payload.

Open JSON Formatter

Frequently asked questions

What is the difference between JSON.stringify and JSON.parse?

JSON.stringify converts a JavaScript value into a JSON string (serialization). JSON.parse converts a JSON string back into a JavaScript value (deserialization). Use stringify when sending data, parse when receiving it.

Which JavaScript values cannot be serialized to JSON?

Functions, undefined, and symbols are omitted from objects or becomenull in arrays. NaN and Infinity becomenull. BigInt throws. Map and Setdo not serialize usefully by default.

How do I convert an object to a JSON string?

Call JSON.stringify(object) for a compact string, orJSON.stringify(object, null, 2) for readable indented output. Pass an array of key names as the second argument to include only specific fields.

What happens to functions in JSON.stringify?

Functions are silently dropped from object properties. Inside arrays, they becomenull. JSON is a data format and cannot represent executable code.

How do I convert a class instance to JSON?

JSON.stringify serializes enumerable own properties. Add a toJSON() method to the class to control exactly which fields are included and how they are formatted.

What is the toJSON method?

If an object defines toJSON(), JSON.stringify calls it and serializes the return value instead of the object itself. Use it to strip private fields, convert non-serializable types, and produce a stable wire format.