What is the difference between JSON.parse and eval() for parsing JSON?

JSON.parse is the correct and safe way to parse JSON. It only accepts valid JSON and throws SyntaxError for anything else. eval() executes arbitrary JavaScript code, so using it to parse JSON is a serious security risk — a malicious JSON string could contain executable code that runs in your application. eval() is also slower for this use case because it compiles the input as JavaScript rather than parsing it as a data format. There is no legitimate reason to use eval() for JSON parsing in modern JavaScript. JSON.parse is faster, safer, and available in every JavaScript environment.

How do I safely handle null values after parsing JSON?

After JSON.parse, any JSON null value becomes the JavaScript null primitive. Accessing a property on null throws a TypeError, so always check for null before traversal. Use optional chaining: data?.user?.name returns undefined instead of throwing if any part of the chain is null or undefined. Use nullish coalescing to provide defaults: data?.user?.name ?? "Anonymous". For array fields that might be null, check with Array.isArray(data?.items) before iterating. For required fields, explicitly validate: if (data.email === null || data.email === undefined) throw new Error("email is required").

Can I parse JSON in a browser without any library?

Yes. JSON.parse is a built-in global function available in all modern browsers and has been since Internet Explorer 8. No library or import is needed. It parses the string synchronously and returns the result. For browser environments, this is the standard approach for parsing fetch responses, localStorage values, and user-provided JSON. The response.json() method on a Fetch API response also uses the same native JSON parser internally. The only case where a library adds value is post-parse validation, not parsing itself.

JSON to JavaScript Object: Safe Parsing Guide

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

Call JSON.parse(jsonString) to convert a JSON string into a JavaScript value. The result is an object, array, string, number, boolean, or null depending on the top-level JSON type. For example, JSON.parse('{"name":"Alice","age":30}') returns the JavaScript object { name: "Alice", age: 30 }. Always wrap the call in try/catch when the input comes from an untrusted source, because JSON.parse throws a SyntaxError if the string is not valid JSON. After parsing, validate that the result has the shape your code expects before using its properties.

Q: What is the result type of JSON.parse?

The TypeScript type of JSON.parse's return value is any, which means TypeScript does not know the shape of the result. In practice, the runtime type depends on the top-level JSON value: an object literal produces a plain object, a JSON array produces an array, a quoted string produces a string, a number produces a number, true or false produce booleans, and null produces null. To get type safety, cast the result or validate it with a runtime type guard after parsing: const data = JSON.parse(raw) as MyExpectedType, or use a validation library like Zod that both parses and narrows the type.

Q: How do I parse a JSON array in JavaScript?

JSON.parse handles top-level JSON arrays the same way as objects. JSON.parse('[1,2,3]') returns [1, 2, 3]. JSON.parse('[{"id":1},{"id":2}]') returns an array of objects. After parsing, use standard array methods: map, filter, forEach, find. Always guard against the case where the parsed value is not an array: if (!Array.isArray(result)) throw new Error("Expected an array"). For large arrays or complex item shapes, validate a sample of items or use a schema validator to confirm every item has the required fields before processing the full array.

Last updated: May 11, 2026

JSON.parse(jsonString) converts a JSON string to a JavaScript value in 1 synchronous call, returning 1 of 6 possible types: Object, Array, string, number, boolean, or null. It throws SyntaxError for invalid JSON — always wrap in try/catch when the input is untrusted. In TypeScript the return type is any; cast to unknown and add a Zod schema or type guard to close that 1-line safety gap. The optional 2nd argument is a reviver function that transforms each parsed value — the most common use is converting ISO 8601 strings to native Date objects. This guide covers 4 topics: the full parse pattern, reviver functions, localStorage round-trip patterns, and TypeScript-safe validation with Zod.

Basic JSON to object conversion

A valid JSON string becomes a JavaScript value: object, array, string, number, boolean, ornull.

const raw = '{"id":42,"name":"Alice","active":true}'
const user = JSON.parse(raw)

console.log(user.name)
// Alice

If you need the reverse direction, see JavaScript object to JSON.

Always catch parse failures

Invalid JSON throws a SyntaxError. This matters for user input, localStorage, uploaded files, query strings, and third-party API responses.

function parseJsonObject(raw) {
  try {
    return { ok: true, value: JSON.parse(raw) }
  } catch (error) {
    return {
      ok: false,
      error: error instanceof Error ? error.message : 'Invalid JSON'
    }
  }
}

If you are debugging a parser failure, the dedicated JSON.parse error guide covers the most common error cases.

Convert JSON to nested objects and arrays

JSON naturally supports nesting. The result is a normal JavaScript object tree that you can traverse with dot notation or array indexing.

const raw = ` + "'{"user":{"profile":{"name":"Alice"}},"roles":["admin","editor"]}'" + `
const data = JSON.parse(raw)

console.log(data.user.profile.name)
console.log(data.roles[0])

For deeper structures and optional fields, read parse nested JSON in JavaScript.

Use a reviver for special value handling

A reviver runs after parsing and lets you convert specific values, such as ISO dates, into richer JavaScript objects.

const raw = '{"createdAt":"2024-01-15T10:30:00.000Z"}'

const result = JSON.parse(raw, (key, value) => {
  if (key === 'createdAt' && typeof value === 'string') {
    return new Date(value)
  }
  return value
})

Parsing is not validation

Parsed JSON can still be the wrong shape. Check required fields or validate with JSON Schema before trusting the data.

const payload = JSON.parse('{"email":123}')

if (typeof payload.email !== 'string') {
  throw new Error('email must be a string')
}

For reusable validation rules, see JSON Schema examples.

Validate JSON before parsing it in code

Use Jsonic's JSON Formatter to catch syntax errors and the JSON Schema Validator to verify object structure.

Validate JSON Syntax Validate Schema

Frequently asked questions

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

Call JSON.parse(jsonString). The result is the JavaScript equivalent of the JSON value. Wrap in try/catch for untrusted input and validate the shape before using it.

What is the difference between JSON.parse and eval()?

JSON.parse is safe and only accepts valid JSON. eval() executes arbitrary JavaScript, making it a serious security risk. Never use eval() for parsing JSON.

How do I handle null values after parsing?

Use optional chaining (data?.user?.name) and nullish coalescing (data?.name ?? 'default') to safely access properties that may benull or missing.

Can I parse JSON in a browser without a library?

Yes. JSON.parse is a built-in global available in all modern browsers and Node.js. No library or import is needed.

What is the result type of JSON.parse?

TypeScript types it as any. At runtime the type depends on the JSON: object, array, string, number, boolean, or null. Cast or validate with a library like Zod to get type safety.

How do I parse a JSON array in JavaScript?

JSON.parse handles top-level arrays: JSON.parse('[1,2,3]') returns a JavaScript array. Check with Array.isArray(result) before iterating to guard against unexpected shapes.