Passer au contenu principal
Le SDK Rust offre un accès pratique et orienté async à l’API REST de Dodo Payments à partir d’applications écrites en Rust. Il propose des requêtes et réponses fortement typées, des assistants de pagination intégrés, et des délais et environnements configurables.

​
Installation

Ajoutez le SDK à votre projet avec Cargo : 
cargo add dodopayments
Ou ajoutez-le manuellement à votre Cargo.toml : 
[dependencies]
dodopayments = "1.106.0"
tokio = { version = "1", features = ["full"] }
serde_json = "1"
futures = "0.3" # required for streaming paginated results
Le SDK nécessite Rust 1.75 ou plus récent, exploitant les fonctionnalités modernes async pour des performances optimales.

​
Démarrage rapide

Le client lit par défaut votre clé API à partir de la variable d’environnement DODO_PAYMENTS_API_KEY. Initialisez le client et créez votre première session de paiement : 
use dodopayments::Client;

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

    let result = client
        .checkout_sessions()
        .create()
        .body(dodopayments::models::CheckoutSessionsCreateParams {
            product_cart: Some(vec![dodopayments::models::ProductItemReq {
                product_id: "product_id".to_string(),
                quantity: 1,
                addons: None,
                amount: None,
                credit_entitlements: None,
            }]),
            ..Default::default()
        })
        .await?;

    println!("{result:?}");
    Ok(())
}
Stockez toujours vos clés API en toute sécurité en utilisant des variables d’environnement. Ne les codez jamais en dur dans votre code source.

​
Fonctionnalités principales

Async First

Basé sur Tokio et reqwest avec support async/await tout au long

Strong Typing

Requêtes et réponses fortement typées pour une sécurité à la compilation

Auto-Pagination

Diffusez chaque élément à travers les pages ou avancez une page à la fois

Configurable

Configurez des environnements, délais et URLs de base par client

​
Configuration

​
Variables d’environnement

Par défaut, Client::from_env() lit votre clé API à partir de la variable d’environnement DODO_PAYMENTS_API_KEY et utilise l’URL de base par défaut sauf si vous la définissez avec DODO_PAYMENTS_BASE_URL : 
export DODO_PAYMENTS_API_KEY="your_api_key"
export DODO_PAYMENTS_BASE_URL="https://test.dodopayments.com" # optional
Vous pouvez aussi configurer le client explicitement. Client::new retourne un Result, alors déverrouillez-le avec ? dans une fonction qui retourne dodopayments::Result : 
use dodopayments::{Client, ClientConfig};

#[tokio::main]
async fn main() -> dodopayments::Result<()> {
    let client = Client::new(
        ClientConfig::new("https://live.dodopayments.com").with_api_key("My API Key"),
    )?;
    println!("{}", client.base_url());
    Ok(())
}

​
Environnements

NomURL de base
live_modehttps://live.dodopayments.com
test_modehttps://test.dodopayments.com
L’URL de base par défaut est https://live.dodopayments.com. Sélectionnez un autre environnement avec l’énumération Environment au lieu de coder les URLs en dur : 
use dodopayments::{Client, ClientConfig, Environment};

let client = Client::new(
    ClientConfig::from_environment(Environment::TestMode).with_api_key("My API Key"),
)?;
Pour continuer à lire la clé API depuis DODO_PAYMENTS_API_KEY via from_env() tout en visant un environnement non par défaut, remplacez-le dans la configuration : 
use dodopayments::{Client, ClientConfig, Environment};

let client = Client::new(ClientConfig::from_env()?.with_environment(Environment::TestMode))?;

​
Délais

Le délai par défaut des requêtes est de 30 secondes. Remplacez-le par client : 
use std::time::Duration;
use dodopayments::{Client, ClientConfig};

let client = Client::new(
    ClientConfig::new("https://live.dodopayments.com")
        .with_api_key("My API Key")
        .with_timeout(Duration::from_secs(60)),
)?;

​
Opérations courantes

​
Créer une session de paiement

Générez une session de paiement : 
let session = client
    .checkout_sessions()
    .create()
    .body(dodopayments::models::CheckoutSessionsCreateParams {
        product_cart: Some(vec![dodopayments::models::ProductItemReq {
            product_id: "prod_123".to_string(),
            quantity: 1,
            addons: None,
            amount: None,
            credit_entitlements: None,
        }]),
        return_url: Some("https://yourdomain.com/return".to_string()),
        ..Default::default()
    })
    .await?;

println!("{session:?}");

​
Gérer les clients

Créez et récupérez les informations des clients : 
// Create a customer
let customer = client
    .customers()
    .create()
    .body(dodopayments::models::CustomerCreateParams {
        email: "customer@example.com".to_string(),
        name: "John Doe".to_string(),
        ..Default::default()
    })
    .await?;

// Retrieve a customer
let customer = client
    .customers()
    .retrieve("cus_123")
    .await?;

println!("{customer:?}");

​
Gérer les abonnements

Créez et gérez des abonnements récurrents : 
let subscription = client
    .subscriptions()
    .create()
    .body(dodopayments::models::SubscriptionCreateParams {
        billing: dodopayments::models::BillingAddress {
            country: "US".to_string(),
            city: "San Francisco".to_string(),
            state: "CA".to_string(),
            street: "1 Market St".to_string(),
            zipcode: "94105".to_string(),
        },
        customer: dodopayments::models::CustomerRequest::AttachExisting(
            dodopayments::models::AttachExistingCustomer {
                customer_id: "cus_123".to_string(),
            },
        ),
        product_id: "pdt_456".to_string(),
        quantity: 1,
        ..Default::default()
    })
    .await?;

println!("{subscription:?}");
billing nécessite au minimum le code ISO à deux lettres country. customer est une énumération CustomerRequest — passez AttachExisting pour un client existant ou New pour un nouveau. Les champs de montant comme product_price sont dans la plus petite dénomination monétaire (par exemple, 2500 = 25,00 $ USD).

​
Facturation basée sur l’utilisation

​
Ingérer des événements d’utilisation

Suivre des événements personnalisés : 
let response = client
    .usage_events()
    .ingest()
    .body(dodopayments::models::UsageEventsIngestParams {
        events: vec![dodopayments::models::EventInput {
            event_id: "api_call_12345".to_string(),
            customer_id: "cus_abc123".to_string(),
            event_name: "api_request".to_string(),
            ..Default::default()
        }],
    })
    .await?;

println!("{response:?}");

​
Lister les événements d’utilisation

let events = client
    .usage_events()
    .list()
    .query(serde_json::json!({
        "customer_id": "cus_abc123",
        "event_name": "api_request",
    }))
    .await?;

for event in &events.items {
    println!("{event:?}");
}

​
Pagination

Les points de terminaison de liste retournent une page typée dont le champ items contient la page de résultats actuelle. Diffusez chaque élément à travers toutes les pages avec into_stream : 
use futures::StreamExt;

let mut items = Box::pin(
    client
        .payments()
        .list()
        .query(serde_json::json!({}))
        .await?
        .into_stream(),
);

while let Some(item) = items.next().await {
    let item = item?;
    println!("{item:?}");
}
Ou avancez une page à la fois avec get_next_page : 
let mut page = client
    .payments()
    .list()
    .query(serde_json::json!({}))
    .await?;

loop {
    for item in &page.items {
        println!("{item:?}");
    }
    match page.get_next_page().await? {
        Some(next) => page = next,
        None => break,
    }
}

​
Gestion des erreurs

Chaque méthode retourne un dodopayments::Result<T>. Les échecs sont représentés par l’énumération dodopayments::Error. Utilisez match pour traiter les erreurs d’API distinctement des erreurs de transport : 
let result = client
    .checkout_sessions()
    .create()
    .body(dodopayments::models::CheckoutSessionsCreateParams {
        product_cart: Some(vec![dodopayments::models::ProductItemReq {
            product_id: "product_id".to_string(),
            quantity: 1,
            addons: None,
            amount: None,
            credit_entitlements: None,
        }]),
        ..Default::default()
    })
    .await;

match result {
    Ok(value) => println!("{value:?}"),
    Err(dodopayments::Error::Api { status, message }) => {
        eprintln!("API returned {status}: {message}");
    }
    Err(err) => eprintln!("request failed: {err}"),
}

​
Points de terminaison non documentés

Pour appeler un point de terminaison non encore exposé en tant que méthode typée, utilisez le générateur de bas niveau request, qui applique l’authentification et l’URL de base : 
let response = client
    .request(reqwest::Method::GET, "/some/path")
    .send()
    .await?;

​
Ressources

GitHub Repository

Voir le code source et contribuer

Crates.io

Voir le paquet publié et les versions

API Reference

Documentation complète de l’API

Discord Community

Obtenez de l’aide et connectez-vous avec les développeurs

​
Support

Besoin d’aide avec le SDK Rust ?

​
Contribuer

Nous accueillons les contributions ! Consultez les directives de contribution pour commencer.
Dernière modification le 26 juin 2026