Go - Dodo Payments Documentation

Le SDK Go fournit une interface Go propre et idiomatique pour intégrer Dodo Payments dans vos applications. Il offre un support de contexte, des réponses fortement typées, des capacités de middleware et est sûr pour une utilisation concurrente.

Installation

Installez le SDK en utilisant les modules Go :

go get github.com/dodopayments/dodopayments-go

Ou pour épingler à une version spécifique :

go get -u 'github.com/dodopayments/dodopayments-go@v1.97.3'

Le SDK nécessite Go 1.22 ou une version ultérieure, tirant parti des fonctionnalités modernes de Go pour des performances optimales.

Démarrage rapide

Initialisez le client et créez votre première session de paiement :

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/dodopayments/dodopayments-go"
	"github.com/dodopayments/dodopayments-go/option"
)

func main() {
	client := dodopayments.NewClient(
		option.WithBearerToken("My Bearer Token"), // defaults to os.LookupEnv("DODO_PAYMENTS_API_KEY")
		option.WithEnvironmentTestMode(),          // defaults to option.WithEnvironmentLiveMode()
	)
	
	checkoutSessionResponse, err := client.CheckoutSessions.New(context.TODO(), dodopayments.CheckoutSessionNewParams{
		CheckoutSessionRequest: dodopayments.CheckoutSessionRequestParam{
			ProductCart: dodopayments.F([]dodopayments.ProductItemReqParam{{
				ProductID: dodopayments.F("product_id"),
				Quantity:  dodopayments.F(int64(1)),
			}}),
		},
	})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("Session ID: %s\n", checkoutSessionResponse.SessionID)
}

Stockez toujours vos clés d’API de manière sécurisée en utilisant des variables d’environnement. Ne les codez jamais en dur dans votre code source.

Fonctionnalités principales

Context Support

Prise en charge complète de context.Context pour les annulations et les délais d’expiration

Strong Typing

Requêtes et réponses fortement typées pour une sécurité en temps de compilation

Middleware

Support extensible des middlewares pour la journalisation, les métriques et la logique personnalisée

Goroutine Safe

Client sûr pour les threads conçu pour les opérations concurrentes

Configuration

Contexte et délais d’attente

Tirez parti du contexte de Go pour les délais d’attente et l’annulation :

import (
	"context"
	"time"
	
	"github.com/dodopayments/dodopayments-go"
	"github.com/dodopayments/dodopayments-go/option"
)

// Create a context with timeout
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()

payment, err := client.Payments.New(ctx, dodopayments.PaymentNewParams{
	Billing: dodopayments.F(dodopayments.BillingAddressParam{
		Country: dodopayments.F(dodopayments.CountryCodeUs),
		City:    dodopayments.F("San Francisco"),
		State:   dodopayments.F("CA"),
		Street:  dodopayments.F("1 Market St"),
		Zipcode: dodopayments.F("94105"),
	}),
	Customer: dodopayments.F[dodopayments.CustomerRequestUnionParam](
		dodopayments.AttachExistingCustomerParam{
			CustomerID: dodopayments.F("cus_123"),
		},
	),
	ProductCart: dodopayments.F([]dodopayments.OneTimeProductCartItemParam{{
		ProductID: dodopayments.F("pdt_456"),
		Quantity:  dodopayments.F(int64(1)),
	}}),
})
if err != nil {
	if ctx.Err() == context.DeadlineExceeded {
		log.Println("Request timed out")
	} else {
		log.Fatal(err)
	}
}

Configuration de la réessai

Configurez le comportement de réessai automatique :

// Configure default for all requests (default is 2)
client := dodopayments.NewClient(
	option.WithMaxRetries(0), // disable retries
)

// Override per-request
client.CheckoutSessions.New(
	context.TODO(),
	dodopayments.CheckoutSessionNewParams{
		CheckoutSessionRequest: dodopayments.CheckoutSessionRequestParam{
			ProductCart: dodopayments.F([]dodopayments.ProductItemReqParam{{
				ProductID: dodopayments.F("product_id"),
				Quantity:  dodopayments.F(int64(0)),
			}}),
		},
	},
	option.WithMaxRetries(5),
)

Opérations courantes

Créer une session de paiement

Générez une session de paiement :

session, err := client.CheckoutSessions.New(ctx, dodopayments.CheckoutSessionNewParams{
	CheckoutSessionRequest: dodopayments.CheckoutSessionRequestParam{
		ProductCart: dodopayments.F([]dodopayments.ProductItemReqParam{{
			ProductID: dodopayments.F("pdt_123"),
			Quantity:  dodopayments.F(int64(1)),
		}}),
		ReturnURL: dodopayments.F("https://yourdomain.com/return"),
	},
})
if err != nil {
	log.Fatal(err)
}

fmt.Printf("Checkout URL: %s\n", session.CheckoutURL)

Gérer les clients

Créez et récupérez des informations sur les clients :

// Create a customer
customer, err := client.Customers.New(ctx, dodopayments.CustomerNewParams{
	Email: dodopayments.F("customer@example.com"),
	Name:  dodopayments.F("John Doe"),
	Metadata: dodopayments.F(map[string]string{
		"user_id": "12345",
	}),
})
if err != nil {
	log.Fatal(err)
}

// Retrieve customer
customer, err = client.Customers.Get(ctx, "cus_123")
if err != nil {
	log.Fatal(err)
}

fmt.Printf("Customer: %s (%s)\n", customer.Name, customer.Email)

Gérer les abonnements

Créez et gérez des abonnements récurrents :

POST /subscriptions (la méthode subscriptions.create du SDK) est obsolète. Elle fonctionne toujours pour les intégrations existantes, mais les nouvelles intégrations doivent créer des abonnements via une Checkout Session.

import "time"

// Create a subscription
subscription, err := client.Subscriptions.New(ctx, dodopayments.SubscriptionNewParams{
	Billing: dodopayments.F(dodopayments.BillingAddressParam{
		Country: dodopayments.F(dodopayments.CountryCodeUs),
		City:    dodopayments.F("San Francisco"),
		State:   dodopayments.F("CA"),
		Street:  dodopayments.F("1 Market St"),
		Zipcode: dodopayments.F("94105"),
	}),
	Customer: dodopayments.F[dodopayments.CustomerRequestUnionParam](
		dodopayments.AttachExistingCustomerParam{
			CustomerID: dodopayments.F("cus_123"),
		},
	),
	ProductID: dodopayments.F("pdt_456"),
	Quantity:  dodopayments.F(int64(1)),
})
if err != nil {
	log.Fatal(err)
}

// Charge an on-demand subscription
// ProductPrice is in the lowest currency denomination (e.g., 2500 = $25.00 USD)
chargeResponse, err := client.Subscriptions.Charge(ctx, subscription.SubscriptionID,
	dodopayments.SubscriptionChargeParams{
		ProductPrice: dodopayments.F(int64(2500)),
	},
)
if err != nil {
	log.Fatal(err)
}

// Get usage history (for metered subscriptions)
usageHistory, err := client.Subscriptions.GetUsageHistory(
	ctx,
	subscription.SubscriptionID,
	dodopayments.SubscriptionGetUsageHistoryParams{
		StartDate: dodopayments.F(time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)),
		EndDate:   dodopayments.F(time.Date(2024, 3, 31, 23, 59, 59, 0, time.UTC)),
	},
)
if err != nil {
	log.Fatal(err)
}

Billing nécessite au minimum le code ISO à deux lettres Country. Customer est un CustomerRequestUnionParam — transmettez AttachExistingCustomerParam{CustomerID: ...} pour un client existant ou NewCustomerParam{Email: ..., Name: ...} pour un nouveau client. ProductPrice est exprimé dans la plus petite unité de la devise.

Facturation basée sur l’utilisation

Ingérer des événements d’utilisation

Suivez les événements personnalisés :

import "github.com/dodopayments/dodopayments-go"

response, err := client.UsageEvents.Ingest(ctx, dodopayments.UsageEventIngestParams{
	Events: dodopayments.F([]dodopayments.EventInputParam{{
		EventID:    dodopayments.F("api_call_12345"),
		CustomerID: dodopayments.F("cus_abc123"),
		EventName:  dodopayments.F("api_request"),
		Timestamp:  dodopayments.F(time.Date(2024, 1, 15, 10, 30, 0, 0, time.UTC)),
	}}),
})
if err != nil {
	log.Fatal(err)
}

Lister les événements d’utilisation

// List events with filters
params := dodopayments.UsageEventListParams{
	CustomerID: dodopayments.F("cus_abc123"),
	EventName:  dodopayments.F("api_request"),
}

events, err := client.UsageEvents.List(ctx, params)
if err != nil {
	log.Fatal(err)
}

for _, event := range events.Items {
	fmt.Printf("Event %s: %s at %s\n", event.EventID, event.EventName, event.Timestamp)
}

Gestion des erreurs

Lorsque l’API renvoie un code d’état indiquant un échec, le SDK renvoie une erreur de type *dodopayments.Error. Elle expose StatusCode, *http.Request sous-jacent et *http.Response, ainsi que le JSON du corps de l’erreur. Utilisez le modèle errors.As pour l’inspecter, puis basez-vous sur StatusCode pour gérer des cas spécifiques :

payment, err := client.Payments.New(ctx, dodopayments.PaymentNewParams{
	Billing: dodopayments.F(dodopayments.BillingAddressParam{
		Country: dodopayments.F(dodopayments.CountryCodeUs),
		City:    dodopayments.F("San Francisco"),
		State:   dodopayments.F("CA"),
		Street:  dodopayments.F("1 Market St"),
		Zipcode: dodopayments.F("94105"),
	}),
	Customer: dodopayments.F[dodopayments.CustomerRequestUnionParam](
		dodopayments.AttachExistingCustomerParam{CustomerID: dodopayments.F("cus_123")},
	),
	ProductCart: dodopayments.F([]dodopayments.OneTimeProductCartItemParam{{
		ProductID: dodopayments.F("pdt_456"),
		Quantity:  dodopayments.F(int64(1)),
	}}),
})
if err != nil {
	var apiErr *dodopayments.Error
	if errors.As(err, &apiErr) {
		fmt.Printf("Status Code: %d\n", apiErr.StatusCode)
		fmt.Println(string(apiErr.DumpResponse(true))) // Serialized HTTP response

		// Handle specific status codes
		switch apiErr.StatusCode {
		case 401:
			log.Println("Authentication failed")
		case 422:
			log.Println("Invalid request parameters")
		case 429:
			log.Println("Rate limit exceeded")
		default:
			log.Printf("API error: %s", apiErr.Error())
		}
	} else {
		log.Fatal(err)
	}
}

Middleware

Ajoutez un middleware personnalisé pour la journalisation ou les métriques :

func Logger(req *http.Request, next option.MiddlewareNext) (res *http.Response, err error) {
	// Before the request
	start := time.Now()
	log.Printf("Request: %s %s\n", req.Method, req.URL)

	// Forward the request to the next handler
	res, err = next(req)

	// After the request
	end := time.Now()
	log.Printf("Response: %d in %v\n", res.StatusCode, end.Sub(start))

	return res, err
}

client := dodopayments.NewClient(
	option.WithMiddleware(Logger),
)

Concurrence

Le client peut être utilisé en toute sécurité de manière concurrente :

package main

import (
	"context"
	"sync"
	"log"

	"github.com/dodopayments/dodopayments-go"
)

func main() {
	client := dodopayments.NewClient()
	
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(idx int) {
			defer wg.Done()
			
			payment, err := client.Payments.New(context.Background(), dodopayments.PaymentNewParams{
				Billing: dodopayments.F(dodopayments.BillingAddressParam{
					Country: dodopayments.F(dodopayments.CountryCodeUs),
					City:    dodopayments.F("San Francisco"),
					State:   dodopayments.F("CA"),
					Street:  dodopayments.F("1 Market St"),
					Zipcode: dodopayments.F("94105"),
				}),
				Customer: dodopayments.F[dodopayments.CustomerRequestUnionParam](
					dodopayments.AttachExistingCustomerParam{CustomerID: dodopayments.F("cus_123")},
				),
				ProductCart: dodopayments.F([]dodopayments.OneTimeProductCartItemParam{{
					ProductID: dodopayments.F("pdt_456"),
					Quantity:  dodopayments.F(int64(1)),
				}}),
			})
			if err != nil {
				log.Printf("Failed to create payment %d: %v", idx, err)
				return
			}
			
			log.Printf("Created payment %d: %s", idx, payment.PaymentID)
		}(i)
	}
	
	wg.Wait()
}

Ressources

GitHub Repository

Consulter le code source et contribuer

API Reference

Documentation complète de l’API

Discord Community

Obtenir de l’aide et échanger avec des développeurs

Report Issues

Signaler des bugs ou demander des fonctionnalités

Assistance

Besoin d’aide avec le SDK Go ?

Discord : Rejoignez notre serveur communautaire pour obtenir une assistance en temps réel
E-mail : Contactez-nous à l’adresse support@dodopayments.com
GitHub : Ouvrez un ticket dans le dépôt

Contribuer

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

Getting Started

Features

Integrate

Merchant of Record

Miscellaneous

Go

Installation

Démarrage rapide

Fonctionnalités principales

Context Support

Strong Typing

Middleware

Goroutine Safe

Configuration

Contexte et délais d’attente

Configuration de la réessai

Opérations courantes

Créer une session de paiement

Gérer les clients

Gérer les abonnements

Facturation basée sur l’utilisation

Ingérer des événements d’utilisation

Lister les événements d’utilisation

Gestion des erreurs

Middleware

Concurrence

Ressources

GitHub Repository

API Reference

Discord Community

Report Issues

Assistance

Contribuer

​Installation

​Démarrage rapide

​Fonctionnalités principales

Context Support

Strong Typing

Middleware

Goroutine Safe

​Configuration

​Contexte et délais d’attente

​Configuration de la réessai

​Opérations courantes

​Créer une session de paiement

​Gérer les clients

​Gérer les abonnements

​Facturation basée sur l’utilisation

​Ingérer des événements d’utilisation

​Lister les événements d’utilisation

​Gestion des erreurs

​Middleware

​Concurrence

​Ressources

GitHub Repository

API Reference

Discord Community

Report Issues

​Assistance

​Contribuer

Installation

Démarrage rapide

Fonctionnalités principales

Configuration

Contexte et délais d’attente

Configuration de la réessai

Opérations courantes

Créer une session de paiement

Gérer les clients

Gérer les abonnements

Facturation basée sur l’utilisation

Ingérer des événements d’utilisation

Lister les événements d’utilisation

Gestion des erreurs

Middleware

Concurrence

Ressources

Assistance

Contribuer