How to Fix "Cannot Use Object of Type stdClass as Array" in PHP json_decode()

By the end of this page, you will understand why json_decode() often returns a stdClass object in PHP, why array syntax like $result['context'] fails in that case, and how to fix it by either using object property access or decoding JSON as an associative array.

In PHP, json_decode() converts a JSON string into a PHP value. The important detail is that it can return different types depending on how you call it.

By default, JSON objects become PHP objects of type stdClass.

That means this JSON:

{"context":"hello","count":3}

usually becomes something like this in PHP:

$result = json_decode($json);

Now $result is an object, not an array. So you must access values using object syntax:

$result->context;

If you try this instead:

$result['context'];

PHP throws this error because bracket syntax is for arrays, not objects.

If you want json_decode() to return an associative array instead of an object, pass as the second argument:

Think of JSON data as a package that PHP can unpack in two different shapes:

• Object shape: like a person with named properties
  • Access with ->
• Array shape: like a box with named slots
  • Access with ['key']

If PHP gives you a person, you cannot open it like a box.

So:

• stdClass object → use ->
• associative array → use ['key']

The error happens because you are treating one shape as if it were the other.

The core syntax of json_decode() is:

json_decode(string $json, ?bool $associative = null)

Example 1: Default behavior returns an object

<?php
$json = '{"context":"hello","count":3}';
$result = json_decode($json);

echo $result->context; // hello
echo $result->count;   // 3

Here, $result is a stdClass object.

Example 2: Return an associative array

<?php
$json = '{"context":"hello","count":3}';
$result = json_decode($json, true);

echo $result['context']; 
 [];   

Consider this code:

<?php
$json = '{"context":"hello"}';
$result = json_decode($json);
echo $result->context;

Step by step:

1. $json stores the JSON string:

   '{"context":"hello"}'
   

2. json_decode($json) parses the JSON.

3. Because no second argument is provided, PHP converts the JSON object into a stdClass object.

4. $result now behaves like this conceptually:

   $result = (object) ['context' => 'hello'];
   

5. echo $result->context; reads the context property from the object.

6. Output:

This concept appears often in real PHP applications.

API responses

When calling an external API:

$response = file_get_contents('https://api.example.com/user');
$data = json_decode($response, true);
echo $data['name'];

If you forget the true, you must use object syntax instead.

AJAX requests

A frontend app may send JSON to PHP, and PHP may decode it:

$input = file_get_contents('php://input');
$data = json_decode($input, true);

Developers often prefer arrays here because they work well with validation and form-like processing.

Configuration files

JSON config files can be loaded into PHP:

$config = json_decode(file_get_contents('config.json'), );
 = [][];

In real projects, developers usually pick one style and stay consistent.

Common pattern: decode to arrays for input data

Many codebases use:

$data = json_decode($json, true);

Why?

• Easier to validate with array-based helpers
• Works naturally with isset(), array_key_exists(), and loops
• Familiar for request payload handling

Example:

$data = json_decode($requestBody, true);

if (!isset($data['email'])) {
    throw new InvalidArgumentException('Email is required');
}

Common pattern: use objects for structured responses

Some developers prefer objects when data feels like an entity:

$user = json_decode($json);

if (!(->email)) {
      ();
}

1. Using array syntax on an object

Broken code:

$result = json_decode($json);
echo $result['context'];

Why it fails:

• json_decode($json) returns a stdClass object by default.
• Objects use ->, not [].

Fix:

echo $result->context;

2. Using object syntax on an associative array

Broken code:

$result = json_decode($json, true);
echo $result->context;

Fix:

echo $result['context'];

3. Mixing styles in nested data

Object vs associative array in PHP

Quick rules

• json_decode($json) → returns object (stdClass) by default
• json_decode($json, true) → returns associative array
• Object access → ->
• Array access → ['key']

Common patterns

$result = json_decode($json);
echo $result->context;

$result = json_decode($json, true);
echo $result['context'];

Nested access

Object:

$result->user->name;

Array:

$result['user']['name'];

Error checking

Why does json_decode() return stdClass instead of an array?

By default, PHP converts JSON objects into stdClass objects. Pass true as the second argument if you want an associative array.

How do I access values from a stdClass object in PHP?

Use object property syntax:

$result->context;

How do I make json_decode() return an array?

Use:

$result = json_decode($json, true);

Then access values with bracket syntax.

Why does print_r() show the data but access still fails?

Because print_r() can display both arrays and objects. Seeing structure does not mean it is an array.

What is the difference between -> and [] in PHP?

is used for object properties. is used for array elements.

• PHP arrays — Important because associative arrays are one of the main ways to work with decoded JSON.
• PHP objects — Related because json_decode() returns stdClass objects by default.
• Associative arrays in PHP — Useful for understanding key-based access like $data['name'].
• Object property access in PHP — Directly related to reading values with ->.
• json_encode() and json_decode() — Core JSON conversion functions in PHP.
• isset() in PHP — Useful for safely checking whether a key or property exists.
• var_dump() and debugging in PHP — Helps identify whether a value is an object, array, or null.
• Error handling in PHP — Relevant for handling invalid JSON safely.