Passer au contenu principal

Documentation Index

Fetch the complete documentation index at: https://docs.dodopayments.com/llms.txt

Use this file to discover all available pages before exploring further.

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 l’annulation et les délais d’attente

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.Create(ctx, dodopayments.PaymentCreateParams{
	Amount:     5000,
	Currency:   "USD",
	CustomerID: "cus_123",
})
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("prod_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 : 
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 Country à deux lettres. Customer est un CustomerRequestUnionParam — passez AttachExistingCustomerParam{CustomerID: ...} pour un client existant ou NewCustomerParam{Email: ..., Name: ...} pour un nouveau. ProductPrice est dans la plus petite dénomination monétaire.

​
Facturation basée sur l’utilisation

​
Ingestions des événements d’utilisation

Suivre les événements personnalisés : 
import "github.com/dodopayments/dodopayments-go"

response, err := client.UsageEvents.Ingest(ctx, dodopayments.UsageEventIngestParams{
	Events: dodopayments.F([]dodopayments.UsageEventIngestParamsEvent{{
		EventID:    dodopayments.F("api_call_12345"),
		CustomerID: dodopayments.F("cus_abc123"),
		EventName:  dodopayments.F("api_request"),
		Timestamp:  dodopayments.F("2024-01-15T10:30:00Z"),
		Metadata: dodopayments.F(map[string]string{
			"endpoint":     "/api/v1/users",
			"method":       "GET",
			"tokens_used":  "150",
		}),
	}}),
})
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.Data {
	fmt.Printf("Event %s: %s at %s\n", event.EventID, event.EventName, event.Timestamp)
}

​
Gestion des erreurs

Gérer des types d’erreurs spécifiques : 
payment, err := client.Payments.Create(ctx, dodopayments.PaymentCreateParams{
	Amount:   5000,
	Currency: "USD",
})
if err != nil {
	if apiErr, ok := err.(*dodopayments.APIError); ok {
		fmt.Printf("API Error: %s\n", apiErr.Message)
		fmt.Printf("Status Code: %d\n", apiErr.StatusCode)
		fmt.Printf("Request ID: %s\n", apiErr.RequestID)
		
		// Handle specific error types
		switch apiErr.Type {
		case dodopayments.ErrorTypeAuthentication:
			log.Println("Authentication failed")
		case dodopayments.ErrorTypeInvalidRequest:
			log.Println("Invalid request parameters")
		case dodopayments.ErrorTypeRateLimit:
			log.Println("Rate limit exceeded")
		default:
			log.Printf("API error: %s\n", apiErr.Message)
		}
	} else {
		log.Fatal(err)
	}
}

​
Middleware

Ajouter 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 est sûr pour une utilisation 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.Create(context.Background(), dodopayments.PaymentCreateParams{
				Amount:     1000,
				Currency:   "USD",
				CustomerID: "cus_123",
			})
			if err != nil {
				log.Printf("Failed to create payment %d: %v", idx, err)
				return
			}
			
			log.Printf("Created payment %d: %s", idx, payment.ID)
		}(i)
	}
	
	wg.Wait()
}

​
Ressources

GitHub Repository

Voir le code source et contribuer

API Reference

Documentation complète de l’API

Discord Community

Obtenir de l’aide et se connecter avec les développeurs

Report Issues

Signaler des bugs ou demander des fonctionnalités

​
Support

Besoin d’aide avec le SDK Go ?

​
Contribuer

Nous accueillons les contributions ! Consultez les directives de contribution pour commencer.
Last modified on May 14, 2026