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:

your-sdk

README.md

Cargo.toml

.gitignore

LICENSE

.devcontainer

examples

src

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:

1 use your_sdk::models::Pet;
2 use serde_json;
3 
4 // Create a model instance
5 let pet = Pet {
6     name: "Fluffy".to_string(),
7     status: "available".to_string(),
8     id: Some(1),
9     category: None,
10 };
11 
12 // Serialize to JSON
13 let json = serde_json::to_string(&pet)?;
14 // {"name":"Fluffy","status":"available","id":1}
15 
16 // Deserialize from JSON
17 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:

1 use your_sdk::models::UpdateContainerGroup;
2 
3 // Only set fields are included in API requests
4 let update = UpdateContainerGroup {
5     replicas: Some(2),
6     country_codes: Some(vec!["us".to_string(), "eu".to_string()]),
7     liveness_probe: None, // This field is omitted from the request
8     display_name: Some("Updated Container".to_string()),
9 };

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

Run the example

Example code structure

Async example

examples/example.rs

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:

1 [dependencies]
2 your-sdk = "1.0.0"
3 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:

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

Install from Git repository

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

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

For a specific version or tag:

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

Publish to crates.io

To share your generated Rust SDK with the community, you can publish it to crates.io. This allows other developers to easily install it using Cargo. Follow the steps below to publish your SDK to crates.io.

Prerequisites

To publish your SDK to crates.io, you need the following:

A crates.io account (create at crates.io)
Cargo installed with Rust toolchain
API token from crates.io

Configure Cargo.toml

Ensure your SDK’s Cargo.toml is properly configured for publication:

Publish your Rust SDK to crates.io

To publish your SDK to crates.io, do the following:

Create crates.io account and get API token:
- Register at crates.io
- Go to Account Settings > API Tokens
- Create a new token with appropriate permissions

$ cargo login <your-api-token>

Verify your package builds correctly:

$ # Check for common issues
$ cargo check
$ 
$ # Run tests
$ cargo test
$ 
$ # Build documentation
$ cargo doc
$ 
$ # Verify package contents
$ cargo package --list

Test the package build:

$ # This creates a .crate file without publishing
$ cargo package

Publish to crates.io:

$ cargo publish

Verify publication:

$ # In a separate test project, add your published crate as a dependency
$ cargo new verify-your-sdk
$ cd verify-your-sdk
$ cargo add your-sdk
$ 
$ # Build the project to verify the crate resolves and compiles
$ cargo check
$ 
$ # Or visit: https://crates.io/crates/your-sdk

Use cargo install your-sdk only if your crate also publishes a binary target.

Publish updates

To publish a new version of your SDK:

Update the version in Cargo.toml:

1 version = "1.0.1"

Update dependencies if needed and test:

$ cargo update
$ cargo test

Publish the new version:

$ cargo publish

Best practices for publishing Rust SDKs

Use the following best practices when publishing your Rust SDK to crates.io:

Follow semantic versioning (MAJOR.MINOR.PATCH).
Include comprehensive documentation with cargo doc.
Use appropriate keywords and categories for discoverability.
Test your package thoroughly with cargo test.
Consider using features for optional functionality.
Keep your API surface minimal and follow Rust naming conventions.
Use #[non_exhaustive] on enums and structs that might grow.
Provide good error messages and use thiserror for error handling.

Advanced configuration

For production SDKs, consider these additional configurations:

Custom feature flags

1 [features]
2 default = ["reqwest-default"]
3 reqwest-default = ["reqwest/default-tls"]
4 reqwest-rustls = ["reqwest/rustls-tls"]
5 blocking = ["reqwest/blocking"]

Documentation settings

1 [package.metadata.docs.rs]
2 all-features = true
3 rustdoc-args = ["--cfg", "docsrs"]

This ensures that docs.rs builds your documentation with all features enabled and proper conditional compilation attributes.