> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dodopayments.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Rust
> Intégrez Dodo Payments dans vos applications Rust avec un SDK orienté async, fortement typé, basé sur Tokio et reqwest
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 :
```bash theme={null}
cargo add dodopayments
```
Ou ajoutez-le manuellement à votre `Cargo.toml` :
```toml theme={null}
[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 :
```rust theme={null}
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
Basé sur Tokio et reqwest avec support `async`/`await` tout au long
Requêtes et réponses fortement typées pour une sécurité à la compilation
Diffusez chaque élément à travers les pages ou avancez une page à la fois
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` :
```bash theme={null}
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` :
```rust theme={null}
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 :
```rust theme={null}
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 :
```rust theme={null}
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 :
```rust theme={null}
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 :
```rust theme={null}
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 :
```rust theme={null}
// 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 :
```rust theme={null}
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 :
```rust theme={null}
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
```rust theme={null}
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` :
```rust theme={null}
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` :
```rust theme={null}
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`. 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 :
```rust theme={null}
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 :
```rust theme={null}
let response = client
.request(reqwest::Method::GET, "/some/path")
.send()
.await?;
```
## Ressources
Voir le code source et contribuer
Voir le paquet publié et les versions
Documentation complète de l'API
Obtenez de l'aide et connectez-vous avec les développeurs
## Support
Besoin d'aide avec le SDK Rust ?
* **Discord** : Rejoignez notre [serveur communautaire](https://discord.gg/bYqAp4ayYh) pour une assistance en temps réel
* **Email** : Contactez-nous à [support@dodopayments.com](mailto:support@dodopayments.com)
* **GitHub** : Ouvrez un problème sur le [répertoire](https://github.com/dodopayments/dodopayments-rust/issues)
## Contribuer
Nous accueillons les contributions ! Consultez les [directives de contribution](https://github.com/dodopayments/dodopayments-rust/blob/main/CONTRIBUTING.md) pour commencer.