PDFFlare
8 min read

How to Convert JSON to Rust Struct (serde Guide)

Need a JSON to Rust struct generator with serde derives? Here's how it works. You're writing a Rust service that consumes JSON. serde is the obvious choice — it generates Serialize/Deserialize impls at compile time, no runtime reflection, zero allocation in the hot path. The slow part is hand-typing the struct from a 30-field JSON sample. Generate it.

In this guide you'll learn how to convert JSON to a Rust struct with PDFFlare's JSON to Rust tool — how serde's derive macros work, why #[serde(rename = "...")] matters for snake_case bindings, and the type-system patterns that take the first-pass struct to production-ready.

Why serde?

serde is the standard Rust serialization framework — used by Axum, Actix, Reqwest, Tokio, and most of the ecosystem. The #[derive(Deserialize, Serialize)] macro generates parsing code at compile time, giving you zero-cost JSON deserialization with type safety.

How to Convert JSON to Rust (Step by Step)

  1. Open PDFFlare's JSON to Rust tool.
  2. Paste a JSON sample. Real production payload.
  3. Click Convert to Rust. One struct per unique shape; #[derive(Debug, Serialize, Deserialize)] on each; #[serde(rename = "original_key")]when the snake_case Rust field doesn't match the JSON key.
  4. Drop into your crate. Add serde and serde_json to Cargo.toml; serde_json::from_str(&data) returns a typed struct.

Real Use Cases

Axum / Actix request bodies

Both frameworks accept Json<T> or web::Json<T> extractors. Drop the generated struct in as T and the framework handles the deserialization.

API clients with reqwest

reqwest's .json::<T>() method deserializes the response straight into your struct — ergonomic, type-safe, zero boilerplate.

Database row mapping

Combine with sqlx or sea-orm for typed query rows. Generate the row struct from a sample, derive both FromRow and Serialize, query and ship.

Tooling and CLIs

Rust's ecosystem (cargo plugins, internal CLIs) often reads JSON config. Generate the config struct from a sample file; serde takes care of the rest.

Common Mistakes (and How to Avoid Them)

  • Forgetting Cargo.toml deps. Add serde = {version = "1", features = ["derive"] } and serde_json.
  • Treating Option<T> as field-level rename. Optional fields need #[serde(default)] for missing-key handling, plus Option<T> for null support.
  • Using f64 for currency. Refine to a fixed- point or decimal type. rust_decimal works with serde out of the box.
  • Trusting the inference for IDs. The generator picks i64 for whole numbers; refine to u64 for unsigned IDs or to a UUID type if the field is a UUID string.

Privacy: Your JSON Stays Local

Conversion runs in your browser. Safe for production payloads.

Related Workflows in the JSON Suite

Adjacent tools you might find useful while working on the same JSON document: the JSON to Go and JSON Schema both pair well with the conversion above. The first handles a different output format that consumers of your data may prefer; the second covers the validation side of the same workflow.

Related Tools

Memory and Performance Considerations in Rust

Rust gives you precise control over memory layout and performance, and a generated struct with default settings works fine for most cases but leaves performance on the table for high-throughput scenarios. Several refinements unlock significant gains when they matter, and ignoring them is harmless when they do not.

The first refinement is borrowed strings. The generator emits owned String fields, which copy data from the input buffer into a new heap allocation per field. For read-only deserialization with short-lived data, you can switch the type to a borrowed reference with a lifetime parameter. Now serde deserializes by referencing into the input buffer rather than copying, eliminating allocations entirely for those fields. The complexity is moderate — you have to track the lifetime through your code — but the performance win is substantial for high-throughput parsing.

The second refinement is custom number types. The generator emits i64 or f64 for numeric fields. If your numbers fit in i32 or u8, switching saves memory and improves cache utilization in tight loops. For decimal values that need exact precision, swap f64 for a decimal crate like rust_decimal — eliminates the floating-point rounding errors that bite financial code. Decisions like these are easy to make once you know the value range, and they compound across millions of records.

The third refinement is custom deserializers. For complex parsing logic — values that may be a string or a number, dates in non-standard formats, optional fields with weird defaults — implementing Deserialize manually gives you full control over what happens. The generator produces straightforward derives; for the cases where straightforward is not enough, you reach for the manual implementation, and the type system makes sure your custom logic is correct at compile time.

Finally, consider error handling. The standard pattern of Result with the question mark operator works well, but for long-running services, you usually want richer error types that capture context. Crates like anyhow and thiserror give you ergonomic error handling that propagates information about what went wrong without sacrificing type safety. Add these to your error path early, before you have a hundred call sites that need updating.

Production Patterns for JSON to Rust Structs

A generated struct is a starting point. Production-grade Rust adds:

Option vs Default for Missing Fields

Rust has Option<T>for explicit absence and serde's #[serde(default)]for fall-back values. Use Option when missing means “not known,” default when missing means “use this fallback.” Both compile to type-safe code; pick the semantic that matches your domain.

Borrowed vs Owned String Fields

The generator emits String for owned data. For read-only zero-copy parsing, switch to &str and add a lifetime parameter. Trickier ergonomically but significantly faster on large inputs.

Custom Deserializers for Wire Quirks

When the API has strange shapes (a field that's sometimes a string, sometimes a number), implement aDeserialize manually or use #[serde(untagged)] on an enum that captures both variants. Beats unwrap-on-the-wrong-shape panics.

When to Use a Different Approach

A few alternatives:

  • For protobuf services, use JSON to Protobuf + prost for binary efficiency.
  • For schema validation, generate a JSON Schema first, validate at the boundary with a schema-aware crate.
  • For matching JS/TS sibling models, use JSON to TypeScript for the front-end.

Common Mistakes to Avoid

  1. Calling .unwrap() on parse results. Crashes on bad input. Use ? propagation or pattern matching instead.
  2. Forgetting #[serde(rename_all = ...)]. If every JSON key is snake_case but your Rust fields are camelCase, add #[serde(rename_all = "snake_case")] on the struct — saves per-field annotations.
  3. Boxing to break recursion unnecessarily. Recursive types need a Box, but only at the recursion site. Don't box every nested struct out of habit; only when the type would otherwise be infinitely sized.
  4. Mixing serde versions. Make sure your workspace uses one serde major version. Subtle breaking changes between 1.x releases are rare but real.
  5. Skipping validation at the boundary. serde decodes shape, not semantics. A negative balance, an invalid email, a too-long username — validate after parse.

Real-World Use Cases

  • Axum / Actix request handlers. Use Json<T> extractor where T is your generated struct — type-safe deserialization at the handler level.
  • CLI tools reading JSON config. Define your config struct via the generator, parse config.json at startup with serde_json::from_reader.
  • WebAssembly clients. Generate Rust structs for the JSON API your wasm module talks to. Same code, no runtime cost.
  • High-performance API clients. serde_json is one of the fastest JSON parsers available. Replace dynamic-language clients for performance-critical paths.

Polishing the Generator's Output

Rust pushes you toward correctness at compile time, and a generated struct that compiles cleanly is already a stronger guarantee than most other languages provide. Whatever your specific use case, treat the generated output as a draft that deserves a careful read-through. Generators are excellent at producing the mechanical structure of an artifact and not at the editorial decisions that make the difference between something a colleague will tolerate and something a colleague will appreciate. Read every section of the output the way you would read a piece of writing you were proofreading for a friend. Look for inconsistent naming, missed opportunities to consolidate similar items, and places where the structure is mechanically correct but conceptually awkward. The five minutes spent on this review are the difference between an artifact that pays back over months and one that needs a second pass before it can be used. The generator handles the heavy lifting; you handle the polish that turns a draft into a deliverable. This division of labor is what makes generated code worthwhile in the first place. Without that final pass of human editorial judgment, the generator's output is merely fast rather than valuable, and the value matters more than the speed in nearly every real production setting.

The same logic applies to documentation, comments, and inline context that your generator output rarely supplies. A generated artifact has structure but no narrative; the narrative is what makes the thing useful to the next person who reads it. Add the few sentences of context that explain why a particular choice was made, what the surrounding system expects, and what the next person should look out for. These small editorial gestures cost almost nothing in the moment and pay back many times over when someone is trying to understand what you produced months later. Treat generation as the first ten percent of the work and these editorial passes as the remaining ninety percent that turns mechanical output into something a colleague will reach for again and again. Build the habit early and the gap between your generated artifacts and hand-written ones gets very small over time, which is the real prize.

Wrapping Up

A clean serde struct is the start of every typed Rust JSON consumer. PDFFlare's JSON to Rust tool generates the first draft; refine for #[serde(default)], decimal types, and Option-vs- missing semantics.

Back to all posts