Introduction

Welcome to the documentation of the DodoPayments Rust SDK.

This library provides a high-performance, type-safe interface to interact with the DodoPayments API. This guide will help you integrate payments into your Rust application.

Keeping developer experience, type safety, and robust error handling in mind, this SDK makes integration simple and reliable.

Contributing

DodoPayments Rust SDK is open source. You can find the source code on GitHub and issues and feature requests can be posted on the GitHub issue tracker. If you’d like to contribute, please raise an issue on the GitHub and considfer opening a pull request.

License

The SDK source and documentation are released under the MIT License

Quick Start

This guide will help you get started with the DodoPayments Rust SDK and make your first API request.

By the end of this guide, you’ll have a basic setup ready and will be able to interact with DodoPayments directly from your Rust application.

Installation

1. Install via CLI

#![allow(unused)]
fn main() {
cargo add dodopayments_rust
}

2. Manual Installation by adding in your Cargo.toml

#![allow(unused)]
fn main() {
dodopayments_rust = "2.0.0"
}

Initialize client

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;
}

Make your first request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.payments().list().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Addons

Create Addon

Create a new addon product that can be attached to subscription products.

Request

use dodopayments_rust::{models::CreateAddonRequest, to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client
        .addons()
        .create()
        .body(CreateAddonRequest {
            name: "Premium Support".to_string(),
            price: 99,
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Body

Responses

200 Status

Create a new addon

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Get Addon Detail

Retrieve detailed information about a specific addon.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let addon_id = "addon_xxxxxxxxxx";

    let resp = client.addons().id(addon_id).retrieve().send().await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

Retrieve a specific addon

500 Status

Something went wrong :(

Get Addons

Retrieve a comprehensive list of all available addons.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.addons().list().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

List all addons

500 Status

Something went wrong :(

Update Addon

Modify the details of an existing addon.

Request

use dodopayments_rust::{models::PatchAddonRequest, to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let addon_id = "addon_xxxxxxxxxx";

    let resp = client
        .addons()
        .id(addon_id)
        .update()
        .body(PatchAddonRequest {
            name: Some("Updated Addon".to_string()),
            price: Some(19),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Body

Responses

200 Status

Patch update an addon

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Update Addon Image

Update images for an existing addon.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let addon_id = "addon_xxxxxxxxxx";

    let resp = client.addons().id(addon_id).update_image().send().await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

Generate presigned upload URL for addon image

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Balance Ledger

Get Balance Ledger Entries

List all customer balances for a specific credit entitlement.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.balance_ledgers_entries().list().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

List of customer balances

404 Status

Credit entitlement not found

500 Status

Something went wrong :(

Brands

Create Brand

Create a new brand.

Request

use dodopayments_rust::{models::CreateBrandRequest, to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client
        .brands()
        .create()
        .body(CreateBrandRequest {
            name: Some("My Brand".to_string()),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Body

Responses

200 Status

Created Brand

Get Brand Detail

Retrieve a specific brand by ID.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let brand_id = "brand_xxxxxxxxxx";

    let resp = client.brands().id(brand_id).retrieve().send().await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

Get a single brand

404 Status

Brand not found

Get Brands

List all brands.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.brands().list().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

List all brands

Update Brand

Update an existing brand's details.

Request

use dodopayments_rust::{models::PatchBrandRequest, to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let brand_id = "brand_xxxxxxxxxx";

    let resp = client
        .brands()
        .id(brand_id)
        .update()
        .body(PatchBrandRequest {
            name: Some("Updated Brand".to_string()),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Body

Responses

200 Status

Updated Brand

403 Status

Primary brand cannot be updated via this API

404 Status

Brand not found

Update Brand Image

Update the images associated with a brand.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let brand_id = "brand_xxxxxxxxxx";

    let resp = client
        .brands()
        .id(brand_id)
        .update_brand_image()
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

Generate presigned upload URL for brand image

Checkout Sessions

Create Checkout

Unified endpoint for creating checkout sessions for all types of billing requirements.

Request

use dodopayments_rust::{
    models::{CreateCheckoutSessionRequest, ProductItemReq},
    to_pretty_json, DodoPaymentsClientBuilder,
};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client
        .checkout_session()
        .create()
        .body(CreateCheckoutSessionRequest {
            product_cart: vec![ProductItemReq {
                product_id: "prod_xxxxxxxxxx".to_string(),
                quantity: 1,
                addons: None,
                amount: None,
            }],
            return_url: Some("https://example.com/success".to_string()),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

Checkout session successfully created

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Preview Checkout Session

Preview a checkout session to calculate pricing, taxes, and totals without creating an actual session.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    println!("Note: preview_checkout requires complex request types.");
    println!("See create_checkout.rs for checkout session creation example.");

    Ok(())
}

Responses

200 Status

Checkout session preview calculated successfully

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Get Checkout Details

Retrieve details of a specific checkout session by its ID.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let checkout_id = "checkout_xxxxxxxxxx";

    let resp = client
        .checkout_session()
        .id(checkout_id)
        .retrieve()
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

Checkout session successfully fetched

404 Status

Not found

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Credit Entitlements

Create Credit Entitlement

Create a new credit entitlement for the authenticated business.

Each entitlement defines how credits behave in terms of expiration, rollover, and overage.

Business Logic

• A unique ID with prefix cde_ is automatically generated for the entitlement
• Created and updated timestamps are automatically set
• Currency is required when price_per_unit is set
• price_per_unit is required when overage_enabled is true
• rollover_timeframe_count and rollover_timeframe_interval must both be set or both be null

Request

use dodopayments_rust::{
    models::CreateCreditEntitlementRequest, to_pretty_json, DodoPaymentsClientBuilder,
};
#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client
        .credit_entitlements()
        .create()
        .body(CreateCreditEntitlementRequest {
            name: "Basic Credits".to_string(),
            description: Some("Monthly credit allocation".to_string()),
            unit: "credits".to_string(),
            price_per_unit: Some("1.00".to_string()),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Body

Responses

201 Status

Credit entitlement created successfully

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Delete Credit Entitlement

Soft-delete a credit entitlement by its ID.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let entitlement_id = "ent_xxxxxxxxxx";

    let resp = client
        .credit_entitlements()
        .id(entitlement_id)
        .delete()
        .send()
        .await?;

    println!("Credit entitlement deleted successfully");

    Ok(())
}

Path Parameters

Responses

200 Status

Credit entitlement deleted successfully

404 Status

Credit entitlement not found

410 Status

Credit entitlement is already deleted

500 Status

Something went wrong :(

Get Credit Entitlement Detail

Retrieve a specific credit entitlement by its ID.

settings for expiration, rollover, and overage policies.

Business Logic

• Only non-deleted credit entitlements can be retrieved through this
• The entitlement must belong to the authenticated business (business_id check)
• Deleted entitlements return a 404 error and must be retrieved via the list with deleted=true

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};


#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let entitlement_id = "ent_xxxxxxxxxx";

    let resp = client
        .credit_entitlements()
        .id(entitlement_id)
        .retrieve()
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

Credit entitlement details

404 Status

Credit entitlement not found

500 Status

Something went wrong :(

Get Credit Entitlements

List all credit entitlements for the authenticated business with pagination support.

entitlements. By default, only non-deleted entitlements are returned.

Business Logic

• Results are ordered by creation date in descending order (newest first)
• Only entitlements belonging to the authenticated business are returned
• The deleted parameter controls visibility of soft-deleted entitlements
• Pagination uses offset-based pagination (offset = page_number * page_size)

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.credit_entitlements().list().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

Credit Entitlements List

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Get Customer Credit Balance

Get a specific customer's balance for a credit entitlement.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};


#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let entitlement_id = "ent_xxxxxxxxxx";
    let customer_id = "cus_xxxxxxxxxx";

    let resp = client
        .credit_entitlements()
        .id(entitlement_id)
        .customer_id(customer_id)
        .retrieve_customer_balance()
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

Customer balance details

404 Status

Credit entitlement or balance not found

500 Status

Something went wrong :(

Get Customer Credit Grants

List credit grants for a customer under a specific credit entitlement.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};


#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let entitlement_id = "ent_xxxxxxxxxx";
    let customer_id = "cus_xxxxxxxxxx";

    let resp = client
        .credit_entitlements()
        .id(entitlement_id)
        .customer_id(customer_id)
        .list_customer_grants()
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

List of customer grants

404 Status

Credit entitlement not found

500 Status

Something went wrong :(

Get Customer Credit Ledger

List ledger entries for a customer under a specific credit entitlement.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

# Path Parameters

| Parameter | Type | Description |
| :--- | :--- | :--- |
| `credit_entitlement_id` | `string` | `Credit Entitlement ID` |
| `customer_id` | `string` | `Customer ID` |
#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let entitlement_id = "ent_xxxxxxxxxx";
    let customer_id = "cus_xxxxxxxxxx";

    let resp = client
        .credit_entitlements()
        .id(entitlement_id)
        .customer_id(customer_id)
        .list_customer_ledger()
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

List of ledger entries

404 Status

Credit entitlement not found

500 Status

Something went wrong :(

Undelete Credit Entitlement

Restore a previously deleted credit entitlement.

making it available again through standard list and get s.

Business Logic

• Only deleted credit entitlements can be restored
• The query filters for deleted_at IS NOT NULL, so non-deleted entitlements will result in 0 rows affected
• If no rows are affected (entitlement doesn't exist, doesn't belong to business, or is not deleted), returns 500
• The updated_at timestamp is automatically updated on successful restoration
• Once restored, the entitlement becomes immediately available in the standard list and get s
• All configuration settings are preserved during delete/restore operations

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};


#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let entitlement_id = "ent_xxxxxxxxxx";

    let resp = client
        .credit_entitlements()
        .id(entitlement_id)
        .undelete()
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

Credit Entitlement Restored Successfully

500 Status

Something went wrong :(

Update Credit Entitlement

Update an existing credit entitlement with partial data.

provided in the request body will be updated; all other fields remain unchanged. This supports nullable fields using the double option pattern.

Business Logic

• Only non-deleted credit entitlements can be updated
• Fields set to null explicitly will clear the database value (using double option pattern)
• The updated_at timestamp is automatically updated on successful modification
• Changes take effect immediately but do not retroactively affect existing credit grants
• The merged state is validated: currency required with price, rollover timeframe fields together, price required for overage

Request

use dodopayments_rust::{
    models::PatchCreditEntitlementRequest, to_pretty_json, DodoPaymentsClientBuilder,
};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let entitlement_id = "ent_xxxxxxxxxx";

    let resp = client
        .credit_entitlements()
        .id(entitlement_id)
        .update()
        .body(PatchCreditEntitlementRequest {
            name: Some("Updated Credits".to_string()),
            description: Some("Updated credit allocation".to_string()),
            unit: Some("credits".to_string()),
            price_per_unit: Some("1.00".to_string()),
            currency: None,
            expires_after_days: None,
            max_rollover_count: None,
            overage_behavior: None,
            overage_enabled: None,
            overage_limit: None,
            rollover_enabled: None,
            rollover_percentage: None,
            rollover_timeframe_count: None,
            rollover_timeframe_interval: None,
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Body

Responses

200 Status

Credit entitlement updated successfully

404 Status

Credit entitlement not found

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Customers

Create Customer

Create a new customer in your Dodo Payments account.

Request

use dodopayments_rust::{models::CreateCustomerRequest, to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client
        .customers()
        .create()
        .body(CreateCustomerRequest {
            email: "customer@example.com".to_string(),
            name: "John Doe".to_string(),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Body

Responses

200 Status

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Create Customer Credit Ledger Entry

Add or deduct monetary funds in a customer's wallet using entry_type 'credit' or 'debit'.

Request

use dodopayments_rust::{
    models::{CreateLedgerEntryRequest, LedgerEntryType},
    to_pretty_json, DodoPaymentsClientBuilder,
};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let entitlement_id = "ent_xxxxxxxxxx";
    let customer_id = "cus_xxxxxxxxxx";

    let resp = client
        .credit_entitlements()
        .id(entitlement_id)
        .customer_id(customer_id)
        .create_customer_ledger_entry()
        .body(CreateLedgerEntryRequest {
            amount: "100".to_string(),
            entry_type: LedgerEntryType::Credit,
            reason: None,
            idempotency_key: None,
            expires_at: None,
            metadata: None,
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Body

Responses

200 Status

400 Status

Insufficient balance for debit

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Create Customer Portal Session

Create a session of the Customer Portal for a specific customer.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let customer_id = "cus_xxxxxxxxxx";

    let resp = client
        .customers()
        .id(customer_id)
        .create_customer_portal()
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

Successfully send email to customer (if they exist)

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Get Customer Detail

Get detailed information about a specific customer.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let customer_id = "cus_xxxxxxxxxx";

    let resp = client.customers().id(customer_id).retrieve().send().await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

500 Status

Something went wrong :(

Get Customer Wallet Ledger Entries

List wallet ledger entries (fund additions and deductions) for a specific customer.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let customer_id = "cus_xxxxxxxxxx";

    let resp = client
        .customers()
        .id(customer_id)
        .retrieve_customer_wallet_ledger_entries()
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

500 Status

Something went wrong :(

Get Customer Wallets

Retrieve monetary wallet balances associated with a specific customer. Wallets hold real funds (USD, EUR, etc.).

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let customer_id = "cus_xxxxxxxxxx";

    let resp = client
        .customers()
        .id(customer_id)
        .list_customer_wallets()
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

500 Status

Something went wrong :(

Get Customers

Get a list of all customers associated with your account.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.customers().list().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

Customers List

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Update Customer

Update a customer's information.

Request

use dodopayments_rust::{models::PatchCustomerRequest, to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let customer_id = "cus_xxxxxxxxxx";

    let resp = client
        .customers()
        .id(customer_id)
        .update()
        .body(PatchCustomerRequest {
            name: Some("Updated Name".to_string()),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Body

Responses

200 Status

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Discounts

Create Discount

Create a discount for your account.

Request

use dodopayments_rust::{
    models::{CreateDiscountRequest, DiscountType},
    to_pretty_json, DodoPaymentsClientBuilder,
};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client
        .discounts()
        .create()
        .body(CreateDiscountRequest {
            amount: 10,
            r#type: DiscountType::Percentage,
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Body

Responses

200 Status

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

Created discount

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Delete Discount

Delete a discount from your account.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let discount_id = "dis_xxxxxxxxxx";

    let resp = client.discounts().id(discount_id).delete().send().await?;

    println!("Discount deleted successfully");

    Ok(())
}

Path Parameters

Responses

204 Status

Soft-deleted discount (no content)

404 Status

Discount not found or already deleted

500 Status

Something went wrong :(

Get Discount By Code

Validate and retrieve a discount by its code name (e.g. 'SAVE20') instead of using the internal discount ID.

This allows real-time validation directly against the API using the human-readable discount code instead of requiring the internal discount_id.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let discount_code = "";

    let resp = client
        .discounts()
        .code(discount_code)
        .retrieve_by_code()
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

Fetched discount by code

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

404 Status

Discount code not found or soft-deleted

422 Status

Discount code expired or usage limit exceeded

500 Status

Something went wrong :(

Get Discount Detail

Validate a discount code to check if it is valid and can be applied.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let discount_id = "dis_xxxxxxxxxx";

    let resp = client.discounts().id(discount_id).validate().send().await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

Fetched discount by ID

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

404 Status

Not found / or soft-deleted

500 Status

Something went wrong :(

Get Discounts

Retrieve a list of all discounts associated with your account.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.discounts().list().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

List of active Discounts

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Update Discount

Update a discount in your account.

Request

use dodopayments_rust::{models::PatchDiscountRequest, to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let discount_id = "dis_xxxxxxxxxx";

    let resp = client
        .discounts()
        .id(discount_id)
        .update()
        .body(PatchDiscountRequest {
            amount: Some(15),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Body

Responses

200 Status

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

Updated discount

• If discount_type is percentage, this is in basis points (e.g., 540 => 5.4%). If not provided, the discount will be applied indefinitely to

404 Status

Discount not found or soft-deleted

500 Status

Something went wrong :(

Disputes

Get Dispute Detail

Get detailed information about a specific dispute.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let dispute_id = "dispute_xxxxxxxxxx";

    let resp = client.disputes().id(dispute_id).retrieve().send().await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

500 Status

Something went wrong :(

Get Disputes

Get a list of all disputes associated with your account.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.disputes().list().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

500 Status

Something went wrong :(

Events

Get Event Deatils

Get a specific usage event by its ID.

• Debugging specific event ingestion issues
• Retrieving event details for customer support
• Validating that events were processed correctly
• Getting the complete metadata for an event

Event ID Format:

The event ID should be the same value that was provided during event ingestion via the /events/ingest . Event IDs are case-sensitive and must match exactly.

Response Details:

The response includes all event data including:

• Complete metadata key-value pairs
• Original timestamp (preserved from ingestion)
• Customer and business association
• Event name and processing information

Example Usage:

GET /events/api_call_12345

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let event_id = "evt_xxxxxxxxxx";

    let resp = client.usage_events().id(event_id).retrieve().send().await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

Event retrieved successfully

401 Status

Unauthorized - invalid or missing API key

404 Status

Event not found - no event exists with the specified ID for your business

422 Status

Unprocessable entity - invalid event ID format

Get Events

Get a list of all usage events.

• Debugging event ingestion issues
• Analyzing customer usage patterns
• Building custom analytics dashboards
• Auditing billing-related events

Filtering Options:

• Customer filtering: Filter by specific customer ID
• Event name filtering: Filter by event type/name
• Meter-based filtering: Use a meter ID to apply the meter's event name and filter criteria automatically
• Time range filtering: Filter events within a specific date range
• Pagination: Navigate through large result sets

Meter Integration:

When using meter_id, the automatically applies:

• The meter's configured event_name filter
• The meter's custom filter criteria (if any)
• If you also provide event_name, it must match the meter's event name

Example Queries:

• Get all events for a customer: ?customer_id=cus_abc123
• Get API request events: ?event_name=api_request
• Get events from last 24 hours: ?start=2024-01-14T10:30:00Z&end=2024-01-15T10:30:00Z
• Get events with meter filtering: ?meter_id=mtr_xyz789
• Paginate results: ?page_size=50&page_number=2

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.usage_events().list().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

Events retrieved successfully

400 Status

Invalid request - invalid query parameters, conflicting meter/event names, or malformed dates

401 Status

Unauthorized - invalid or missing API key

404 Status

Meter not found - the specified meter_id does not exist

422 Status

Unprocessable entity - validation errors in query parameters

Ingest Event

Ingest events for usage-based billing.

• Usage-based billing and metering
• Analytics and reporting
• Customer behavior tracking

Important Notes:

• Duplicate Prevention:
  • Duplicate event_id values within the same request are rejected (entire request fails)
  • Subsequent requests with existing event_id values are ignored (idempotent behavior)
• Rate Limiting: Maximum 1000 events per request
• Time Validation: Events with timestamps older than 1 hour or more than 5 minutes in the future will be rejected
• Metadata Limits: Maximum 50 key-value pairs per event, keys max 100 chars, values max 500 chars

Example Usage:

{
  "events": [
    {
      "event_id": "api_call_12345",
      "customer_id": "cus_abc123",
      "event_name": "api_request",
      "timestamp": "2024-01-15T10:30:00Z",
      "metadata": {
        "": "/api/v1/users",
        "method": "GET",
        "tokens_used": "150"
      }
    }
  ]
}

Request

use dodopayments_rust::{models::IngestEventsRequest, to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client
        .usage_events()
        .ingest()
        .body(IngestEventsRequest {
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Body

Responses

200 Status

Events ingested successfully

400 Status

Invalid request - validation errors, duplicate event IDs, or invalid timestamps

401 Status

Unauthorized - invalid or missing API key

413 Status

Payload too large - request exceeds maximum allowed size

422 Status

Unprocessable entity - malformed JSON or schema validation errors

429 Status

Too many requests - rate limit exceeded

Licenses

Activate License

Activate a license for the user.

Request

use dodopayments_rust::{
    models::ActivateLicenseKeyRequest, to_pretty_json, DodoPaymentsClientBuilder,
};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client
        .licenses()
        .activate()
        .body(ActivateLicenseKeyRequest {
            license_key: "lic_xxxxxxxxxx".to_string(),
            name: "My Device".to_string(),
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Body

Responses

201 Status

License key instance created

403 Status

License key cannot be activated (inactive)

404 Status

License key not found

422 Status

License key activation limit reached

500 Status

Something went wrong :(

Deactivate License

Deactivate a license for the user.

Request

use dodopayments_rust::{
    models::DeactivateLicenseKeyRequest, to_pretty_json, DodoPaymentsClientBuilder,
};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client
        .licenses()
        .deactivate()
        .body(DeactivateLicenseKeyRequest {
            license_key: "lic_xxxxxxxxxx".to_string(),
            license_key_instance_id: "lki_xxxxxxxxxx".to_string(),
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Body

Responses

200 Status

License key instance deactivated successfully

403 Status

License key instance not found or does not belong to this license key

404 Status

License key not found

500 Status

Something went wrong :(

Get License Key

Retrieve the details of a specific license key by its ID.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let license_key_id = "lic_xxxxxxxxxx";

    let resp = client
        .licenses()
        .license_keys()
        .id(license_key_id)
        .retrieve()
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

License key found

404 Status

License key not found

500 Status

Something went wrong :(

Get License Key Instance

Retrieve details of a specific license key instance by its ID.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let license_key_id = "lic_xxxxxxxxxx";
    let instance_id = "lki_xxxxxxxxxx";

    let resp = client
        .licenses()
        .license_keys()
        .id(license_key_id)
        .license_key_instances()
        .id(instance_id)
        .retrieve()
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

License key instance found

404 Status

License key instance not found

500 Status

Something went wrong :(

Get License Key Instances

Retrieve a list of instances for a specific license key.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let license_key_id = "lic_xxxxxxxxxx";

    let resp = client
        .licenses()
        .license_keys()
        .id(license_key_id)
        .license_key_instances()
        .list()
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

500 Status

Something went wrong :(

Get Licenses

Retrieve a list of license keys associated with your account.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.licenses().license_keys().list().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

500 Status

Something went wrong :(

Update License Key

Update a license key by its ID.

Request

use dodopayments_rust::{
    models::PatchLicenseKeyRequest, to_pretty_json, DodoPaymentsClientBuilder,
};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let license_key_id = "lic_xxxxxxxxxx";

    let resp = client
        .licenses()
        .license_keys()
        .id(license_key_id)
        .update()
        .body(PatchLicenseKeyRequest {
            activations_limit: Some(10),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Body

Responses

200 Status

License key updated successfully

400 Status

Cannot set expiry for subscription-based license

404 Status

License key not found

422 Status

New activation limit is less than current instances count

500 Status

Something went wrong :(

Update License Key Instance

Update a specific license key instance by its ID.

Request

use dodopayments_rust::{
    models::PatchLicenseKeyInstanceRequest, to_pretty_json, DodoPaymentsClientBuilder,
};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let license_key_id = "lic_xxxxxxxxxx";
    let instance_id = "lki_xxxxxxxxxx";

    let resp = client
        .licenses()
        .license_keys()
        .id(license_key_id)
        .license_key_instances()
        .id(instance_id)
        .update()
        .body(PatchLicenseKeyInstanceRequest {
            name: "Updated Device Name".to_string(),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Body

Responses

200 Status

License key instance updated

404 Status

License key instance not found

500 Status

Something went wrong :(

Validate License

Validate a license for the user.

Request

use dodopayments_rust::{
    models::ValidateLicenseKeyRequest, to_pretty_json, DodoPaymentsClientBuilder,
};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client
        .licenses()
        .validate()
        .body(ValidateLicenseKeyRequest {
            license_key: "lic_xxxxxxxxxx".to_string(),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Body

Responses

200 Status

License key validation result

422 Status

Invalid request format

500 Status

Something went wrong :(

Meters

Archive Meter

Archive a meter by its ID.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let meter_id = "meter_xxxxxxxxxx";

    let resp = client.meters().id(meter_id).archive().send().await?;

    println!("Meter archived successfully");

    Ok(())
}

Path Parameters

Responses

204 Status

Meter deleted successfully

404 Status

Meter not found

500 Status

Something went wrong :(

Create Meter

Create a new meter.

Request

use dodopayments_rust::{models::CreateMeterRequest, to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client
        .meters()
        .create()
        .body(CreateMeterRequest {
            name: "API Calls".to_string(),
            event_name: "api_call".to_string(),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Body

Responses

201 Status

Meter created successfully

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Get Meter Details

Retrieve a meter by its ID.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let meter_id = "meter_xxxxxxxxxx";

    let resp = client.meters().id(meter_id).retrieve().send().await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

Meter details

404 Status

Meter not found

500 Status

Something went wrong :(

Get Meters

Get a list of all meters.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.meters().list().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

Meters List

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Unarchive Meter

Unarchive a meter by its ID.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let meter_id = "meter_xxxxxxxxxx";

    let resp = client.meters().id(meter_id).unarchive().send().await?;

    println!("Meter unarchived successfully");

    Ok(())
}

Path Parameters

Responses

200 Status

Meter Unarchived Successfully

500 Status

Something went wrong :(

Misc

Get Supported Countries

Retrieve a list of countries supported by Dodo Payments for checkout.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.misc().list_supported_countries().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

Currently Supported Countries

No specific fields defined.

500 Status

Something went wrong :(

Payments

Create Payment

Create a one-time payment for a customer.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    println!("Note: create payment API is deprecated. Use checkout sessions instead.");
    println!("See create_checkout.rs example");

    Ok(())
}

Body

Responses

200 Status

One Time payment successfully initiated

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Get Payment Detail

Get detailed information about a specific payment.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let payment_id = "pay_xxxxxxxxxx";

    let resp = client.payments().id(payment_id).retrieve().send().await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

Especially relevant for adaptive pricing where the tax component must be tracked separately

Especially relevant for adaptive pricing where the tax component must be tracked separately

Especially relevant for adaptive pricing where the tax component must be tracked separately

Especially relevant for adaptive pricing where the tax component must be tracked separately

500 Status

Something went wrong :(

Get Payment Invoice

Get an invoice by Payment ID.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let payment_id = "pay_xxxxxxxxxx";

    let invoice = client
        .payments()
        .id(payment_id)
        .retrieve_invoice()
        .send()
        .await?;

    std::fs::write("invoice.pdf", &invoice.0)?;

    println!("Invoice saved to invoice.pdf");

    Ok(())
}

Path Parameters

Responses

200 Status

PDF document

429 Status

Too Many Requests have been sent

500 Status

Something went wrong :(

Get Payment Line Items

Retrieve line items for a specific payment.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let payment_id = "pay_xxxxxxxxxx";

    let resp = client.payments().id(payment_id).line_items().send().await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

Get Payments

Get a list of all payments associated with your account.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.payments().list().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

500 Status

Something went wrong :(

Payouts

Get Payouts

Get a list of all payouts associated with your account.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.payouts().list().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

Payouts List

500 Status

Something went wrong :(

Products

Create Product

Create a new product.

Request

use dodopayments_rust::{models::CreateProductRequest, to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client
        .products()
        .create()
        .body(CreateProductRequest {
            name: "Premium Plan".to_string(),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Body

Responses

200 Status

Product Created Successfully

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Create Product Short Link

Create a short checkout URL with a custom slug for a product.

Request

use dodopayments_rust::{
    models::CreateShortLinkRequest, to_pretty_json, DodoPaymentsClientBuilder,
};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let product_id = "prod_xxxxxxxxxx";

    let resp = client
        .products()
        .id(product_id)
        .create_short_link()
        .body(CreateShortLinkRequest {
            slug: "my-product-link".to_string(),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Body

Responses

200 Status

Short URL

404 Status

Product not found

409 Status

Slug is already taken

500 Status

Something went wrong :(

Delete Product

Archive a product associated with your account.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let product_id = "prod_xxxxxxxxxx";

    let resp = client.products().id(product_id).archive().send().await?;

    println!("Product archived successfully");

    Ok(())
}

Path Parameters

Responses

200 Status

Product Delected Successfully

410 Status

Product is deleted

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Get Product Detail

Get detailed information about a specific product.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let product_id = "prod_xxxxxxxxxx";

    let resp = client.products().id(product_id).retrieve().send().await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

Product Details

500 Status

Something went wrong :(

Get Product Short Links

List all short checkout links created by the business.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.products().list_short_links().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

Short URLs for the Business

500 Status

Something went wrong :(

Get Products

Get a list of all products associated with your account.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.products().list().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

Products List

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Unarchive Product

Unarchive a previously archived product.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let product_id = "prod_xxxxxxxxxx";

    let resp = client.products().id(product_id).unarchive().send().await?;

    println!("Product unarchived successfully");

    Ok(())
}

Path Parameters

Responses

200 Status

Product Delected Successfully

500 Status

Something went wrong :(

Update Product

Update a product's details.

Request

use dodopayments_rust::{models::PatchProductRequest, to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let product_id = "prod_xxxxxxxxxx";

    let resp = client
        .products()
        .id(product_id)
        .update()
        .body(PatchProductRequest {
            name: Some("Updated Product".to_string()),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Body

Responses

200 Status

Product Updated Successfully

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Update Product File

Update the files associated with a product.

Request

use dodopayments_rust::{models::UploadProductFile, to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let product_id = "prod_xxxxxxxxxx";

    let resp = client
        .products()
        .id(product_id)
        .update_files()
        .body(UploadProductFile {
            file_name: "product_file.pdf".to_string(),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Body

Responses

200 Status

Aws s3 presigned URL. Upload image to this URL within 60s

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Update Product Image

Update images for a product.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let product_id = "prod_xxxxxxxxxx";

    let resp = client
        .products()
        .id(product_id)
        .update_image()
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

Aws s3 presigned URL. Upload image to this URL within 60s

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Refunds

Create Refund

Create a refund for a payment.

Request

use dodopayments_rust::{models::CreateRefundRequest, to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client
        .refunds()
        .create()
        .body(CreateRefundRequest {
            payment_id: "pay_xxxxxxxxxx".to_string(),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Body

Responses

200 Status

Refund successfully initiated

400 Status

Invalid Request Parameters

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Get Refund Detail

Get detailed information about a specific refund.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let refund_id = "ref_xxxxxxxxxx";

    let resp = client.refunds().id(refund_id).retrieve().send().await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

500 Status

Something went wrong :(

Get Refunds

Get a list of all refunds associated with your account.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.refunds().list().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

500 Status

Something went wrong :(

Subscriptions

Change Subscription Plan

Preview the effects of a subscription plan change before committing to it.

Request

use dodopayments_rust::{
    models::UpdateSubscriptionPlanReq, to_pretty_json, DodoPaymentsClientBuilder,
};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let subscription_id = "sub_xxxxxxxxxx";

    let resp = client
        .subscriptions()
        .id(subscription_id)
        .change_plan()
        .body(UpdateSubscriptionPlanReq {
            product_id: "prod_xxxxxxxxxx".to_string(),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Body

Responses

200 Status

Preview of subscription plan change

500 Status

Something went wrong :(

Create Subscription

Create a subscription for a customer.

Request

use dodopayments_rust::{
    models::CreateSubscriptionRequest, to_pretty_json, DodoPaymentsClientBuilder,
};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client
        .subscriptions()
        .create()
        .body(CreateSubscriptionRequest {
            product_id: "prod_xxxxxxxxxx".to_string(),

            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Body

Responses

200 Status

Subscription successfully initiated

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Create Subscription Charge

Create an on-demand charge for a subscription.

Request

use dodopayments_rust::{
    models::CreateSubscriptionChargeRequest, to_pretty_json, DodoPaymentsClientBuilder,
};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let subscription_id = "sub_xxxxxxxxxx";

    let resp = client
        .subscriptions()
        .id(subscription_id)
        .charge()
        .body(CreateSubscriptionChargeRequest {
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Body

Responses

200 Status

Subscription Charge successfully created

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Get Subscription Detail

Get detailed information about a specific subscription.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let subscription_id = "sub_xxxxxxxxxx";

    let resp = client
        .subscriptions()
        .id(subscription_id)
        .retrieve()
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

500 Status

Something went wrong :(

Get Subscription Usage History

Retrieve the complete usage history for a subscription with usage-based billing.

This provides insights into customer usage patterns and billing calculations over time.

What You'll Get:

• Billing periods: Each item represents a billing cycle with start and end dates
• Meter usage: Detailed breakdown of usage for each meter configured on the subscription
• Usage calculations: Total units consumed, free threshold units, and chargeable units
• Historical tracking: Complete audit trail of usage-based charges

Use Cases:

• Customer support: Investigate billing questions and usage discrepancies
• Usage analytics: Analyze customer consumption patterns over time
• Billing transparency: Provide customers with detailed usage breakdowns
• Revenue optimization: Identify usage trends to optimize pricing strategies

Filtering Options:

• Date range filtering: Get usage history for specific time periods
• Meter-specific filtering: Focus on usage for a particular meter
• Pagination: Navigate through large usage histories efficiently

Important Notes:

• Only returns data for subscriptions with usage-based (metered) components
• Usage history is organized by billing periods (subscription cycles)
• Free threshold units are calculated and displayed separately from chargeable units
• Historical data is preserved even if meter configurations change

Example Query Patterns:

• Get last 3 months: ?start_date=2024-01-01T00:00:00Z&end_date=2024-03-31T23:59:59Z
• Filter by meter: ?meter_id=mtr_api_requests
• Paginate results: ?page_size=20&page_number=1
• Recent usage: ?start_date=2024-03-01T00:00:00Z (from March 1st to now)

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let subscription_id = "sub_xxxxxxxxxx";

    let resp = client
        .subscriptions()
        .id(subscription_id)
        .usage_history()
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Responses

200 Status

Usage history retrieved successfully

400 Status

Invalid request - malformed parameters or validation errors

401 Status

Unauthorized - invalid or missing API key

404 Status

Subscription not found - no subscription exists with the specified ID

422 Status

Unprocessable entity - invalid query parameter values or date ranges

500 Status

Internal server error - please contact support if this persists

Get Subscriptions

Get a list of all subscriptions associated with your account.

Request

use dodopayments_rust::{to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client.subscriptions().list().send().await?;
    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Responses

200 Status

500 Status

Something went wrong :(

Update Subscription

Update a subscription's details.

Request

use dodopayments_rust::{
    models::PatchSubscriptionRequest, to_pretty_json, DodoPaymentsClientBuilder,
};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let subscription_id = "sub_xxxxxxxxxx";

    let resp = client
        .subscriptions()
        .id(subscription_id)
        .update()
        .body(PatchSubscriptionRequest {
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Path Parameters

Body

Responses

200 Status

Subscription successfully updated

422 Status

Invalid Request Object or Parameters

500 Status

Something went wrong :(

Webhooks

Create Webhook

Create a new webhook for a business.

Request

use dodopayments_rust::{models::CreateWebhookRequest, to_pretty_json, DodoPaymentsClientBuilder};

#[tokio::main]

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DODO_API_KEY")?;

    let client = DodoPaymentsClientBuilder::new()
        .bearer_token(&api_key)
        .enviroment("test_mode")
        .build()?;

    let resp = client
        .webhooks()
        .create()
        .body(CreateWebhookRequest {
            url: "https://example.com/webhook".to_string(),
            ..Default::default()
        })
        .send()
        .await?;

    println!("{}", to_pretty_json(&resp)?);

    Ok(())
}

Body

Responses

200 Status

created Successfully

Delete Webhook

Delete a specific webhook.