KeyError in Python

The exact error string

user = {"name": "Ada", "age": 36}
print(user["email"])

Traceback (most recent call last):
  File "app.py", line 2, in <module>
    print(user["email"])
KeyError: 'email'

The dict is valid; it simply has no 'email' key. Square-bracket access demands the key exist — when it doesn't, Python raises KeyError and prints the key it couldn't find.

Why Python raises KeyError

Square-bracket access (d[key]) treats the key as required. Python raises KeyError instead of quietly returning None so that missing required data is detected immediately, at the point of the bug, rather than failing mysteriously later. dict.get() is the explicit opt-in for keys that may legitimately be absent — so the two access styles document your intent.

Common KeyError variations

The cause is the same whatever key is named after the error — these are just different missing keys:

• KeyError: 'name', KeyError: 'email', KeyError: 'id' — a string field missing from a dict (often an API field that wasn't sent)
• KeyError: 'user', KeyError: 'data', KeyError: 'response' — a wrapper key that isn't where you expect; the payload is nested differently
• KeyError: 0 — integer access on a dict with no key 0 (usually the value is really a list — see Fix 4)

Fix 1: use .get() for optional keys

dict.get() returns None (or a default you choose) instead of raising, which is the right tool whenever a key may legitimately be missing:

user.get("email")                 # None — no error
user.get("email", "n/a")          # 'n/a' — your own default

age = user.get("age", 0)          # 0 if 'age' is missing
print(age + 1)                    # safe arithmetic with a fallback

The most common cause: optional fields in API responses

APIs routinely omit optional fields, so a key present on one response is missing on the next — and square-bracket access then raises. Use .get() for anything not guaranteed:

user = response.json()

email = user.get("email")         # ✅ None if the field was omitted
email = user["email"]             # ❌ KeyError when 'email' is absent

Fix 2: the key isn't what you think

If a key "should" be there but isn't, print the real keys. The usual culprits are casing, whitespace, and string-vs-int:

print(list(user.keys()))          # ['name', 'age']  -> no 'email'

# common mismatches:
data["Name"]                      # ❌ case differs from 'name'
data["name "]                     # ❌ trailing space in the key
data[1]                           # ❌ key is the string '1', not int 1

Fix 3: nested JSON without crashing

For nested structures, chain .get() with empty-dict defaults so a missing level returns nothing instead of raising:

city = data.get("user", {}).get("address", {}).get("city")

# or be explicit when a missing key is truly exceptional:
try:
    city = data["user"]["address"]["city"]
except KeyError as e:
    print(f"missing key: {e}")
    city = None

When the JSON shape varies or is deeply nested, a JSONPath query navigates it without a chain of .get() calls — and the JSON Formatter shows the exact keys the API actually returned.

Fix 4: KeyError: 0 usually means a list

KeyError: 0 means you used d[0] on a dict with no key 0. Often the value is really a list, where [0] is the first element:

resp = {"items": [{"id": 1}, {"id": 2}]}

resp[0]                           # ❌ KeyError: 0 — resp is a dict
resp["items"][0]                  # ✅ {'id': 1} — index the list inside

Debugging checklist

• ✓ Read the missing key printed after KeyError:
• ✓ Optional key? Use d.get(key) or d.get(key, default)
• ✓ Print list(d.keys()) — check case, whitespace, and string-vs-int
• ✓ Nested? Chain .get(..., {}) or wrap in try/except KeyError
• ✓ KeyError: 0? The value is probably a list — index it by position
• ✓ From an API? Confirm the real shape in the JSON Formatter