> ## 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
> Integrieren Sie Dodo Payments in Ihre Rust-Anwendungen mit einem asynchronen, stark typisierten SDK, das auf Tokio und reqwest basiert.
Das Rust SDK bietet bequemen, asynchronen Zugriff auf die REST-API von Dodo Payments aus in Rust geschriebenen Anwendungen. Es bietet stark typisierte Anfragen und Antworten, eingebaute Paginierungshilfen sowie konfigurierbare Timeouts und Umgebungen.
## Installation
Fügen Sie das SDK mit Cargo zu Ihrem Projekt hinzu:
```bash theme={null}
cargo add dodopayments
```
Oder fügen Sie es manuell zu Ihrer `Cargo.toml` hinzu:
```toml theme={null}
[dependencies]
dodopayments = "1.106.0"
tokio = { version = "1", features = ["full"] }
serde_json = "1"
futures = "0.3" # required for streaming paginated results
```
Das SDK erfordert Rust 1.75 oder höher und nutzt moderne asynchrone Funktionen für optimale Leistung.
## Schnellstart
Der Client liest standardmäßig Ihren API-Schlüssel aus der Umgebungseinstellung `DODO_PAYMENTS_API_KEY`. Initialisieren Sie den Client und erstellen Sie Ihre erste Checkout-Sitzung:
```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(())
}
```
Speichern Sie Ihre API-Schlüssel immer sicher mit Umgebungseinstellungen. Nie hartkodiert in Ihrem Quellcode.
## Hauptmerkmale
Basierend auf Tokio und reqwest mit `async`/`await` Unterstützung
Stark typisierte Anfragen und Antworten für Sicherheit zur Kompilierungszeit
Streamen Sie jedes Element über Seiten hinweg oder vorwärts eine Seite nach der anderen
Konfigurieren Sie Umgebungen, Timeouts und Basis-URLs pro Client
## Konfiguration
### Umgebungseinstellungen
Standardmäßig liest `Client::from_env()` Ihren API-Schlüssel aus der Umgebungseinstellung `DODO_PAYMENTS_API_KEY` und verwendet die Standard-Basis-URL, es sei denn, Sie setzen `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
```
Sie können den Client auch explizit konfigurieren. `Client::new` gibt ein `Result` zurück, also verwenden Sie `?` in einer Funktion, die `dodopayments::Result` zurückgibt:
```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(())
}
```
### Umgebungen
| Name | Basis-URL |
| ----------- | ------------------------------- |
| `live_mode` | `https://live.dodopayments.com` |
| `test_mode` | `https://test.dodopayments.com` |
Die Standardbasis-URL ist `https://live.dodopayments.com`. Wählen Sie eine andere Umgebung mit der `Environment`-Enum anstelle von hartcodierten URLs:
```rust theme={null}
use dodopayments::{Client, ClientConfig, Environment};
let client = Client::new(
ClientConfig::from_environment(Environment::TestMode).with_api_key("My API Key"),
)?;
```
Um den API-Schlüssel weiterhin aus `DODO_PAYMENTS_API_KEY` über `from_env()` zu lesen und gleichzeitig eine nicht standardmäßige Umgebung anzusprechen, überschreiben Sie ihn in der Konfiguration:
```rust theme={null}
use dodopayments::{Client, ClientConfig, Environment};
let client = Client::new(ClientConfig::from_env()?.with_environment(Environment::TestMode))?;
```
### Timeouts
Das standardmäßige Anforderungszeitlimit beträgt 30 Sekunden. Überschreiben Sie es pro 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)),
)?;
```
## Allgemeine Operationen
### Erstellen einer Checkout-Sitzung
Erstellen Sie eine Checkout-Sitzung:
```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:?}");
```
### Kunden verwalten
Erstellen und Abrufen von Kundendaten:
```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:?}");
```
### Abonnements verwalten
Erstellen und verwalten Sie wiederkehrende Abonnements:
```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` erfordert mindestens den zweibuchstabigen ISO `country`-Code. `customer` ist ein `CustomerRequest`-Enum — übergeben Sie `AttachExisting` für einen bestehenden Kunden oder `New` für einen neuen. Betragsfelder wie `product_price` sind in der kleinsten Währungseinheit (z.B., `2500` = \$25,00 USD).
## Nutzungsbasierte Abrechnung
### Verbrauchsevents aufzeichnen
Benutzerdefinierte Events verfolgen:
```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:?}");
```
### Verbrauchsevents auflisten
```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:?}");
}
```
## Paginierung
Listenendpunkte geben eine typisierte Seite zurück, deren `items`-Feld die aktuelle Seite der Ergebnisse enthält. Streamen Sie jedes Element über alle Seiten mit `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:?}");
}
```
Oder gehen Sie mit `get_next_page` eine Seite nach der anderen weiter:
```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,
}
}
```
## Fehlerbehandlung
Jede Methode gibt ein `dodopayments::Result` zurück. Fehler werden durch das `dodopayments::Error`-Enum dargestellt. Verwenden Sie Match, um API-Fehler unterschiedlich von Transportfehlern zu behandeln:
```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}"),
}
```
## Undokumentierte Endpunkte
Um einen Endpunkt aufzurufen, der noch nicht als typisierte Methode vorhanden ist, verwenden Sie den Low-Level `request`-Builder, der Authentifizierung und die Basis-URL anwendet:
```rust theme={null}
let response = client
.request(reqwest::Method::GET, "/some/path")
.send()
.await?;
```
## Ressourcen
Quellcode anzeigen und beitragen
Veröffentlichtes Crate und Versionen anzeigen
Vollständige API-Dokumentation
Hilfe bekommen und mit Entwicklern verbinden
## Unterstützung
Brauchen Sie Hilfe mit dem Rust SDK?
* **Discord**: Treten Sie unserem [Community-Server](https://discord.gg/bYqAp4ayYh) für Echtzeitunterstützung bei
* **E-Mail**: Kontaktieren Sie uns unter [support@dodopayments.com](mailto:support@dodopayments.com)
* **GitHub**: Öffnen Sie ein Ticket im [Repository](https://github.com/dodopayments/dodopayments-rust/issues)
## Beiträge
Beiträge sind willkommen! Überprüfen Sie die [Richtlinien für Beiträge](https://github.com/dodopayments/dodopayments-rust/blob/main/CONTRIBUTING.md), um loszulegen.