JSON in Python — Unicode Escapes Cause Downstream Failure

Every time you tap 'place order' on an e-commerce site, check the weather on your phone, or log into an app, JSON is quietly doing the heavy lifting behind the scenes. It's the format web APIs use to send data back and forth, the format config files are stored in, and the format data pipelines use to pass records between services. If you're writing Python in 2024 and you're not comfortable with JSON, you've got a gap that'll slow you down on almost every real project.

The problem JSON solves is surprisingly simple: computers need to share structured data with each other, but every language stores data differently in memory. A Python dictionary isn't the same as a JavaScript object internally — but both can be serialized into a JSON string that looks identical. JSON is the agreed-upon middle ground, a plain-text format that any language can read and write without needing to know anything about the other side's internals.

By the end of this article you'll be able to read JSON from a file, write Python data structures back out as JSON, parse API responses with confidence, handle encoding edge cases, and avoid the three mistakes that trip up even experienced developers. You'll also know exactly what to say when an interviewer asks you about serialization.

What JSON in Python Actually Does — and Doesn't

Python's json module maps JSON types to Python types: object→dict, array→list, string→str, number→int/float, boolean→bool, null→None. The core mechanic is the encoder/decoder pair: json.dumps() serializes Python objects to a JSON string, json.loads() deserializes a JSON string back to Python objects. Under the hood, the encoder walks the object tree recursively, handling each type with a default fallback that raises TypeError for non-serializable types.

Key property: Python's json module uses strict Unicode escaping by default — it escapes non-ASCII characters as \uXXXX sequences. This is safe for ASCII-only consumers but can silently corrupt data when downstream parsers interpret \u escapes differently (e.g., JavaScript's JSON.parse handles them correctly, but some C/C++ parsers or legacy systems may not). The ensure_ascii=False parameter disables this, emitting raw UTF-8 instead. Also, the module does not validate UTF-8 by default — malformed surrogates can pass through.

Use json when you need language-agnostic data exchange between Python services and non-Python systems. It's the default for REST APIs, configuration files, and data pipelines. Avoid it for binary data (use base64 encoding or a binary format like MessagePack). For high-throughput systems, json.loads() is O(n) in string length but the encoder is slower than alternatives like orjson or ujson — benchmark your payloads if latency matters.

json.loads() vs json.load() — The Difference That Trips Everyone Up

Python's built-in json module gives you four functions you'll use constantly: json.loads(), json.load(), json.dumps(), and json.dump(). The naming is deceptively similar, and mixing them up is the single most common JSON mistake in Python.

Here's the mental model: the functions with an 's' on the end work with strings. The ones without the 's' work with file objects. That's it. json.loads() takes a JSON-formatted string and returns a Python object. json.load() takes an open file handle and reads JSON directly from it. Same relationship on the output side: json.dumps() returns a string, json.dump() writes directly to a file.

Why does this distinction matter? Because when you're hitting a web API, requests.get().text gives you a string — so you reach for json.loads(). When you're reading a config file from disk, you open the file and reach for json.load(). Picking the wrong one gives you a confusing AttributeError or TypeError that's hard to debug if you don't know the root cause.

import json

# ── CASE 1: Parsing a JSON STRING (e.g. from an API response) ──
# Imagine requests.get(...).text returned this string:
api_response_text = '{"user": "alice", "score": 42, "active": true}'

# json.loads() deserializes a STRING into a Python dict
user_data = json.loads(api_response_text)

print(type(user_data))        # Confirm it's a dict, not a string
print(user_data["user"])      # Access like any normal Python dict
print(user_data["active"])    # JSON 'true' becomes Python True (bool)

print("---")

# ── CASE 2: Reading JSON from a FILE ──
# First, let's write a sample file so the example is fully self-contained
sample_config = {
    "app_name": "DataPipeline",
    "version": "2.1.0",
    "debug": False,
    "max_retries": 3
}

# Write the config to disk first
with open("config.json", "w", encoding="utf-8") as config_file:
    json.dump(sample_config, config_file)  # dump() writes to a FILE OBJECT

# Now read it back — json.load() reads from a FILE OBJECT, not a string
with open("config.json", "r", encoding="utf-8") as config_file:
    loaded_config = json.load(config_file)

print(type(loaded_config))              # Also a dict
print(loaded_config["app_name"])        # 'DataPipeline'
print(loaded_config["debug"])           # False (Python bool)
print(loaded_config["max_retries"])     # 3 (Python int)

Writing JSON Files the Right Way — Formatting, Encoding, and Sorting

Writing raw JSON to a file works fine, but the output is a single compressed line that's nearly unreadable when you open the file. In production you often need human-readable output — for config files, logs, or debugging. The json.dump() and json.dumps() functions have optional parameters that give you full control over the output format.

The indent parameter is the big one. Pass indent=2 or indent=4 and your output is immediately readable with proper nesting. The sort_keys=True parameter alphabetises the keys, which is invaluable for config files or any output that goes into version control — it makes diffs clean and predictable instead of random.

The ensure_ascii=False parameter is critical and often forgotten. By default, Python's json module escapes every non-ASCII character — so a name like 'María' becomes '\u004dar\u00eda'. That's technically valid JSON, but it's unreadable and bloated. Setting ensure_ascii=False writes the actual Unicode characters directly, which is almost always what you want when handling international data.

Finally, always open your JSON files with encoding='utf-8' explicitly. Don't rely on the system default — it varies between Windows, Mac, and Linux and will cause encoding bugs that are maddening to debug across environments.

import json

# Real-world example: saving a user profile with international characters
user_profile = {
    "user_id": 1047,
    "full_name": "María García",       # Non-ASCII characters — common in real data
    "email": "maria.garcia@example.com",
    "preferences": {
        "theme": "dark",
        "language": "es",
        "notifications": True
    },
    "tags": ["premium", "verified", "beta-tester"]
}

# ── BAD: Default output — technically valid but unreadable ──
bad_output = json.dumps(user_profile)
print("Raw (hard to read):")
print(bad_output)
print()

# ── GOOD: Formatted, Unicode-safe, sorted keys ──
good_output = json.dumps(
    user_profile,
    indent=2,              # 2-space indentation for readability
    sort_keys=True,        # Alphabetical keys — great for version control diffs
    ensure_ascii=False     # Write 'María' not '\u004dar\u00eda'
)
print("Formatted (production-ready):")
print(good_output)

# ── Writing to a file with explicit UTF-8 encoding ──
output_path = "user_profile.json"
with open(output_path, "w", encoding="utf-8") as output_file:
    json.dump(
        user_profile,
        output_file,
        indent=2,
        sort_keys=True,
        ensure_ascii=False   # Critical: don't escape María into \u sequences
    )

print(f"\nProfile saved to {output_path}")

Handling Non-Serializable Types — Dates, Decimals, and Custom Objects

Here's where Python and JSON have a real fight. JSON only natively supports strings, numbers, booleans, null, arrays, and objects. It has no concept of a Python datetime, a Decimal, a set, or any custom class you've built. The moment you try to serialize one of these, Python throws a TypeError: Object of type X is not JSON serializable — and it stops everything.

This isn't a bug, it's a design decision. JSON is meant to be language-agnostic, so it can't encode Python-specific types. Your job is to tell Python how to translate those types into something JSON understands.

The cleanest way is to write a custom encoder by subclassing json.JSONEncoder and overriding its default() method. You get called for any type the encoder doesn't know how to handle, and you return a JSON-compatible representation. This is the approach used in production codebases because it's explicit, testable, and reusable — you define the encoding logic once and pass the encoder class anywhere you call json.dump() or json.dumps().

For quick scripts, the default parameter shortcut works fine — pass a lambda or small function. But for anything going into a team codebase, write a proper encoder class. It's more readable and your colleagues will thank you.

import json
from datetime import datetime, date
from decimal import Decimal

# ── The types that break vanilla JSON serialization ──
order_record = {
    "order_id": "ORD-9921",
    "created_at": datetime(2024, 3, 15, 10, 30, 0),  # datetime — not JSON serializable
    "ship_date": date(2024, 3, 17),                   # date — also not JSON serializable
    "total_amount": Decimal("199.99"),                # Decimal — not JSON serializable
    "item_ids": {101, 205, 309},                      # set — not JSON serializable
    "status": "pending"
}

# Try without a custom encoder — this will raise TypeError
try:
    json.dumps(order_record)
except TypeError as encoding_error:
    print(f"Without custom encoder: {encoding_error}")

print()

# ── Solution: Custom JSONEncoder subclass ──
class AppJSONEncoder(json.JSONEncoder):
    """Handles Python types that vanilla JSON can't serialize."""

    def default(self, obj):
        # datetime: serialize as ISO 8601 string — universally understood
        if isinstance(obj, datetime):
            return obj.isoformat()          # e.g. '2024-03-15T10:30:00'

        # date: serialize as ISO date string
        if isinstance(obj, date):
            return obj.isoformat()          # e.g. '2024-03-17'

        # Decimal: convert to float — fine for display, use string for finance
        if isinstance(obj, Decimal):
            return float(obj)               # or str(obj) if precision matters

        # set: JSON has arrays, not sets — convert and sort for determinism
        if isinstance(obj, set):
            return sorted(list(obj))        # sort so output is always consistent

        # Let the parent class raise TypeError for anything we don't handle
        return super().default(obj)


# Now serialize cleanly using our custom encoder
serialised_order = json.dumps(
    order_record,
    cls=AppJSONEncoder,    # Pass the encoder CLASS (not an instance)
    indent=2,
    ensure_ascii=False
)

print("Serialized order record:")
print(serialised_order)

# ── Deserializing back: parse the date string yourself ──
loaded_order = json.loads(serialised_order)
print("\nRound-trip — created_at is now a string:")
print(type(loaded_order["created_at"]), loaded_order["created_at"])

# Convert back to datetime when needed
parsed_datetime = datetime.fromisoformat(loaded_order["created_at"])
print(f"Re-parsed datetime: {parsed_datetime}")

Real-World Pattern: Fetching and Processing an API Response

Everything we've covered comes together the moment you touch a real API. The pattern is always the same: make an HTTP request, get back a JSON string in the response body, parse it into a Python dict, do your work, optionally write results to a file. Understanding each step means you're never guessing.

The requests library's response object has a convenient .json() shortcut method that calls json.loads() on response.text for you — but only if the response's Content-Type header is application/json. If it's not, you'll get a requests.exceptions.JSONDecodeError. It's worth knowing this so you're not surprised.

The pattern below also shows defensive coding: checking that the response key you expect actually exists before accessing it, and handling the case where an API returns a successful HTTP 200 but puts error details in the JSON body — which is extremely common with third-party APIs. This is the difference between code that works in a demo and code that survives contact with the real world.

import json
import urllib.request   # Using stdlib so no pip install needed for this example
import urllib.error
from datetime import datetime

# ── Simulating an API response (using a real public API) ──
# We'll use JSONPlaceholder — a free, stable fake REST API for testing
API_URL = "https://jsonplaceholder.typicode.com/users/1"

def fetch_user_profile(user_url: str) -> dict | None:
    """Fetch a user profile from an API and return it as a Python dict."""
    try:
        with urllib.request.urlopen(user_url, timeout=10) as response:
            # response.read() returns bytes — decode to string first
            raw_bytes = response.read()
            json_string = raw_bytes.decode("utf-8")

            # Parse the JSON string into a Python dict
            user_data = json.loads(json_string)
            return user_data

    except urllib.error.URLError as network_error:
        print(f"Network error: {network_error}")
        return None
    except json.JSONDecodeError as parse_error:
        print(f"Response wasn't valid JSON: {parse_error}")
        return None


def save_profile_snapshot(user_data: dict, output_path: str) -> None:
    """Enrich the profile with a timestamp and save it to a JSON file."""
    # Add metadata before saving — this is extremely common in pipelines
    enriched_profile = {
        "fetched_at": datetime.utcnow().isoformat() + "Z",  # ISO 8601 UTC
        "source_url": API_URL,
        "profile": user_data
    }

    with open(output_path, "w", encoding="utf-8") as output_file:
        json.dump(
            enriched_profile,
            output_file,
            indent=2,
            ensure_ascii=False   # Safe for names with accents or non-Latin chars
        )
    print(f"Snapshot saved to: {output_path}")


# ── Main flow ──
print(f"Fetching profile from {API_URL}...")
user = fetch_user_profile(API_URL)

if user:
    # Defensive access — check keys exist before using them
    user_name = user.get("name", "Unknown")
    user_email = user.get("email", "No email provided")
    company_name = user.get("company", {}).get("name", "No company")

    print(f"Name:    {user_name}")
    print(f"Email:   {user_email}")
    print(f"Company: {company_name}")

    # Save the enriched snapshot
    save_profile_snapshot(user, "user_snapshot.json")

    # ── Reading it back to verify the round-trip ──
    print("\nVerifying saved file...")
    with open("user_snapshot.json", "r", encoding="utf-8") as saved_file:
        reloaded = json.load(saved_file)

    print(f"Fetched at: {reloaded['fetched_at']}")
    print(f"Stored name: {reloaded['profile']['name']}")

Graceful Error Handling for JSON Parsing and Encoding

Production systems encounter malformed JSON more often than you'd think. A truncated network response, a misconfigured upstream service, or a file corrupted mid-write can all produce invalid JSON. Your code needs to handle these failures without crashing the entire pipeline.

The most common JSON parsing error is JSONDecodeError, which is a subclass of ValueError. It tells you exactly where the parser failed: line number, column number, and the unexpected character. Use this information in your logging to speed up debugging.

Another frequent issue is UnicodeDecodeError when opening files that aren't UTF-8. Some legacy systems output UTF-16, Latin-1, or UTF-8 with a BOM (byte order mark). Python's open() with encoding='utf-8' will fail on these. Use encoding='utf-8-sig' to strip the BOM automatically, or detect encoding with the chardet library for unknown sources.

A defensive strategy: never let a single malformed JSON entry crash your entire batch job. If you're processing a line-delimited JSON file (one JSON object per line), wrap each line parse in a try-except, log the error, and continue. This is standard in ETL pipelines.

import json
from pathlib import Path

# Simulate a file with one bad line
log_file_content = """{"user": "alice", "action": "login"}
{"user": "bob", "action": "logout"
{"user": "carol", "action": "purchase"}
"""

# Write to temp file
Path("events.log").write_text(log_file_content, encoding="utf-8")

# ── Defensive line-by-line parsing ──
valid_events = []
with open("events.log", "r", encoding="utf-8") as handle:
    for line_number, line in enumerate(handle, start=1):
        line = line.strip()
        if not line:
            continue
        try:
            event = json.loads(line)
            valid_events.append(event)
        except json.JSONDecodeError as err:
            print(f"[WARN] Line {line_number}: {err.msg} at position {err.pos} — skipped")

print(f"\nProcessed {len(valid_events)} valid events")

# ── Handling Unicode with BOM ──
# Simulate a file with UTF-8 BOM
bom_data = b'\xef\xbb\xbf{"version": 1}'  # UTF-8 BOM + JSON
Path("with_bom.json").write_bytes(bom_data)

# This fails:
try:
    with open("with_bom.json", "r", encoding="utf-8") as f:
        json.load(f)
except json.JSONDecodeError as err:
    print(f"Without BOM handling: {err}")

# This works:
with open("with_bom.json", "r", encoding="utf-8-sig") as f:
    data = json.load(f)
print(f"With utf-8-sig: {data}")

JSON Syntax Pitfalls That'll Burn You in Production

JSON looks like Python dicts. That's the problem. Your brain auto-completes Python syntax where JSON has none. Single quotes? Illegal in JSON. Trailing commas? JSON will choke on them. Boolean values? True and False in Python become true and false in JSON. Python's None becomes null.

The json module enforces this at parse time. But here's where teams get burned: generated JSON from a microservice that accidentally serializes datetime objects using str() instead of .isoformat() — you'll get a string that looks valid but breaks every consumer expecting ISO 8601. The parser won't catch it because JSON itself is syntactically valid. That's a semantic failure that slips through CI.

Another classic: numeric precision. JSON doesn't distinguish between int and float like Python does. When deserializing back, you might get 1.0 as a float when you expected an integer. This propagates silently through your data pipeline until something downstream does a strict type check. Python's json module defaults to float for all JSON numbers with decimals. Explicit type conversion after parsing isn't optional — it's disaster insurance.

// io.thecodeforge — python tutorial

import json

# This will blow up — trailing comma
bad_json = '{"name": "deployment", "version": 2,}'
try:
    json.loads(bad_json)
except json.JSONDecodeError as e:
    print(f"Parse failure: {e}")

# This parses fine but data types shift
api_response = '{"active": true, "count": 42, "cost": 19.99}'
data = json.loads(api_response)
print(type(data["active"]))   # bool — correct
print(type(data["count"]))    # int — correct
print(type(data["cost"]))     # float — correct

# But implicit float conversion kills equality checks
response2 = '{"value": 0.0}'
print(json.loads(response2)["value"] == 0)  # True? Actually True in Python
print(json.loads(response2)["value"] is 0)  # False — it's a float object

# Null vs None — same object but careful
response3 = '{"user": null}'
user = json.loads(response3)["user"]
print(user is None)  # True — they're the same

Custom Serializers — When the Default json Module Isn't Enough

The stock json module handles dicts, lists, strings, ints, floats, booleans, and None. That's it. Try to serialize a datetime, Decimal, or numpy array and you'll hit TypeError: Object of type datetime is not JSON serializable. This isn't a bug — it's a design decision. Python's json doesn't know how to represent your domain objects in JSON, and it shouldn't try to guess.

Your first instinct might be to convert everything to strings before serialization. Resist that. Strings lose type information. When you deserialize a date string, you now have to manually parse it back — and someone will forget. Instead, provide a custom default function or subclass json.JSONEncoder. This centralizes your serialization logic so every endpoint, every cache, every message queue serializes the same way.

The cleanest pattern: a ProductionEncoder that handles your common types — datetime to ISO 8601, Decimal to float (or string if precision matters), UUID to hex string. On deserialization, don't fight the json module's object_hook — use it. It fires for every JSON object, letting you reconstruct your domain types. Or better yet, use Pydantic's .model_dump_json() and .model_validate_json() which handle this transparently with schema validation.

Here's the brutal truth: if you're manually looping through a dict to convert types before serialization, you're reinventing a wheel with known defects. Use the tools the language gives you — or the libraries your team already maintains.

// io.thecodeforge — python tutorial

import json
from datetime import datetime, date
from decimal import Decimal
from uuid import UUID

class ProductionEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        if isinstance(obj, date):
            return obj.isoformat()
        if isinstance(obj, Decimal):
            return float(obj)  # Or str(obj) for precision-critical data
        if isinstance(obj, UUID):
            return str(obj)
        # Let the parent raise TypeError for unknown types
        return super().default(obj)

# Usage — encoder handles custom types automatically
data = {
    "created_at": datetime(2024, 1, 15, 14, 30, 0),
    "price": Decimal("19.99"),
    "user_id": UUID("12345678-1234-5678-1234-567812345678"),
    "name": "deployment_42"
}

print(json.dumps(data, cls=ProductionEncoder, indent=2))

Parsing Streaming JSON Without Blowing Up Your Memory

You load a 2GB JSON file into memory with json.load(). Your container runs on 1GB RAM. Your process hits OOM and the orchestrator kills it. Now you're debugging why production crashed at 3 AM. I've been that engineer. Don't be that engineer.

Line-delimited JSON (NDJSON) exists exactly for this reason — one JSON object per line, no outer array. You can iterate over the file line by line, parsing each record individually. Memory stays flat. This is the standard for export dumps, log streams, and event data from services like Kafka.

But what if you don't control the format? What if you're stuck with a single massive JSON array containing 10 million records? The ijson library handles this. It's an incremental JSON parser that yields objects as they're parsed, without building the entire parse tree in memory. You subscribe to path patterns — "item" or "results.items" — and process each object as it streams past.

Here's the rule: if the JSON file fits in memory, use json.load(). If it doesn't, use NDJSON. If you can't control the format, reach for streaming parsers. Never assume your production machine has infinite RAM. Memory pressure doesn't crash your code — it crashes your platform.

// io.thecodeforge — python tutorial

import json

# Simulating NDJSON — each line is a complete JSON object
ndjson_data = """{"user": "alice", "action": "login"}
{"user": "bob", "action": "purchase"}
{"user": "alice", "action": "logout"}
""".strip()

# Stream parsing — process one object at a time
processed = 0
for line in ndjson_data.split('\n'):
    record = json.loads(line)
    # Process individual record — memory doesn't accumulate
    print(f"{record['user']} performed {record['action']}")
    processed += 1

print(f"Processed {processed} records sequentially")

# For large file I/O, use this pattern:
# with open('events.ndjson', 'r') as f:
#     for line in f:
#         record = json.loads(line)
#         process(record)

Encoders and Decoders — Why You Need Separate Control

The json module splits serialization into two distinct phases: encoding (Python → JSON) and decoding (JSON → Python). Default behavior handles common types, but custom encoders and decoders give you surgical control. A JSONEncoder subclass overrides .default() to handle types like Decimal or datetime without cluttering your classes with __json__ methods. A JSONDecoder subclass overrides .decode() and optionally .raw_decode() to intercept parsing — critical for restoring custom objects or enforcing strict type checks. Without separate encoder/decoder classes, you mix concerns: every serialization call repeats the same conversion logic, and decoding loses type information. Production systems that exchange decimals or dates across services must convert bidirectionally. Centralize that logic in one encoder and one decoder instead of scattering it across your codebase. This pattern also improves testability — you unit-test the encoder and decoder in isolation, not inside your business logic.

// io.thecodeforge — python tutorial

import json
from decimal import Decimal
from datetime import datetime

class CustomEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, Decimal):
            return float(obj)
        if isinstance(obj, datetime):
            return obj.isoformat()
        return super().default(obj)

class CustomDecoder(json.JSONDecoder):
    def decode(self, s):
        obj = super().decode(s)
        # reconstruct: inject post-processing here
        return obj

# usage
payload = {'price': Decimal('19.99'), 'at': datetime.now()}
encoded = json.dumps(payload, cls=CustomEncoder)
print(encoded)

Command-Line Interface — Why Scripting Engineers Own the Terminal

Python's json.tool module gives you a production-grade CLI without writing a single parse loop. Run python -m json.tool input.json to validate, pretty-print, and catch syntax errors before your code touches the data. The --sort-keys flag imposes deterministic output — essential for diff-driven CI pipelines or config file comparisons. Pipe raw JSON from curl directly: curl api.example.com | python -m json.tool --compact strips whitespace for size-sensitive logs. This CLI isn't a toy — it's the same parsing engine your production code uses, so what passes validation here passes in your application. Automate it in CI: reject commits that contain invalid JSON before they reach staging. The json.tool also mirrors json.loads behavior for top-level non-object values — valid JSON like "hello" or 42 passes without error, unlike strict parsers in other languages. Use the CLI as your first line of defense, not your last resort.

// io.thecodeforge — python tutorial

# Validate and pretty-print a file
python -m json.tool data.json

# Compact output for logs
python -m json.tool --compact data.json

# Sort keys for deterministic diffs
python -m json.tool --sort-keys data.json

# Pipe from curl and format
curl -s https://api.example.com/v1/data | python -m json.tool

orjson: Fast JSON Library Alternative

When performance is critical, the standard library's json module may not be fast enough. orjson is a third-party library written in Rust that offers significantly faster serialization and deserialization, especially for large datasets. It supports bytes output by default, handles datetime objects natively, and has a simpler API for common use cases. However, it does not support all Python types (e.g., complex numbers) and may have different behavior for edge cases like NaN. To use orjson, install it via pip install orjson. Below is a comparison of parsing a large JSON string with json vs orjson. The speed difference can be 2-5x depending on the data. Note that orjson returns bytes by default, so you may need to decode to string if you need a Python dict. For maximum performance, use orjson's dumps with option=orjson.OPT_SERIALIZE_NUMPY if you work with NumPy arrays. In production, consider orjson for high-throughput APIs or data pipelines where JSON parsing is a bottleneck.

import json
import orjson
import time

large_json = '{"key": "value"}' * 100000

# Standard json
start = time.time()
data = json.loads(large_json)
print(f"json.loads: {time.time() - start:.4f}s")

# orjson
start = time.time()
data = orjson.loads(large_json)
print(f"orjson.loads: {time.time() - start:.4f}s")

# Serialization
start = time.time()
out = json.dumps(data)
print(f"json.dumps: {time.time() - start:.4f}s")

start = time.time()
out = orjson.dumps(data)
print(f"orjson.dumps: {time.time() - start:.4f}s")

pydantic for JSON Validation and Parsing

Pydantic is a data validation library that uses Python type hints to define data models. It automatically validates and parses JSON data, converting it to Python objects with proper types. This eliminates the need for manual validation and error handling when working with JSON APIs. For example, you can define a model with fields like name: str and age: int, and pydantic will ensure the JSON data matches those types, raising a ValidationError if not. It also supports nested models, optional fields, and custom validators. To use pydantic, install it via pip install pydantic. Below is an example of parsing a JSON string into a pydantic model. The model automatically coerces types (e.g., string to int) and validates constraints. In production, pydantic is widely used in FastAPI for request validation, but it can be used standalone for any JSON parsing task. It also integrates with JSON Schema for generating documentation.

from pydantic import BaseModel, ValidationError
import json

class User(BaseModel):
    name: str
    age: int
    email: str | None = None

json_data = '{"name": "Alice", "age": 30, "email": "alice@example.com"}'
try:
    user = User.model_validate_json(json_data)
    print(user)
except ValidationError as e:
    print(e)

# Invalid data
bad_json = '{"name": "Bob", "age": "invalid"}'
try:
    User.model_validate_json(bad_json)
except ValidationError as e:
    print(e)

JSON Lines (.jsonl) for Streaming Data

JSON Lines is a format where each line is a valid JSON object, making it ideal for streaming data, log files, and large datasets that cannot fit in memory. Unlike a JSON array, which must be parsed as a whole, JSON Lines can be processed line by line, reducing memory usage. The .jsonl extension is commonly used. In Python, you can read a JSON Lines file by iterating over lines and parsing each with json.loads(). For writing, you serialize each object and write it as a separate line. This format is popular in data science (e.g., Hugging Face datasets) and logging systems. Below is an example of reading and writing JSON Lines. Note that each line must be a valid JSON object, and there is no trailing comma or enclosing array. In production, JSON Lines is useful for ETL pipelines where you process records incrementally. It also allows appending new records without rewriting the entire file.

import json

# Writing JSON Lines
data = [
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 25},
    {"name": "Charlie", "age": 35}
]

with open('data.jsonl', 'w') as f:
    for record in data:
        f.write(json.dumps(record) + '\n')

# Reading JSON Lines
with open('data.jsonl', 'r') as f:
    for line in f:
        record = json.loads(line)
        print(record)