Passer au contenu principal
Le SDK C# offre un accès pratique à l’API REST de Dodo Payments depuis des applications écrites en C#. Il propose une API asynchrone basée sur Task avec un typage fort.

​
Installation

Installez le SDK avec la CLI .NET : 
dotnet add package DodoPayments.Client
Le SDK nécessite .NET Standard 2.0 ou une version ultérieure. Il fonctionne avec ASP.NET Core, les applications Console et d’autres types de projets .NET.

​
Démarrage rapide

Initialisez le client et créez une session de paiement : 
using System;
using DodoPayments.Client;
using DodoPayments.Client.Models.CheckoutSessions;

// Configured using the DODO_PAYMENTS_API_KEY and DODO_PAYMENTS_BASE_URL environment variables
DodoPaymentsClient client = new();

CheckoutSessionCreateParams parameters = new()
{
    ProductCart =
    [
        new()
        {
            ProductID = "product_id",
            Quantity = 1,
        },
    ],
};

var checkoutSessionResponse = await client.CheckoutSessions.Create(parameters);

Console.WriteLine(checkoutSessionResponse.SessionId);
Stockez toujours vos clés API de manière sécurisée en utilisant des variables d’environnement, des secrets utilisateur ou Azure Key Vault. Ne les codez jamais en dur dans votre code source et ne les committez pas dans le contrôle de version.

​
Fonctionnalités principales

Async/Await

API complète basée sur Task asynchrones pour des opérations non bloquantes

Strong Typing

Sécurité de type complète avec les types de référence annulables

Dependency Injection

Prise en charge de premier plan de l’injection de dépendances .NET

Configuration

Configuration simple via des variables d’environnement ou appsettings.json

​
Configuration

​
Variables d’environnement

Configurez en utilisant des variables d’environnement :
.env
DODO_PAYMENTS_API_KEY=your_api_key_here

// Automatically reads from environment variables
DodoPaymentsClient client = new();
Consultez ce tableau pour les options disponibles :
PropertyEnvironment variableRequiredDefault value
BearerTokenDODO_PAYMENTS_API_KEYtrue-
WebhookKeyDODO_PAYMENTS_WEBHOOK_KEYfalse-
BaseUrlDODO_PAYMENTS_BASE_URLtrue"https://live.dodopayments.com"

​
Configuration manuelle

Configurez manuellement avec un jeton bearer : 
DodoPaymentsClient client = new() { BearerToken = "My Bearer Token" };

​
Opérations courantes

​
Créer une session de paiement

Générez une session de paiement : 
var parameters = new CheckoutSessionCreateParams
{
    ProductCart =
    [
        new()
        {
            ProductID = "prod_123",
            Quantity = 1
        }
    ],
    ReturnUrl = "https://yourdomain.com/return"
};

var session = await client.CheckoutSessions.Create(parameters);
Console.WriteLine($"Checkout URL: {session.Url}");

​
Gérer les clients

Créez et récupérez les informations client : 
// Create a customer
var createParams = new CustomerCreateParams
{
    Email = "customer@example.com",
    Name = "John Doe",
    Metadata = new Dictionary<string, string>
    {
        { "user_id", "12345" }
    }
};

var customer = await client.Customers.Create(createParams);

// Retrieve customer
var retrieved = await client.Customers.Retrieve("cus_123");
Console.WriteLine($"Customer: {retrieved.Name} ({retrieved.Email})");

​
Gérer les abonnements

Créez et gérez les abonnements récurrents : 
// Create a subscription
var subscriptionParams = new SubscriptionCreateParams
{
    CustomerID = "cus_123",
    ProductID = "prod_456",
    PriceID = "price_789"
};

var subscription = await client.Subscriptions.Create(subscriptionParams);

// Cancel subscription
await client.Subscriptions.Cancel(subscription.Id);

​
Pagination

Le SDK définit des méthodes qui renvoient des listes paginées de résultats avec des moyens pratiques d’accéder aux résultats soit page par page, soit élément par élément sur toutes les pages.

​
Pagination automatique

Pour parcourir tous les résultats sur toutes les pages, utilisez la méthode Paginate : 
using System;

var page = await client.Payments.List(parameters);
await foreach (var item in page.Paginate())
{
    Console.WriteLine(item);
}

​
Pagination manuelle

Pour accéder aux éléments d’une page spécifique et demander manuellement la page suivante : 
using System;

var page = await client.Payments.List();
while (true)
{
    foreach (var item in page.Items)
    {
        Console.WriteLine(item);
    }
    if (!page.HasNext())
    {
        break;
    }
    page = await page.Next();
}

​
Intégration ASP.NET Core

​
Enregistrement du service

Enregistrez le client dans Program.cs :
Program.cs
using DodoPayments.Client;

var builder = WebApplication.CreateBuilder(args);

// Register DodoPayments client
builder.Services.AddSingleton<DodoPaymentsClient>(sp =>
{
    var configuration = sp.GetRequiredService<IConfiguration>();
    return new DodoPaymentsClient
    {
        BearerToken = configuration["DodoPayments:ApiKey"]
    };
});

builder.Services.AddControllers();

var app = builder.Build();
app.MapControllers();
app.Run();

​
Configuration

Ajoutez la configuration dans appsettings.json :
appsettings.json
{
  "DodoPayments": {
    "ApiKey": "your_api_key_here"
  }
}

​
Contrôleur API

Créez un contrôleur en utilisant l’injection de dépendances : 
using Microsoft.AspNetCore.Mvc;
using DodoPayments.Client;
using DodoPayments.Client.Models.CheckoutSessions;

[ApiController]
[Route("api/[controller]")]
public class PaymentsController : ControllerBase
{
    private readonly DodoPaymentsClient _client;
    private readonly ILogger<PaymentsController> _logger;

    public PaymentsController(DodoPaymentsClient client, ILogger<PaymentsController> logger)
    {
        _client = client;
        _logger = logger;
    }

    [HttpPost("checkout")]
    public async Task<IActionResult> CreateCheckout([FromBody] CheckoutRequest request)
    {
        try
        {
            var parameters = new CheckoutSessionCreateParams
            {
                ProductCart = request.Items,
                ReturnUrl = Url.Action("Return", "Checkout", null, Request.Scheme)
            };

            var session = await _client.CheckoutSessions.Create(parameters);

            return Ok(new { checkoutUrl = session.Url });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to create checkout");
            return BadRequest(new { error = ex.Message });
        }
    }
}

public record CheckoutRequest(List<ProductCartItem> Items);

​
Modèle de couche de service

Créez un service pour la logique métier : 
public interface IPaymentService
{
    Task<CheckoutSessionResponse> CreateCheckoutAsync(List<ProductCartItem> items);
    Task<PaymentResponse> ProcessPaymentAsync(decimal amount, string currency, string customerId);
}

public class PaymentService : IPaymentService
{
    private readonly DodoPaymentsClient _client;
    private readonly ILogger<PaymentService> _logger;

    public PaymentService(DodoPaymentsClient client, ILogger<PaymentService> logger)
    {
        _client = client;
        _logger = logger;
    }

    public async Task<CheckoutSessionResponse> CreateCheckoutAsync(List<ProductCartItem> items)
    {
        var parameters = new CheckoutSessionCreateParams
        {
            ProductCart = items,
            ReturnUrl = "https://yourdomain.com/return"
        };

        return await _client.CheckoutSessions.Create(parameters);
    }

    public async Task<PaymentResponse> ProcessPaymentAsync(
        decimal amount,
        string currency,
        string customerId)
    {
        try
        {
            var parameters = new PaymentCreateParams
            {
                Amount = (long)(amount * 100), // Convert to cents
                Currency = currency,
                CustomerID = customerId
            };

            return await _client.Payments.Create(parameters);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to process payment");
            throw;
        }
    }
}

​
Secrets utilisateur (développement)

Pour le développement, utilisez les secrets utilisateur pour stocker les clés API : 
dotnet user-secrets init
dotnet user-secrets set "DodoPayments:ApiKey" "your_api_key_here"

​
Tests

Exemple de test unitaire utilisant xUnit : 
using Xunit;
using DodoPayments.Client;
using DodoPayments.Client.Models.CheckoutSessions;

public class PaymentServiceTests
{
    private readonly DodoPaymentsClient _client;

    public PaymentServiceTests()
    {
        _client = new DodoPaymentsClient
        {
            BearerToken = "test_key"
        };
    }

    [Fact]
    public async Task CreateCheckout_ShouldReturnSession()
    {
        // Arrange
        var parameters = new CheckoutSessionCreateParams
        {
            ProductCart =
            [
                new()
                {
                    ProductID = "prod_test",
                    Quantity = 1
                }
            ]
        };

        // Act
        var session = await _client.CheckoutSessions.Create(parameters);

        // Assert
        Assert.NotNull(session);
        Assert.NotNull(session.SessionId);
    }
}

​
Ressources

GitHub Repository

Voir le code source et contribuer

API Reference

Documentation complète de l’API

Discord Community

Obtenez de l’aide et connectez-vous avec les développeurs

Report Issues

Signalez des dysfonctionnements ou demandez des fonctionnalités

​
Support

Besoin d’aide avec le SDK C# ?

​
Contribution

Nous acceptons les contributions ! Consultez les directives de contribution pour commencer.