Python Dict to JSON: Why You Get Single Quotes, True and None (and the Fix)

November 2, 2026 · 5 min read

Printing a Python dict with print(d), str(d) or an f-string gives Python syntax, with single quotes, True, False and None, which is not JSON. Use json.dumps(d) to produce real JSON with double quotes, true, false and null. If you only have the printed text, convert it with ast.literal_eval and then json.dumps, or paste it into the JSON fixer, which rewrites single quotes and Python literals and shows each change.

str(dict) versus json.dumps

import json

user = {"name": "O'Brien", "active": True, "manager": None, "tags": ("a", "b"), 1: "one"}

print(str(user))
# {'name': "O'Brien", 'active': True, 'manager': None, 'tags': ('a', 'b'), 1: 'one'}

print(json.dumps(user))
# {"name": "O'Brien", "active": true, "manager": null, "tags": ["a", "b"], "1": "one"}

Notice the mixed quoting in the first row: Python's repr switches to double quotes when a string contains an apostrophe. That detail is why simple find-and-replace fixes fail, as shown further down.

The errors this causes downstream

When printed dict text reaches a JSON parser, the error depends on the language. They all point at the first single quote or Python literal:

For the full list of Python messages, see Python JSONDecodeError explained; for the JavaScript side, Unexpected token in JSON.

Fix 1: serialize with json.dumps at the source

Wherever the text is produced (an API response, a file, a log line meant for machines, a message queue), replace str(d) with json.dumps(d). Useful options:

import json
from datetime import datetime

record = {"city": "Zürich", "at": datetime(2026, 11, 2, 9, 30), "ids": {3, 1, 2}}

json.dumps(record, default=str)
# {"city": "Z\u00fcrich", "at": "2026-11-02 09:30:00", "ids": "{1, 2, 3}"}

def to_jsonable(o):
    if isinstance(o, datetime):
        return o.isoformat()
    if isinstance(o, set):
        return sorted(o)
    raise TypeError(f"Object of type {type(o).__name__} is not JSON serializable")

json.dumps(record, default=to_jsonable, ensure_ascii=False, indent=2)
# {
#   "city": "Zürich",
#   "at": "2026-11-02T09:30:00",
#   "ids": [1, 2, 3]
# }

Write files with json.dump(data, f) (no s) and open them with encoding="utf-8". In web frameworks, return data through the framework's JSON helper (Flask's jsonify, Django's JsonResponse, FastAPI's automatic serialization) rather than formatting a string yourself.

Fix 2: convert a dict string you already have

If the text was already printed, logged or stored, parse it as Python, then dump it as JSON. ast.literal_eval evaluates Python literals only (strings, numbers, tuples, lists, dicts, sets, booleans and None), so it does not run arbitrary code the way eval does:

import ast
import json

text = "{'name': \"O'Brien\", 'active': True, 'manager': None}"
data = ast.literal_eval(text)
print(json.dumps(data))
# {"name": "O'Brien", "active": true, "manager": null}

Know its limits before relying on it:

• It raises ValueError: malformed node or string when the repr contains objects, for example datetime.datetime(2026, 11, 2, 0, 0) or Decimal('1.5'). Those values cannot be recovered without custom handling.
• Python's documentation warns that very large or deeply nested input can exhaust memory or the C stack and crash the interpreter. Do not feed it untrusted input of unbounded size.
• Never use plain eval as a shortcut. It executes any code in the string.
• Text that is mostly JSON but contains true/null and single quotes at the same time is neither valid Python nor valid JSON, and both parsers reject it.

Why replace("'", '"') is a trap

The popular one-liner json.loads(text.replace("'", '"')) works on toy examples and corrupts real data:

text = "{'name': \"O'Brien\", 'ok': True}"   # what print(d) produced
text.replace("'", '"')
# {"name": "O"Brien", "ok": True}
#            ^ the apostrophe now ends the string; True is still not JSON

Apostrophes inside values turn into string terminators, double-quoted strings from the repr get mangled, and True/None are left untouched. Regex variants fail the same way on apostrophes. Use ast.literal_eval, or a tokenizer-based repair that understands string boundaries.

Fix 3: repair it in the browser

When the dict text is in a ticket, a log or a chat and you just need valid JSON, paste it into the JSON fixer. It converts single-quoted strings and keys, True, False and None, and trailing commas, and lists every change in a diff so you can check what it did. It runs locally, so log data with customer details is not uploaded. If the text came from an LLM, Fix LLM JSON also removes Markdown fences and surrounding prose.

Going the other way: JSON to a Python dict

json.loads(text) returns a dict with True, False and None restored. Keys that were integers in Python come back as strings, and tuples come back as lists, because JSON has no such types. If you want typed classes instead of plain dicts, JSON to Python generates dataclasses or Pydantic models from a sample. For a broader tour of what breaks JSON, see the common JSON errors hub.