Conversor de Rust para JSON
Cole structs Rust com derive Serialize. Receba JSON limpo de volta.
O que esta ferramenta faz
Se você já definiu uma struct, jogou #[derive(Serialize)] em cima dela e percebeu que só precisa do JSON sem ter que escrever o boilerplate do serde, adicionar o serde_json no Cargo.toml e rodar cargo run — esta ferramenta faz exatamente isso. Cole o Rust aqui e receba JSON válido sem mexer em cargo. Ela lida com um único literal de struct, um módulo inteiro com vários tipos, ou algo com Vec e Option profundamente aninhados — o resultado é o mesmo: um documento JSON limpo com cada campo preservado.
O conversor acompanha como o serde realmente serializa os valores. String e &str viram strings JSON. i32, u64, f32, f64 viram números JSON. bool vira true/false. Vec<T>, &[T] e [T; N] viram arrays JSON. HashMap<String, V> / BTreeMap<String, V> viram objetos JSON. Option<T> com None vira null em JSON; com Some(value), o tipo interno é serializado. Tuplas saem como arrays heterogêneos — o comportamento exato está documentado em serde.rs/data-model.
Os atributos do serde são respeitados. #[serde(rename = "x")] renomeia a chave JSON, #[serde(skip)] remove o campo e #[serde(flatten)] puxa os campos da struct aninhada para o objeto pai. Tipos enum seguem por padrão a representação externally-tagged (configurável com #[serde(tag = "type")]). Cole várias structs de uma vez e cada uma sai como entrada de nível superior. Se você trabalha com serviços web construídos sobre a biblioteca padrão do Rust com axum/actix, esta saída cai direto nos seus testes de integração.
Como usar
Três passos. Funciona igual, tanto para um struct literal quanto para um módulo inteiro com uma dúzia de tipos.
Cole seu Rust (ou carregue o exemplo)
Jogue seu Rust no editor da esquerda como está. Uma struct, um tuple struct, um enum com variantes, vários tipos ou Vec/Option/HashMap aninhados — tudo funciona. Clique em Carregar exemplo para ver um caso realista primeiro.
Você não precisa remover as declarações use, lifetimes nem atributos derive. Deixe a sintaxe Rust como está — os atributos do serde fazem parte do que o parser lê.
Clique em Converter
Clique no botão verde Converter. A ferramenta lê o Rust, preserva cada struct e cada campo e emite o JSON em uma passada só. Um pequeno indicador de carregamento aparece durante o processo.
Copie o JSON
O painel da direita se preenche com JSON indentado. Copie para um teste com reqwest, um teste de integração do axum, seus exemplos OpenAPI ou um comando curl. Sem rebuild.
Quando isso realmente ajuda
Fixtures de serviços web
Você tem uma struct de requisição do axum ou actix e precisa do JSON para um teste ou chamada curl. Cola a struct, pega o JSON, segue a vida — sem ciclo de cargo.
Templates de config para CLIs
Uma CLI baseada em clap com uma struct Config. Converta para um template JSON que os usuários possam editar, sem ter que escrever uma impl <code>Default</code> sob medida só para a documentação.
Seeds para testes de integração
Transforme os literais de struct dos seus testes unitários em arquivos JSON de seed para testes de integração, mock servers ou fixtures de banco embutido.
Docs que acompanham o código
Gere exemplos JSON para o seu README ou spec OpenAPI direto a partir dos tipos Rust reais, para que a documentação pare de ficar desatualizada.
Perguntas frequentes
Preciso do serde e do serde_json no meu Cargo.toml?
Para esta ferramenta, não — ela roda no servidor e não compila seu código. Para uso em runtime dentro do seu app, o combo padrão é o serde com a feature derive e o serde_json.
Ela respeita #[serde(rename)], #[serde(skip)] e #[serde(flatten)]?
Sim. #[serde(rename = "x")] renomeia a chave JSON, #[serde(skip)] remove o campo da saída e #[serde(flatten)] sobe os campos da struct aninhada para o pai — exatamente como descreve a documentação dos atributos de campo do serde.
Como Option, Vec e HashMap são tratados?
Option<T> com None vira null em JSON; com Some(v), o valor interno é serializado. Vec<T>, slices e arrays viram arrays JSON. HashMap<String, V> e BTreeMap<String, V> viram objetos JSON; mapas com chaves não-string têm as chaves convertidas para string.
E enums com variantes?
Por padrão, variantes de enum usam a representação externally-tagged ({ "VariantName": {...} }). Os atributos #[serde(tag = "type")], #[serde(untagged)] e #[serde(content = "data")] alternam para internally-tagged, untagged ou adjacently-tagged — a ferramenta lê esses atributos e emite a saída conforme.
Meu código fica armazenado?
Seu código é enviado ao backend para a conversão e não fica persistido — não logamos o payload. Dá uma olhada em código sensível antes de colar.
E se o Rust usa lifetimes ou generics?
Lifetimes (&'a str) são ignorados — JSON não tem esse conceito. Generics concretizados (Vec<User>) funcionam. Generics não instanciados saem como null. Macros que se expandem para sintaxe real funcionam; macros que dependem de um crate proc-macro invisível aqui são tratadas como opacas.
Outras ferramentas que podem te ajudar
Rust para JSON é uma peça do quebra-cabeça. Estas combinam bem: