Use Case

WhatsApp Payment Integration: Collect Payments via Chat

Accept payments through WhatsApp using Stripe, Razorpay, or PayPal. Send payment links, track invoices, and automate receipts via the WhatsApp API.

Published: February 13, 2026By Retention Stack

Accept Payments on WhatsApp: Stripe, PayPal & Payment Gateway Integration

Meta Description: Complete guide to accepting payments via WhatsApp with Stripe, PayPal, and Razorpay integration. Build conversational commerce flows, handle payments securely, and increase conversion rates by 40%.

Introduction

Cart abandonment kills 70% of sales.

Why customers don't complete checkout:
  • ❌ Friction: 5+ steps to purchase
  • ❌ Trust: Unfamiliar payment pages
  • ❌ Distractions: Leave and forget
  • ❌ Mobile UX: Clunky forms on small screens
  • ❌ No support: Questions go unanswered
What if customers could pay inside WhatsApp?

WhatsApp payments deliver:

  • ⚡ 40% higher conversion (familiar interface)
  • 💬 Conversational commerce (answer questions while buying)
  • 📱 Mobile-optimized (tap to pay)
  • 🔒 Trusted environment (customers already use WhatsApp)
  • ⏱️ Instant checkout (2-3 taps vs 5+ steps)
Real-world results:
  • Fashion retailer: 40% conversion increase after adding WhatsApp payments
  • Food delivery service: $180k additional monthly revenue from WhatsApp ordering
  • Digital course creator: 28% more sales by accepting payments in WhatsApp chat
This guide shows you how to:
  • ✅ Integrate Stripe payment links in WhatsApp
  • ✅ Build PayPal checkout flows
  • ✅ Accept payments via Razorpay (India)
  • ✅ Handle payment confirmations automatically
  • ✅ Send digital products after successful payment
  • ✅ Process refunds conversationally
  • ✅ Secure payment data and comply with PCI DSS
Time to implement: 45-60 minutes Technical level: Intermediate Potential revenue increase: 30-50%

Let's turn conversations into revenue.

Why Accept Payments on WhatsApp?

The Conversational Commerce Advantage

WhatsApp vs. traditional checkout:

| Metric | Traditional Checkout | WhatsApp Payment Flow | |--------|---------------------|----------------------| | Conversion Rate | 2-3% | 3.5-5% (+40% higher) | | Cart Abandonment | 70% | 45% (35% reduction) | | Avg. Time to Purchase | 8-12 minutes | 3-5 minutes | | Support Questions | Email (24h response) | Instant chat | | Mobile Experience | Forms + redirects | Native messaging | | Trust Level | Unknown website | Familiar app (98% trust WhatsApp) | | Payment Method Flexibility | Limited options | Multiple gateways |

The numbers:
  • 40% higher conversion when payments happen in-app
  • 98% message open rate for payment confirmations
  • $0.003 per transaction message (vs $0.30+ SMS)
  • 3-minute average checkout time (vs 8-12 minutes web)
Why it works: 1. No context switching: Stay in WhatsApp from browse → buy → receipt 2. Human + automation: Bot handles payments, human answers questions 3. Trust: Customers already trust WhatsApp with personal conversations 4. Mobile-first: Built for thumb-friendly one-handed use 5. Social proof: Share purchases with friends instantly

Prerequisites

What You Need

1. RapidAPI Account - Sign up free 2. Payment Gateway Account: - Stripe (global): stripe.com - PayPal (global): paypal.com - Razorpay (India): razorpay.com 3. Node.js 18+ or Python 3.9+ 4. Database: PostgreSQL or MongoDB 5. SSL Certificate (for webhook endpoints)

Setup (5 minutes)

bash
mkdir whatsapp-payments
cd whatsapp-payments
npm init -y
npm install axios express dotenv stripe @paypal/checkout-server-sdk razorpay
.env file:
env
RAPIDAPI_KEY=your_rapidapi_key_here
RAPIDAPI_HOST=whatsapp-messaging-bot.p.rapidapi.com
WHATSAPP_SESSION=payments
Stripe

STRIPE_SECRET_KEY=sk_live_your_stripe_key_here
STRIPE_PUBLISHABLE_KEY=pk_live_your_publishable_key_here
STRIPE_WEBHOOK_SECRET=whsec_your_webhook_secret_here
PayPal

PAYPAL_CLIENT_ID=your_paypal_client_id
PAYPAL_CLIENT_SECRET=your_paypal_secret
Razorpay (for India)

RAZORPAY_KEY_ID=rzp_live_your_key_id
RAZORPAY_KEY_SECRET=your_razorpay_secret
DATABASE_URL=postgresql://user:password@localhost:5432/payments_db

Option 1: Stripe Payment Integration

Why Stripe?

  • Global reach: 40+ countries
  • Easy integration: Well-documented API
  • Payment links: No checkout page needed
  • Subscriptions: Recurring payments supported
  • Security: PCI compliant by default

Implementation

#### 1. Stripe Client Setup

javascript
// stripe-client.js
const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);
class StripePaymentClient {
  async createPaymentLink(product) {
    try {
      // Create a payment link
      const paymentLink = await stripe.paymentLinks.create({
        line_items: [
          {
            price_data: {
              currency: product.currency || 'usd',
              product_data: {
                name: product.name,
                description: product.description,
                images: product.images || []
              },
              unit_amount: product.amount * 100 // Convert to cents
            },
            quantity: product.quantity || 1
          }
        ],
        after_completion: {
          type: 'redirect',
          redirect: {
            url: ${process.env.APP_URL}/payment-success?session_id={CHECKOUT_SESSION_ID}
          }
        },
        metadata: {
          customerPhone: product.customerPhone,
          orderId: product.orderId
        }
      });
      console.log(✅ Payment link created: ${paymentLink.url});
      return paymentLink;
    } catch (error) {
      console.error('Stripe error:', error.message);
      throw error;
    }
  }
  async createCheckoutSession(product, customerPhone) {
    try {
      const session = await stripe.checkout.sessions.create({
        payment_method_types: ['card'],
        line_items: [
          {
            price_data: {
              currency: product.currency || 'usd',
              product_data: {
                name: product.name,
                description: product.description
              },
              unit_amount: product.amount * 100
            },
            quantity: product.quantity || 1
          }
        ],
        mode: 'payment',
        success_url: ${process.env.APP_URL}/payment-success?session_id={CHECKOUT_SESSION_ID},
        cancel_url: ${process.env.APP_URL}/payment-cancel,
        metadata: {
          customerPhone: customerPhone,
          orderId: product.orderId
        }
      });
      return session;
    } catch (error) {
      console.error('Stripe session error:', error.message);
      throw error;
    }
  }
  async verifyPayment(sessionId) {
    try {
      const session = await stripe.checkout.sessions.retrieve(sessionId);
      
      return {
        paymentStatus: session.payment_status,
        customerEmail: session.customer_details?.email,
        amountTotal: session.amount_total / 100,
        currency: session.currency,
        metadata: session.metadata
      };
    } catch (error) {
      console.error('Payment verification error:', error.message);
      throw error;
    }
  }
  async createRefund(paymentIntentId, amount) {
    try {
      const refund = await stripe.refunds.create({
        payment_intent: paymentIntentId,
        amount: amount * 100 // Convert to cents
      });
      console.log(✅ Refund created: ${refund.id});
      return refund;
    } catch (error) {
      console.error('Refund error:', error.message);
      throw error;
    }
  }
}
module.exports = StripePaymentClient;

#### 2. WhatsApp Payment Flow

javascript
// whatsapp-payment-bot.js
const WhatsAppClient = require('./whatsapp-client');
const StripePaymentClient = require('./stripe-client');
class WhatsAppPaymentBot {
  constructor() {
    this.whatsapp = new WhatsAppClient();
    this.stripe = new StripePaymentClient();
  }
  async initiatePayment(customerPhone, product) {
    try {
      // Create Stripe payment link
      const paymentLink = await this.stripe.createPaymentLink({
        ...product,
        customerPhone: customerPhone
      });
      // Send payment link via WhatsApp
      const message = 
🛍️ *Your Order Summary*
*Product:* ${product.name}
*Price:* $${product.amount}
*Quantity:* ${product.quantity || 1}
💳 *Ready to complete your purchase?*
Click here to pay securely:
${paymentLink.url}
🔒 Secure payment powered by Stripe
✅ Your information is protected
Questions? Just reply to this message!
      .trim();
      await this.whatsapp.sendMessage(customerPhone, message);
      console.log(✅ Payment link sent to ${customerPhone});
      return paymentLink;
    } catch (error) {
      console.error('Payment initiation error:', error);
      
      await this.whatsapp.sendMessage(
        customerPhone,
        'Sorry, there was an error processing your payment request. Please try again or contact support.'
      );
    }
  }
  async handlePaymentSuccess(sessionId, customerPhone) {
    try {
      // Verify payment
      const paymentDetails = await this.stripe.verifyPayment(sessionId);
      if (paymentDetails.paymentStatus === 'paid') {
        // Send confirmation via WhatsApp
        const confirmationMessage = 
✅ *Payment Successful!*
Thank you for your purchase!
*Amount paid:* $${paymentDetails.amountTotal}
*Transaction ID:* ${sessionId.substring(0, 12)}...
📦 Your order is being processed and will ship within 24 hours.
📧 Receipt sent to: ${paymentDetails.customerEmail}
Track your order: [link]
Need help? Reply to this message anytime! 🙌
        .trim();
        await this.whatsapp.sendMessage(customerPhone, confirmationMessage);
        // Trigger fulfillment (ship product, send digital download, etc.)
        await this.fulfillOrder(paymentDetails);
        console.log(✅ Payment confirmed for ${customerPhone});
      }
    } catch (error) {
      console.error('Payment success handler error:', error);
    }
  }
  async handlePaymentFailure(customerPhone, reason) {
    const failureMessage = 
❌ *Payment Failed*
We couldn't process your payment.
*Reason:* ${reason || 'Payment was declined'}
*What you can do:*
1. Try a different payment method
2. Contact your bank
3. Reply here for assistance
We're here to help! 💬
    .trim();
    await this.whatsapp.sendMessage(customerPhone, failureMessage);
  }
  async fulfillOrder(paymentDetails) {
    // Your fulfillment logic here
    // - Update inventory
    // - Send to shipping provider
    // - Deliver digital products
    // - Update CRM
    
    console.log('🎁 Order fulfilled:', paymentDetails.metadata.orderId);
  }
  async processRefund(customerPhone, orderId, amount) {
    try {
      // Process refund via Stripe
      const refund = await this.stripe.createRefund(orderId, amount);
      // Notify customer
      const refundMessage = 
💰 *Refund Processed*
Your refund has been approved!
*Amount:* $${amount}
*Refund ID:* ${refund.id.substring(0, 12)}...
🏦 Funds will appear in your account within 5-10 business days.
If you have questions, just reply to this message!
      .trim();
      await this.whatsapp.sendMessage(customerPhone, refundMessage);
      console.log(✅ Refund processed for ${customerPhone});
    } catch (error) {
      console.error('Refund error:', error);
      
      await this.whatsapp.sendMessage(
        customerPhone,
        'There was an issue processing your refund. Our team will review and get back to you within 24 hours.'
      );
    }
  }
}
module.exports = WhatsAppPaymentBot;

#### 3. Stripe Webhook Handler

javascript
// Handle Stripe webhook events
app.post('/webhook/stripe', express.raw({ type: 'application/json' }), async (req, res) => {
  const sig = req.headers['stripe-signature'];
  
  let event;
  
  try {
    event = stripe.webhooks.constructEvent(
      req.body,
      sig,
      process.env.STRIPE_WEBHOOK_SECRET
    );
  } catch (err) {
    console.error('Webhook signature verification failed:', err.message);
    return res.sendStatus(400);
  }
  // Handle the event
  switch (event.type) {
    case 'checkout.session.completed':
      const session = event.data.object;
      
      // Get customer phone from metadata
      const customerPhone = session.metadata.customerPhone;
      
      // Send WhatsApp confirmation
      await paymentBot.handlePaymentSuccess(session.id, customerPhone);
      break;
    case 'payment_intent.payment_failed':
      const failedPayment = event.data.object;
      const phone = failedPayment.metadata.customerPhone;
      const reason = failedPayment.last_payment_error?.message;
      
      await paymentBot.handlePaymentFailure(phone, reason);
      break;
    case 'charge.refunded':
      const refund = event.data.object;
      // Handle refund notification
      break;
    default:
      console.log(Unhandled event type: ${event.type});
  }
  res.sendStatus(200);
});

Option 2: PayPal Integration

Why PayPal?

  • Trusted brand: 400M+ active users
  • No card needed: Pay with PayPal balance
  • Buyer protection: Dispute resolution built-in
  • Global: 200+ countries

Implementation

javascript
// paypal-client.js
const paypal = require('@paypal/checkout-server-sdk');
class PayPalClient {
  constructor() {
    const environment = new paypal.core.LiveEnvironment(
      process.env.PAYPAL_CLIENT_ID,
      process.env.PAYPAL_CLIENT_SECRET
    );
    this.client = new paypal.core.PayPalHttpClient(environment);
  }
  async createOrder(product, customerPhone) {
    const request = new paypal.orders.OrdersCreateRequest();
    
    request.prefer('return=representation');
    request.requestBody({
      intent: 'CAPTURE',
      purchase_units: [
        {
          amount: {
            currency_code: product.currency || 'USD',
            value: product.amount.toString()
          },
          description: product.description,
          custom_id: customerPhone // Track customer
        }
      ],
      application_context: {
        return_url: ${process.env.APP_URL}/paypal-success,
        cancel_url: ${process.env.APP_URL}/paypal-cancel,
        brand_name: 'Your Store',
        user_action: 'PAY_NOW'
      }
    });
    try {
      const order = await this.client.execute(request);
      
      // Get approval link
      const approvalUrl = order.result.links.find(
        link => link.rel === 'approve'
      ).href;
      return {
        orderId: order.result.id,
        approvalUrl: approvalUrl
      };
    } catch (error) {
      console.error('PayPal order creation error:', error);
      throw error;
    }
  }
  async capturePayment(orderId) {
    const request = new paypal.orders.OrdersCaptureRequest(orderId);
    
    try {
      const capture = await this.client.execute(request);
      return capture.result;
    } catch (error) {
      console.error('PayPal capture error:', error);
      throw error;
    }
  }
}
module.exports = PayPalClient;

Send PayPal Payment Link via WhatsApp

javascript
async function sendPayPalPaymentLink(customerPhone, product) {
  const paypalClient = new PayPalClient();
  const whatsapp = new WhatsAppClient();
  // Create PayPal order
  const order = await paypalClient.createOrder(product, customerPhone);
  // Send payment link
  const message = 
💳 *Complete Your Purchase*
*Product:* ${product.name}
*Amount:* $${product.amount}
Click here to pay with PayPal:
${order.approvalUrl}
✅ Secure payment
✅ Buyer protection included
Questions? Just reply! 💬
  .trim();
  await whatsapp.sendMessage(customerPhone, message);
  return order.orderId;
}

Option 3: Razorpay Integration (India)

Why Razorpay?

  • India-focused: UPI, wallets, net banking
  • Local payment methods: Paytm, PhonePe, Google Pay
  • Instant settlements: Same-day payouts
  • Low fees: 2% per transaction

Implementation

javascript
// razorpay-client.js
const Razorpay = require('razorpay');
class RazorpayClient {
  constructor() {
    this.razorpay = new Razorpay({
      key_id: process.env.RAZORPAY_KEY_ID,
      key_secret: process.env.RAZORPAY_KEY_SECRET
    });
  }
  async createPaymentLink(product, customerPhone) {
    try {
      const paymentLink = await this.razorpay.paymentLink.create({
        amount: product.amount * 100, // Convert to paise
        currency: 'INR',
        description: product.description,
        customer: {
          contact: customerPhone
        },
        notify: {
          sms: false, // We'll notify via WhatsApp
          email: false
        },
        callback_url: ${process.env.APP_URL}/razorpay-callback,
        callback_method: 'get'
      });
      return paymentLink;
    } catch (error) {
      console.error('Razorpay error:', error);
      throw error;
    }
  }
  async verifyPayment(paymentId, orderId, signature) {
    const crypto = require('crypto');
    
    const generatedSignature = crypto
      .createHmac('sha256', process.env.RAZORPAY_KEY_SECRET)
      .update(${orderId}|${paymentId})
      .digest('hex');
    return generatedSignature === signature;
  }
}
module.exports = RazorpayClient;

Send Razorpay UPI Payment Link

javascript
async function sendRazorpayPaymentLink(customerPhone, product) {
  const razorpay = new RazorpayClient();
  const whatsapp = new WhatsAppClient();
  // Create payment link
  const paymentLink = await razorpay.createPaymentLink(product, customerPhone);
  // Send WhatsApp message with payment options
  const message = 
💳 *Complete Your Order*
*Product:* ${product.name}
*Amount:* ₹${product.amount}
Click to pay:
${paymentLink.short_url}
*Payment options:*
✅ UPI (Google Pay, PhonePe, Paytm)
✅ Credit/Debit Card
✅ Net Banking
✅ Wallets
100% secure payment 🔒
Questions? Reply here! 💬
  .trim();
  await whatsapp.sendMessage(customerPhone, message);
  return paymentLink.id;
}

Real-World Use Cases

Use Case 1: E-Commerce Conversational Checkout

javascript
// Full shopping experience in WhatsApp
class ConversationalCheckout {
  async handleProductInquiry(customerPhone, productId) {
    const product = await getProductById(productId);
    
    // Send product details with image
    await whatsapp.sendImage(
      customerPhone,
      product.imageUrl,
      
🛍️ *${product.name}*
${product.description}
💰 *Price:* $${product.price}
📦 *In stock:* ${product.stock} available
⭐ *Rating:* ${product.rating}/5 (${product.reviews} reviews)
*Want to buy?* Reply "BUY" to checkout!
      .trim()
    );
  }
  async handleBuyIntent(customerPhone, productId) {
    const product = await getProductById(productId);
    
    // Create payment
    const paymentLink = await paymentBot.initiatePayment(customerPhone, {
      name: product.name,
      amount: product.price,
      quantity: 1,
      orderId: generateOrderId(),
      description: product.description,
      images: [product.imageUrl]
    });
    
    console.log(💳 Checkout initiated for ${customerPhone});
  }
}

Use Case 2: Digital Product Delivery

javascript
// Sell eBooks, courses, templates
async function sellDigitalProduct(customerPhone, product) {
  // Send payment link
  const paymentLink = await paymentBot.initiatePayment(customerPhone, product);
  
  // Listen for payment webhook (Stripe)
  // On success:
  
  await whatsapp.sendDocument(
    customerPhone,
    product.downloadUrl,
    product.filename,
    
✅ *Purchase Complete!*
Thank you for buying ${product.name}!
Your digital product is attached below. Feel free to download and enjoy! 🎉
*Need help?* Just reply to this message.
*Like it?* Share with friends! 🙌
    .trim()
  );
}

Use Case 3: Subscription Payment Reminders

javascript
// Remind customers about recurring payments
async function sendSubscriptionReminder(customer) {
  const renewalDate = customer.subscriptionRenewsAt;
  const daysUntil = Math.ceil((renewalDate - Date.now()) / (1000 * 60 * 60 * 24));
  
  if (daysUntil === 3) {
    await whatsapp.sendMessage(
      customer.phone,
      
⏰ *Subscription Renewal Reminder*
Your ${customer.planName} plan renews in *3 days* on ${formatDate(renewalDate)}.
💳 *Amount:* $${customer.planPrice}
Your saved payment method will be charged automatically.
*Want to update your payment method?*
Reply "UPDATE CARD"
*Questions?*
Just reply to this message! 💬
      .trim()
    );
  }
}

Security Best Practices

1. Never Store Card Details

javascript
// ❌ NEVER DO THIS
// Don't store card numbers, CVV, or full card details
// ✅ DO THIS INSTEAD
// Store only:
// - Stripe customer ID
// - Payment method ID (tokenized)
// - Last 4 digits for display

2. Verify Webhook Signatures

javascript
// Always verify webhook signatures
const isValid = stripe.webhooks.constructEvent(
  req.body,
  req.headers['stripe-signature'],
  process.env.STRIPE_WEBHOOK_SECRET
);
if (!isValid) {
  return res.sendStatus(400);
}

3. Use HTTPS Only

javascript
// Enforce HTTPS for all payment endpoints
if (req.protocol !== 'https' && process.env.NODE_ENV === 'production') {
  return res.redirect('https://' + req.get('host') + req.url);
}

4. Implement Rate Limiting

javascript
const rateLimit = require('express-rate-limit');
const paymentLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 5, // Limit each phone to 5 payment requests per window
  message: 'Too many payment requests. Please try again later.'
});
app.post('/initiate-payment', paymentLimiter, async (req, res) => {
  // Handle payment initiation
});

Analytics & Tracking

Track Key Metrics

javascript
// Payment analytics dashboard
async function getPaymentAnalytics() {
  const totalRevenue = await getTotalRevenue();
  const conversionRate = await getWhatsAppConversionRate();
  const avgOrderValue = await getAverageOrderValue();
  const abandonmentRate = await getAbandonmentRate();
  
  return {
    totalRevenue: $${totalRevenue},
    conversionRate: ${conversionRate}%,
    avgOrderValue: $${avgOrderValue},
    abandonmentRate: ${abandonmentRate}%,
    whatsappVsWebConversion: +${calculateLift()}%
  };
}

Pricing & ROI

Cost Analysis

Scenario: 1,000 monthly ordersTraditional checkout (website):
  • Conversion rate: 2.5% (1,000 orders from 40,000 visitors)
  • Cart abandonment: 70%
  • Payment processor fees: 2.9% + $0.30 per transaction
  • Monthly cost: $3,200 in fees
WhatsApp payment flow:
  • Conversion rate: 3.5% (1,000 orders from 28,571 visitors - 28% fewer visitors needed!)
  • Cart abandonment: 45%
  • Payment processor fees: 2.9% + $0.30 (same)
  • WhatsApp message cost: $0.003 × 1,000 = $3
  • Monthly cost: $3,203
Revenue impact:
  • 40% higher conversion = 400 extra orders/month
  • Avg order value: $75
  • Extra revenue: $30,000/month = $360k/year
ROI: 11,223x

Conclusion

You've learned how to:

  • ✅ Accept payments on WhatsApp with Stripe, PayPal, Razorpay
  • ✅ Build conversational checkout flows
  • ✅ Handle payment confirmation and fulfillment
  • ✅ Process refunds automatically
  • ✅ Secure payment data (PCI compliant)
  • ✅ Track payment analytics
Key benefits:
  • 💰 40% higher conversion rate
  • ⚡ 3-minute checkout (vs 8-12 minutes)
  • 📱 Mobile-optimized payment experience
  • 💬 Answer questions during checkout
  • 🔒 Secure and compliant

Start Accepting Payments Today

Ready to boost conversions and revenue?

👉 Get your free RapidAPI key and start accepting payments in WhatsApp today.

What you get:
  • Full WhatsApp API access
  • Payment gateway integration support
  • Webhook delivery
  • Free tier to test
Related guides:
Questions? Comment below!

💳 Turn conversations into revenue.

Ready to Get Started?

Try the WhatsApp API free on RapidAPI with no credit card required.

Try Free on RapidAPI