Rust SDK

cargo add signalstack

# Enable the tokio runtime (default)
cargo add signalstack --features tokio

# Or use async-std
cargo add signalstack --features async-std

use signalstack::{SignalStack, SignalStackConfig};

// Using environment variable
let client = SignalStack::new()?;

// Explicit configuration
let client = SignalStack::with_config(SignalStackConfig {
    api_key: Some("ssk_live_YOUR_API_KEY".into()),
    timeout: std::time::Duration::from_secs(30),
    max_retries: 3,
    base_url: "https://signal-stack-ten.vercel.app/v1".into(),
});

// Async initialization with builder
let client = SignalStack::builder()
    .api_key("ssk_live_YOUR_API_KEY")
    .timeout(std::time::Duration::from_secs(30))
    .build()?;

use signalstack::input::VerifyBusinessInput;

let result = client
    .verify_business(VerifyBusinessInput {
        company_name: "Acme Corp".into(),
        jurisdiction: Some("us_de".into()),
        registration_number: None,
        officers: Some(true),
        filings: Some(true),
    })
    .await?;

println!("Status: {}", result.status);        // "active"
println!("Trust score: {}", result.trust_score); // 0.94
for officer in result.officers.unwrap_or_default() {
    println!("  {} — {}", officer.name, officer.role);
}

use signalstack::input::{VerifyDocumentInput, DocumentSource};

let result = client
    .verify_document(VerifyDocumentInput {
        source: DocumentSource::Url,
        content: "https://example.com/report.pdf".into(),
        mime_type: None,
        check_deepfakes: Some(true),
        check_watermarks: None,
    })
    .await?;

println!("AI probability: {}", result.ai_generated_probability); // 0.87
println!("Flags: {:?}", result.manipulation_flags);
// [ManipulationFlag::AiGeneratedText, ManipulationFlag::MetadataStripped]

use signalstack::input::VerifyMediaInput;
use signalstack::response::Authenticity;

let result = client
    .verify_media(VerifyMediaInput {
        url: Some("https://example.com/photo.jpg".into()),
        file: None,
        check_deepfakes: Some(true),
        check_provenance: Some(true),
        check_watermarks: Some(true),
    })
    .await?;

println!("Authenticity: {:?}", result.authenticity); // Authenticity::Manipulated
println!("Deepfake score: {}", result.deepfake_score); // 0.94
println!("Provenance: {:?}", result.provenance_source);

use signalstack::input::VerifyClaimInput;
use signalstack::response::Verdict;

let result = client
    .verify_claim(VerifyClaimInput {
        claim: "Water boils at 100°C at sea level".into(),
        sources: Some(vec![
            "web".into(),
            "wikipedia".into(),
            "semantic_scholar".into(),
        ]),
        language: None,
        max_evidence: None,
    })
    .await?;

println!("Verdict: {:?}", result.verdict);       // Verdict::True
println!("Trust score: {}", result.trust_score); // 0.97
for evidence in result.evidence {
    println!("  [{}] {}", evidence.source, evidence.snippet);
}

use signalstack::error::SignalStackError;

match client.verify_claim(input).await {
    Ok(result) => println!("Success: {}", result.trust_score),
    Err(SignalStackError::RateLimit(e)) => {
        println!("Rate limited. Retry after {}s", e.retry_after);
    }
    Err(SignalStackError::Authentication(e)) => {
        eprintln!("Check API key: {}", e.message);
    }
    Err(SignalStackError::Validation(e)) => {
        eprintln!("Validation error: {:?}", e.details);
    }
    Err(SignalStackError::Server(e)) => {
        eprintln!("Server error: {}", e.status_code);
    }
    Err(e) => eprintln!("Unexpected error: {}", e),
}