How can I read JSON arrays of objects and check each record?

Decode the JSON, then check the outer value before treating it as a list of records. Python’s JSON decoder maps JSON arrays to lists and JSON objects to dictionaries. Check the top-level value with isinstance(data, list), then each item with isinstance(record, dict) before testing its keys. [S1]

The keys you require depend on your application. For example, if each record must contain name and email, make that list explicit in your validation code. Checking key presence does not establish that a value is non-empty, correctly formatted, or otherwise suitable; add separate checks if those are part of your requirements.

Here is a copyable validation example. It assumes data is the value produced by decoding your JSON. The required keys and record values are placeholders.

required_keys = {"name", "email"}

data = [
    {"name": "<name>", "email": "<email>"},
    {"name": "<name>"},
    "<not-an-object>",
    {"name": "<name>", "email": "<email>"},
]

if not isinstance(data, list):
    print("Problem: top-level JSON value is not an array")
else:
    for position, record in enumerate(data):
        if not isinstance(record, dict):
            print(f"Position {position}: expected an object")
            continue

        missing = required_keys - record.keys()
        if missing:
            print(f"Position {position}: missing keys {sorted(missing)}")

For this sample, the findings are Position 1: missing keys ['email'] and Position 2: expected an object. The loop checks the decoded records and reports findings; it does not add keys or otherwise change them. Check the item’s type before checking its keys so that a non-object item is reported as a separate problem. The decoder’s mapping of JSON arrays and objects to Python lists and dictionaries is what makes these type checks relevant. [S1]

The outer type check catches a valid JSON value that is not an array. A single JSON object decodes to a Python dictionary, so the example reports that the top-level value is not an array and does not enter the record loop. [S1]

Keep that check separate from the per-record checks: the latter are only useful after confirming that the outer value is a list.

Keep structural checks and value checks distinct. First confirm an item is a dictionary; then, for each required key that exists, apply the rules your application actually needs. For instance, if name must be a non-empty string, check its type and contents explicitly. Finding a key does not prove its value is valid.

For useful findings, include the array position, the key involved, and the problem in plain language. Keep the decoded input unchanged while collecting messages. The JSON decoder’s type mapping does not define your required keys or application-specific value rules; those are decisions for your data requirements. [S1]