Payment Gateway Comparison: Stripe vs Square vs Adyen vs Wise 2026

# Pricing Comparison Calculator

class PaymentGatewayCalculator:
    """Compare payment gateway costs based on volume"""
    
    def __init__(self):
        self.gateways = {
            'stripe': {
                'online': {'percentage': 2.9, 'flat': 0.30},
                'in_person': {'percentage': 2.6, 'flat': 0.10},
                'international': 1.0
            },
            'square': {
                'online': {'percentage': 2.9, 'flat': 0.30},
                'in_person': {'percentage': 1.75, 'flat': 0.10},
                'retail': {'percentage': 2.5, 'flat': 0.10}
            },
            'adyen': {
                'standard': {'percentage': 2.5, 'flat': 0.12},
                'high_volume': {'percentage': 1.8, 'flat': 0.08}
            },
            'wise': {
                'transfer_fee': 0.5,  # % of amount
                'conversion_markup': 0.5  # % markup on mid-market
            }
        }
    
    def calculate_monthly_cost(self, gateway: str, 
                               monthly_volume: int,
                               transaction_count: int,
                               avg_transaction: float = 50) -> dict:
        """Calculate monthly costs for each gateway"""
        
        if gateway == 'stripe':
            fees = self.gateways['stripe']['online']
            total_fees = (
                (monthly_volume * fees['percentage'] / 100) +
                (transaction_count * fees['flat'])
            )
            
        elif gateway == 'square':
            fees = self.gateways['square']['online']
            total_fees = (
                (monthly_volume * fees['percentage'] / 100) +
                (transaction_count * fees['flat'])
            )
            
        elif gateway == 'adyen':
            if monthly_volume > 500000:
                fees = self.gateways['adyen']['high_volume']
            else:
                fees = self.gateways['adyen']['standard']
            total_fees = (
                (monthly_volume * fees['percentage'] / 100) +
                (transaction_count * fees['flat'])
            )
            
        elif gateway == 'wise':
            # Wise charges per transfer, not percentage
            total_fees = transaction_count * 0.50  # average transfer fee
            
        return {
            'gateway': gateway,
            'monthly_volume': monthly_volume,
            'transaction_count': transaction_count,
            'total_fees': round(total_fees, 2),
            'effective_rate': round((total_fees / monthly_volume) * 100, 3) if monthly_volume > 0 else 0
        }
    
    def compare_all(self, monthly_volume: int, 
                    transaction_count: int) -> list:
        """Compare all gateways"""
        results = []
        for gateway in ['stripe', 'square', 'adyen']:
            results.append(
                self.calculate_monthly_cost(
                    gateway, monthly_volume, transaction_count
                )
            )
        return sorted(results, key=lambda x: x['total_fees'])

# Usage
calculator = PaymentGatewayCalculator()

# Compare for $50,000 monthly volume, 1000 transactions
for result in calculator.compare_all(50000, 1000):
    print(f"{result['gateway'].upper()}: ${result['total_fees']:.2f}/month "
          f"(effective rate: {result['effective_rate']}%)")

// Stripe Payment Integration
const stripe = require('stripe')('sk_test_...');

class StripePaymentProcessor {
    constructor(apiKey) {
        this.stripe = stripe;
    }
    
    async createPaymentIntent(amount, currency, customerId) {
        const paymentIntent = await this.stripe.paymentIntents.create({
            amount: amount,  // Amount in cents
            currency: currency,
            customer: customerId,
            automatic_payment_methods: {
                enabled: true,
            },
            metadata: {
                order_id: 'order_12345'
            }
        });
        
        return {
            clientSecret: paymentIntent.client_secret,
            paymentIntentId: paymentIntent.id
        };
    }
    
    async createCustomer(email, name, metadata) {
        const customer = await this.stripe.customers.create({
            email: email,
            name: name,
            metadata: metadata
        });
        
        return customer;
    }
    
    async createSubscription(customerId, priceId) {
        const subscription = await this.stripe.subscriptions.create({
            customer: customerId,
            items: [{ price: priceId }],
            payment_behavior: 'default_incomplete',
            expand: ['latest_invoice.payment_intent']
        });
        
        return {
            subscriptionId: subscription.id,
            clientSecret: subscription.latest_invoice.payment_intent.client_secret
        };
    }
    
    async handleWebhook(payload, signature) {
        const webhookSecret = 'whsec_...';
        
        try {
            const event = this.stripe.webhooks.constructEvent(
                payload,
                signature,
                webhookSecret
            );
            
            switch (event.type) {
                case 'payment_intent.succeeded':
                    console.log('Payment succeeded:', event.data.object.id);
                    break;
                case 'payment_intent.payment_failed':
                    console.log('Payment failed:', event.data.object.id);
                    break;
                case 'customer.subscription.created':
                    console.log('Subscription created:', event.data.object.id);
                    break;
                case 'customer.subscription.deleted':
                    console.log('Subscription cancelled:', event.data.object.id);
                    break;
            }
            
            return { received: true };
        } catch (err) {
            console.error('Webhook error:', err.message);
            throw err;
        }
    }
}

// Frontend: Stripe Elements
/*
<script>
    const stripe = Stripe('pk_test_...');
    const elements = stripe.elements();
    
    const cardElement = elements.create('card', {
        style: {
            base: {
                fontSize: '16px',
                color: '#32325d',
                '::placeholder': { color: '#aab7c4' }
            }
        }
    });
    
    cardElement.mount('#card-element');
    
    async function handleSubmit() {
        const { error, paymentMethod } = await stripe.createPaymentMethod({
            type: 'card',
            card: cardElement
        });
        
        if (error) {
            console.error(error);
        } else {
            console.log('PaymentMethod:', paymentMethod.id);
            // Send to your server
        }
    }
</script>
*/

# Square Payment Integration
import squareupsdk
from squareupsdk import ApiClient
from squareupsdk import Configuration
from squareupsdk import PaymentsApi
from squareupsdk import OrdersApi

class SquarePaymentProcessor:
    def __init__(self, access_token, environment='sandbox'):
        self.access_token = access_token
        configuration = Configuration()
        
        if environment == 'production':
            configuration.host = 'https://connect.squareup.com'
        else:
            configuration.host = 'https://connect.squareupsandbox.com'
            
        configuration.access_token = access_token
        self.api_client = ApiClient(configuration)
        self.payments_api = PaymentsApi(self.api_client)
        self.orders_api = OrdersApi(self.api_client)
    
    def create_payment(self, source_id, amount_money, currency='USD',
                      order_id=None, customer_id=None):
        """Create a payment"""
        
        idempotency_key = str(uuid.uuid4())
        
        body = {
            'source_id': source_id,  # From Square Web Payment SDK
            'idempotency_key': idempotency_key,
            'amount_money': {
                'amount': int(amount_money * 100),  # Convert to cents
                'currency': currency
            }
        }
        
        if order_id:
            body['order_id'] = order_id
            
        if customer_id:
            body['customer_id'] = customer_id
        
        try:
            response = self.payments_api.create_payment(body)
            return {
                'payment_id': response.payment.id,
                'status': response.payment.status,
                'receipt_url': response.payment.receipt_url
            }
        except Exception as e:
            print(f"Payment error: {e}")
            raise
    
    def create_order(self, location_id, line_items):
        """Create an order"""
        
        order = {
            'location_id': location_id,
            'line_items': [
                {
                    'name': item['name'],
                    'quantity': str(item['quantity']),
                    'base_price_money': {
                        'amount': int(item['price'] * 100),
                        'currency': 'USD'
                    }
                }
                for item in line_items
            ]
        }
        
        response = self.orders_api.create_order(order)
        return {
            'order_id': response.order.id,
            'total': response.order.total_money.amount / 100
        }
    
    def refund_payment(self, payment_id, amount, reason=None):
        """Process a refund"""
        
        idempotency_key = str(uuid.uuid4())
        
        body = {
            'payment_id': payment_id,
            'idempotency_key': idempotency_key,
            'amount_money': {
                'amount': int(amount * 100),
                'currency': 'USD'
            }
        }
        
        if reason:
            body['reason'] = reason
        
        # RefundsApi would be used here
        pass

// Adyen Payment Integration
package com.example.adyen;

import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.PaymentRequest;
import com.adyen.model.PaymentResult;
import com.adyen.service.PaymentApi;
import com.adyen.model.*;

public class AdyenPaymentProcessor {
    
    private Client client;
    private PaymentApi paymentApi;
    
    public AdyenPaymentProcessor(String apiKey, String merchantAccount) {
        this.client = new Client(apiKey, Environment.TEST);
        this.paymentApi = new PaymentApi(client);
        this.merchantAccount = merchantAccount;
    }
    
    public PaymentResult processPayment(String amount, String currency,
                                        String paymentMethodJson,
                                        String returnUrl) throws Exception {
        
        // Parse payment method from JSON
        JSONObject paymentMethodObj = new JSONObject(paymentMethodJson);
        
        // Build payment request
        PaymentRequest request = new PaymentRequest();
        request.setMerchantAccount(merchantAccount);
        
        // Amount
        Amount adyenAmount = new Amount();
        adyenAmount.setCurrency(currency);
        adyenAmount.setValue(new BigDecimal(amount).movePointRight(2).longValue());
        request.setAmount(adyenAmount);
        
        // Payment method
        JSONObject method = new JSONObject();
        method.put("type", paymentMethodObj.getString("type"));
        method.put("encryptedCardNumber", paymentMethodObj.getString("encryptedCardNumber"));
        method.put("encryptedExpiryMonth", paymentMethodObj.getString("encryptedExpiryMonth"));
        method.put("encryptedExpiryYear", paymentMethodObj.getString("encryptedExpiryYear"));
        method.put("encryptedSecurityCode", paymentMethodObj.getString("encryptedSecurityCode"));
        
        DefaultPaymentMethod defaultPaymentMethod = new DefaultPaymentMethod();
        defaultPaymentMethod.setType("scheme");
        defaultPaymentMethod.setEncryptedCardNumber(method.optString("encryptedCardNumber"));
        defaultPaymentMethod.setEncryptedExpiryMonth(method.optString("encryptedExpiryMonth"));
        defaultPaymentMethod.setEncryptedExpiryYear(method.optString("encryptedExpiryYear"));
        defaultPaymentMethod.setEncryptedSecurityCode(method.optString("encryptedSecurityCode"));
        
        request.setPaymentMethod(defaultPaymentMethod);
        request.setReturnUrl(returnUrl);
        request.setShopperReference("SHOPPER_123");
        request.setShopperInteraction("Ecommerce");
        request.setRecurringProcessingModel("CardOnFile");
        
        // Send payment request
        return paymentApi.payments(request);
    }
    
    public PaymentResult handle3DS(String paymentData) throws Exception {
        // Handle 3D Secure authentication result
        PaymentRequest3DSecure request = new PaymentRequest3DSecure();
        request.setMerchantAccount(merchantAccount);
        request.setDetails(new JSONObject(paymentData));
        
        return paymentApi.paymentDetails(request);
    }
}

# Wise Payment Integration
import requests
from datetime import datetime

class WisePayment:
    def __init__(self, api_key, profile_id):
        self.api_key = api_key
        self.profile_id = profile_id
        self.base_url = "https://api.wise.com/v1"
        self.headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }
    
    def get_quote(self, source_currency, target_currency, amount):
        """Get exchange rate quote"""
        
        endpoint = "/quotes"
        
        payload = {
            "profile": self.profile_id,
            "sourceCurrency": source_currency,
            "targetCurrency": target_currency,
            "targetAmount": amount,
            "type": "FIXED"
        }
        
        response = requests.post(
            f"{self.base_url}{endpoint}",
            json=payload,
            headers=self.headers
        )
        
        return response.json()
    
    def create_transfer(self, target_account_id, quote_id, reference):
        """Create a transfer"""
        
        endpoint = "/transfers"
        
        payload = {
            "targetAccount": target_account_id,
            "quoteUuid": quote_id,
            "customerTransactionId": f"txn_{datetime.now().timestamp()}",
            "type": "REGULAR",
            "details": {
                "reference": reference,
                "transferPurpose": "verification.transfers.utility_bill"
            }
        }
        
        response = requests.post(
            f"{self.base_url}{endpoint}",
            json=payload,
            headers=self.headers
        )
        
        return response.json()
    
    def fund_transfer(self, transfer_id):
        """Fund (execute) the transfer"""
        
        endpoint = f"/transfers/{transfer_id}/fund"
        
        response = requests.post(
            f"{self.base_url}{endpoint}",
            headers=self.headers
        )
        
        return response.json()
    
    def get_requirements(self, source_currency, target_currency, 
                         target_country):
        """Get requirements for a transfer"""
        
        endpoint = "/requirements"
        
        params = {
            "sourceCurrency": source_currency,
            "targetCurrency": target_currency,
            "targetAccount": target_country
        }
        
        response = requests.get(
            f"{self.base_url}{endpoint}",
            params=params,
            headers=self.headers
        )
        
        return response.json()
    
    def get_balance(self, currency=None):
        """Get account balance"""
        
        if currency:
            endpoint = f"/balance/{currency}"
        else:
            endpoint = "/balance"
        
        response = requests.get(
            f"{self.base_url}{endpoint}",
            headers=self.headers
        )
        
        return response.json()

Choose Stripe If:
  - Building SaaS or online platform
  - Developer experience is priority
  - Need subscription/marketplace features
  - Have technical resources for integration
  - Primarily online, not in-person
  - Need extensive third-party integrations
  
Example Use Cases:
  - E-commerce platforms
  - SaaS subscriptions
  - Marketplaces
  - Digital products/services
  - Mobile apps

Choose Square If:
  - Physical retail/storefront
  - Food & beverage business
  - Want all-in-one POS + payments
  - Need inventory management
  - Simplicity over customization
  - Have limited technical resources
  
Example Use Cases:
  - Retail stores
  - Restaurants/Cafes
  - Pop-up shops
  - Mobile vendors
  - Simple e-commerce

Choose Adyen If:
  - Enterprise business with high volume
  - Need global payment reach
  - Require local acquiring
  - Have complex payment requirements
  - Need advanced fraud protection
  - Marketplace with high transaction volume
  
Example Use Cases:
  - Global enterprises
  - Large marketplaces
  - Airlines
  - Gaming platforms
  - High-volume e-commerce

Choose Wise If:
  - Cross-border payments are primary need
  - Need multi-currency accounts
  - Paying international contractors/sellers
  - Have international customer base
  - Need best exchange rates
  - Simple transfer needs
  
Example Use Cases:
  - Freelancer payments
  - International payroll
  - Marketplace payouts
  - E-commerce international customers
  - Subscription in multiple currencies

# Payment Gateway Migration Strategy

class PaymentMigrationManager:
    """
    Manages migration between payment gateways
    while maintaining service continuity
    """
    
    def __init__(self, source_gateway, target_gateway):
        self.source = source_gateway
        self.target = target_gateway
    
    def migrate_customers(self, batch_size=100):
        """
        Migrate customers with payment methods
        """
        
        # 1. Export from source
        customers = self.source.get_all_customers()
        
        migrated = 0
        failed = []
        
        for customer in customers:
            try:
                # Get payment methods
                payment_methods = self.source.get_payment_methods(
                    customer['id']
                )
                
                # Create in target
                new_customer = self.target.create_customer(
                    email=customer['email'],
                    name=customer['name'],
                    metadata=customer.get('metadata', {})
                )
                
                # Copy payment methods (tokenize in target)
                for pm in payment_methods:
                    new_pm = self.target.tokenize_payment_method(
                        source_token=pm['token'],
                        customer_id=new_customer['id']
                    )
                
                migrated += 1
                
            except Exception as e:
                failed.append({
                    'customer_id': customer['id'],
                    'error': str(e)
                })
        
        return {
            'migrated': migrated,
            'failed': failed,
            'total': len(customers)
        }
    
    def migrate_subscriptions(self):
        """
        Migrate active subscriptions
        """
        
        subscriptions = self.source.get_active_subscriptions()
        
        for sub in subscriptions:
            new_sub = self.target.create_subscription(
                customer_id=self._get_mapped_customer(sub['customer_id']),
                price_id=self._map_price(sub['price_id']),
                billing_cycle=sub.get('billing_cycle', 'monthly')
            )
            
            # Preserve original start date
            self.target.set_start_date(
                new_sub['id'],
                sub['created_at']
            )
    
    def dual_write_period(self, days=30):
        """
        Period where both gateways are active
        """
        
        # During this period:
        # 1. Process new payments on target
        # 2. Keep source for refunds/chargebacks
        # 3. Monitor for issues
        # 4. Gradually shift traffic
        pass