Rust

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

Nom	URL de base
`live_mode`	`https://live.dodopayments.com`
`test_mode`	`https://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: "pdt_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()
    .customer_id("cus_123")
    .await?;

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

Gérer les abonnements

Créez et gérez des abonnements récurrents :

POST /subscriptions (the SDK’s subscriptions.create method) est obsolète. Il fonctionne toujours pour les intégrations existantes, mais les nouvelles intégrations doivent créer des abonnements via une Checkout Session.

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 country à deux lettres. customer est une énumération CustomerRequest — transmettez AttachExisting pour un client existant ou New pour un nouveau client. Les champs de montant tels que product_price sont exprimés dans la plus petite unité monétaire (par exemple, 2500 = 25,00 $ USD).

Facturation à l’utilisation

Ingérer des événements d’utilisation

Suivez les événements personnalisés :

let response = client
    .usage_events()
    .ingest()
    .body(dodopayments::models::UsageEventsIngestParams {
        events: Some(vec![dodopayments::models::EventInput {
            customer_id: "cus_abc123".to_string(),
            event_id: "api_call_12345".to_string(),
            event_name: "api_request".to_string(),
            metadata: None,
            timestamp: None,
        }]),
        ..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 endpoints de liste renvoient une page typée dont le champ items contient la page actuelle de résultats. Parcourez tous les éléments de 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:?}");
}

Vous pouvez aussi avancer d’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 renvoie un dodopayments::Result<T>. Les échecs sont représentés par l’énumération dodopayments::Error. Faites une correspondance sur cette énumération pour gérer 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}"),
}

Endpoints non documentés

Pour appeler un endpoint qui n’est pas encore exposé en tant que méthode typée, utilisez le builder 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

Afficher le code source et contribuer

Crates.io

Afficher le crate publié et les versions

API Reference

Documentation complète de l’API

Discord Community

Obtenir de l’aide et échanger avec les développeurs

Assistance

Besoin d’aide avec le SDK Rust ?

Discord : Rejoignez notre serveur communautaire pour bénéficier d’une assistance en temps réel
E-mail : Contactez-nous à l’adresse support@dodopayments.com
GitHub : Ouvrez une issue sur le dépôt

Contribuer

Les contributions sont les bienvenues ! Consultez les instructions de contribution pour commencer.

Getting Started

Features

Integrate

Merchant of Record

Miscellaneous

Installation

Démarrage rapide

Fonctionnalités principales

Async First

Strong Typing

Auto-Pagination

Configurable

Configuration

Variables d’environnement

Environnements

Délais

Opérations courantes

Créer une session de paiement

Gérer les clients

Gérer les abonnements

Facturation à l’utilisation

Ingérer des événements d’utilisation

Lister les événements d’utilisation

Gestion des erreurs

Endpoints non documentés

Ressources

GitHub Repository

Crates.io

API Reference

Discord Community

Assistance

Contribuer

​Installation

​Démarrage rapide

​Fonctionnalités principales

Async First

Strong Typing

Auto-Pagination

Configurable

​Configuration

​Variables d’environnement

​Environnements

​Délais

​Opérations courantes

​Créer une session de paiement

​Gérer les clients

​Gérer les abonnements

​Facturation à l’utilisation

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

​Lister les événements d’utilisation

​Pagination

​Gestion des erreurs

​Endpoints non documentés

​Ressources

GitHub Repository

Crates.io

API Reference

Discord Community

​Assistance

​Contribuer

Installation

Démarrage rapide

Fonctionnalités principales

Configuration

Variables d’environnement

Environnements

Délais

Opérations courantes

Créer une session de paiement

Gérer les clients

Gérer les abonnements

Facturation à l’utilisation

Ingérer des événements d’utilisation

Lister les événements d’utilisation

Pagination

Gestion des erreurs

Endpoints non documentés

Ressources

Assistance

Contribuer