How can I handle malformed JSON without losing the original file?

Open the file in read mode and pass the open file object to json.load(). Keep the json.JSONDecodeError handler narrowly around that call, and handle OSError separately for problems opening or reading the file. That way, a file-access failure is not reported as a JSON syntax problem. The JSON decoder error provides a message, line, and column you can show to help locate malformed content. [S1]

For example, using [sample.json] as a placeholder path:

import json

path = "[sample.json]"

try:
    with open(path, "r", encoding="utf-8") as source:
        try:
            data = json.load(source)
        except json.JSONDecodeError as exc:
            print(
                f"Invalid JSON: {exc.msg} "
                f"(line {exc.lineno}, column {exc.colno})"
            )
        except UnicodeDecodeError as exc:
            print(f"Could not decode the file as text: {exc}")
        else:
            print("JSON loaded successfully")
except OSError as exc:
    print(f"Could not access the file: {exc}")

This reads the source; it does not write or repair it. The separate UnicodeDecodeError handler matters because text-decoding failure is different from a JSON syntax error. [S1]

Because different failures call for different next steps. A missing file, permissions problem, or other file-access failure is not the same as malformed JSON. A broad handler can blur that distinction and tell you to fix JSON when the file could not be read. Keep the syntax-error handler around json.load() and handle OSError separately for file access. [S1]

The example also treats text-decoding failure separately. It does not claim every input problem is a syntax error, and it avoids printing the full document. For a small local debugging sample, the exception message and location are a focused starting point.

Use the reported line and column to inspect that area of the file in a text editor. They identify where the decoder encountered the problem; they do not automatically repair the document or prove that the preceding text is the only issue. The decoder error also exposes a position and the document, but you usually need not print the entire document to make a useful report. [S1]

To protect the original, keep this workflow read-only: run the parser, inspect the reported location, and make any proposed correction in a separate copy. If you want to test repaired JSON, save that test as a different file, such as [sample-fixed-test.json], and parse that copy. Do not add a write step targeting the original path.

For a malformed file, make the report actionable but concise. For example, assuming the file is named [sample.json], a hypothetical error report could be:

File: [sample.json]
Problem: Invalid JSON — [decoder message]
Location: line [line number], column [column number]
Next step: Inspect this location; make any test correction in a separate copy.

Those bracketed values are placeholders, not a claim about your file. Use the decoder’s actual msg, lineno, and colno values in your program. [S1] For file-access and text-decoding failures, report the corresponding problem type instead of using the “Invalid JSON” label. This keeps the report useful without suggesting that the source was changed or that parsing itself found a repair.