Serde and JSON

Why serde?

Programs constantly exchange data: web APIs send JSON, config files use TOML or YAML, caches store binary data. Serialisation means turning a value in memory into text or bytes; deserialisation is the reverse. serde (SERialise/DEserialise) is the crate almost every Rust project uses for this. It is fast, and it turns messy text into typed structs, so the rest of your code never deals with raw strings.

cargo add serde --features derive
cargo add serde_json

Struct to JSON and back

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
struct Order {
    id: u32,
    item: String,
    qty: u32,
    paid: bool,
}

fn main() -> Result<(), serde_json::Error> {
    let o = Order { id: 7, item: String::from("thali"), qty: 2, paid: true };

    let text = serde_json::to_string(&o)?;
    println!("{text}");   // {"id":7,"item":"thali","qty":2,"paid":true}

    let back: Order = serde_json::from_str(r#"{"id":8,"item":"lassi","qty":1,"paid":false}"#)?;
    println!("{:?}", back);
    Ok(())
}

Serialize and Deserialize are traits (module 7). The derive writes their code for you from the struct's fields at compile time, so there is no slow run-time inspection of your types. The same derive works for every format crate: serde_json for JSON, toml for TOML files, and others, which is why learning serde once pays off everywhere.

from_str checks everything: if a field is missing, has the wrong type, or the JSON is broken, you get an Err with a clear message such as "missing field `qty` at line 1 column 30". Once you have an Order, every field is guaranteed to be valid.

Matching other naming styles

JavaScript APIs usually use camelCase (orderId), while Rust uses snake_case (order_id). Attributes tell serde how to map names, so your Rust code stays idiomatic.

#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct Payment {
    order_id: u32,              // JSON: "orderId"
    #[serde(rename = "txnRef")]
    reference: String,          // JSON: "txnRef"
    upi_id: Option<String>,     // may be missing or null
    #[serde(default)]
    retries: u32,               // missing -> 0
}

Enums and nested data

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "lowercase")]
enum Status { Placed, Shipped, Delivered }

#[derive(Serialize, Deserialize, Debug)]
struct Tracking {
    id: u32,
    status: Status,             // "shipped"
    stops: Vec<String>,         // JSON array
}

Unknown shape: serde_json::Value

When you do not know the structure in advance, read into serde_json::Value, a type that can hold any JSON. Prefer typed structs whenever you can; they catch mistakes much earlier.

let v: serde_json::Value = serde_json::from_str(r#"{"city":"Pune","temp":31}"#)?;
println!("{}", v["city"]);          // "Pune"
println!("{}", v["temp"].as_i64().unwrap_or(0) + 1);   // 32

Common mistakes

• Forgetting the derive feature: "cannot find derive macro Serialize". Use cargo add serde --features derive.
• Making every field Option "to be safe". Then the compiler cannot help you; only use Option for truly optional data.
• Using f64 for money in JSON. Send paise as an integer or a string.
• Ignoring the error from from_str. Show it: it says exactly which field and position failed.