Rust SDK

use rdcpass::{Client, Environment};

// Staging environment: https://gateway.staging.rdcpass.cd
pub fn client() -> Result<Client, rdcpass::Error> {
    Client::builder()
        .environment(Environment::Sandbox)
        .key_id("key_test_3c7e1a9f42")
        .key_secret(std::env::var("RDCPASS_KEY_SECRET").unwrap_or_default())
        .encryption_key(std::env::var("RDCPASS_ENCRYPTION_KEY").unwrap_or_default())
        .build()
}

use rdcpass::{Client, Identity};

// from_env() reads RDCPASS_KEY_ID, RDCPASS_KEY_SECRET,
// RDCPASS_ENCRYPTION_KEY and RDCPASS_ENVIRONMENT.
// Production (https://api.rdcpass.cd) also requires your mTLS client certificate.
pub fn client() -> Result<Client, Box<dyn std::error::Error>> {
    let identity = Identity::from_pem_files("/etc/rdcpass/client.crt", "/etc/rdcpass/client.key")?;
    Ok(Client::builder().from_env().identity(identity).build()?)
}

use rdcpass::kyc::KycValidationParams;
use rdcpass::{Client, Identifier, Match};

#[tokio::main]
async fn main() -> Result<(), rdcpass::Error> {
    let client = Client::from_env()?;

    let params = KycValidationParams::builder()
        .reference("cust-0001")
        .identifier(Identifier::rdcpass_id("COD-2103-0214-4937"))
        .match_claims(Match::new().full_name("Kabeya Mwamba Tshisekedi").date_of_birth("1988-04-12"))
        .purpose("customer_onboarding")
        .scopes(["kyc.documents.primary", "kyc.phone_numbers"])
        .build();

    let validation = client.kyc().validations().create(&params).await?;

    println!("{:?}", validation.result); // Verified
    println!("{}", validation.kyc.basic.full_name); // Kabeya Mwamba Tshisekedi
    println!("{:?}", validation.scopes_withheld); // []
    Ok(())
}

{
  "id": "kyc_8d2f6a1c93",
  "object": "kyc_validation",
  "livemode": true,
  "reference": "cust-0001",
  "status": "completed",
  "result": "verified",
  "certified_account": true,
  "identifier": {
    "type": "rdcpass_id",
    "value": "COD-2103-0214-4937"
  },
  "match": {
    "full_name": "match",
    "date_of_birth": "match",
    "age": "not_provided",
    "score": 0.98
  },
  "account": {
    "rdcpass_id": "COD-2103-0214-4937",
    "status": "active",
    "certified": true,
    "created_at": "2025-03-14T09:22:41Z",
    "level_of_assurance": "LOA3"
  },
  "kyc": {
    "basic": {
      "full_name": "Kabeya Mwamba Tshisekedi",
      "first_name": "Kabeya",
      "last_name": "Tshisekedi",
      "date_of_birth": "1988-04-12",
      "age": 38,
      "gender": "male",
      "nationality": "COD"
    },
    "documents": {
      "primary": {
        "type": "passport",
        "number": "OB1234567",
        "issued_at": "2022-06-01",
        "expires_at": "2027-05-31",
        "issuing_authority": "Direction Générale de Migration",
        "status": "valid",
        "image": {
          "content_type": "image/jpeg",
          "url": "https://files.rdcpass.cd/d/9f2c41e8b7a3?sig=Qm9fX2t5Y19zaWc&exp=1790418002",
          "expires_at": "2026-09-26T10:20:02Z"
        }
      }
    },
    "phone_numbers": [
      {
        "number": "+243812345678",
        "operator": "Vodacom",
        "is_primary": true,
        "verified": true
      },
      {
        "number": "+243991234567",
        "operator": "Airtel",
        "is_primary": false,
        "verified": true
      }
    ]
  },
  "scopes_applied": [
    "kyc.basic",
    "kyc.documents.primary",
    "kyc.phone_numbers"
  ],
  "scopes_withheld": [],
  "purpose": "customer_onboarding",
  "created_at": "2026-09-26T10:15:02Z"
}

use rdcpass::login::{AuthorizationUrlParams, ExchangeCodeParams};

// 1. Build the authorize URL. The SDK generates state and the PKCE
//    code_verifier / code_challenge (S256) for you.
let auth = client.login().authorization_url(
    &AuthorizationUrlParams::builder()
        .client_id("app_8f2a1c0e9b")
        .redirect_uri("https://yourapp.example.com/callback")
        .scopes(["openid", "profile", "rdcpass:kyc.phone_numbers"])
        .build(),
)?;
// Store auth.state and auth.code_verifier in the user's session,
// then redirect to auth.url.

// 2. On your callback, check state and exchange the code.
if returned_state != session.state {
    return Err("state mismatch".into());
}
let tokens = client
    .login()
    .exchange_code(
        &ExchangeCodeParams::builder()
            .client_id("app_8f2a1c0e9b")
            .code(code)
            .code_verifier(&session.code_verifier)
            .redirect_uri("https://yourapp.example.com/callback")
            .build(),
    )
    .await?;
let user = client.login().user_info(&tokens.access_token).await?;

use std::time::Duration;

use futures::StreamExt;
use rdcpass::kyc::{KycValidationBatchParams, KycValidationParams};
use rdcpass::{Identifier, RequestOptions, WaitOptions};

// Submit up to 10,000 items asynchronously (Prefer: respond-async).
let params = KycValidationBatchParams::builder()
    .purpose("customer_onboarding")
    .item(KycValidationParams::builder().reference("cust-0001").identifier(Identifier::rdcpass_id("COD-2103-0214-4937")).build())
    .item(KycValidationParams::builder().reference("cust-0002").identifier(Identifier::ceni("1234567890123")).build())
    .build();
let batch = client
    .kyc()
    .validations()
    .batches()
    .create_with(&params, RequestOptions::new().respond_async())
    .await?;

// Poll GET /v1/batches/{id} until the batch reaches a final status.
let done = client
    .batches()
    .wait(&batch.id, WaitOptions::new().poll_interval(Duration::from_secs(5)).timeout(Duration::from_secs(1800)))
    .await?;
println!("{:?} {} {}", done.status, done.succeeded_items, done.failed_items);

// Stream every result; the SDK follows next_cursor page by page.
let mut results = client.batches().results(&batch.id).limit(500).stream();
while let Some(item) = results.next().await {
    let item = item?;
    println!("{} {:?}", item.reference, item.status);
}

use axum::{body::Bytes, extract::State, http::{HeaderMap, StatusCode}};
use rdcpass::webhooks::EventData;

// Use the raw body: the signature covers "{timestamp}.{raw_body}".
async fn rdcpass_webhook(State(client): State<rdcpass::Client>, headers: HeaderMap, body: Bytes) -> StatusCode {
    let event = match client.webhooks().construct_event(&body, &headers) {
        Ok(event) => event,
        Err(_) => return StatusCode::BAD_REQUEST,
    };

    match event.data {
        EventData::Job(job) if event.kind == "kyc_validation.completed" => println!("{} {:?}", job.id, job.status),
        EventData::Batch(batch) => println!("{} {}", batch.id, batch.failed_items),
        _ => {}
    }
    StatusCode::OK
}

let params = KycValidationParams::builder()
    .identifier(Identifier::rdcpass_id("COD-2103-0214-4937"))
    .purpose("customer_onboarding")
    .scopes(["kyc.biometrics.iris"])
    .build();

match client.kyc().validations().create(&params).await {
    Ok(validation) => println!("{:?}", validation.result),
    Err(rdcpass::Error::Api(e)) => {
        eprintln!("{} {} {} {:?}", e.status, e.code, e.message, e.request_id);
        if e.code == "scope_not_granted" {
            // 403: request the scope for your application in the console
        }
    }
    Err(other) => return Err(other.into()),
}

let client = Client::builder().from_env().max_retries(5).build()?; // default 3; 0 disables

// Every POST gets an Idempotency-Key automatically. Pass your own to make
// retries safe across process restarts:
let params = FraudReportParams::builder()
    .kind("identity_usurpation")
    .subject(FraudSubject::identifier(Identifier::rdcpass_id("COD-2103-0214-4937")))
    .description("Account opened with a stolen passport.")
    .build();
client
    .fraud()
    .reports()
    .create_with(
        &params,
        RequestOptions::new().idempotency_key("fraud-case-INC-2026-88213").max_retries(1),
    )
    .await?;

use std::time::Duration;

// The SDK emits `tracing` spans and events under the "rdcpass" target.
tracing_subscriber::fmt().with_env_filter("rdcpass=debug").init();

let client = Client::builder()
    .from_env()
    .timeout(Duration::from_secs(20)) // per attempt (default 30s)
    .build()?;

// Override per request.
let params = AmlScreeningParams::builder()
    .subject(AmlSubject::identifier(Identifier::rdcpass_id("COD-1907-5521-0386")))
    .purpose("regulatory_compliance")
    .build();
client
    .aml()
    .screenings()
    .create_with(&params, RequestOptions::new().timeout(Duration::from_secs(60)))
    .await?;