Your app shouldn't see the data it's processing.

Our SDKs let you split sensitive data client-side, compute across an MPC network your app never touches, and reconstruct only the final answer locally. No raw values in your logs and your database. Structurally impossible to leak, include in a breach notification, or produce in a regulatory audit.

Get Started with Rust SDK

See how it works

use stoffel_rust_sdk::prelude::*;

async fn submit_computation() -> Result<i64> {
    // Connect to MPC network
    let client = StoffelClient::builder()
        .with_servers(&["mpc1.example.com:9000", "mpc2.example.com:9000"])
        .client_id(12345)
        .connect()
        .await?;

    // Submit inputs and get result
    let result = client.run(&[42, 100]).await?;

    Ok(result)
}

Why use SDKs instead of just encrypting things?

Because encryption still means someone has the keys — and whoever holds the keys holds the liability. With MPC, your app splits data into shares before it leaves the client, computes across a network that can't reconstruct inputs, and rebuilds only the final answer locally. No keys to compromise and no plaintext to seize.

Split before it leaves

Turn inputs into shares on the client. The original value never hits your network — and never appears in a network log, a packet capture, or a transit record.

Compute without seeing

The MPC network processes shares it can't reverse-engineer, even if nodes collude. No party in the computation — including Stoffel — can access the underlying data.

Rebuild only the answer

Get result shares back. Combine them locally. Intermediate steps? Gone. Nothing in the computation history that can be reconstructed, audited against you, or used to infer the original inputs.

Available SDKs

Rust SDK

Production-ready

Build MPC applications with a mature, fully-functional SDK. Includes MPCaaS architecture separating app developers from infrastructure operators, QUIC networking, and comprehensive error handling.

Python SDK

In development

Clean high-level interface currently under active development. Not production-ready—use Rust SDK for production work today.

Solidity SDK

Production-ready

Integrate MPC into smart contracts for on-chain privacy. Coordinate computations, manage access control, and handle inputs from blockchain applications.

How it actually works

share(input)

Create client-side shares. This happens in your app before anything leaves. The raw value stays local.

Send

start_session()

send(shares)

Computation runs across MPC parties. None of them can reconstruct your input, even working together.

Rebuild

reconstruct(result_shares)

Combine result pieces locally. Only the final answer gets revealed. The intermediate steps are mathematically destroyed — they never existed as retrievable data. What never existed can't be breached, subpoenaed, or reconstructed — by anyone.