json.decoder.JSONDecodeError: Extra data: line 1 column N (char N)

The exact error string

The traceback ends with a line like this (the column and char index vary with your input):

Traceback (most recent call last):
  File "app.py", line 5, in <module>
    data = json.loads(text)
json.decoder.JSONDecodeError: Extra data: line 1 column 14 (char 13)

You may also see it raised through the requests library as requests.exceptions.JSONDecodeError or from response.json() — both wrap the same underlying json.decoder.JSONDecodeError.

What “line 1 column N (char N)” means

The number in parentheses is the character index where parsing stopped being happy. For Extra data, that index is the first character after a complete, valid JSON value. In char 13, the parser read a full value across the first 13 characters, then hit something it did not expect at index 13.

This is the opposite of Expecting value: line 1 column 1 (char 0), which fails at the very start. With Extra data, the beginning is valid JSON — the problem is that there is more than one value.

Here is exactly where the parser gives up on {"id":1}{"id":2}:

Valid — one JSON value, parsed cleanly:
{"id":1}

Invalid — two values with nothing between them:
{"id":1}{"id":2}
        ^
        char 8 (column 9) — the first value ended at the } just
        before here, so everything from this point on is "Extra data".

Note the off-by-one between the two numbers: char is 0-based (the 9th character is index 8), while column is 1-based. They point at the same spot — the first character the parser did not expect.

Cause 1: Two or more JSON objects in one string

The classic trigger. Two objects concatenated — even separated by a newline — are not a single JSON document:

import json

text = '{"id": 1}\n{"id": 2}'   # two objects, not one
data = json.loads(text)          # JSONDecodeError: Extra data: line 2 column 1 (char 10)

json.loads() parses the first {"id": 1}, then finds a second object where it expected the end of the string.

Cause 2: JSON Lines / NDJSON parsed all at once

Log files, bulk exports, and many streaming APIs use JSON Lines (also called NDJSON): one JSON object per line. Passing the whole file to json.loads() always fails:

import json

with open("events.jsonl") as f:
    data = json.loads(f.read())   # Extra data at the end of the first line

Each line is its own document. The fix is to parse line by line (see below). If you are unsure whether your data is JSON or JSON Lines, the difference is covered in JSON vs JSONL.

Cause 3: Trailing content after a valid value

Sometimes the body is a single object with stray characters appended — a duplicated write, a leftover comma, a second print, or two responses glued together:

import json

text = '{"ok": true}garbage'     # trailing junk
json.loads(text)                  # Extra data: line 1 column 13 (char 12)

text = '{"a": 1},'                # leftover trailing comma after the object
json.loads(text)                  # Extra data: line 1 column 9 (char 8)

Cause 4: Appending to a JSON file

Opening a .json file in append mode ("a") and writing another object produces two top-level values in one file. Later, json.load() reads the first and reports Extra data on the second. For multiple records, write a JSON array or switch to JSON Lines deliberately.

Extra data vs other JSONDecodeError messages

Python's json module raises a different message for each kind of problem. If the wording in your traceback is not Extra data, match it here and jump straight to the fix:

How to debug it

Print the raw content so you can see the boundary the parser tripped on. repr() reveals newlines and hidden characters a plain print() hides:

import json

text = open("data.json").read()
print(repr(text[:200]))           # see exactly what follows the first value

try:
    json.loads(text)
except json.JSONDecodeError as e:
    print("failed at char", e.pos)         # the boundary index
    print("context:", repr(text[e.pos-5:e.pos+5]))

The fix: parse the right number of values

If the source is JSON Lines, loop over the lines and parse each one:

import json

records = []
with open("events.jsonl") as f:
    for line in f:
        line = line.strip()
        if not line:
            continue              # skip blank lines
        records.append(json.loads(line))

If you have a stream of concatenated values with no newline separators, use raw_decode() to read them one at a time:

import json

def iter_json(text):
    decoder = json.JSONDecoder()
    idx = 0
    while idx < len(text):
        text = text[idx:].lstrip()
        if not text:
            break
        obj, end = decoder.raw_decode(text)
        yield obj
        idx = end

for obj in iter_json('{"id": 1}{"id": 2}'):
    print(obj)

If it is supposed to be one value, fix the producer so it emits a single JSON document — wrap multiple records in an array [ {...}, {...} ] rather than concatenating them.