rustsf 0.1.1

Salesforce SDK for Rust, supports the latest API version 68.0, (Winter 2026)
Documentation

crate-name at crates.io crate-name at docs.rs

RustSF

Thé most comprehensive Salesforce SDK for Rust, that supports most of the primary Salesforce APIs. It contains many examples and has very detailed documententation.

The currently supported Salesforce APIs with the latest version 67.0 (Summer 2026) are:

  • Rest API, enabled via the feature rest-api
  • Tooling API, enabled via the feature tooling-api
  • Metadata API, enabled via the feature metadata-api

It also supports the following APIs, but they still need a bit of work:

  • Bulk API v1
  • Bulk API v2
  • Streaming API

And we have a number of APIs which are high on the wish list. If you are interested in contributing, please start a discussion with your suggestions.

  • CPQ API
  • Heroku Platform API
  • Streaming API

Notes

This repo was forked from rustforce and a PR from tance77, for the rustforce repo seemed to be abandoned. The rustforce repo also lacked some important features and had some design flows around API versioning.

Usage

[dependencies]
rustsf = { version = "0.0.2", features = ["rest-api", "tooling-api", "metadata-api"] }
use rustsf::{Client, RestApi, Credentials, QueryResponse};
use serde::Deserialize;
use std::env;
use anyhow::Result;

#[derive(Deserialize, Debug)]
#[serde(rename_all = "PascalCase")]
struct Account {
    id: String,
    name: String,
}

#[tokio::main]
async fn main() -> Result<()> {
    let mut credentials = Credentials::new();
    credentials.set_client_id(env::var("SFDC_CLIENT_ID").unwrap());
    credentials.set_client_secret(env::var("SFDC_CLIENT_SECRET").unwrap());
    credentials.set_username(env::var("SFDC_USERNAME").unwrap());
    credentials.set_password(env::var("SFDC_PASSWORD").unwrap());

    let mut client = Client::new(credentials).await?;
    let mut api = RestApi::new(client);

    let res: QueryResponse<Account> = api.query("SELECT Id, Name FROM Account").await?;
    println!("{:?}", res);

    Ok(())
}

Authentication

Username Password Flow (OAuth2)

let mut credentials = Credentials::new();
credentials.set_client_id(env::var("SFDC_CLIENT_ID").unwrap());
credentials.set_client_secret(env::var("SFDC_CLIENT_SECRET").unwrap());
credentials.set_username(env::var("SFDC_USERNAME").unwrap());
credentials.set_password(env::var("SFDC_PASSWORD").unwrap());

let mut client = Client::new(credentials).await?;

Using an Existing Access Token

let mut credentials = Credentials::new();
credentials.set_access_token(Some(AccessToken {
    value,
    issued_at,
    token_type,
}));
credentials.set_instance_url("https://na1.salesforce.com");
let mut client = Client::new(credentials).await?;

SFDX AUTH URL

let mut client = Client::new(AuthUrl::new("...SFDX_AUTH_URL...")).await?;

REST API

All REST API methods are accessed through RestApi:

Example:

let mut api = RestApi::new(client);

Query Records

let res: QueryResponse<Account> = api.query("SELECT Id, Name FROM Account").await?;

Examples: Query, Query All, Query More

Find By Id

Finds a single record by its Salesforce ID. Example:

let account = api.find_by_id::<Account>("Account", "{sf_id}").await?;

CRUD Record operations

let account = Account { name: "Test Account"};

let res = api.create_sobject("Account", account).await?;
let res = api.create("Account", vec![account]).await?;

Examples:

Update Record

api.update("Account", "{sobject_id}", params).await?;

Upsert Record

let res = api.upsert("Account", "{external_key_name}", "{external_key}", params).await?;
println!("{:?}", res.status()); // 200 = updated, 201 = created

Delete Record

api.destroy("Account", "{sobject_id}").await?;

Describe Global

use rustsf::rest_api::responses::DescribeGlobalResponse;

let res: DescribeGlobalResponse = api.describe_global().await?;

Describe SObject

use rustforce::DescribeResponse;

let res: DescribeResponse = api.describe("Account").await?;

Versions

use rustforce::VersionResponse;

let versions: Vec<VersionResponse> = api.versions().await?;

Search (SOSL)

use rustforce::SearchResponse;

let res: SearchResponse = api.search_sosl("FIND {Rust}").await?;

Bulk API v1

use rustforce::BulkApi;

let mut bulk = BulkApi::new(client);
let res = bulk.create_job(params).await?;

Bulk API v2

use rustforce::BulkApiV2;

let mut bulk = BulkApiV2::new(client);
let res = bulk.create_job(params).await?;