Features

🦀 Idiomatic Rust

snake_case field names
Serde derive macros
pub struct and pub fields
Nested struct generation

📦 Serde Integration

#[derive(Serialize, Deserialize)]
#[serde(rename)] for camelCase keys
Option<T> for nullable fields
Vec<T> for arrays

⚙️ Configurable Output

Selectable integer types
Optional Clone derive
Configurable pub visibility
All-nullable option

Rust Serde Guide

Serde Derive Macros

Serde is Rust's serialization framework. Add it to your Cargo.toml and use derive macros for zero-cost JSON serialization.

# Cargo.toml
[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
pub struct User {
    pub id: i64,
    pub name: String,
    #[serde(rename = "isActive")]
    pub is_active: bool,
}

Parsing JSON in Rust

use serde_json;

fn main() {
    let json = r#"{"id": 1, "name": "Alice"}"#;
    let user: User = serde_json::from_str(json).unwrap();
    println!("{:?}", user);

    // Serialize back to JSON
    let serialized = serde_json::to_string_pretty(&user).unwrap();
    println!("{}", serialized);
}

Common Use Cases

Axum / Actix: Request/response body types for Rust web frameworks
CLI Tools: Parse JSON config files and API responses
WASM: Serialize data to/from JavaScript interop
gRPC: Intermediate types for JSON-to-protobuf pipelines
Data Processing: Parse large JSON datasets efficiently

FAQ

Q: Why are field names converted to snake_case?

A: Rust convention requires snake_case for field names. When the original JSON uses camelCase, a #[serde(rename = "...")] attribute is added so serde maps them correctly.

Q: When should I use Option<T>?

A: Use Option<T> for fields that may be absent or null in the JSON. Serde handles deserialization to None automatically with #[serde(skip_serializing_if = "Option::is_none")].

Tips for Serde structs in real projects

Serde makes JSON handling in Rust fast and type safe. Because Rust has no implicit nulls or loose numbers, it pays to review generated structs for optional fields and number sizes before relying on them.

Tips and common pitfalls

Add #[serde(default)] to fields that may be missing so decoding falls back to the default value instead of failing.
Use #[serde(rename_all = "camelCase")] on the struct instead of renaming every field individually.
Choose u64 or i64 for IDs, and f64 only for true decimals. Money is safer as an integer number of cents.
For unknown or dynamic sections, use serde_json::Value and parse that part later.

JSON to Rust Struct