JSON with serde_json

Parse and emit JSON with typed structs, dynamic Value, and streaming for large payloads.

Recipe

Quick-reference recipe card - copy-paste ready.

use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
 
#[derive(Serialize, Deserialize)]
struct Event { kind: String, payload: Value }
 
let raw = r#"{"kind":"click","payload":{"x":1}}"#;
let ev: Event = serde_json::from_str(raw)?;
let dynamic = json!({ "ok": true, "count": ev.payload["x"] });
let out = serde_json::to_string(&dynamic)?;

When to reach for this: HTTP APIs, config files, and logs overwhelmingly use JSON in Rust services.

Working Example

use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
 
#[derive(Debug, Serialize, Deserialize)]
struct User {
    id: u64,
    email: String,
    #[serde(default)]
    tags: Vec<String>,
}
 
fn main() -> serde_json::Result<()> {
    let u = User { id: 1, email: "a@b.co".into(), tags: vec![] };
    let compact = serde_json::to_string(&u)?;
    let pretty = serde_json::to_string_pretty(&u)?;
 
    let parsed: User = serde_json::from_str(&compact)?;
    assert_eq!(parsed.email, "a@b.co");
 
    let mut v: Value = serde_json::from_str(r#"{"meta":{"version":1}}"#)?;
    v["meta"]["source"] = json!("api");
    assert_eq!(v["meta"]["version"], 1);
 
    Ok(())
}

What this demonstrates:

• to_string vs to_string_pretty for wire vs debug output.
• from_str into strongly typed User.
• Value for partially structured or evolving JSON.
• json! macro for literal construction.

Deep Dive

How It Works

• serde_json implements Serde's Serializer and Deserializer for JSON.
• Typed deserialization validates structure at parse time.
• Value defers schema enforcement until you index fields.

Common APIs

Rust Notes

// Fallible field access on Value
let n = v.get("count").and_then(|x| x.as_u64()).unwrap_or(0);

Gotchas

• unwrap on parse - Untrusted JSON panics in production. Fix: Propagate serde_json::Error or map to 400/422.
• f64 for money - Floating point rounding in JSON numbers. Fix: Store cents as integers or use decimal crates.
• Large DOM in memory - Value allocates entire document. Fix: serde_json::Deserializer::from_reader with stream types.
• UTF-8 loss - Invalid UTF-8 in strings fails deserialization. Fix: Validate upstream; use bytes only when required.
• Duplicate keys - Last key wins in Value; typed structs error on duplicates by default. Fix: Know your producer behavior.

Alternatives

FAQs

Related

• serde Basics - Derive fundamentals
• Customizing Serialization - Field attributes
• Error Handling & Validation - Untrusted input
• Other Formats - TOML, YAML, bincode
• Request Validation - HTTP boundary

Stack versions: This page was written for Rust 1.97.0 (edition 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, and Polars 0.46+.