Razorpay is a popular payment gateway in India that supports UPI, net banking, credit/debit cards, wallets, and more. This guide covers complete integration with Java/Spring Boot.
1. Project Setup and Dependencies
Maven Dependencies (pom.xml)
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>razorpay-java-integration</artifactId>
<version>1.0.0</version>
<properties>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<spring.boot.version>2.7.14</spring.boot.version>
<razorpay.version>2.8.1</razorpay.version>
<jackson.version>2.15.2</jackson.version>
</properties>
<dependencies>
<!-- Spring Boot -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>${spring.boot.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
<version>${spring.boot.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
<version>${spring.boot.version}</version>
</dependency>
<!-- Razorpay Java SDK -->
<dependency>
<groupId>com.razorpay</groupId>
<artifactId>razorpay-java</artifactId>
<version>${razorpay.version}</version>
</dependency>
<!-- JSON Processing -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>${jackson.version}</version>
</dependency>
<!-- Database -->
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<!-- Lombok (Optional) -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<!-- Security -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
<version>${spring.boot.version}</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring.boot.version}</version>
</plugin>
</plugins>
</build>
</project>
2. Configuration Classes
Application Properties (application.yml)
# Razorpay Configuration
razorpay:
key-id: ${RAZORPAY_KEY_ID:rzp_test_xxxxxxxxxxxx}
key-secret: ${RAZORPAY_KEY_SECRET:}
webhook-secret: ${RAZORPAY_WEBHOOK_SECRET:}
timeout: 30000
max-retries: 3
# Server Configuration
server:
port: 8080
servlet:
context-path: /api
# Database
spring:
datasource:
url: jdbc:h2:mem:testdb
driverClassName: org.h2.Driver
username: sa
password:
jpa:
database-platform: org.hibernate.dialect.H2Dialect
hibernate:
ddl-auto: create-drop
show-sql: true
h2:
console:
enabled: true
path: /h2-console
# Logging
logging:
level:
com.razorpay: DEBUG
com.example.razorpay: DEBUG
Razorpay Configuration Class
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Data
@Component
@ConfigurationProperties(prefix = "razorpay")
public class RazorpayConfig {
private String keyId;
private String keySecret;
private String webhookSecret;
private int timeout = 30000;
private int maxRetries = 3;
}
3. Database Entities
Payment Entity
import lombok.Data;
import javax.persistence.*;
import java.math.BigDecimal;
import java.time.LocalDateTime;
@Entity
@Table(name = "payments")
@Data
public class Payment {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "razorpay_order_id", unique = true)
private String razorpayOrderId;
@Column(name = "razorpay_payment_id", unique = true)
private String razorpayPaymentId;
@Column(name = "razorpay_signature")
private String razorpaySignature;
@Column(name = "amount", precision = 10, scale = 2)
private BigDecimal amount;
@Column(name = "currency")
private String currency = "INR";
@Column(name = "status")
@Enumerated(EnumType.STRING)
private PaymentStatus status;
@Column(name = "customer_name")
private String customerName;
@Column(name = "customer_email")
private String customerEmail;
@Column(name = "customer_phone")
private String customerPhone;
@Column(name = "description")
private String description;
@Column(name = "payment_method")
private String paymentMethod;
@Column(name = "bank")
private String bank;
@Column(name = "wallet")
private String wallet;
@Column(name = "vpa")
private String vpa; // For UPI payments
@Column(name = "card_id")
private String cardId;
@Column(name = "invoice_id")
private String invoiceId;
@Column(name = "refund_status")
private String refundStatus;
@Column(name = "refund_id")
private String refundId;
@Column(name = "error_code")
private String errorCode;
@Column(name = "error_description")
private String errorDescription;
@Column(name = "created_at")
private LocalDateTime createdAt;
@Column(name = "updated_at")
private LocalDateTime updatedAt;
@PrePersist
protected void onCreate() {
createdAt = LocalDateTime.now();
updatedAt = LocalDateTime.now();
}
@PreUpdate
protected void onUpdate() {
updatedAt = LocalDateTime.now();
}
public enum PaymentStatus {
CREATED, ATTEMPTED, PAID, FAILED, CANCELLED, REFUNDED, PARTIALLY_REFUNDED
}
}
Refund Entity
import lombok.Data;
import javax.persistence.*;
import java.math.BigDecimal;
import java.time.LocalDateTime;
@Entity
@Table(name = "refunds")
@Data
public class Refund {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "razorpay_refund_id", unique = true)
private String razorpayRefundId;
@Column(name = "razorpay_payment_id")
private String razorpayPaymentId;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "payment_id")
private Payment payment;
@Column(name = "amount", precision = 10, scale = 2)
private BigDecimal amount;
@Column(name = "currency")
private String currency = "INR";
@Column(name = "status")
private String status;
@Column(name = "speed_processed")
private String speedProcessed;
@Column(name = "speed_requested")
private String speedRequested;
@Column(name = "notes")
private String notes;
@Column(name = "receipt")
private String receipt;
@Column(name = "created_at")
private LocalDateTime createdAt;
@PrePersist
protected void onCreate() {
createdAt = LocalDateTime.now();
}
}
4. Data Transfer Objects (DTOs)
Payment Request DTO
import lombok.Data;
import javax.validation.constraints.*;
import java.math.BigDecimal;
@Data
public class PaymentRequestDTO {
@NotNull(message = "Amount is required")
@DecimalMin(value = "1.00", message = "Amount must be at least ₹1.00")
private BigDecimal amount;
@NotBlank(message = "Currency is required")
private String currency = "INR";
@NotBlank(message = "Customer email is required")
@Email(message = "Invalid email format")
private String customerEmail;
@NotBlank(message = "Customer name is required")
private String customerName;
private String customerPhone;
private String description;
private String notes; // JSON string for additional data
@AssertTrue(message = "Must accept terms and conditions")
private Boolean acceptTerms = false;
// UPI Specific
private String upiId;
// Card Specific
private String cardNumber;
private String cardHolderName;
private String cardExpiryMonth;
private String cardExpiryYear;
private String cardCvv;
// Wallet Specific
private String wallet;
}
Payment Response DTO
import lombok.Data;
import java.math.BigDecimal;
@Data
public class PaymentResponseDTO {
private String orderId;
private String paymentId;
private BigDecimal amount;
private String currency;
private String status;
private String description;
private String customerEmail;
private String razorpaySignature;
private String errorCode;
private String errorDescription;
private String paymentMethod;
private String bank;
private String wallet;
private String vpa;
private String cardId;
private String createdAt;
// For order creation
private String razorpayKeyId;
private String orderCreationResponse;
}
Webhook DTO
import lombok.Data;
import java.util.Map;
@Data
public class WebhookDTO {
private String entity;
private String event;
private Map<String, Object> payload;
private Long createdAt;
}
5. Razorpay Service Layer
Main Razorpay Service
import com.razorpay.*;
import lombok.extern.slf4j.Slf4j;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.util.List;
@Slf4j
@Service
public class RazorpayService {
private final RazorpayClient razorpayClient;
private final RazorpayConfig config;
@Autowired
public RazorpayService(RazorpayConfig config) throws RazorpayException {
this.config = config;
this.razorpayClient = new RazorpayClient(config.getKeyId(), config.getKeySecret());
}
/**
* Create a Razorpay Order
*/
public JSONObject createOrder(PaymentRequestDTO paymentRequest) throws RazorpayException {
try {
JSONObject orderRequest = new JSONObject();
// Convert amount to paise (Indian currency smallest unit)
BigDecimal amountInRupees = paymentRequest.getAmount();
int amountInPaise = amountInRupees.multiply(new BigDecimal("100")).intValue();
orderRequest.put("amount", amountInPaise);
orderRequest.put("currency", paymentRequest.getCurrency());
orderRequest.put("receipt", "receipt_" + System.currentTimeMillis());
orderRequest.put("payment_capture", 1); // Auto capture payment
// Add notes if provided
if (paymentRequest.getNotes() != null && !paymentRequest.getNotes().isEmpty()) {
JSONObject notes = new JSONObject(paymentRequest.getNotes());
orderRequest.put("notes", notes);
}
// Customer details
JSONObject customer = new JSONObject();
customer.put("name", paymentRequest.getCustomerName());
customer.put("email", paymentRequest.getCustomerEmail());
customer.put("contact", paymentRequest.getCustomerPhone());
orderRequest.put("customer", customer);
// Notify customer
orderRequest.put("notify", JSONObject.NULL);
log.info("Creating Razorpay order: {}", orderRequest.toString());
Order order = razorpayClient.orders.create(orderRequest);
log.info("Order created successfully: {}", order.toString());
return new JSONObject(order.toString());
} catch (RazorpayException e) {
log.error("Error creating Razorpay order: {}", e.getMessage(), e);
throw e;
}
}
/**
* Verify Payment Signature
*/
public boolean verifyPaymentSignature(String orderId, String paymentId, String signature) {
try {
String generatedSignature = Utils.generateSignature(orderId + "|" + paymentId, config.getKeySecret());
return generatedSignature.equals(signature);
} catch (Exception e) {
log.error("Error verifying payment signature: {}", e.getMessage(), e);
return false;
}
}
/**
* Verify Webhook Signature
*/
public boolean verifyWebhookSignature(String payload, String signature) {
try {
return Utils.verifyWebhookSignature(payload, signature, config.getWebhookSecret());
} catch (Exception e) {
log.error("Error verifying webhook signature: {}", e.getMessage(), e);
return false;
}
}
/**
* Capture Payment
*/
public JSONObject capturePayment(String paymentId, BigDecimal amount) throws RazorpayException {
try {
int amountInPaise = amount.multiply(new BigDecimal("100")).intValue();
JSONObject captureRequest = new JSONObject();
captureRequest.put("amount", amountInPaise);
captureRequest.put("currency", "INR");
Payment payment = razorpayClient.payments.capture(paymentId, captureRequest);
return new JSONObject(payment.toString());
} catch (RazorpayException e) {
log.error("Error capturing payment {}: {}", paymentId, e.getMessage(), e);
throw e;
}
}
/**
* Fetch Payment Details
*/
public JSONObject getPaymentDetails(String paymentId) throws RazorpayException {
try {
Payment payment = razorpayClient.payments.fetch(paymentId);
return new JSONObject(payment.toString());
} catch (RazorpayException e) {
log.error("Error fetching payment {}: {}", paymentId, e.getMessage(), e);
throw e;
}
}
/**
* Fetch Order Details
*/
public JSONObject getOrderDetails(String orderId) throws RazorpayException {
try {
Order order = razorpayClient.orders.fetch(orderId);
return new JSONObject(order.toString());
} catch (RazorpayException e) {
log.error("Error fetching order {}: {}", orderId, e.getMessage(), e);
throw e;
}
}
/**
* Create Refund
*/
public JSONObject createRefund(String paymentId, BigDecimal amount, String notes) throws RazorpayException {
try {
JSONObject refundRequest = new JSONObject();
if (amount != null) {
int amountInPaise = amount.multiply(new BigDecimal("100")).intValue();
refundRequest.put("amount", amountInPaise);
}
if (notes != null && !notes.isEmpty()) {
JSONObject notesJson = new JSONObject();
notesJson.put("reason", notes);
refundRequest.put("notes", notesJson);
}
Refund refund = razorpayClient.refunds.create(paymentId, refundRequest);
return new JSONObject(refund.toString());
} catch (RazorpayException e) {
log.error("Error creating refund for payment {}: {}", paymentId, e.getMessage(), e);
throw e;
}
}
/**
* Fetch Refund Details
*/
public JSONObject getRefundDetails(String refundId) throws RazorpayException {
try {
Refund refund = razorpayClient.refunds.fetch(refundId);
return new JSONObject(refund.toString());
} catch (RazorpayException e) {
log.error("Error fetching refund {}: {}", refundId, e.getMessage(), e);
throw e;
}
}
/**
* Create Payment Link
*/
public JSONObject createPaymentLink(PaymentRequestDTO paymentRequest) throws RazorpayException {
try {
JSONObject linkRequest = new JSONObject();
int amountInPaise = paymentRequest.getAmount().multiply(new BigDecimal("100")).intValue();
linkRequest.put("amount", amountInPaise);
linkRequest.put("currency", paymentRequest.getCurrency());
linkRequest.put("accept_partial", false);
linkRequest.put("first_min_partial_amount", amountInPaise);
linkRequest.put("description", paymentRequest.getDescription());
linkRequest.put("customer", new JSONObject()
.put("name", paymentRequest.getCustomerName())
.put("email", paymentRequest.getCustomerEmail())
.put("contact", paymentRequest.getCustomerPhone()));
linkRequest.put("notify", new JSONObject()
.put("sms", true)
.put("email", true));
linkRequest.put("reminder_enable", true);
linkRequest.put("callback_url", "https://your-domain.com/payment/callback");
linkRequest.put("callback_method", "get");
com.razorpay.PaymentLink paymentLink = razorpayClient.paymentLink.create(linkRequest);
return new JSONObject(paymentLink.toString());
} catch (RazorpayException e) {
log.error("Error creating payment link: {}", e.getMessage(), e);
throw e;
}
}
/**
* Create UPI Intent
*/
public JSONObject createUpiIntent(PaymentRequestDTO paymentRequest) throws RazorpayException {
try {
JSONObject intentRequest = new JSONObject();
int amountInPaise = paymentRequest.getAmount().multiply(new BigDecimal("100")).intValue();
intentRequest.put("amount", amountInPaise);
intentRequest.put("currency", paymentRequest.getCurrency());
intentRequest.put("payment_capture", 1);
intentRequest.put("method", "upi");
if (paymentRequest.getUpiId() != null && !paymentRequest.getUpiId().isEmpty()) {
JSONObject upi = new JSONObject();
upi.put("vpa", paymentRequest.getUpiId());
intentRequest.put("upi", upi);
}
Order order = razorpayClient.orders.create(intentRequest);
return new JSONObject(order.toString());
} catch (RazorpayException e) {
log.error("Error creating UPI intent: {}", e.getMessage(), e);
throw e;
}
}
}
Payment Processing Service
import com.razorpay.RazorpayException;
import lombok.extern.slf4j.Slf4j;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.Optional;
@Slf4j
@Service
public class PaymentProcessingService {
@Autowired
private RazorpayService razorpayService;
@Autowired
private PaymentRepository paymentRepository;
@Autowired
private RefundRepository refundRepository;
/**
* Process Payment Creation
*/
@Transactional
public PaymentResponseDTO processPaymentCreation(PaymentRequestDTO paymentRequest) throws RazorpayException {
try {
// Create order in Razorpay
JSONObject orderResponse = razorpayService.createOrder(paymentRequest);
// Save payment record
Payment payment = new Payment();
payment.setRazorpayOrderId(orderResponse.getString("id"));
payment.setAmount(paymentRequest.getAmount());
payment.setCurrency(paymentRequest.getCurrency());
payment.setCustomerName(paymentRequest.getCustomerName());
payment.setCustomerEmail(paymentRequest.getCustomerEmail());
payment.setCustomerPhone(paymentRequest.getCustomerPhone());
payment.setDescription(paymentRequest.getDescription());
payment.setStatus(Payment.PaymentStatus.CREATED);
payment = paymentRepository.save(payment);
// Prepare response
PaymentResponseDTO response = new PaymentResponseDTO();
response.setOrderId(orderResponse.getString("id"));
response.setAmount(paymentRequest.getAmount());
response.setCurrency(paymentRequest.getCurrency());
response.setStatus("created");
response.setRazorpayKeyId(razorpayService.getConfig().getKeyId());
response.setOrderCreationResponse(orderResponse.toString());
log.info("Payment process initiated for order: {}", orderResponse.getString("id"));
return response;
} catch (Exception e) {
log.error("Error processing payment creation: {}", e.getMessage(), e);
throw e;
}
}
/**
* Process Payment Verification
*/
@Transactional
public PaymentResponseDTO processPaymentVerification(String orderId, String paymentId, String signature) {
try {
// Verify payment signature
boolean isValidSignature = razorpayService.verifyPaymentSignature(orderId, paymentId, signature);
if (!isValidSignature) {
log.warn("Invalid payment signature for order: {}, payment: {}", orderId, paymentId);
throw new RuntimeException("Invalid payment signature");
}
// Fetch payment details from Razorpay
JSONObject paymentDetails = razorpayService.getPaymentDetails(paymentId);
// Update payment record
Optional<Payment> paymentOpt = paymentRepository.findByRazorpayOrderId(orderId);
if (paymentOpt.isEmpty()) {
throw new RuntimeException("Payment record not found for order: " + orderId);
}
Payment payment = paymentOpt.get();
payment.setRazorpayPaymentId(paymentId);
payment.setRazorpaySignature(signature);
payment.setStatus(Payment.PaymentStatus.PAID);
payment.setPaymentMethod(paymentDetails.optString("method"));
payment.setBank(paymentDetails.optString("bank"));
payment.setWallet(paymentDetails.optString("wallet"));
payment.setVpa(paymentDetails.optString("vpa"));
payment.setCardId(paymentDetails.optString("card_id"));
payment = paymentRepository.save(payment);
// Prepare response
PaymentResponseDTO response = new PaymentResponseDTO();
response.setPaymentId(paymentId);
response.setOrderId(orderId);
response.setAmount(payment.getAmount());
response.setCurrency(payment.getCurrency());
response.setStatus("paid");
response.setPaymentMethod(payment.getPaymentMethod());
response.setBank(payment.getBank());
response.setWallet(payment.getWallet());
response.setVpa(payment.getVpa());
log.info("Payment verified successfully for order: {}, payment: {}", orderId, paymentId);
return response;
} catch (Exception e) {
log.error("Error processing payment verification: {}", e.getMessage(), e);
// Update payment status to failed
paymentRepository.findByRazorpayOrderId(orderId).ifPresent(payment -> {
payment.setStatus(Payment.PaymentStatus.FAILED);
payment.setErrorCode("VERIFICATION_FAILED");
payment.setErrorDescription(e.getMessage());
paymentRepository.save(payment);
});
throw new RuntimeException("Payment verification failed: " + e.getMessage());
}
}
/**
* Process Refund
*/
@Transactional
public JSONObject processRefund(String paymentId, BigDecimal amount, String reason) throws RazorpayException {
try {
// Create refund in Razorpay
JSONObject refundResponse = razorpayService.createRefund(paymentId, amount, reason);
// Save refund record
Optional<Payment> paymentOpt = paymentRepository.findByRazorpayPaymentId(paymentId);
if (paymentOpt.isPresent()) {
Payment payment = paymentOpt.get();
Refund refund = new Refund();
refund.setRazorpayRefundId(refundResponse.getString("id"));
refund.setRazorpayPaymentId(paymentId);
refund.setPayment(payment);
refund.setAmount(new BigDecimal(refundResponse.getInt("amount")).divide(new BigDecimal("100")));
refund.setCurrency(refundResponse.getString("currency"));
refund.setStatus(refundResponse.getString("status"));
refund.setSpeedProcessed(refundResponse.optString("speed_processed"));
refund.setSpeedRequested(refundResponse.optString("speed_requested"));
refund.setNotes(reason);
refundRepository.save(refund);
// Update payment status
payment.setRefundStatus("refunded");
if (amount.compareTo(payment.getAmount()) < 0) {
payment.setStatus(Payment.PaymentStatus.PARTIALLY_REFUNDED);
} else {
payment.setStatus(Payment.PaymentStatus.REFUNDED);
}
paymentRepository.save(payment);
}
log.info("Refund processed successfully: {}", refundResponse.getString("id"));
return refundResponse;
} catch (Exception e) {
log.error("Error processing refund: {}", e.getMessage(), e);
throw e;
}
}
}
6. Repository Layer
Payment Repository
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
@Repository
public interface PaymentRepository extends JpaRepository<Payment, Long> {
Optional<Payment> findByRazorpayOrderId(String razorpayOrderId);
Optional<Payment> findByRazorpayPaymentId(String razorpayPaymentId);
List<Payment> findByCustomerEmail(String customerEmail);
List<Payment> findByStatus(Payment.PaymentStatus status);
List<Payment> findByCreatedAtBetween(LocalDateTime start, LocalDateTime end);
@Query("SELECT p FROM Payment p WHERE p.amount >= :minAmount AND p.amount <= :maxAmount")
List<Payment> findByAmountRange(@Param("minAmount") BigDecimal minAmount,
@Param("maxAmount") BigDecimal maxAmount);
@Query("SELECT COUNT(p) FROM Payment p WHERE p.status = :status")
Long countByStatus(@Param("status") Payment.PaymentStatus status);
@Query("SELECT SUM(p.amount) FROM Payment p WHERE p.status = 'PAID' AND p.createdAt BETWEEN :start AND :end")
BigDecimal getTotalRevenueByPeriod(@Param("start") LocalDateTime start,
@Param("end") LocalDateTime end);
}
Refund Repository
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
@Repository
public interface RefundRepository extends JpaRepository<Refund, Long> {
Optional<Refund> findByRazorpayRefundId(String razorpayRefundId);
List<Refund> findByRazorpayPaymentId(String razorpayPaymentId);
List<Refund> findByStatus(String status);
}
7. REST Controller
Payment Controller
import com.razorpay.RazorpayException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.HashMap;
import java.util.Map;
@Slf4j
@RestController
@RequestMapping("/api/payments")
public class PaymentController {
@Autowired
private PaymentProcessingService paymentProcessingService;
@Autowired
private RazorpayService razorpayService;
/**
* Create Payment Order
*/
@PostMapping("/create-order")
public ResponseEntity<?> createPaymentOrder(@Valid @RequestBody PaymentRequestDTO paymentRequest) {
try {
PaymentResponseDTO response = paymentProcessingService.processPaymentCreation(paymentRequest);
return ResponseEntity.ok(response);
} catch (RazorpayException e) {
log.error("Error creating payment order: {}", e.getMessage(), e);
Map<String, Object> errorResponse = new HashMap<>();
errorResponse.put("error", true);
errorResponse.put("message", "Failed to create payment order");
errorResponse.put("error_code", e.getStatusCode());
errorResponse.put("error_description", e.getMessage());
return ResponseEntity.badRequest().body(errorResponse);
}
}
/**
* Verify Payment
*/
@PostMapping("/verify")
public ResponseEntity<?> verifyPayment(
@RequestParam String order_id,
@RequestParam String payment_id,
@RequestParam String signature) {
try {
PaymentResponseDTO response = paymentProcessingService.processPaymentVerification(order_id, payment_id, signature);
return ResponseEntity.ok(response);
} catch (Exception e) {
log.error("Error verifying payment: {}", e.getMessage(), e);
Map<String, Object> errorResponse = new HashMap<>();
errorResponse.put("error", true);
errorResponse.put("message", "Payment verification failed");
errorResponse.put("error_description", e.getMessage());
return ResponseEntity.badRequest().body(errorResponse);
}
}
/**
* Get Payment Details
*/
@GetMapping("/{paymentId}")
public ResponseEntity<?> getPaymentDetails(@PathVariable String paymentId) {
try {
var paymentDetails = razorpayService.getPaymentDetails(paymentId);
return ResponseEntity.ok(paymentDetails.toMap());
} catch (RazorpayException e) {
log.error("Error fetching payment details: {}", e.getMessage(), e);
return ResponseEntity.notFound().build();
}
}
/**
* Create Refund
*/
@PostMapping("/{paymentId}/refund")
public ResponseEntity<?> createRefund(
@PathVariable String paymentId,
@RequestParam(required = false) BigDecimal amount,
@RequestParam(required = false) String reason) {
try {
var refundResponse = paymentProcessingService.processRefund(paymentId, amount, reason);
return ResponseEntity.ok(refundResponse.toMap());
} catch (RazorpayException e) {
log.error("Error creating refund: {}", e.getMessage(), e);
Map<String, Object> errorResponse = new HashMap<>();
errorResponse.put("error", true);
errorResponse.put("message", "Refund creation failed");
errorResponse.put("error_code", e.getStatusCode());
errorResponse.put("error_description", e.getMessage());
return ResponseEntity.badRequest().body(errorResponse);
}
}
/**
* Create UPI Payment Intent
*/
@PostMapping("/upi/intent")
public ResponseEntity<?> createUpiIntent(@Valid @RequestBody PaymentRequestDTO paymentRequest) {
try {
var upiResponse = razorpayService.createUpiIntent(paymentRequest);
return ResponseEntity.ok(upiResponse.toMap());
} catch (RazorpayException e) {
log.error("Error creating UPI intent: {}", e.getMessage(), e);
Map<String, Object> errorResponse = new HashMap<>();
errorResponse.put("error", true);
errorResponse.put("message", "Failed to create UPI intent");
errorResponse.put("error_code", e.getStatusCode());
errorResponse.put("error_description", e.getMessage());
return ResponseEntity.badRequest().body(errorResponse);
}
}
/**
* Create Payment Link
*/
@PostMapping("/payment-link")
public ResponseEntity<?> createPaymentLink(@Valid @RequestBody PaymentRequestDTO paymentRequest) {
try {
var paymentLinkResponse = razorpayService.createPaymentLink(paymentRequest);
return ResponseEntity.ok(paymentLinkResponse.toMap());
} catch (RazorpayException e) {
log.error("Error creating payment link: {}", e.getMessage(), e);
Map<String, Object> errorResponse = new HashMap<>();
errorResponse.put("error", true);
errorResponse.put("message", "Failed to create payment link");
errorResponse.put("error_code", e.getStatusCode());
errorResponse.put("error_description", e.getMessage());
return ResponseEntity.badRequest().body(errorResponse);
}
}
}
Webhook Controller
import lombok.extern.slf4j.Slf4j;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.stream.Collectors;
@Slf4j
@RestController
@RequestMapping("/api/webhooks")
public class WebhookController {
@Autowired
private RazorpayService razorpayService;
@Autowired
private PaymentRepository paymentRepository;
/**
* Handle Razorpay Webhooks
*/
@PostMapping("/razorpay")
public ResponseEntity<?> handleRazorpayWebhook(HttpServletRequest request, @RequestBody String payload) {
try {
// Get signature from header
String razorpaySignature = request.getHeader("X-Razorpay-Signature");
if (razorpaySignature == null) {
log.warn("Missing Razorpay signature in webhook");
return ResponseEntity.badRequest().body("Missing signature");
}
// Verify webhook signature
boolean isValidSignature = razorpayService.verifyWebhookSignature(payload, razorpaySignature);
if (!isValidSignature) {
log.warn("Invalid webhook signature: {}", razorpaySignature);
return ResponseEntity.badRequest().body("Invalid signature");
}
// Parse webhook payload
JSONObject webhookData = new JSONObject(payload);
String event = webhookData.getString("event");
JSONObject payloadData = webhookData.getJSONObject("payload");
log.info("Received Razorpay webhook event: {}", event);
// Process different webhook events
switch (event) {
case "payment.captured":
handlePaymentCaptured(payloadData);
break;
case "payment.failed":
handlePaymentFailed(payloadData);
break;
case "refund.processed":
handleRefundProcessed(payloadData);
break;
case "subscription.charged":
handleSubscriptionCharged(payloadData);
break;
default:
log.info("Unhandled webhook event: {}", event);
}
return ResponseEntity.ok().body("Webhook processed successfully");
} catch (Exception e) {
log.error("Error processing webhook: {}", e.getMessage(), e);
return ResponseEntity.status(500).body("Error processing webhook");
}
}
private void handlePaymentCaptured(JSONObject payload) {
try {
JSONObject payment = payload.getJSONObject("payment").getJSONObject("entity");
String paymentId = payment.getString("id");
String orderId = payment.getString("order_id");
log.info("Payment captured: {}, Order: {}", paymentId, orderId);
// Update payment status in database
paymentRepository.findByRazorpayOrderId(orderId).ifPresent(p -> {
p.setRazorpayPaymentId(paymentId);
p.setStatus(Payment.PaymentStatus.PAID);
p.setPaymentMethod(payment.optString("method"));
p.setBank(payment.optString("bank"));
p.setWallet(payment.optString("wallet"));
p.setVpa(payment.optString("vpa"));
paymentRepository.save(p);
});
// TODO: Send confirmation email, update order status, etc.
} catch (Exception e) {
log.error("Error handling payment.captured webhook: {}", e.getMessage(), e);
}
}
private void handlePaymentFailed(JSONObject payload) {
try {
JSONObject payment = payload.getJSONObject("payment").getJSONObject("entity");
String paymentId = payment.getString("id");
String orderId = payment.getString("order_id");
String errorCode = payment.getJSONObject("error").getString("code");
String errorDescription = payment.getJSONObject("error").getString("description");
log.warn("Payment failed: {}, Order: {}, Error: {}", paymentId, orderId, errorCode);
// Update payment status in database
paymentRepository.findByRazorpayOrderId(orderId).ifPresent(p -> {
p.setRazorpayPaymentId(paymentId);
p.setStatus(Payment.PaymentStatus.FAILED);
p.setErrorCode(errorCode);
p.setErrorDescription(errorDescription);
paymentRepository.save(p);
});
} catch (Exception e) {
log.error("Error handling payment.failed webhook: {}", e.getMessage(), e);
}
}
private void handleRefundProcessed(JSONObject payload) {
try {
JSONObject refund = payload.getJSONObject("refund").getJSONObject("entity");
String refundId = refund.getString("id");
String paymentId = refund.getString("payment_id");
log.info("Refund processed: {}, Payment: {}", refundId, paymentId);
// Update refund status in database
// Implementation depends on your refund tracking logic
} catch (Exception e) {
log.error("Error handling refund.processed webhook: {}", e.getMessage(), e);
}
}
private void handleSubscriptionCharged(JSONObject payload) {
try {
JSONObject subscription = payload.getJSONObject("subscription").getJSONObject("entity");
String subscriptionId = subscription.getString("id");
log.info("Subscription charged: {}", subscriptionId);
// Handle subscription payment
// Implementation depends on your subscription logic
} catch (Exception e) {
log.error("Error handling subscription.charged webhook: {}", e.getMessage(), e);
}
}
}
8. Frontend Integration Example
HTML/JavaScript Payment Form
<!DOCTYPE html>
<html>
<head>
<title>Razorpay Payment Integration</title>
<script src="https://checkout.razorpay.com/v1/checkout.js"></script>
<style>
.payment-form {
max-width: 400px;
margin: 50px auto;
padding: 20px;
border: 1px solid #ddd;
border-radius: 8px;
}
.form-group {
margin-bottom: 15px;
}
label {
display: block;
margin-bottom: 5px;
font-weight: bold;
}
input, select {
width: 100%;
padding: 8px;
border: 1px solid #ccc;
border-radius: 4px;
}
button {
background-color: #528FF0;
color: white;
padding: 10px 20px;
border: none;
border-radius: 4px;
cursor: pointer;
width: 100%;
}
button:hover {
background-color: #3a7bd5;
}
</style>
</head>
<body>
<div class="payment-form">
<h2>Make Payment</h2>
<form id="paymentForm">
<div class="form-group">
<label for="amount">Amount (₹)</label>
<input type="number" id="amount" name="amount" min="1" step="0.01" required>
</div>
<div class="form-group">
<label for="customerName">Name</label>
<input type="text" id="customerName" name="customerName" required>
</div>
<div class="form-group">
<label for="customerEmail">Email</label>
<input type="email" id="customerEmail" name="customerEmail" required>
</div>
<div class="form-group">
<label for="customerPhone">Phone</label>
<input type="tel" id="customerPhone" name="customerPhone" required>
</div>
<div class="form-group">
<label for="description">Description</label>
<input type="text" id="description" name="description">
</div>
<button type="submit">Pay Now</button>
</form>
</div>
<script>
document.getElementById('paymentForm').addEventListener('submit', async function(e) {
e.preventDefault();
const formData = {
amount: document.getElementById('amount').value,
customerName: document.getElementById('customerName').value,
customerEmail: document.getElementById('customerEmail').value,
customerPhone: document.getElementById('customerPhone').value,
description: document.getElementById('description').value,
currency: 'INR',
acceptTerms: true
};
try {
// Create order on your backend
const response = await fetch('/api/payments/create-order', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify(formData)
});
const orderData = await response.json();
if (orderData.error) {
alert('Error: ' + orderData.error_description);
return;
}
// Razorpay checkout options
const options = {
key: orderData.razorpayKeyId, // Your Razorpay key ID
amount: orderData.amount * 100, // Amount in paise
currency: orderData.currency,
name: 'Your Company Name',
description: orderData.description,
order_id: orderData.orderId,
handler: async function(response) {
// Handle successful payment
const verificationResponse = await fetch('/api/payments/verify', {
method: 'POST',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
},
body: new URLSearchParams({
order_id: response.razorpay_order_id,
payment_id: response.razorpay_payment_id,
signature: response.razorpay_signature
})
});
const verificationResult = await verificationResponse.json();
if (verificationResult.error) {
alert('Payment verification failed: ' + verificationResult.error_description);
} else {
alert('Payment successful! Payment ID: ' + verificationResult.paymentId);
// Redirect to success page or update UI
}
},
prefill: {
name: formData.customerName,
email: formData.customerEmail,
contact: formData.customerPhone
},
notes: {
description: formData.description
},
theme: {
color: '#528FF0'
}
};
const razorpay = new Razorpay(options);
razorpay.open();
} catch (error) {
console.error('Error:', error);
alert('An error occurred while processing your payment.');
}
});
</script>
</body>
</html>
This comprehensive Razorpay integration provides complete payment processing capabilities for Indian businesses, including order creation, payment verification, refunds, webhook handling, and support for various payment methods like UPI, cards, and wallets.