> ## 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

> Integrera Dodo Payments i dina Rust-applikationer med ett async-first, starkt typat SDK byggt på Tokio och reqwest

Rust SDK ger bekväm, async-first tillgång till Dodo Payments REST API från applikationer skrivna i Rust. Det erbjuder starkt typade requests och svar, inbyggda pagineringshjälpare och konfigurerbara tidsgränser och miljöer.

## Installation

Lägg till SDK till ditt projekt med Cargo:

```bash theme={null}
cargo add dodopayments
```

Eller lägg till det manuellt i din `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
```

<Info>
  SDK kräver Rust 1.75 eller senare och använder moderna async-funktioner för optimal prestanda.
</Info>

## Snabbstart

Klienten läser din API-nyckel från miljövariabeln `DODO_PAYMENTS_API_KEY` som standard. Initiera klienten och skapa din första checkout-session:

```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(())
}
```

<Warning>
  Förvara alltid dina API-nycklar säkert med miljövariabler. Hårdkoda dem aldrig i din källkod.
</Warning>

## Kärnfunktioner

<CardGroup cols={2}>
  <Card title="Async First" icon="bolt">
    Byggd på Tokio och reqwest med `async`/`await`-stöd genomgående
  </Card>

  <Card title="Strong Typing" icon="shield-check">
    Starkt typade requests och svar för säkerhet vid kompilering
  </Card>

  <Card title="Auto-Pagination" icon="layer-group">
    Strömma varje objekt över sidor eller gå vidare en sida i taget
  </Card>

  <Card title="Configurable" icon="sliders">
    Konfigurera miljöer, tidsgränser och bas-URL:er per klient
  </Card>
</CardGroup>

## Konfiguration

### Miljövariabler

Som standard läser `Client::from_env()` din API-nyckel från miljövariabeln `DODO_PAYMENTS_API_KEY` och använder standard bas-URL om du inte ställer in `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
```

Du kan också konfigurera klienten explicit. `Client::new` returnerar en `Result`, så avkoda den med `?` inuti en funktion som returnerar `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(())
}
```

### Miljöer

| Namn        | Bas-URL                         |
| ----------- | ------------------------------- |
| `live_mode` | `https://live.dodopayments.com` |
| `test_mode` | `https://test.dodopayments.com` |

Standard bas-URL är `https://live.dodopayments.com`. Välj en annan miljö med enum `Environment` istället för att hårdkoda URL:er:

```rust theme={null}
use dodopayments::{Client, ClientConfig, Environment};

let client = Client::new(
    ClientConfig::from_environment(Environment::TestMode).with_api_key("My API Key"),
)?;
```

För att fortsätta läsa API-nyckeln från `DODO_PAYMENTS_API_KEY` via `from_env()` när du riktar in dig på en icke-standardmiljö, åsidosätt den i konfigurationen:

```rust theme={null}
use dodopayments::{Client, ClientConfig, Environment};

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

### Tidsgränser

Standard tidsgräns för förfrågningar är 30 sekunder. Åsidosätt det per klient:

```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)),
)?;
```

## Vanliga operationer

### Skapa en Checkout-session

Generera en checkout-session:

```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:?}");
```

### Hantera Kunder

Skapa och hämta kundinformation:

```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:?}");
```

### Hantera Prenumerationer

Skapa och hantera återkommande prenumerationer:

```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:?}");
```

<Info>
  `billing` kräver minst den tvåbokstaviga ISO-koden `country`. `customer` är en `CustomerRequest` enum — pass `AttachExisting` för en befintlig kund eller `New` för en ny. Beloppsfält som `product_price` är i den lägsta valutadenominationen (t.ex., `2500` = \$25.00 USD).
</Info>

## Användningsbaserad Fakturering

### Samla in Användningshändelser

Spåra anpassade händelser:

```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:?}");
```

### Lista Användningshändelser

```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:?}");
}
```

## Paginering

Listendpunkter returnerar en typad sida vars `items`-fält håller den aktuella sidan av resultat. Strömma varje objekt över alla sidor med `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:?}");
}
```

Eller gå vidare en sida i taget med `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,
    }
}
```

## Felhantering

Varje metod returnerar en `dodopayments::Result<T>`. Fel representeras av enum `dodopayments::Error`. Matcha på den för att hantera API-fel åtskilt från transportfel:

```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}"),
}
```

## Odokumenterade Endpunkter

För att anropa en endpunkt som ännu inte exponeras som en typad metod, använd den låg-nivå `request`-byggaren, som tillämpar autentisering och bas-URL:

```rust theme={null}
let response = client
    .request(reqwest::Method::GET, "/some/path")
    .send()
    .await?;
```

## Resurser

<CardGroup cols={2}>
  <Card title="GitHub Repository" icon="github" href="https://github.com/dodopayments/dodopayments-rust">
    Visa källkod och bidra
  </Card>

  <Card title="Crates.io" icon="cube" href="https://crates.io/crates/dodopayments">
    Visa det publicerade packet och versionerna
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    Komplett API-dokumentation
  </Card>

  <Card title="Discord Community" icon="discord" href="https://discord.gg/bYqAp4ayYh">
    Få hjälp och anslut med utvecklare
  </Card>
</CardGroup>

## Support

Behöver du hjälp med Rust SDK?

* **Discord**: Gå med i vår [community server](https://discord.gg/bYqAp4ayYh) för support i realtid
* **Email**: Kontakta oss på [support@dodopayments.com](mailto:support@dodopayments.com)
* **GitHub**: Öppna ett ärende på [repo](https://github.com/dodopayments/dodopayments-rust/issues)

## Bidra

Vi välkomnar bidrag! Kolla in [bidragsriktlinjerna](https://github.com/dodopayments/dodopayments-rust/blob/main/CONTRIBUTING.md) för att komma igång.