Introduction

In Python, json.loads() does not guess whether you want a dictionary or a list. It follows the structure of the JSON text. If the top-level JSON value is an object, you get a dict. If the top-level value is an array, you get a list.

The Top-Level JSON Shape Decides the Python Type

A JSON object becomes a dictionary:

1import json
2
3text = '{"name": "Ava", "age": 31}'
4value = json.loads(text)
5
6print(value)
7print(type(value))

The parsed type is dict because the JSON starts with an object.

A JSON array becomes a list:

1import json
2
3text = '[{"name": "Ava"}, {"name": "Liam"}]'
4value = json.loads(text)
5
6print(value)
7print(type(value))

This time the parsed type is list because the top-level JSON value is an array.

Validate the Root Type If You Need a Dictionary

If your program requires a dictionary, parse first and then validate that the root value has the expected type.

1import json
2
3
4def loads_dict(text: str) -> dict:
5    value = json.loads(text)
6    if not isinstance(value, dict):
7        raise ValueError("Expected top-level JSON object")
8    return value
9
10
11config = loads_dict('{"debug": true, "port": 8080}')
12print(config["port"])

This is the cleanest way to fail early when an API or file gives you a shape your code does not support.

Turning a List into a Dictionary Requires a Rule

If the incoming JSON is a list but your code wants a dictionary, the parser is not wrong. The data shape is different from your desired application shape. You need a second transformation step.

For example, you might convert a list of objects into a dictionary keyed by id:

1import json
2
3text = '[{"id": 1, "name": "Ava"}, {"id": 2, "name": "Liam"}]'
4items = json.loads(text)
5indexed = {item["id"]: item for item in items}
6
7print(indexed[1])

That dictionary is not the direct parse result. It is a deliberate transformation built on top of the parsed list.

object_hook Does Not Change Array Roots

Python's JSON decoder supports hooks such as object_hook, but those hooks run when JSON objects are decoded. If the top-level value is an array, the outermost result is still a list.

That means hooks can customize inner dictionaries, but they do not magically convert a list root into a dictionary root. If the JSON starts with [ and ], the top-level parsed container is still list-shaped.

Watch for Invalid JSON Syntax

Another common source of confusion is mixing Python literal syntax with JSON syntax. JSON requires double quotes around keys and string values.

Valid JSON:

text = '{"name": "Ava"}'

Invalid JSON:

text = "{'name': 'Ava'}"

If the input uses Python-style single quotes, json.loads() fails before type conversion even becomes relevant.

Common Pitfalls

Expecting json.loads() to return a dictionary when the top-level JSON value is actually an array is the core misunderstanding behind this issue.

Trying to force a list into a dictionary without a clear transformation rule usually creates brittle code later.

Confusing Python literal syntax with JSON syntax leads to decoding errors that can distract from the real type-shape question.

Assuming every API response should be a dictionary is incorrect because many APIs are designed to return top-level lists.

Validating the type too late makes downstream code fail in less obvious places than an early explicit check would.

Summary

• 'json.loads() returns a dict for a JSON object and a list for a JSON array.'
• If your code requires a dictionary, validate the parsed root type explicitly.
• Converting a parsed list into a dictionary requires a second transformation rule.
• 'object_hook customizes decoded objects but does not turn a top-level array into a dictionary.'
• Keep JSON syntax and Python literal syntax separate when debugging parse results.