जावा

Java SDK, Java applications को Dodo Payments REST API का typed access देता है। इसमें हर जगह Java types का उपयोग होता है: Optional उन fields के लिए जो अनुपस्थित हो सकते हैं, Stream results को iterate करने के लिए, और CompletableFuture asynchronous calls के लिए।

स्थापना

मावेन

अपने pom.xml में निर्भरता जोड़ें:

pom.xml

<dependency>
  <groupId>com.dodopayments.api</groupId>
  <artifactId>dodo-payments-java</artifactId>
  <version>1.118.0</version>
</dependency>

ग्रेडल

अपने build.gradle.kts में dependency जोड़ें:

build.gradle.kts

implementation("com.dodopayments.api:dodo-payments-java:1.118.0")

SDK releases API changes के लिए support जोड़ते हैं। सबसे recent version खोजने के लिए Maven Central देखें।

SDK के लिए Java 8 या उसके बाद का version आवश्यक है, इसलिए यह Java 11, 17 और 21 पर भी चलता है।

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

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

import com.dodopayments.api.client.DodoPaymentsClient;
import com.dodopayments.api.client.okhttp.DodoPaymentsOkHttpClient;
import com.dodopayments.api.models.checkoutsessions.CheckoutSessionRequest;
import com.dodopayments.api.models.checkoutsessions.CheckoutSessionResponse;
import com.dodopayments.api.models.checkoutsessions.ProductItemReq;

// Configure using environment variables (DODO_PAYMENTS_API_KEY, DODO_PAYMENTS_WEBHOOK_KEY, DODO_PAYMENTS_BASE_URL)
// Or system properties (dodopayments.apiKey, dodopayments.webhookKey, dodopayments.baseUrl)
DodoPaymentsClient client = DodoPaymentsOkHttpClient.fromEnv();

CheckoutSessionRequest params = CheckoutSessionRequest.builder()
    .addProductCart(ProductItemReq.builder()
        .productId("pdt_123")
        .quantity(1)
        .build())
    .build();
    
CheckoutSessionResponse checkoutSessionResponse = client.checkoutSessions().create(params);
System.out.println(checkoutSessionResponse.sessionId());

fromEnv(), live mode से connect करता है, जब तक DODO_PAYMENTS_BASE_URL या dodopayments.baseUrl कुछ और न कहे। test mode का उपयोग करने के लिए Test Mode देखें। test mode API key केवल test mode में काम करती है।

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

मुख्य सुविधाएं

Type Safety

compile-time checks के लिए typed request और response classes।

Shared Client

एक client बनाएं और उसे सभी requests में reuse करें: इसमें connection और thread pools होते हैं। Request और response objects immutable होते हैं।

Builder Pattern

हर request class में एक builder होता है, और toBuilder() एक modified copy बनाता है।

Async Support

client.async() ऐसा client लौटाता है जिसकी methods CompletableFuture लौटाती हैं।

Configuration

Environment Variables

fromEnv() इन environment variables या matching system properties को पढ़ता है। System properties को प्राथमिकता मिलती है:

.env

DODO_PAYMENTS_API_KEY=your_api_key_here
DODO_PAYMENTS_BASE_URL=https://live.dodopayments.com

// Automatically reads from environment variables
DodoPaymentsClient client = DodoPaymentsOkHttpClient.fromEnv();

API key DODO_PAYMENTS_API_KEY या dodopayments.apiKey से आती है। Webhook signing secret DODO_PAYMENTS_WEBHOOK_KEY या dodopayments.webhookKey से, और base URL DODO_PAYMENTS_BASE_URL या dodopayments.baseUrl से आता है। एक client बनाएं और उसे reuse करें, क्योंकि हर client का अपना connection pool और thread pools होता है। Webhook verify करने के लिए raw request body और headers को client.webhooks().unwrap(UnwrapWebhookParams.builder().body(rawBody).headers(headers).build()) में pass करें, जहां headers एक com.dodopayments.api.core.http.Headers है। यह आपके webhook key से signature check करता है और parsed event लौटाता है, या DodoPaymentsWebhookException throw करता है। Headers के बिना, unwrap signature verify नहीं करता। client.webhooks().unsafeUnwrap(rawBody) body को verify किए बिना parse करता है, इसलिए इसका उपयोग केवल testing के लिए करें। Webhooks देखें।

Manual Configuration

Builder पर हर option set करें:

import java.time.Duration;

DodoPaymentsClient client = DodoPaymentsOkHttpClient.builder()
    .bearerToken("your_api_key_here")
    .baseUrl("https://live.dodopayments.com")
    .maxRetries(4)
    .timeout(Duration.ofSeconds(30))
    .responseValidation(true)
    .build();

By default, client दो बार retry करता है और 1 minute के बाद timeout हो जाता है। यह connection errors और 408, 409, 429 या 500 और उससे ऊपर के status वाली responses को retry करता है। किसी एक call के लिए timeout override करने हेतु, method के दूसरे argument के रूप में RequestOptions.builder().timeout(Duration.ofSeconds(30)).build() pass करें। responseValidation(true) पहले से check करता है कि पूरी response expected types से match करती है। इसके बिना, SDK DodoPaymentsInvalidDataException केवल तब throw करता है जब आप unexpected type वाली property पढ़ते हैं।

Test Mode

test mode (https://test.dodopayments.com) का उपयोग करने के लिए builder पर testMode() call करें:

DodoPaymentsClient testClient = DodoPaymentsOkHttpClient.builder()
    .fromEnv()
    .testMode()
    .build();

सामान्य Operations

इस section के examples Quick Start से client का उपयोग करते हैं।

Checkout Session बनाएं

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

CheckoutSessionRequest params = CheckoutSessionRequest.builder()
    .addProductCart(ProductItemReq.builder()
        .productId("pdt_123")
        .quantity(1)
        .build())
    .returnUrl("https://yourdomain.com/return")
    .build();

CheckoutSessionResponse session = client.checkoutSessions().create(params);
System.out.println("Checkout URL: " + session.checkoutUrl().orElse(""));

checkoutUrl() एक Optional<String> लौटाता है। हर checkout URL केवल एक बार काम करता है और 24 hours के बाद expire हो जाता है। हर session option के लिए Checkout Sessions देखें।

Customers manage करें

email address, name और metadata के साथ customer बनाएं, फिर उसे ID से retrieve करें:

import com.dodopayments.api.core.JsonValue;
import com.dodopayments.api.models.customers.Customer;
import com.dodopayments.api.models.customers.CustomerCreateParams;
import com.dodopayments.api.models.misc.Metadata;

// Create a customer
CustomerCreateParams createParams = CustomerCreateParams.builder()
    .email("customer@example.com")
    .name("John Doe")
    .metadata(Metadata.builder()
        .putAdditionalProperty("user_id", JsonValue.from("12345"))
        .build())
    .build();

Customer customer = client.customers().create(createParams);

// Retrieve customer
Customer retrieved = client.customers().retrieve("cus_123");
System.out.println("Customer: " + retrieved.name() + " (" + retrieved.email() + ")");

Subscriptions handle करें

payment link के साथ subscription बनाएं, फिर यदि यह on-demand subscription है तो उसे charge करें।

POST /subscriptions (SDK का subscriptions().create() method) deprecated है। यह existing integrations के लिए अभी भी काम करता है, लेकिन नई integrations को subscriptions बनाने के लिए Checkout Session का उपयोग करना चाहिए।

import com.dodopayments.api.models.payments.AttachExistingCustomer;
import com.dodopayments.api.models.payments.BillingAddress;
import com.dodopayments.api.models.misc.CountryCode;
import com.dodopayments.api.models.subscriptions.SubscriptionChargeParams;
import com.dodopayments.api.models.subscriptions.SubscriptionChargeResponse;
import com.dodopayments.api.models.subscriptions.SubscriptionCreateParams;
import com.dodopayments.api.models.subscriptions.SubscriptionCreateResponse;

// Create a subscription
SubscriptionCreateParams subscriptionParams = SubscriptionCreateParams.builder()
    .billing(BillingAddress.builder()
        .city("San Francisco")
        .country(CountryCode.US)
        .state("CA")
        .street("1 Market St")
        .zipcode("94105")
        .build())
    .customer(AttachExistingCustomer.builder()
        .customerId("cus_123")
        .build())
    .productId("pdt_456")
    .quantity(1)
    .paymentLink(true)
    .returnUrl("https://yourdomain.com/return")
    .build();

SubscriptionCreateResponse subscription = client.subscriptions().create(subscriptionParams);
System.out.println("Subscription ID: " + subscription.subscriptionId());

// Charge an on-demand subscription
// product_price is in the lowest currency denomination (e.g., 2500 = $25.00 USD)
SubscriptionChargeParams chargeParams = SubscriptionChargeParams.builder()
    .subscriptionId(subscription.subscriptionId())
    .productPrice(2500)
    .build();

SubscriptionChargeResponse chargeResponse = client.subscriptions().charge(chargeParams);
System.out.println("Payment ID: " + chargeResponse.paymentId());

productPrice सबसे छोटी currency unit में होता है, जैसे USD के लिए cents या INR के लिए paise। $25.00 charge करने के लिए 2500 pass करें।

subscriptions().charge(...) on-demand subscriptions के लिए है। Dodo Payments अन्य subscriptions को product के billing schedule के अनुसार automatically bill करता है।

Usage-Based Billing

Meters configure करें

एक meter बनाएं जो events को count करे, फिर अपने meters की list बनाएं। autoPager() हर meter पर iterate करता है और आवश्यकता के अनुसार अधिक pages fetch करता है:

import com.dodopayments.api.models.meters.*;

// Create API calls meter
MeterCreateParams apiMeterParams = MeterCreateParams.builder()
    .name("API Requests")
    .eventName("api_request")
    .aggregation(MeterAggregation.builder()
        .type(MeterAggregation.Type.COUNT)
        .build())
    .measurementUnit("calls")
    .build();

Meter apiMeter = client.meters().create(apiMeterParams);
System.out.println("Meter created: " + apiMeter.id());

// List all meters
client.meters().list()
    .autoPager()
    .forEach(m -> System.out.println("Meter: " + m.name() + " - " + m.aggregation()));

Usage Events ingest करें

किसी customer के लिए usage event भेजें। Event metadata values JsonValue objects होते हैं:

import com.dodopayments.api.core.JsonValue;
import com.dodopayments.api.models.usageevents.EventInput;
import com.dodopayments.api.models.usageevents.*;
import java.time.OffsetDateTime;

// Ingest single event
UsageEventIngestParams singleEventParams = UsageEventIngestParams.builder()
    .addEvent(EventInput.builder()
        .eventId("api_call_" + System.currentTimeMillis())
        .customerId("cus_abc123")
        .eventName("api_request")
        .timestamp(OffsetDateTime.now())
        .metadata(EventInput.Metadata.builder()
            .putAdditionalProperty("endpoint", JsonValue.from("/api/v1/users"))
            .putAdditionalProperty("method", JsonValue.from("GET"))
            .putAdditionalProperty("tokens_used", JsonValue.from("150"))
            .build())
        .build())
    .build();

UsageEventIngestResponse response = client.usageEvents().ingest(singleEventParams);
System.out.println("Processed: " + response.ingestedCount());

eventId idempotency key है, इसलिए हर event को unique value दें। 1 hour से अधिक पुराना या 5 minutes से अधिक future का timestamp reject कर दिया जाता है।

Events को batch में ingest करें

एक request में अधिकतम 1,000 events भेजें। यह example पिछले example के imports का उपयोग करता है:

UsageEventIngestParams.Builder batchBuilder = UsageEventIngestParams.builder();

for (int i = 0; i < 100; i++) {
    batchBuilder.addEvent(EventInput.builder()
        .eventId("batch_event_" + i + "_" + System.currentTimeMillis())
        .customerId("cus_abc123")
        .eventName("video_transcode")
        .timestamp(OffsetDateTime.now().minusSeconds(i))
        .metadata(EventInput.Metadata.builder()
            .putAdditionalProperty("video_id", JsonValue.from("video_" + i))
            .putAdditionalProperty("duration_seconds", JsonValue.from(String.valueOf(120 + i)))
            .build())
        .build());
}

UsageEventIngestResponse batchResponse = client.usageEvents().ingest(batchBuilder.build());
System.out.println("Batch processed: " + batchResponse.ingestedCount() + " events");

Error Handling

SDK unchecked exceptions throw करता है। Error status के लिए यह DodoPaymentsServiceException की subclass throw करता है, जिसमें statusCode(), headers() और body() होते हैं। Base class से पहले उन specific classes को catch करें जिन्हें आप handle करना चाहते हैं:

import com.dodopayments.api.errors.*;
import com.dodopayments.api.models.payments.Payment;

try {
    Payment payment = client.payments().retrieve("pay_invalid");
} catch (NotFoundException e) {
    System.err.println("Payment not found: " + e.getMessage());
} catch (UnauthorizedException e) {
    System.err.println("Authentication failed: " + e.getMessage());
} catch (PermissionDeniedException e) {
    System.err.println("Permission denied: " + e.getMessage());
} catch (BadRequestException e) {
    System.err.println("Invalid request: " + e.getMessage());
} catch (UnprocessableEntityException e) {
    System.err.println("Validation error: " + e.getMessage());
} catch (RateLimitException e) {
    System.err.println("Rate limit exceeded: " + e.getMessage());
    // Thrown after the SDK's automatic retries are used up
} catch (InternalServerException e) {
    System.err.println("Server error: " + e.getMessage());
} catch (DodoPaymentsServiceException e) {
    System.err.println("API error: " + e.statusCode() + " - " + e.getMessage());
}

जिन statuses की अपनी class नहीं होती, जैसे 409, वे UnexpectedStatusCodeException throw करते हैं। Network failures DodoPaymentsIoException throw करते हैं, और जिन responses को SDK interpret नहीं कर पाता वे DodoPaymentsInvalidDataException throw करती हैं। ये सभी DodoPaymentsException को extend करते हैं।

SDK connection errors और 408, 409, 429 या 500 और उससे ऊपर के status वाली responses को default रूप से दो बार exponential backoff के साथ retry करता है।

Async Operations

Asynchronous client प्राप्त करने के लिए client पर async() call करें। इसकी methods CompletableFuture लौटाती हैं:

import java.util.concurrent.CompletableFuture;

CompletableFuture<CheckoutSessionResponse> future = client.async()
    .checkoutSessions()
    .create(params);

// Handle response asynchronously
future.thenAccept(response -> {
    System.out.println("Session created: " + response.sessionId());
}).exceptionally(ex -> {
    System.err.println("Error: " + ex.getMessage());
    return null;
});

शुरुआत से asynchronous client बनाने के लिए DodoPaymentsOkHttpClientAsync.fromEnv() का उपयोग करें।

Spring Boot Integration

Configuration Class

एक client को bean के रूप में register करें और property से environment चुनें:

import com.dodopayments.api.client.DodoPaymentsClient;
import com.dodopayments.api.client.okhttp.DodoPaymentsOkHttpClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class DodoPaymentsConfig {
    
    @Value("${dodo.api.key}")
    private String apiKey;
    
    @Value("${dodo.environment:test}")
    private String environment;
    
    @Bean
    public DodoPaymentsClient dodoPayments() {
        return DodoPaymentsOkHttpClient.builder()
            .bearerToken(apiKey)
            .baseUrl(environment.equals("live") 
                ? "https://live.dodopayments.com" 
                : "https://test.dodopayments.com")
            .build();
    }
}

Service Layer

Client को service में inject करें:

import com.dodopayments.api.client.DodoPaymentsClient;
import com.dodopayments.api.models.checkoutsessions.*;
import java.util.List;
import org.springframework.stereotype.Service;

@Service
public class PaymentService {
    
    private final DodoPaymentsClient client;
    
    public PaymentService(DodoPaymentsClient client) {
        this.client = client;
    }
    
    public CheckoutSessionResponse createCheckout(List<ProductItemReq> items) {
        CheckoutSessionRequest params = CheckoutSessionRequest.builder()
            .productCart(items)
            .returnUrl("https://yourdomain.com/return")
            .build();
            
        return client.checkoutSessions().create(params);
    }
}

Resources

GitHub Repository

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

API Reference

हर endpoint, parameter और response।

Discord Community

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

Report Issues

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

Support

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

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

Contributing

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

Getting Started

Features

Integrate

Merchant of Record

Miscellaneous

स्थापना

मावेन

ग्रेडल

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

मुख्य सुविधाएं

Type Safety

Shared Client

Builder Pattern

Async Support

Configuration

Environment Variables

Manual Configuration

Test Mode

सामान्य Operations

Checkout Session बनाएं

Customers manage करें

Subscriptions handle करें

Usage-Based Billing

Meters configure करें

Usage Events ingest करें

Events को batch में ingest करें

Error Handling

Async Operations

Spring Boot Integration

Configuration Class

Service Layer

Resources

GitHub Repository

API Reference

Discord Community

Report Issues

Support

Contributing

​स्थापना

​मावेन

​ग्रेडल

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

​मुख्य सुविधाएं

Type Safety

Shared Client

Builder Pattern

Async Support

​Configuration

​Environment Variables

​Manual Configuration

​Test Mode

​सामान्य Operations

​Checkout Session बनाएं

​Customers manage करें

​Subscriptions handle करें

​Usage-Based Billing

​Meters configure करें

​Usage Events ingest करें

​Events को batch में ingest करें

​Error Handling

​Async Operations

​Spring Boot Integration

​Configuration Class

​Service Layer

​Resources

GitHub Repository

API Reference

Discord Community

Report Issues

​Support

​Contributing

स्थापना

मावेन

ग्रेडल

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

मुख्य सुविधाएं

Configuration

Environment Variables

Manual Configuration

Test Mode

सामान्य Operations

Checkout Session बनाएं

Customers manage करें

Subscriptions handle करें

Usage-Based Billing

Meters configure करें

Usage Events ingest करें

Events को batch में ingest करें

Error Handling

Async Operations

Spring Boot Integration

Configuration Class

Service Layer

Resources

Support

Contributing