Go - Dodo Payments Documentation

Go SDK, Go applications को Dodo Payments REST API का typed access देता है। हर method एक context.Context लेता है, request parameters एक Field wrapper का उपयोग करते हैं, जो zero values को omitted fields से अलग करता है, और आप हर request में middleware जोड़ सकते हैं।

स्थापना

अपने project में module जोड़ें:

go get github.com/dodopayments/dodopayments-go

किसी specific version को pin करने के लिए:

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

SDK के लिए Go 1.22 या बाद का version आवश्यक है।

त्वरित प्रारंभ

एक client बनाएँ, फिर एक checkout session बनाएँ:

package main

import (
	"context"
	"fmt"
	"os"

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

func main() {
	client := dodopayments.NewClient(
		option.WithBearerToken(os.Getenv("DODO_PAYMENTS_API_KEY")), // This is the default and can be omitted
		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("pdt_123"),
				Quantity:  dodopayments.F(int64(1)),
			}}),
		},
	})
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("Session ID: %s\n", checkoutSessionResponse.SessionID)
}

यदि आप option.WithBearerToken को छोड़ देते हैं, तो NewClient, DODO_PAYMENTS_API_KEY environment variable को पढ़ता है। यदि आप option.WithEnvironmentTestMode() को छोड़ देते हैं, तो client live mode से connect होता है। Test mode API key केवल test mode में काम करती है।

API keys को environment variables या secrets manager में रखें। उन्हें अपने source code में कभी hardcode न करें।

Core Features

Context Support

हर method cancellation और timeouts के लिए एक context.Context लेता है।

Strong Typing

Compile-time checks के लिए typed request parameters और response structs।

Middleware

Logging, metrics और custom logic के लिए option.WithMiddleware के साथ middleware जोड़ें।

Goroutine Safe

Goroutines के बीच एक client share करें।

Configuration

NewClient environment से DODO_PAYMENTS_API_KEY, DODO_PAYMENTS_WEBHOOK_KEY (आपका webhook signing secret) और DODO_PAYMENTS_BASE_URL पढ़ता है। आपके द्वारा pass किए गए options, जैसे option.WithBearerToken, option.WithWebhookKey और option.WithBaseURL, इन values को override करते हैं। Webhook को verify करने के लिए raw request body और headers को client.Webhooks.Unwrap(rawBody, r.Header) में pass करें। यह आपके webhook key के साथ signature को check करता है और parsed event लौटाता है। client.Webhooks.UnsafeUnwrap(rawBody) body को verify किए बिना parse करता है, इसलिए इसका उपयोग केवल testing के लिए करें। Webhooks देखें। इस page के examples client का उपयोग करते हैं, जो Quick Start से है।

Context और Timeouts

Requests का default रूप से timeout नहीं होता। Context deadline retries सहित पूरे call को limit करती है। प्रत्येक attempt को limit करने के लिए option.WithRequestTimeout() जोड़ें:

import (
	"context"
	"log"
	"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()

// Note: POST /payments is deprecated — prefer checkout sessions for new
// integrations. Shown here only to illustrate context handling.
_, 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)),
	}}),
}, option.WithRequestTimeout(5*time.Second)) // Per-attempt timeout
if err != nil {
	if ctx.Err() == context.DeadlineExceeded {
		log.Println("Request timed out")
	} else {
		log.Fatal(err)
	}
}

Retry Configuration

SDK connection errors और 408, 409, 429 या 500 और उससे अधिक status वाले responses को retry करता है। यह default रूप से exponential backoff के साथ दो बार retry करता है। Client या किसी single request पर option.WithMaxRetries set करें:

// 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("pdt_123"),
				Quantity:  dodopayments.F(int64(1)),
			}}),
		},
	},
	option.WithMaxRetries(5),
)

Common Operations

इस section के examples भी एक context का उपयोग करते हैं, जैसे ctx := context.Background()।

Create a Checkout Session

एक checkout session बनाएँ, फिर customer को लौटाए गए CheckoutURL पर redirect करें:

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)

प्रत्येक checkout URL एक बार काम करता है और 24 घंटे बाद expire हो जाता है। प्रत्येक session option के लिए Checkout Sessions देखें।

Manage Customers

एक email address और name के साथ customer बनाएँ, फिर उसे ID से retrieve करें। Metadata values shared package के union types का उपयोग करती हैं:

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

// 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(dodopayments.MetadataParam{
		"user_id": shared.UnionString("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)

Handle Subscriptions

एक subscription बनाएँ, on-demand subscription को charge करें और subscription का usage history पढ़ें।

POST /subscriptions (SDK का Subscriptions.New method) deprecated है। यह मौजूदा integrations के लिए अभी भी काम करता है, लेकिन नए integrations को Checkout Session के माध्यम से subscriptions बनानी चाहिए।

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)
}
fmt.Printf("Payment ID: %s\n", chargeResponse.PaymentID)

// 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)
}
fmt.Printf("Usage periods on this page: %d\n", len(usageHistory.Items))

Billing के लिए केवल Country आवश्यक है, जो two-letter ISO country code है। Customer एक CustomerRequestUnionParam है: मौजूदा customer के लिए AttachExistingCustomerParam{CustomerID: ...} या नया customer बनाने के लिए NewCustomerParam{Email: ..., Name: ...} pass करें। Charge on-demand subscriptions के लिए है, और ProductPrice सबसे छोटी currency unit में है। GetUsageHistory results का एक page लौटाता है; GetUsageHistoryAutoPaging हर page पर iterate करता है।

Usage-Based Billing

Ingest Usage Events

किसी customer के लिए usage events भेजें:

import (
	"time"

	"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.Now()),
	}}),
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Ingested %d events\n", response.IngestedCount)

EventID idempotency key है, इसलिए प्रत्येक event को unique value दें। यदि एक ही request में समान EventID दो बार दिखाई देता है, तो पूरी request reject कर दी जाती है। यदि कोई EventID पहले ही ingest किया जा चुका है, तो नया event ignore कर दिया जाता है। एक request में अधिकतम 1,000 events स्वीकार किए जाते हैं। Timestamp default रूप से current time पर set होता है और यदि यह 1 घंटे से अधिक past या 5 मिनट से अधिक future में हो, तो reject कर दिया जाता है।

List Usage Events

Customer और event name से filtered events की list बनाएँ:

// 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)
}

List एक page लौटाता है। हर page पर iterate करने के लिए client.UsageEvents.ListAutoPaging(ctx, params) call करें और iter.Next(), iter.Current() और iter.Err() के साथ loop चलाएँ। अन्य list methods में भी यही AutoPaging variant होता है, और प्रत्येक page में एक GetNextPage() method होता है।

Error Handling

जब API non-success status code लौटाता है, तो SDK *dodopayments.Error type की error लौटाता है। इसमें StatusCode, *http.Request और *http.Response, तथा error body का JSON होता है। इसका निरीक्षण करने के लिए errors.As का उपयोग करें और specific cases handle करने के लिए StatusCode पर branch करें:

// Note: POST /payments is deprecated — prefer checkout sessions for new
// integrations. Shown here only to illustrate error handling.
_, 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)
	}
}

अन्य errors unwrapped लौटाई जाती हैं। उदाहरण के लिए, यदि HTTP transport fail हो जाता है, तो आपको एक *url.Error मिल सकता है जो एक *net.OpError को wrap करता है। apiErr.DumpRequest(true) serialized request लौटाता है।

Middleware

option.WithMiddleware के साथ middleware जोड़ें। Middleware प्रत्येक request और एक next function प्राप्त करता है जो उसे भेजता है:

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 (res is nil when err is not nil)
	if err != nil {
		log.Printf("Request failed after %v: %v\n", time.Since(start), err)
		return res, err
	}
	log.Printf("Response: %d in %v\n", res.StatusCode, time.Since(start))

	return res, err
}

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

एक option.WithMiddleware call में कई middleware बाएँ से दाएँ run होते हैं। NewClient को pass किए गए middleware, single request को pass किए गए middleware से पहले run होते हैं।

Concurrency

Client concurrent use के लिए safe है, इसलिए आप एक client को कई goroutines के बीच share कर सकते हैं:

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()
			
			// Note: POST /payments is deprecated — prefer checkout sessions
			// for new integrations. Shown here only to illustrate concurrency.
			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()
}

Resources

GitHub Repository

Source code, releases और पूरी method list।

API Reference

प्रत्येक endpoint, parameter और response।

Discord Community

प्रश्न पूछें और अन्य developers के साथ बातचीत करें।

Report Issues

Bugs report करें या features का अनुरोध करें।

Support

Go SDK के लिए सहायता प्राप्त करने हेतु:

Discord: Real-time सहायता के लिए community server से जुड़ें।
Email: support@dodopayments.com पर संपर्क करें।
GitHub: repository पर issue खोलें।

Contributing

योगदान देने के लिए contributing guidelines पढ़ें।

Getting Started

Features

Integrate

Merchant of Record

Miscellaneous

Go

स्थापना

त्वरित प्रारंभ

Core Features

Context Support

Strong Typing

Middleware

Goroutine Safe

Configuration

Context और Timeouts

Retry Configuration

Common Operations

Create a Checkout Session

Manage Customers

Handle Subscriptions

Usage-Based Billing

Ingest Usage Events

List Usage Events

Error Handling

Middleware

Concurrency

Resources

GitHub Repository

API Reference

Discord Community

Report Issues

Support

Contributing

​स्थापना

​त्वरित प्रारंभ

​Core Features

Context Support

Strong Typing

Middleware

Goroutine Safe

​Configuration

​Context और Timeouts

​Retry Configuration

​Common Operations

​Create a Checkout Session

​Manage Customers

​Handle Subscriptions

​Usage-Based Billing

​Ingest Usage Events

​List Usage Events

​Error Handling

​Middleware

​Concurrency

​Resources

GitHub Repository

API Reference

Discord Community

Report Issues

​Support

​Contributing

स्थापना

त्वरित प्रारंभ

Core Features

Configuration

Context और Timeouts

Retry Configuration

Common Operations

Create a Checkout Session

Manage Customers

Handle Subscriptions

Usage-Based Billing

Ingest Usage Events

List Usage Events

Error Handling

Middleware

Concurrency

Resources

Support

Contributing