Skip to main content

​
Unkey for Rust

An asynchronous Rust SDK for the Unkey API. All the API key management features you love, now with more type safety!

​
MSRV

The minimum supported Rust verision for the project is 1.63.0.

​
Setup

​
Using cargo

$ cargo add unkey

​
Manually

Add the following to your Cargo.toml dependencies array: 
unkey = "0.4"

​
Getting Started

​
Examples

​
Verifying a key

use unkey::models::VerifyKeyRequest;
use unkey::Client;

async fn verify_key() {
    let c = Client::new("unkey_ABC");
    let req = VerifyKeyRequest::new("test_DEF", "api_JJJ");

    match c.verify_key(req).await {
        Ok(res) => println!("{res:?}"),
        Err(err) => eprintln!("{err:?}"),
    }
}

​
Creating a key

use unkey::models::CreateKeyRequest;
use unkey::Client;

async fn create_key() {
    let c = Client::new("unkey_ABC");
    let req = CreateKeyRequest::new("api_123")
        .set_prefix("test")
        .set_remaining(100)
        .set_name("test_name")
        .set_owner_id("jonxslays");

    match c.create_key(req).await {
        Ok(res) => println!("{res:?}"),
        Err(err) => eprintln!("{err:?}"),
    }
}

​
Updating a key

use unkey::models::{Refill, RefillInterval, UpdateKeyRequest};
use unkey::Client;

async fn update_key() {
    let c = Client::new("unkey_ABC");
    let req = UpdateKeyRequest::new("key_XYZ")
        .set_name(Some("new_name")) // Update the keys name
        .set_ratelimit(None) // Remove any ratelimit on the key
        .set_expires(None) // Remove any expiration date
        .set_refill(Some(Refill::new(100, RefillInterval::Daily)));

    match c.update_key(req).await {
        Ok(_) => println!("Success"), // Nothing on success
        Err(err) => eprintln!("{err:?}"),
    }
}

​
Revoking a key

use unkey::models::RevokeKeyRequest;
use unkey::Client;

async fn revoke_key() {
    let c = Client::new("unkey_ABC");
    let req = RevokeKeyRequest::new("key_XYZ");

    match c.revoke_key(req).await {
        Ok(_) => println!("Success"), // Nothing on success
        Err(err) => eprintln!("{err:?}"),
    }
}

​
Listing api keys

use unkey::models::ListKeysRequest;
use unkey::Client;

async fn list_keys() {
    let c = Client::new("unkey_ABC");
    let req = ListKeysRequest::new("api_123");

    match c.list_keys(req).await {
        Ok(res) => println!("{res:?}"),
        Err(err) => eprintln!("{err:?}"),
    }
}

​
Getting api information

use unkey::models::GetApiRequest;
use unkey::Client;

async fn get_api() {
    let c = Client::new("unkey_ABC");
    let req = GetApiRequest::new("api_123");

    match c.get_api(req).await {
        Ok(res) => println!("{res:?}"),
        Err(err) => eprintln!("{err:?}"),
    }
}

​
Getting key details

use unkey::models::GetKeyRequest;
use unkey::Client;

async fn get_key() {
    let c = Client::new("unkey_ABC");
    let req = GetKeyRequest::new("key_123");

    match c.get_key(req).await {
        Ok(res) => println!("{res:?}"),
        Err(err) => eprintln!("{err:?}"),
    }
}

​
Update remaining verifications

use unkey::models::{UpdateOp, UpdateRemainingRequest};
use unkey::Client;

async fn update_remaining() {
    let c = Client::new("unkey_ABC");
    let req = UpdateRemainingRequest::new("key_123", Some(100), UpdateOp::Set);

    match c.update_remaining(req).await {
        Ok(res) => println!("{res:?}"),
        Err(err) => eprintln!("{err:?}"),
    }
}
⌘I