> ## 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.

# Go

> अपने Go अनुप्रयोगों में Dodo Payments को एक आदर्श, प्रदर्शनकारी SDK के साथ एकीकृत करें

Go SDK आपके अनुप्रयोगों में Dodo Payments को एकीकृत करने के लिए एक साफ और आदर्श Go इंटरफेस प्रदान करता है। यह संदर्भ समर्थन, मजबूत प्रकार की प्रतिक्रियाएँ, मध्यवर्ती क्षमताएँ प्रदान करता है, और समवर्ती उपयोग के लिए सुरक्षित है।

## स्थापना

SDK को Go मॉड्यूल का उपयोग करके स्थापित करें:

```bash theme={null}
go get github.com/dodopayments/dodopayments-go
```

या किसी विशेष संस्करण पर पिन करने के लिए:

```bash theme={null}
go get -u 'github.com/dodopayments/dodopayments-go@v1.97.3'
```

<Info>
  SDK को बेहतर प्रदर्शन के लिए आधुनिक Go सुविधाओं का उपयोग करते हुए Go 1.22 या उसके बाद के संस्करणों की आवश्यकता होती है।
</Info>

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

क्लाइंट को प्रारंभ करें और अपना पहला चेकआउट सत्र बनाएं:

```go theme={null}
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)
}
```

<Warning>
  अपने API कुंजियों को हमेशा पर्यावरण चर का उपयोग करके सुरक्षित रूप से स्टोर करें। इन्हें कभी भी अपने स्रोत कोड में हार्डकोड न करें।
</Warning>

## मुख्य विशेषताएँ

<CardGroup cols={2}>
  <Card title="Context Support" icon="clock">
    रद्दीकरण और समय-सीमाओं के लिए context.Context का पूर्ण समर्थन
  </Card>

  <Card title="Strong Typing" icon="shield-check">
    संकलन-समय सुरक्षा के लिए दृढ़ रूप से टाइप किए गए अनुरोध और प्रतिक्रियाएँ
  </Card>

  <Card title="Middleware" icon="layer-group">
    लॉगिंग, मीट्रिक और कस्टम लॉजिक के लिए विस्तार योग्य मिडलवेयर समर्थन
  </Card>

  <Card title="Goroutine Safe" icon="bolt">
    सम्मिलित (Concurrent) संचालन के लिए डिज़ाइन किया गया थ्रेड-सुरक्षित क्लाइंट
  </Card>
</CardGroup>

## कॉन्फ़िगरेशन

### संदर्भ और समय सीमा

समय सीमा और रद्दीकरण के लिए Go के संदर्भ का लाभ उठाएं:

```go theme={null}
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)
	}
}
```

### पुनः प्रयास कॉन्फ़िगरेशन

स्वचालित पुनः प्रयास व्यवहार को कॉन्फ़िगर करें:

```go theme={null}
// 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),
)
```

## सामान्य संचालन

### चेकआउट सत्र बनाएं

एक चेकआउट सत्र उत्पन्न करें:

```go theme={null}
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)
```

### ग्राहकों का प्रबंधन करें

ग्राहक जानकारी बनाएं और पुनः प्राप्त करें:

```go theme={null}
// 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)
```

### सदस्यताओं को संभालें

आवर्ती सदस्यताओं को बनाएं और प्रबंधित करें:

```go theme={null}
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)
}
```

<Info>
  `Billing` को कम से कम दो-अक्षरों वाला ISO `Country` कोड चाहिए। `Customer` एक `CustomerRequestUnionParam` है — एक मौजूदा ग्राहक के लिए `AttachExistingCustomerParam{CustomerID: ...}` पास करें या एक नए के लिए `NewCustomerParam{Email: ..., Name: ...}`। `ProductPrice` सबसे कम मुद्रा मूल्यवर्ग में है।
</Info>

## उपयोग-आधारित बिलिंग

### उपयोग इवेंट्स इन्गेस्ट करें

कस्टम इवेंट्स को ट्रैक करें:

```go theme={null}
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)
}
```

### उपयोग इवेंट्स सूचीबद्ध करें

```go theme={null}
// 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)
}
```

## त्रुटि हैंडलिंग

जब API एक गैर-सफलता स्थिति कोड लौटाता है, तो SDK एक प्रकार की त्रुटि लौटाता है
`*dodopayments.Error`। यह `StatusCode`, अंतर्निहित `*http.Request` और
`*http.Response`, और त्रुटि बॉडी के JSON को उजागर करता है। इसे जाँचने के लिए `errors.As` पैटर्न का उपयोग करें और विशिष्ट मामलों को संभालने के लिए `StatusCode` पर शाखा करें:

```go theme={null}
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)
	}
}
```

## मिडलवेयर

लॉगिंग या मेट्रिक्स के लिए कस्टम मिडलवेयर जोड़ें:

```go theme={null}
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),
)
```

## सहकालिता

क्लाइंट सहकारी उपयोग के लिए सुरक्षित है:

```go theme={null}
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()
}
```

## संसाधन

<CardGroup cols={2}>
  <Card title="GitHub Repository" icon="github" href="https://github.com/dodopayments/dodopayments-go">
    स्रोत कोड देखें और योगदान करें
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    पूर्ण एपीआई प्रलेखन
  </Card>

  <Card title="Discord Community" icon="discord" href="https://discord.gg/bYqAp4ayYh">
    सहायता प्राप्त करें और डेवलपर्स से कनेक्ट करें
  </Card>

  <Card title="Report Issues" icon="bug" href="https://github.com/dodopayments/dodopayments-go/issues">
    बग रिपोर्ट करें या सुविधाओं का अनुरोध करें
  </Card>
</CardGroup>

## समर्थन

Go SDK के लिए सहायता चाहिए?

* **Discord**: वास्तविक समय समर्थन के लिए हमारे [समुदाय सर्वर](https://discord.gg/bYqAp4ayYh) से जुड़ें
* **ईमेल**: हमसे संपर्क करें [support@dodopayments.com](mailto:support@dodopayments.com) पर
* **GitHub**: [रिपॉजिटरी](https://github.com/dodopayments/dodopayments-go) पर एक मुद्दा खोलें

## योगदान

हम योगदान का स्वागत करते हैं! शुरू करने के लिए [योगदान दिशानिर्देश](https://github.com/dodopayments/dodopayments-go/blob/main/CONTRIBUTING.md) देखें।