Strongly typed JSON library for Rust

Last update: Aug 8, 2022

Serde JSON   Build Status Latest Version Rustc Version 1.31+

Serde is a framework for serializing and deserializing Rust data structures efficiently and generically.


[dependencies]
serde_json = "1.0"

You may be looking for:

JSON is a ubiquitous open-standard format that uses human-readable text to transmit data objects consisting of key-value pairs.

{
    "name": "John Doe",
    "age": 43,
    "address": {
        "street": "10 Downing Street",
        "city": "London"
    },
    "phones": [
        "+44 1234567",
        "+44 2345678"
    ]
}

There are three common ways that you might find yourself needing to work with JSON data in Rust.

  • As text data. An unprocessed string of JSON data that you receive on an HTTP endpoint, read from a file, or prepare to send to a remote server.
  • As an untyped or loosely typed representation. Maybe you want to check that some JSON data is valid before passing it on, but without knowing the structure of what it contains. Or you want to do very basic manipulations like insert a key in a particular spot.
  • As a strongly typed Rust data structure. When you expect all or most of your data to conform to a particular structure and want to get real work done without JSON's loosey-goosey nature tripping you up.

Serde JSON provides efficient, flexible, safe ways of converting data between each of these representations.

Operating on untyped JSON values

Any valid JSON data can be manipulated in the following recursive enum representation. This data structure is serde_json::Value.

enum Value {
    Null,
    Bool(bool),
    Number(Number),
    String(String),
    Array(Vec<Value>),
    Object(Map<String, Value>),
}

A string of JSON data can be parsed into a serde_json::Value by the serde_json::from_str function. There is also from_slice for parsing from a byte slice &[u8] and from_reader for parsing from any io::Read like a File or a TCP stream.

use serde_json::{Result, Value};

fn untyped_example() -> Result<()> {
    // Some JSON input data as a &str. Maybe this comes from the user.
    let data = r#"
        {
            "name": "John Doe",
            "age": 43,
            "phones": [
                "+44 1234567",
                "+44 2345678"
            ]
        }"#;

    // Parse the string of data into serde_json::Value.
    let v: Value = serde_json::from_str(data)?;

    // Access parts of the data by indexing with square brackets.
    println!("Please call {} at the number {}", v["name"], v["phones"][0]);

    Ok(())
}

The result of square bracket indexing like v["name"] is a borrow of the data at that index, so the type is &Value. A JSON map can be indexed with string keys, while a JSON array can be indexed with integer keys. If the type of the data is not right for the type with which it is being indexed, or if a map does not contain the key being indexed, or if the index into a vector is out of bounds, the returned element is Value::Null.

When a Value is printed, it is printed as a JSON string. So in the code above, the output looks like Please call "John Doe" at the number "+44 1234567". The quotation marks appear because v["name"] is a &Value containing a JSON string and its JSON representation is "John Doe". Printing as a plain string without quotation marks involves converting from a JSON string to a Rust string with as_str() or avoiding the use of Value as described in the following section.

The Value representation is sufficient for very basic tasks but can be tedious to work with for anything more significant. Error handling is verbose to implement correctly, for example imagine trying to detect the presence of unrecognized fields in the input data. The compiler is powerless to help you when you make a mistake, for example imagine typoing v["name"] as v["nmae"] in one of the dozens of places it is used in your code.

Parsing JSON as strongly typed data structures

Serde provides a powerful way of mapping JSON data into Rust data structures largely automatically.

use serde::{Deserialize, Serialize};
use serde_json::Result;

#[derive(Serialize, Deserialize)]
struct Person {
    name: String,
    age: u8,
    phones: Vec<String>,
}

fn typed_example() -> Result<()> {
    // Some JSON input data as a &str. Maybe this comes from the user.
    let data = r#"
        {
            "name": "John Doe",
            "age": 43,
            "phones": [
                "+44 1234567",
                "+44 2345678"
            ]
        }"#;

    // Parse the string of data into a Person object. This is exactly the
    // same function as the one that produced serde_json::Value above, but
    // now we are asking it for a Person as output.
    let p: Person = serde_json::from_str(data)?;

    // Do things just like with any other Rust data structure.
    println!("Please call {} at the number {}", p.name, p.phones[0]);

    Ok(())
}

This is the same serde_json::from_str function as before, but this time we assign the return value to a variable of type Person so Serde will automatically interpret the input data as a Person and produce informative error messages if the layout does not conform to what a Person is expected to look like.

Any type that implements Serde's Deserialize trait can be deserialized this way. This includes built-in Rust standard library types like Vec<T> and HashMap<K, V>, as well as any structs or enums annotated with #[derive(Deserialize)].

Once we have p of type Person, our IDE and the Rust compiler can help us use it correctly like they do for any other Rust code. The IDE can autocomplete field names to prevent typos, which was impossible in the serde_json::Value representation. And the Rust compiler can check that when we write p.phones[0], then p.phones is guaranteed to be a Vec<String> so indexing into it makes sense and produces a String.

The necessary setup for using Serde's derive macros is explained on the Using derive page of the Serde site.

Constructing JSON values

Serde JSON provides a json! macro to build serde_json::Value objects with very natural JSON syntax.

use serde_json::json;

fn main() {
    // The type of `john` is `serde_json::Value`
    let john = json!({
        "name": "John Doe",
        "age": 43,
        "phones": [
            "+44 1234567",
            "+44 2345678"
        ]
    });

    println!("first phone number: {}", john["phones"][0]);

    // Convert to a string of JSON and print it out
    println!("{}", john.to_string());
}

The Value::to_string() function converts a serde_json::Value into a String of JSON text.

One neat thing about the json! macro is that variables and expressions can be interpolated directly into the JSON value as you are building it. Serde will check at compile time that the value you are interpolating is able to be represented as JSON.

let full_name = "John Doe";
let age_last_year = 42;

// The type of `john` is `serde_json::Value`
let john = json!({
    "name": full_name,
    "age": age_last_year + 1,
    "phones": [
        format!("+44 {}", random_phone())
    ]
});

This is amazingly convenient but we have the problem we had before with Value which is that the IDE and Rust compiler cannot help us if we get it wrong. Serde JSON provides a better way of serializing strongly-typed data structures into JSON text.

Creating JSON by serializing data structures

A data structure can be converted to a JSON string by serde_json::to_string. There is also serde_json::to_vec which serializes to a Vec<u8> and serde_json::to_writer which serializes to any io::Write such as a File or a TCP stream.

use serde::{Deserialize, Serialize};
use serde_json::Result;

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

fn print_an_address() -> Result<()> {
    // Some data structure.
    let address = Address {
        street: "10 Downing Street".to_owned(),
        city: "London".to_owned(),
    };

    // Serialize it to a JSON string.
    let j = serde_json::to_string(&address)?;

    // Print, write to a file, or send to an HTTP server.
    println!("{}", j);

    Ok(())
}

Any type that implements Serde's Serialize trait can be serialized this way. This includes built-in Rust standard library types like Vec<T> and HashMap<K, V>, as well as any structs or enums annotated with #[derive(Serialize)].

Performance

It is fast. You should expect in the ballpark of 500 to 1000 megabytes per second deserialization and 600 to 900 megabytes per second serialization, depending on the characteristics of your data. This is competitive with the fastest C and C++ JSON libraries or even 30% faster for many use cases. Benchmarks live in the serde-rs/json-benchmark repo.

Getting help

Serde is one of the most widely used Rust libraries so any place that Rustaceans congregate will be able to help you out. For chat, consider trying the #general or #beginners channels of the unofficial community Discord, the #rust-usage channel of the official Rust Project Discord, or the #general stream in Zulip. For asynchronous, consider the [rust] tag on StackOverflow, the /r/rust subreddit which has a pinned weekly easy questions post, or the Rust Discourse forum. It's acceptable to file a support issue in this repo but they tend not to get as many eyes as any of the above and may get closed without a response after some time.

No-std support

As long as there is a memory allocator, it is possible to use serde_json without the rest of the Rust standard library. This is supported on Rust 1.36+. Disable the default "std" feature and enable the "alloc" feature:

[dependencies]
serde_json = { version = "1.0", default-features = false, features = ["alloc"] }

For JSON support in Serde without a memory allocator, please see the serde-json-core crate.


License

Licensed under either of Apache License, Version 2.0 or MIT license at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

GitHub

https://github.com/serde-rs/json
Comments
  • 1. Perfect accuracy float parsing

    Float parsing is currently implemented by calculating the significand as u64, casting to f64, and then multiplying or dividing by a nonnegative power of 10. For example the input 10.9876543210987654 would be parsed into the value 109876543210987654_u64 as f64 / 10e15.

    This algorithm is sometimes correct, or else usually close to correct in practical usage. It matches how JSON parsers are implemented in other languages.

    However, it can happen that the result from this algorithm is not the mathematically nearest 64-bit floating point value to the exact value of the input. A "correct" algorithm would always produce the mathematically nearest answer. This requires high precision big-integer arithmetic in the general case so there would be a large performance cost; if implemented, we would likely want this behind a cfg that is off by default, with the current approximate behavior as default. This way programs can opt in to the more expensive algorithm as required.

    fn main() {
        let input = "10.9876543210987654";
        let n: f64 = serde_json::from_str(input).unwrap();
    
        // produces 10.9876543210987644982878919108770787715911865234375
        // which is low by 9.017e-16
        let current_algorithm = 109876543210987654_u64 as f64 / 10e15;
        println!("{}", precise::to_string(current_algorithm));
        assert_eq!(n, current_algorithm);
    
        // produces 10.98765432109876627464473131112754344940185546875
        // which is high by 8.746e-16 (closer)
        let correct_answer = 10.9876543210987654_f64;
        println!("{}", precise::to_string(correct_answer));
        assert_ne!(n, correct_answer);
    }
    
    Reviewed by dtolnay at 2019-04-21 21:07
  • 2. Allow increasing recursion limit

    I am parsing/serializing pretty large JSON files and I regularly encounter RecursionLimitExceeded. I need a way to instantiate a Serializer/Deserializer with a much larger recursion limit.

    Could we introduce code to let us tweak that?

    Reviewed by Yoric at 2017-06-14 08:29
  • 3. Parser cannot read arbitrary precision numbers

    http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf specifies in the second paragraph of the introduction that JSON is agnostic about numbers, and simply represents them as a series of digits.

    However, serde-json parses anything with a decimal point as a Rust f64, which causes numbers to be read incorrectly. There is no way to avoid this because this behaviour is chosen as soon as a decimal point is encountered. This makes it impossible to use serde-json to interoperate with financial software using JSON.

    Reviewed by apoelstra at 2015-11-05 12:31
  • 4. Add a RawValue type

    It would be helpful to have a type similar to Go's json.RawMessage that is not tokenized during deserialization, but rather its raw contents stored as a Vec<u8> or &'de [u8].

    The following pseudo-code demonstrates the idea.

    #[derive(Deserialize)]
    struct Struct {
        /// Deserialized normally.
        core_data: Vec<i32>,
    
        /// Contents of `user_data` are copied / borrowed directly from the input
        /// with no modification.
        ///
        /// `RawValue<'static>` is akin to `Vec<u8>`.
        /// `RawValue<'a>` is akin to `&'a [u8]`.
        user_data: serde_json::RawValue<'static>,
    }
    
    fn main() {
        let json = r#"
        {
            "core_data": [1, 2, 3],
            "user_data": { "foo": {}, "bar": 123, "baz": "abc" }
        }
        "#;
        
        let s: Struct = serde_json::from_bytes(&json).unwrap();
        println!("{}", s.user_data); // "{ \"foo\": {}, \"bar\": 123, \"baz\": \"abc\" }"
    }
    

    The main advantage of this is would be to have 'lazily-deserialized' values.

    Reviewed by alteous at 2017-09-03 18:06
  • 5. Output JSON schema during build process

    It would be great if Serde could optionally produce a JSON schema as a side-effect of the build process. AFAIK it has all the information it needs to write one. You just need to translate the structs/enums to their appropriate schema representations (read: matching JSON type).

    Additional:

    While the above is an awesome starting block, it would also be really nice if you could compile-time check that Serde's JSON will validate against an externally provided schema. This isn't totally necessary, as you could do this after the fact with a tool like ajv. It would just provide stronger guarantees if it was compile-time checked.

    Motivation

    • Compatibility: Presently there is no way to guarantee that JSON produced by Serde is compatible with another framework. We can only write tests against JSON samples and write code to match an API spec. We have no way of knowing if either of them is up-to-date or correct.
    • Extendability: Having a portable artifact of your data-representation is an enormously useful tool. In many dynamic languages, you can auto generate data bindings and UIs provided a schema. This allows devs to quickly develop across platforms and languages while maintaining integrity of their data.

    Anticipated Questions:

    • Why Serde? - Serde already has all of the user-facing hardware necessary to produce a schema. Using attributes and types already in the user's code makes adding this feature "free" and to existing libraries.
    • Why at compile-time? - Validating against a schema at compile-time enables devs to "Hack without fear", because they will know that they are properly encoding their data types. It allows devs to easily update their code and immediately know if their schema/data-bindings are out of date.
    Reviewed by lylemoffitt at 2016-12-24 04:31
  • 6. Consider serializing map integer keys as strings

    Right now serde_json rejects serializing maps with integer keys because semantically speaking, JSON only supports maps with string keys. There are workarounds in serde 0.7 with the new #[serde(serialize_with="...", deserialize_with="...)] (see this gist), but it still can be annoying if this keeps causing problems.

    Is there any real value about erroring out on non-key values?

    Reviewed by erickt at 2016-02-27 22:50
  • 7. Round trip floats

    Ideally this test would pass.

    extern crate serde_json;
    
    #[macro_use]
    extern crate quickcheck;
    
    quickcheck! {
        fn floats(n: f64) -> bool {
            let j = serde_json::to_string(&n).unwrap();
            serde_json::from_str::<f64>(&j).unwrap() == n
        }
    }
    

    On the printing side grisu2 guarantees that the f64 closest to the string representation is identical to the original input, so the inaccuracy is somewhere on the parsing side.

    Reviewed by dtolnay at 2016-08-02 04:16
  • 8. Arbitrary precision numbers

    Fixes #18.

    serde_json = { version = "0.9", features = ["arbitrary_precision"] }
    
    #[derive(Serialize, Deserialize)]
    struct S {
        n: serde_json::Number,
        v: serde_json::Value,
    }
    
    let s: S = serde_json::from_str(...)?;
    
    // full precision
    println!("{}", s.n);
    println!("{}", s.v);
    println!("{}", serde_json::to_string(&s)?);
    
    Reviewed by dtolnay at 2017-02-11 21:11
  • 9. Having issues iterating through an serde_json::Value

    Sorry to post this on the issues forum, but I cannot find a clean way to do this. I am new to rust and would like to do iterate through this data structure (when printed withprintln!("{:?}\n\n",v);)

    Array([Object({"24h_volume_usd": String("7555680000.0"), "available_supply": String("16896337.0"), "id": String("bitcoin"), "last_updated": String("1520039066"), "market_cap_usd": String("187946404620"), "max_supply": String("21000000.0"), "name": String("Bitcoin"), "percent_change_1h": String("0.46"), "percent_change_24h": String("0.45"), "percent_change_7d": String("7.4"), "price_btc": String("1.0"), "price_usd": String("11123.5"), "rank": String("1"), "symbol": String("BTC"), "total_supply": String("16896337.0")}), Object({"24h_volume_usd": String("1859040000.0"), "available_supply": String("97947252.0"), "id": String("ethereum"), "last_updated": String("1520039051"), "market_cap_usd": String("84237477378.0"), "max_supply": Null, "name": String("Ethereum"), "percent_change_1h": String("0.3"), "percent_change_24h": String("-1.49"), "percent_change_7d": String("-0.41"), "price_btc": String("0.0775658"), "price_usd": String("860.029"), "rank": String("2"), "symbol": String("ETH"), "total_supply": String("97947252.0")}), Object({"24h_volume_usd": String("276913000.0"), "available_supply": String("39091956706.0"), "id": String("ripple"), "last_updated": String("1520039041"), "market_cap_usd": String("36054628946.0"), "max_supply": String("100000000000"), "name": String("Ripple"), "percent_change_1h": String("1.39"), "percent_change_24h": String("-0.6"), "percent_change_7d": String("-7.81"), "price_btc": String("0.00008318"), "price_usd": String("0.922303"), "rank": String("3"), "symbol": String("XRP"), "total_supply": String("99992520283.0")}), Object({"24h_volume_usd": String("417415000.0"), "available_supply": String("16996550.0"), "id": String("bitcoin-cash"), "last_updated": String("1520039053"), "market_cap_usd": String("21658363734.0"), "max_supply": String("21000000.0"), "name": String("Bitcoin Cash"), "percent_change_1h": String("-0.15"), "percent_change_24h": String("-1.56"), "percent_change_7d": String("-0.24"), "price_btc": String("0.114927"), "price_usd": String("1274.28"), "rank": String("4"), "symbol": String("BCH"), "total_supply": String("16996550.0")})])
    
    
    extern crate term_painter;
    extern crate reqwest;
    
    
    extern crate serde_json;
    // JSON Parsing and Construction
    // https://github.com/serde-rs/json
    use serde_json::{Value};
    
    mod getcointicker;
    
    //use std::io;
    
    //https://lukaskalbertodt.github.io/term-painter/term_painter/
    use term_painter::ToStyle;
    use term_painter::Color::*;
    //use term_painter::Attr::*;
    use getcointicker::coinprices;
    
    fn main() {
        println!("rusty{}, ",
            Yellow.paint("Horde"),
        );
        let cp = match coinprices(4) {
            Result::Ok(val) => {val},
            Result::Err(err) => {format!("Unable to get coin prices: {}",err)}
        };
        //println!("{}",cp);  
        let v: Value = match serde_json::from_str(&cp){
            Result::Ok(val) => {val},
            Result::Err(err) => {panic!("Unable to parse json: {}",err)}
        };
        
        //what is the proper way to iterate through all the values in the array
        for i in &v.into_iter() {
            println!("{:?}\n\n",v[i]);
        }
        println!("{:?}\n\n",v[0]); //this works no problem
            
        println!("{}",v[0]["market_cap_usd"]);  
    }
    
    

    I have tried several ways...the latest was the following:

    error[E0599]: no method named `into_iter` found for type `serde_json::Value` in the current scope
      --> src/main.rs:34:16
       |
    34 |     for i in v.into_iter() {
       |                ^^^^^^^^^
       |
       = note: the method `into_iter` exists but the following trait bounds were not satisfied:
               `serde_json::Value : std::iter::IntoIterator`
               `&serde_json::Value : std::iter::IntoIterator`
               `&mut serde_json::Value : std::iter::IntoIterator`
    
    error: aborting due to previous error
    
    error: Could not compile `rustyhorde`.
    

    Thank you so much for your help!

    Reviewed by hortinstein at 2018-03-03 01:10
  • 10. where did StreamDeserializer::new go?

    Im upgrading from 0.8 to 0.9 and noticed there was an undocumented breaking change for StreamDeserializer. I can no longer construct an instance for one a type implements Deserialize. it looks like its now behind into_iter on Deserialize for types that implement Read. Please advise

    Reviewed by softprops at 2017-01-30 06:57
  • 11. Implement issue #68 - add pointer_mut

    I was thinking that JSON Patch support would be useful, and saw the Issues for that and for pointer_mut support. #68 pointer_mut seemed necessary for implementing Patch, so I took a swing at it! This is my first open-source Rust PR so criticism is welcome but be gentle, haha!

    I moved pointer into a new trait (Pointer) and added pointer_mut to it as well. To maintain symmetry I also added a pointer_owned method that consumes the Value and returns an owned Value. Because of the new trait this is a breaking change (you need to import the trait for pointer to work now.)

    Unit tests were added and all pass, documentation was added but is mostly just copy-paste from the existing code. I also wrote a benchmark to verify that the changes I made to pointer weren't slower than the existing code, but left out the change to the .rs.in file I made to run the bench. On my machine, the new and old pointer methods were very close in performance. The new one actually seems slightly faster but they were within deviation range of each other so I'm making no claims except that my refactors shouldn't have negatively affected the method.

    Reviewed by CryptArchy at 2016-12-03 21:55
  • 12. Missing Field(s) Error discards record of the missing fields.

    The Problem

    When trying to deserialize a json object with missing fields to a struct with serde_json, one may get an Error of the Catergory Data. Sadly those Categories don't entail any information and the Error doesn't expose any Category specific information (except for the category itself). This (as far as I can tell) doesn't make it possible to crate custom error messages when certain fields are missing.

    Downsides

    Can't think of any.

    Reviewed by einsJannis at 2022-07-30 10:04
  • 13. feature: `remove_by_pointer` method

    Added Value::remove_by_pointer method that allows you to remove a value from a nested JSON object specified by JSON pointer as in Value::pointer{_mut}.

    Reviewed by e-rhodes at 2022-07-19 21:16
  • 14. Is help maintaining wanted?

    I just ran into an issue whilst coding and found an issue here describing my challenge exactly, a handful of months old, with zero reaction from maintainers. Looking around the repo's issues and PRs it looks like there are quite a few outstanding questions and suggestions (although quite a few recently merged PRs as well!)

    I'm pretty new to rust but as far as I understand this is still the JSON library in the rust ecosystem (to which, great job, well done, amazing 🥳 ). In my experience, this library handles its core functionality well, and perhaps little maintenance is needed, nevertheless, some maintenance is no doubt nice.

    So instead of complaining, I thought I'd ask (: , is help welcome for anything? With just question answering, or PR reviewing, or PR merging?

    Perhaps this can be the first step in others helping out to improve maintenance a little. Thanks for a great lib! 💛

    Reviewed by alextes at 2022-07-13 13:34
  • 15. Deserialize empty map into None

    I have a JSON format which could be either a tagged value or an empty map {}. Examples of JSON:

    {"A" : 123}
    
    {"B" : 234}
    
    {}
    

    I want to deserialize it into a enum, so I defined one:

    #[derive(Debug, Serialize, Deserialize)]
    enum Enum {
        A(i64),
        B(i64),
        #[serde(other)]
        None,
    }
    

    Despite having one option labeled with #[serde(other)] de-serialization fails for {} .

    Playground: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=dd5719ccc279964cc65d545a2261a177

    Reviewed by lexa at 2022-07-05 14:17
JSON Schema validation library

A JSON Schema validator implementation. It compiles schema into a validation tree to have validation as fast as possible.

Aug 13, 2022
A port of the Node.js library json-file-store

A port of the Node.js library json-file-store

Jul 19, 2022
JSON parser which picks up values directly without performing tokenization in Rust
JSON parser which picks up values directly without performing tokenization in Rust

Pikkr JSON parser which picks up values directly without performing tokenization in Rust Abstract Pikkr is a JSON parser which picks up values directl

Jul 2, 2022
JSON implementation in Rust
JSON implementation in Rust

json-rust Parse and serialize JSON with ease. Changelog - Complete Documentation - Cargo - Repository Why? JSON is a very loose format where anything

Aug 14, 2022
Rust port of gjson,get JSON value by dotpath syntax

A-JSON Read JSON values quickly - Rust JSON Parser change name to AJSON, see issue Inspiration comes from gjson in golang Installation Add it to your

May 2, 2022
A rust script to convert a better bibtex json file from Zotero into nice organised notes in Obsidian

Zotero to Obsidian script This is a script that takes a better bibtex JSON file exported by Zotero and generates an organised collection of reference

Feb 12, 2022
CLI tool to convert HOCON into valid JSON or YAML written in Rust.

{hocon:vert} CLI Tool to convert HOCON into valid JSON or YAML. Under normal circumstances this is mostly not needed because hocon configs are parsed

Jul 7, 2022
Typify - Compile JSON Schema documents into Rust types.

Typify Compile JSON Schema documents into Rust types. This can be used ... via the macro import_types!("types.json") to generate Rust types directly i

Aug 13, 2022
A easy and declarative way to test JSON input in Rust.

assert_json A easy and declarative way to test JSON input in Rust. assert_json is a Rust macro heavily inspired by serde json macro. Instead of creati

Nov 30, 2021
A small rust database that uses json in memory.

Tiny Query Database (TQDB) TQDB is a small library for creating a query-able database that is encoded with json. The library is well tested (~96.30% c

Jan 4, 2022
A JSON Query Language CLI tool built with Rust 🦀

JQL A JSON Query Language CLI tool built with Rust ?? ?? Core philosophy ?? Stay lightweight ?? Keep its features as simple as possible ?? Avoid redun

Aug 6, 2022
rurl is like curl but with a json configuration file per request

rurl rurl is a curl-like cli tool made in rust, the difference is that it takes its params from a json file so you can have all different requests sav

Nov 20, 2021
A tool for outputs semantic difference of json

jsondiff A tool for outputs semantic difference of json. "semantic" means: sort object key before comparison sort array before comparison (optional, b

Sep 22, 2021
Easily create dynamic css using json notation

jss! This crate provides an easy way to write dynamic css using json notation. This gives you more convenient than you think. Considering using a dyna

May 14, 2022
Decode Metaplex mint account metadata into a JSON file.

Simple Metaplex Decoder (WIP) Install From Source Install Rust. curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh Clone the source: git c

Aug 4, 2022
A fast and simple command-line tool for common operations over JSON-lines files

rjp: Rapid JSON-lines processor A fast and simple command-line tool for common operations over JSON-lines files, such as: converting to and from text

Jul 8, 2022
A node package based on jsonschema-rs for performing JSON schema validation

A node package based on jsonschema-rs for performing JSON schema validation.

Jul 31, 2022
Tools for working with Twitter JSON data

Twitter stream user info extractor This project lets you parse JSON data from the Twitter API or other sources to extract some basic user information,

Apr 21, 2022
A fast way to minify JSON

COMPACTO (work in progress) A fast way to minify JSON. Usage/Examples # Compress # Input example (~0.11 KB) # { # "id": "123", # "name": "Edua

Feb 27, 2022