JSON to Rust Struct

Generate Rust structs with serde from JSON, free, in your browser.

Class name:

JSON

Rust Struct

#[derive(Serialize, Deserialize)]
pub struct Address {
    pub city: String,
    pub zip: String,
}

#[derive(Serialize, Deserialize)]
pub struct User {
    pub name: String,
    pub age: i64,
    pub skills: Vec<String>,
    pub address: Address,
}

Processed in your browser

What it's for

From JSON to Rust Struct with serde

Compatible with the serde ecosystem

Generates structs ready to use with serde_json, reqwest, Actix-web, Axum, and any Rust ecosystem crate.

100% private

Your JSON never leaves your browser. No signup, no telemetry, no server uploads.

Correct Rust conventions

Automatic snake_case, Option<T> for nullables, correct numeric types (i64, f64). Idiomatic code.

Instant

Structs generated in real time. No buttons, no waiting, no limits.

How it works

Three steps, no hassle

Paste your JSON

Paste the JSON you want to model. Can be a nested object, an array, or any valid JSON structure.

Instant generation

The tool generates Rust structs with serde derivations automatically, following snake_case conventions.

Copy the code

Copy the generated code and add the serde dependency to your Cargo.toml to use it directly.

FAQ

Got questions?

What is serde?

serde (serialization/deserialization) is the most popular serialization framework in the Rust ecosystem. It converts Rust structs to and from formats like JSON, YAML, TOML, MessagePack, CBOR, and many more. The key to serde is that it uses compile-time macros, meaning zero runtime overhead: the generated code is as efficient as if you had written the serialization manually.

What does the #[derive] macro do?

The #[derive(Serialize, Deserialize)] macro in Rust instructs the compiler to automatically generate the implementation of serde's Serialize and Deserialize traits for the struct. This eliminates the need to write serialization code manually. It is equivalent to implementing an interface, but the code is generated at compile time via procedural macros.

Why is snake_case used in Rust?

snake_case is Rust's official naming convention for variables, struct fields, and functions (defined in the Rust API Guidelines). However, REST APIs often return JSON in camelCase. serde handles this mismatch automatically with the #[serde(rename_all = "camelCase")] attribute at the struct level, or #[serde(rename = "fieldName")] per individual field.

How are nullable fields handled?

In Rust there is no null — instead the Option<T> type is used, which can be Some(value) or None. When a JSON field can be null or absent, the corresponding Rust type is Option<T>, for example Option<String> or Option<i64>. serde automatically deserializes null as None and skips fields with None when serializing (with #[serde(skip_serializing_if = "Option::is_none")]).

How do I add serde to my project?

Add these lines to your Cargo.toml: serde = { version = "1.0", features = ["derive"] } and serde_json = "1.0". The "derive" feature enables the #[derive(Serialize, Deserialize)] macros. serde_json provides serde_json::from_str() for deserialization and serde_json::to_string() for serialization. These are among the most downloaded crates in the Rust ecosystem.