How to Parse JSON in PHP: json_decode and json_encode

json_decode: parse JSON into PHP

json_decode takes a JSON string and returns a PHP value. By default it returns objects: $data = json_decode($json); gives you a stdClass, so you access fields with arrow syntax like $data->name. This is fine, but many developers prefer arrays.

The associative flag: objects vs arrays

Pass true as the second argument to get associative arrays instead of objects: $data = json_decode($json, true); lets you use $data['name']. This is the most common pattern in PHP code because array access is familiar and easy to iterate with foreach. Choosing objects versus arrays is mostly a style decision — pick one and be consistent across your codebase.

$obj = json_decode($json);        // stdClass: $obj->name
$arr = json_decode($json, true);  // array:    $arr['name']

json_encode: produce JSON from PHP

json_encode converts a PHP value to a JSON string: echo json_encode($data);. It handles arrays, objects, and scalars. A key subtlety: an associative array encodes as a JSON object, while a sequential, zero-indexed array encodes as a JSON array. If your array keys are not a clean 0,1,2 sequence, PHP emits an object — a frequent source of surprise when an expected array comes out as an object.

Pretty printing and options

json_encode accepts bitmask flags. JSON_PRETTY_PRINT indents the output for readability, JSON_UNESCAPED_SLASHES keeps forward slashes unescaped, and JSON_UNESCAPED_UNICODE outputs multibyte characters directly instead of \u escapes — useful for non-Latin text. Combine them with the bitwise OR operator, for example json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE).

Error handling done right

Historically, json_decode returned null on failure, which is ambiguous because the JSON value null also decodes to null. The old way to disambiguate is json_last_error() and json_last_error_msg() after decoding. The modern, recommended approach is to pass the JSON_THROW_ON_ERROR flag so invalid JSON raises a JsonException you can catch with try/catch — explicit, clean, and impossible to ignore.

try {
    $data = json_decode($json, true, 512, JSON_THROW_ON_ERROR);
} catch (JsonException $e) {
    // handle invalid JSON explicitly
}

Common gotchas

• A return of null may mean an error or a literal null — use JSON_THROW_ON_ERROR to tell them apart.
• Associative arrays with non-sequential keys encode as JSON objects, not arrays.
• Deeply nested data can hit the recursion depth limit; raise the depth argument if needed.
• Invalid UTF-8 in strings causes json_encode to fail unless you handle encoding first.
• Large integers may lose precision; use JSON_BIGINT_AS_STRING on decode when exact values matter.

Inspecting JSON outside PHP

When a payload behaves unexpectedly, it helps to look at the raw JSON. Paste it into a validator to confirm it is well-formed and find the exact error location, or a formatter to read the structure. That is quicker than scattering var_dump calls to discover the shape PHP actually decoded.