Flutter Zoho Payments Plugin #

A Flutter plugin for integrating Zoho Payments SDK into your Flutter applications. This plugin provides a simple and secure way to accept payments through Zoho's payment gateway.

Features #

• ✅ Easy integration with Zoho Payments SDK
• ✅ Support for multiple payment methods:
  • UPI
  • Credit/Debit Cards
  • Net Banking
• ✅ Secure payment processing
• ✅ Production and Sandbox environment support
• ✅ Comprehensive error handling
• ✅ Type-safe Dart API

Platform Support #

Installation #

Add flutter_zoho_payments to your pubspec.yaml:

dependencies:
  flutter_zoho_payments: ^0.2.3

Setup #

Android Setup #

1. Ensure your android/app/build.gradle has minSdkVersion 26 or higher:

android {
    defaultConfig {
        minSdkVersion 26
    }
}

2. Add Zoho's Maven repository to your android/build.gradle or android/build.gradle.kts (project level):

For Groovy (build.gradle):

allprojects {
    repositories {
        google()
        mavenCentral()
        maven { url = uri("https://maven.zohodl.com") }  // Add this line
    }
}

For Kotlin DSL (build.gradle.kts):

allprojects {
    repositories {
        google()
        mavenCentral()
        maven { url = uri("https://maven.zohodl.com") }  // Add this line
    }
}

3. The plugin automatically includes the required permissions for internet access.

Backend Setup #

You'll need a backend server to create payment sessions. The plugin expects your backend to handle:

• Creating payment sessions with Zoho Payments API
• Verifying payment signatures
• Managing order details

Usage #

1. Initialize the SDK #

import 'package:flutter_zoho_payments/flutter_zoho_payments.dart';

final zohoPayments = ZohoPayments();

// Initialize with your credentials
await zohoPayments.initialize(
  apiKey: 'your_zoho_api_key',
  accountId: 'your_zoho_account_id',
);

2. Create a Payment Request #

// First, create a payment session on your backend
// This example assumes you have an endpoint that returns a session ID
final sessionId = await createPaymentSession(); // Your backend call

// Create the payment request
final paymentRequest = PaymentRequest(
  paymentSessionId: sessionId,
  amount: 100.0,
  currency: 'INR',
  customerName: 'John Doe',
  customerEmail: '[email protected]',
  customerPhone: '+919876543210',
  paymentMethod: PaymentMethod.upi, // Optional: pre-select payment method
  environment: ZohoEnvironment.sandbox, // Optional: defaults to sandbox
);

3. Start Payment #

try {
  final result = await zohoPayments.startPayment(paymentRequest);
  
  if (result.isSuccess) {
    print('Payment successful! ID: ${result.paymentId}');
    // Verify payment on your backend using paymentId and signature
  } else if (result.isCancelled) {
    print('Payment cancelled by user');
  } else {
    print('Payment failed: ${result.errorMessage}');
  }
} on ZohoPaymentsException catch (e) {
  print('Payment error: ${e.message}');
}

Complete Example #

import 'package:flutter/material.dart';
import 'package:flutter_zoho_payments/flutter_zoho_payments.dart';

class PaymentScreen extends StatefulWidget {
  @override
  _PaymentScreenState createState() => _PaymentScreenState();
}

class _PaymentScreenState extends State<PaymentScreen> {
  final _zohoPayments = ZohoPayments();
  
  @override
  void initState() {
    super.initState();
    _initializePayments();
  }
  
  Future<void> _initializePayments() async {
    try {
      await _zohoPayments.initialize(
        apiKey: 'your_api_key',
        accountId: 'your_account_id',
      );
    } catch (e) {
      print('Failed to initialize: $e');
    }
  }
  
  Future<void> _makePayment() async {
    try {
      // Get session ID from your backend
      final sessionId = await _createPaymentSession();
      
      final result = await _zohoPayments.startPayment(
        PaymentRequest(
          paymentSessionId: sessionId,
          amount: 100.0,
          customerName: 'Test User',
          customerEmail: '[email protected]',
          environment: ZohoEnvironment.live, // Use live for production
        ),
      );
      
      if (result.isSuccess) {
        // Payment successful
        _showSuccessDialog(result.paymentId!);
      }
    } catch (e) {
      print('Payment error: $e');
    }
  }
  
  // ... rest of your UI code
}

API Reference #

ZohoPayments Class #

The main class for interacting with Zoho Payments.

Methods

initialize()

Initializes the Zoho Payments SDK with your credentials.

Future<bool> initialize({
  required String apiKey,
  required String accountId,
})

startPayment()

Starts the payment flow with the given payment request.

Future<PaymentResult> startPayment(PaymentRequest request)

PaymentRequest Class #

Represents a payment request with all necessary details.

Properties

PaymentResult Class #

Contains the result of a payment transaction.

Properties

Methods

• isSuccess - Returns true if payment was successful
• isFailure - Returns true if payment failed
• isCancelled - Returns true if payment was cancelled

Error Handling #

The plugin throws ZohoPaymentsException for errors. Always wrap payment operations in try-catch:

try {
  final result = await zohoPayments.startPayment(request);
} on ZohoPaymentsException catch (e) {
  print('Error code: ${e.code}');
  print('Error message: ${e.message}');
}

Security Best Practices #

1. Never hardcode API credentials - Store them securely and load from environment variables
2. Always verify payments on your backend - Use the payment ID and signature to verify with Zoho's API
3. Use HTTPS for all backend communications
4. Implement proper session management - Sessions should expire after a reasonable time
5. Log payment attempts for debugging and audit purposes

Testing #

The plugin supports both sandbox and live environments:

// For testing (default)
PaymentRequest(
  paymentSessionId: sessionId,
  amount: 100.0,
  environment: ZohoEnvironment.sandbox,
)

// For production
PaymentRequest(
  paymentSessionId: sessionId,
  amount: 100.0,
  environment: ZohoEnvironment.live,
)

Always test thoroughly in sandbox before switching to live environment.

Limitations #

• Currently supports Android only (iOS support coming soon)
• Payment UI customization is limited to Zoho's provided options
• Requires minimum Android SDK 26 (Android 8.0)

Contributing #

Contributions are welcome! Please feel free to submit a Pull Request.

License #

This project is licensed under the MIT License - see the LICENSE file for details.

Support #

For issues and feature requests, please create an issue on GitHub.

For Zoho Payments specific questions, refer to Zoho Payments Documentation.