Loop Through Dynamic JSON Keys in PHP with foreach

You will learn how PHP represents decoded JSON, how to choose arrays or objects with json_decode(), and how nested foreach loops handle JSON with dynamic keys. You will also learn how to safely read optional fields such as age when they may not exist for every record.

JSON objects contain named properties. In the example, the outer JSON object has dynamic property names such as John, Jennifer, and James. Each name points to another JSON object containing details.

When you call json_decode($json, true), PHP converts JSON objects into associative arrays:

$data = json_decode($json, true);

The resulting shape is conceptually:

[
    'John' => ['status' => 'Wait'],
    'Jennifer' => ['status' => 'Active'],
    'James' => [
        'status' => 'Active',
        'age' => 56,
        'count' => 10,
        'progress' => 0.0029857,
        'bad' => 0,
    ],
]

An associative array stores values under keys, rather than only numeric positions. foreach is useful because it gives you both the current key and its value without knowing the keys beforehand.

Think of the decoded JSON as a filing cabinet.

• The outer cabinet has drawers labelled John, Jennifer, and James.
• Each drawer contains a folder of labelled facts, such as status, age, and count.
• You do not need to know every drawer label first: foreach opens each drawer in turn.
• A second foreach reads every labelled fact inside that drawer.

The variable before => receives the label (key), and the variable after => receives what is stored under that label (value).

Use json_decode() with true when you want associative arrays, then use nested foreach loops.

<?php

$json = file_get_contents('/home/michael/test.json');
$people = json_decode($json, true, 512, JSON_THROW_ON_ERROR);

foreach ($people as $name => $details) {
    echo "$name\n";

    foreach ($details as $field => $value) {
        echo "  $field: $value\n";
    }
}

Possible output:

John
  status: Wait
Jennifer
  status: Active
James
  status: Active
  age: 56
  count: 10
  progress: 0.0029857
  bad: 0

The outer loop assigns:

• $name: a dynamic top-level key, such as James

Consider this smaller JSON document:

$json = '{
  "John": {"status": "Wait"},
  "James": {"status": "Active", "age": 56}
}';

$people = json_decode($json, true, 512, JSON_THROW_ON_ERROR);

foreach ($people as $name => $details) {
    echo "$name\n";

    foreach ($details as $field => $value) {
        echo "$field = $value\n";
    }
}

Execution trace:

1. json_decode(..., true) converts the outer JSON object into an associative array.
2. On the first outer-loop iteration, $name is John and $details is ['status' => 'Wait'].
3. The inner loop runs once: $field is status and is .

Dynamic JSON keys appear in many practical situations:

• Configuration files: Feature flags may be grouped by an unknown environment or service name.
• API responses: A reporting API may return account IDs as object keys, with metrics inside each account.
• Import scripts: A JSON export may use product SKUs, usernames, or dates as keys.
• Monitoring data: Server names can be keys, while CPU, memory, and status values are nested fields.
• Translation files: Language codes such as en, fr, and de can map to nested message collections.

For example, an API might return server health by host name:

foreach ($servers as $hostname => $metrics) {
    $cpu = $metrics['cpu'] ?? null;
    echo "$hostname uses $cpu% CPU\n";
}

In production PHP code, developers usually combine iteration with validation and safe access.

Validate file and JSON input

<?php

$path = '/home/michael/test.json';

if (!is_readable($path)) {
    throw new RuntimeException("Cannot read JSON file: $path");
}

$contents = file_get_contents($path);
$people = json_decode($contents, true, 512, JSON_THROW_ON_ERROR);

if (!is_array($people)) {
    throw new UnexpectedValueException('Expected the JSON root to be an object.');
}

JSON_THROW_ON_ERROR makes invalid JSON fail immediately with a JsonException, instead of silently returning null.

Use guard clauses for unexpected records

External data can be incomplete or malformed. Skip entries that do not have the expected array structure.

Leaving array keys unquoted

This is incorrect:

// Broken: status is treated as a constant in older PHP versions.
echo $json_a['John'][status];

Use quotes for string keys:

echo $json_a['John']['status'];

Assuming every field exists

John does not have an age field. This can produce an undefined array key warning:

// Broken for people without an age.
echo $details['age'];

Use a fallback or check for the key:

echo $details['age'] ?? 'Not provided';

Using object syntax after decoding into arrays

With the second argument set to true, the result uses arrays. This is incorrect:

// Decode a JSON object into associative arrays
$data = json_decode($json, true, 512, JSON_THROW_ON_ERROR);

// Loop through dynamic top-level keys
foreach ($data as $key => $value) {
    // $key: for example, "James"
    // $value: nested array
}

// Loop through nested dynamic keys
foreach ($data as $name => $details) {
    foreach ($details as $field => $value) {
        echo "$name - $field: $value\n";
    }
}

// Safely read an optional field
$status = $details['status'] ?? 'Unknown';

// Check a field explicitly
if (array_key_exists('age', $details)) {
    echo $details['age'];
}

How do I loop through unknown JSON keys in PHP?

Decode the JSON into an associative array and use foreach ($data as $key => $value). The $key variable receives each unknown property name.

Why does json_decode($json, true) use square brackets?

The true argument tells PHP to convert JSON objects to associative arrays. PHP arrays use square-bracket access, such as $person['status'].

How do I access a nested JSON value in PHP?

For known keys, use nested array access: $data['James']['status']. For unknown keys, iterate with nested foreach loops.

What happens if a JSON field is missing?

Direct access can raise an undefined array key warning. Use $details['age'] ?? null or another appropriate default value.

Should I use json_last_error() or JSON_THROW_ON_ERROR?

For modern PHP, JSON_THROW_ON_ERROR is usually clearer because malformed JSON raises a JsonException at the decoding line.

Can I decode JSON into objects instead of arrays?

Yes. Omit the argument and use object access such as . Do not mix object access with array access.

• Associative arrays in PHP — Dynamic JSON object properties become associative-array keys when decoding with true.
• PHP foreach loops — The primary loop construct for visiting array keys and values.
• Nested arrays — Each person in the example contains another collection of fields.
• json_decode() — Converts a JSON string into PHP arrays or objects.
• Null coalescing operator (??) — Supplies defaults for optional or missing JSON fields.
• Exception handling in PHP — Useful for handling JsonException from invalid JSON.
• PHP objects vs arrays — Important because the decoding choice determines whether to use -> or [].