Rust - Dodo Payments Documentation

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:

cargo add dodopayments

Oder fügen Sie es manuell zu Ihrer Cargo.toml hinzu:

[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:

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

Async First

Basierend auf Tokio und reqwest mit async/await Unterstützung

Strong Typing

Stark typisierte Anfragen und Antworten für Sicherheit zur Kompilierungszeit

Auto-Pagination

Streamen Sie jedes Element über Seiten hinweg oder vorwärts eine Seite nach der anderen

Configurable

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:

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:

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:

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:

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:

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:

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:

// 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:

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:

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

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:

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:

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<T> zurück. Fehler werden durch das dodopayments::Error-Enum dargestellt. Verwenden Sie Match, um API-Fehler unterschiedlich von Transportfehlern zu behandeln:

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:

let response = client
    .request(reqwest::Method::GET, "/some/path")
    .send()
    .await?;

Ressourcen

GitHub Repository

Quellcode anzeigen und beitragen

Crates.io

Veröffentlichtes Crate und Versionen anzeigen

API Reference

Vollständige API-Dokumentation

Discord Community

Hilfe bekommen und mit Entwicklern verbinden

Unterstützung

Brauchen Sie Hilfe mit dem Rust SDK?

Discord: Treten Sie unserem Community-Server für Echtzeitunterstützung bei
E-Mail: Kontaktieren Sie uns unter support@dodopayments.com
GitHub: Öffnen Sie ein Ticket im Repository

Beiträge

Beiträge sind willkommen! Überprüfen Sie die Richtlinien für Beiträge, um loszulegen.

​Installation

​Schnellstart

​Hauptmerkmale

Async First

Strong Typing

Auto-Pagination

Configurable

​Konfiguration

​Umgebungseinstellungen

​Umgebungen

​Timeouts

​Allgemeine Operationen

​Erstellen einer Checkout-Sitzung

​Kunden verwalten

​Abonnements verwalten

​Nutzungsbasierte Abrechnung

​Verbrauchsevents aufzeichnen

​Verbrauchsevents auflisten

​Paginierung

​Fehlerbehandlung

​Undokumentierte Endpunkte

​Ressourcen

GitHub Repository

Crates.io

API Reference

Discord Community

​Unterstützung

​Beiträge

Installation

Schnellstart

Hauptmerkmale

Konfiguration

Umgebungseinstellungen

Umgebungen

Timeouts

Allgemeine Operationen

Erstellen einer Checkout-Sitzung

Kunden verwalten

Abonnements verwalten

Nutzungsbasierte Abrechnung

Verbrauchsevents aufzeichnen

Verbrauchsevents auflisten

Paginierung

Fehlerbehandlung

Undokumentierte Endpunkte

Ressourcen

Unterstützung

Beiträge