> For clean Markdown content of this page, append .md to this URL. For the complete documentation index, see https://learning.postman.com/llms.txt.

# Use Rust SDKs generated in Postman

This guide provides instructions for using Rust SDKs generated by Postman SDK Generator. It covers how to import the SDK into your project, run example code, and best practices for using the SDK effectively in your applications.

The Postman SDK Generator creates Rust SDKs with type-safe models, service modules for API endpoints, comprehensive error handling with `Result<T, E>`, async/await support using Tokio, and extensive documentation to help you integrate with your API quickly and efficiently. Models leverage Serde for JSON serialization/deserialization and provide compile-time type safety with Rust's powerful type system.

## SDK structure

Generated Rust SDKs include the following key components:

* Core client — `src/lib.rs` as the main entry point and `src/client.rs` for the SDK client implementation.
* Service modules — Organized in `src/services/` with individual modules for each service.
* Data models — Type-safe structs and enums in `src/models/` powered by Serde.
* HTTP infrastructure — Located in `src/http/` handling configuration, transport, request handling, and authentication.
* Dependencies — Specified in `Cargo.toml` (reqwest, Serde, tokio for async support).
  The directory structure includes documentation files, example implementations, and configuration for both development and production environments.

The following is an example of the typical structure of a generated Rust SDK:

Main documentation

Rust package configuration

Git ignore rules

Dev container configuration

Basic SDK usage example

Library main entry point

Main SDK client implementation

Error types and handling

HTTP module declarations

HTTP client implementation

SDK configuration types

Auth dispatch

API key authentication

Bearer token authentication

Basic authentication

Service module declarations

Individual service implementations

Model module declarations

Individual model definitions

## Type safety with Serde

Generated models leverage Serde for serialization and Rust's type system for compile-time safety. All API interactions are validated at compile time, eliminating runtime type errors.

### Model serialization

Models automatically serialize to and from JSON using Serde. The SDK handles field renaming, optional fields, and nested structures:

```rust
use your_sdk::models::Pet;
use serde_json;

// Create a model instance
let pet = Pet {
    name: "Fluffy".to_string(),
    status: "available".to_string(),
    id: Some(1),
    category: None,
};

// Serialize to JSON
let json = serde_json::to_string(&pet)?;
// {"name":"Fluffy","status":"available","id":1}

// Deserialize from JSON
let pet: Pet = serde_json::from_str(&json)?;
```

### Optional and nullable fields

The SDK distinguishes between `Option<T>` fields (can be omitted) and fields that can be explicitly null using custom serde annotations:

```rust
use your_sdk::models::UpdateContainerGroup;

// Only set fields are included in API requests
let update = UpdateContainerGroup {
    replicas: Some(2),
    country_codes: Some(vec!["us".to_string(), "eu".to_string()]),
    liveness_probe: None, // This field is omitted from the request
    display_name: Some("Updated Container".to_string()),
};
```

### Error handling

The SDK uses Rust's `Result<T, E>` type for comprehensive error handling. All API calls return a `Result` with detailed error information.

## Example usage

Each generated SDK includes an `examples/` directory with working projects demonstrating various SDK usage patterns.

The examples include the following features:

* Async usage patterns with Tokio
* SDK configuration with different authentication methods
* Type-safe API calls with full IntelliSense support
* Comprehensive error handling with custom error types
* Best practices for production usage

#### Location

`examples/example.rs`

#### Run the example

```bash
cd path/to/your-sdk
cargo run --example example
```

#### Example code structure

```rust
use your_sdk::{YourSdkClient, YourSdkConfig};
use your_sdk::http::Environment;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = YourSdkConfig::builder()
        .access_token("your-api-key")
        .environment(Environment::Production)
        .timeout_ms(30000)
        .build()
        .expect("Failed to build configuration");
    let client = YourSdkClient::new(config)?;
    match client.pets().list_pets(None).await {
        Ok(pets) => {
            println!("Pets: {:?}", pets);
        }
        Err(error) => {
            eprintln!("Error: {}", error);
        }
    }
    Ok(())
}
```

#### Async example

```rust
use your_sdk::{YourSdkClient, YourSdkConfig};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = YourSdkConfig::builder()
        .access_token("your-bearer-token")
        .build()
        .expect("Failed to build configuration");
    let client = YourSdkClient::new(config)?;
    // Multiple concurrent requests
    let (pet1, pet2) = tokio::try_join!(
        client.pets().get_pet_by_id("123".to_string()),
        client.pets().get_pet_by_id("456".to_string())
    )?;
    println!("Pet 1: {:?}", pet1);
    println!("Pet 2: {:?}", pet2);
    Ok(())
}
```

## Install the Rust SDK

You can add the generated SDK to your Rust project using Cargo, either from a published crate or as a local dependency.

### Install using Cargo

To add the SDK as a dependency from crates.io, add it to your `Cargo.toml`:

```toml
[dependencies]
your-sdk = "1.0.0"
tokio = { version = "1.0", features = ["full"] }
```

Then use it in your code:

### Install from a local path

To use the SDK from a local directory, add it as a path dependency in your `Cargo.toml`:

```toml
[dependencies]
your-sdk = { path = "../path/to/your-sdk" }
tokio = { version = "1.0", features = ["full"] }
```

### Install from Git repository

To install from a Git repository, add it as a Git dependency:

```toml
[dependencies]
your-sdk = { git = "https://github.com/your-org/your-sdk", branch = "main" }
tokio = { version = "1.0", features = ["full"] }
```

For a specific version or tag:

```toml
[dependencies]
your-sdk = { git = "https://github.com/your-org/your-sdk", tag = "v1.0.0" }
```

## Publish

To publish your generated Rust SDK, see [Publish Rust SDKs generated in Postman](/docs/sdk-generator/publish/rust-manual/).