Shopify Order Created
        ↓
Webhook fires to your server
        ↓
Your server processes order details
        ↓
Format WhatsApp message
        ↓
Send via WhatsApp API
        ↓
Customer receives notification (5s)

mkdir shopify-whatsapp-integration
cd shopify-whatsapp-integration
npm init -y
npm install express body-parser axios dotenv crypto

# RapidAPI
RAPIDAPI_KEY=your_rapidapi_key_here
RAPIDAPI_HOST=whatsapp-messaging-bot.p.rapidapi.com
WHATSAPP_SESSION=my-store

# Shopify
SHOPIFY_WEBHOOK_SECRET=your_shopify_webhook_secret
SHOPIFY_STORE_NAME=your-store

# Server
PORT=3000

require('dotenv').config();
const express = require('express');
const bodyParser = require('body-parser');
const crypto = require('crypto');
const axios = require('axios');

const app = express();

// WhatsApp API client
class WhatsAppClient {
  constructor() {
    this.baseURL = `https://${process.env.RAPIDAPI_HOST}`;
    this.session = process.env.WHATSAPP_SESSION;
    this.headers = {
      'X-RapidAPI-Key': process.env.RAPIDAPI_KEY,
      'X-RapidAPI-Host': process.env.RAPIDAPI_HOST,
      'Content-Type': 'application/json'
    };
  }

  async sendMessage(phoneNumber, message) {
    try {
      const response = await axios.post(
        `${this.baseURL}/v1/sendText`,
        {
          chatId: phoneNumber.replace(/\D/g, ''), // Remove non-digits
          text: message
        },
        { headers: this.headers }
      );
      return response.data;
    } catch (error) {
      console.error('WhatsApp API Error:', error.response?.data || error.message);
      throw error;
    }
  }

  async sendImage(phoneNumber, imageUrl, caption) {
    try {
      const response = await axios.post(
        `${this.baseURL}/v1/sendImage`,
        {
          chatId: phoneNumber.replace(/\D/g, ''),
          url: imageUrl,
          caption: caption
        },
        { headers: this.headers }
      );
      return response.data;
    } catch (error) {
      console.error('WhatsApp Image Error:', error.response?.data || error.message);
      throw error;
    }
  }
}

const whatsapp = new WhatsAppClient();

// Verify Shopify webhook signature
function verifyShopifyWebhook(req) {
  const hmac = req.get('X-Shopify-Hmac-Sha256');
  const body = JSON.stringify(req.body);
  
  const hash = crypto
    .createHmac('sha256', process.env.SHOPIFY_WEBHOOK_SECRET)
    .update(body, 'utf8')
    .digest('base64');
  
  return hmac === hash;
}

// Middleware
app.use(bodyParser.json());

// Health check
app.get('/', (req, res) => {
  res.json({ status: 'running', message: 'Shopify-WhatsApp Integration' });
});

// Order Created Webhook
app.post('/webhooks/shopify/order-created', async (req, res) => {
  // Verify webhook authenticity
  if (!verifyShopifyWebhook(req)) {
    return res.status(401).json({ error: 'Invalid webhook signature' });
  }

  try {
    const order = req.body;
    
    // Extract order details
    const orderNumber = order.name; // e.g., "#1234"
    const customerName = order.customer?.first_name || 'Valued Customer';
    const customerPhone = order.customer?.phone || order.shipping_address?.phone;
    const totalPrice = `${order.total_price}`;
    const orderUrl = `https://${process.env.SHOPIFY_STORE_NAME}.myshopify.com/admin/orders/${order.id}`;
    
    // Get line items (products ordered)
    const items = order.line_items.map(item => 
      `• ${item.quantity}x ${item.title}`
    ).join('\n');

    // Format WhatsApp message
    const message = `
🎉 *Order Confirmed!*

Hi ${customerName}! Thank you for your order.

*Order:* ${orderNumber}
*Total:* ${totalPrice}

*Items:*
${items}

We're processing your order and will notify you once it ships!

Track your order: ${orderUrl}

Questions? Just reply to this message! 😊
    `.trim();

    // Send WhatsApp notification
    if (customerPhone) {
      await whatsapp.sendMessage(customerPhone, message);
      console.log(`✅ Order confirmation sent to ${customerPhone} for order ${orderNumber}`);
    } else {
      console.warn(`⚠️ No phone number for order ${orderNumber}`);
    }

    res.status(200).json({ success: true });
  } catch (error) {
    console.error('Error processing order webhook:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

// Order Fulfilled Webhook
app.post('/webhooks/shopify/order-fulfilled', async (req, res) => {
  if (!verifyShopifyWebhook(req)) {
    return res.status(401).json({ error: 'Invalid webhook signature' });
  }

  try {
    const order = req.body;
    
    const orderNumber = order.name;
    const customerName = order.customer?.first_name || 'Valued Customer';
    const customerPhone = order.customer?.phone || order.shipping_address?.phone;
    
    // Get tracking info
    const fulfillment = order.fulfillments[0];
    const trackingNumber = fulfillment?.tracking_number || 'N/A';
    const trackingUrl = fulfillment?.tracking_url || '#';
    const carrier = fulfillment?.tracking_company || 'Courier';

    const message = `
📦 *Your Order Has Shipped!*

Hi ${customerName}! Great news - your order ${orderNumber} is on the way!

*Carrier:* ${carrier}
*Tracking Number:* ${trackingNumber}

Track your package: ${trackingUrl}

Estimated delivery: 2-5 business days

Questions? Reply to this message anytime! 🚚
    `.trim();

    if (customerPhone) {
      await whatsapp.sendMessage(customerPhone, message);
      console.log(`✅ Shipping notification sent for order ${orderNumber}`);
    }

    res.status(200).json({ success: true });
  } catch (error) {
    console.error('Error processing fulfillment webhook:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

// Cart Abandonment (requires custom Shopify app or Shopify Plus)
app.post('/webhooks/shopify/cart-abandoned', async (req, res) => {
  if (!verifyShopifyWebhook(req)) {
    return res.status(401).json({ error: 'Invalid webhook signature' });
  }

  try {
    const cart = req.body;
    
    const customerPhone = cart.customer?.phone;
    const customerName = cart.customer?.first_name || 'there';
    const cartUrl = cart.abandoned_checkout_url;
    const itemCount = cart.line_items.length;
    const total = `${cart.total_price}`;

    const message = `
👋 Hi ${customerName}!

You left ${itemCount} item(s) in your cart.

*Cart Total:* ${total}

Complete your order now and get *10% OFF* with code: COMEBACK10

👉 ${cartUrl}

This offer expires in 24 hours!
    `.trim();

    if (customerPhone) {
      // Wait 30 minutes before sending (best practice)
      setTimeout(async () => {
        await whatsapp.sendMessage(customerPhone, message);
        console.log(`✅ Cart abandonment message sent to ${customerPhone}`);
      }, 30 * 60 * 1000); // 30 minutes
    }

    res.status(200).json({ success: true });
  } catch (error) {
    console.error('Error processing cart abandonment:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

// Start server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`✅ Server running on port ${PORT}`);
  console.log(`📱 WhatsApp notifications active`);
});

# Install Railway CLI
npm install -g @railway/cli

# Login and deploy
railway login
railway init
railway up

# Create Procfile
echo "web: node server.js" > Procfile

# Deploy
heroku create my-shopify-whatsapp
git add .
git commit -m "Initial commit"
git push heroku main

# On your server
git clone your-repo
cd shopify-whatsapp-integration
npm install
pm2 start server.js
pm2 save

<?php
/**
 * Plugin Name: WhatsApp Order Notifications
 * Description: Send WhatsApp notifications for WooCommerce orders
 * Version: 1.0.0
 * Author: Your Name
 */

if (!defined('ABSPATH')) exit;

class WhatsApp_Notifications {
    
    private $api_key;
    private $api_host;
    private $session;
    
    public function __construct() {
        $this->api_key = get_option('whatsapp_rapidapi_key');
        $this->api_host = 'whatsapp-messaging-bot.p.rapidapi.com';
        $this->session = 'woocommerce';
        
        // Hook into WooCommerce order events
        add_action('woocommerce_order_status_processing', array($this, 'send_order_confirmation'), 10, 1);
        add_action('woocommerce_order_status_completed', array($this, 'send_order_completed'), 10, 1);
        
        // Admin settings
        add_action('admin_menu', array($this, 'add_admin_menu'));
        add_action('admin_init', array($this, 'register_settings'));
    }
    
    public function send_order_confirmation($order_id) {
        $order = wc_get_order($order_id);
        
        if (!$order) return;
        
        $phone = $order->get_billing_phone();
        $name = $order->get_billing_first_name();
        $order_number = $order->get_order_number();
        $total = $order->get_formatted_order_total();
        $order_url = $order->get_view_order_url();
        
        // Get order items
        $items = array();
        foreach ($order->get_items() as $item) {
            $items[] = '• ' . $item->get_quantity() . 'x ' . $item->get_name();
        }
        $items_text = implode("\n", $items);
        
        $message = "🎉 *Order Confirmed!*\n\n";
        $message .= "Hi $name! Thank you for your order.\n\n";
        $message .= "*Order:* #$order_number\n";
        $message .= "*Total:* $total\n\n";
        $message .= "*Items:*\n$items_text\n\n";
        $message .= "We're processing your order now!\n\n";
        $message .= "Track your order: $order_url\n\n";
        $message .= "Questions? Just reply! 😊";
        
        $this->send_whatsapp_message($phone, $message);
    }
    
    public function send_order_completed($order_id) {
        $order = wc_get_order($order_id);
        
        if (!$order) return;
        
        $phone = $order->get_billing_phone();
        $name = $order->get_billing_first_name();
        $order_number = $order->get_order_number();
        
        $message = "✅ *Order Delivered!*\n\n";
        $message .= "Hi $name!\n\n";
        $message .= "Your order #$order_number has been delivered.\n\n";
        $message .= "We hope you love it! 💚\n\n";
        $message .= "Please rate your experience: " . home_url('/feedback') . "\n\n";
        $message .= "Thank you for shopping with us!";
        
        $this->send_whatsapp_message($phone, $message);
    }
    
    private function send_whatsapp_message($phone, $message) {
        if (empty($this->api_key)) {
            error_log('WhatsApp API key not configured');
            return false;
        }
        
        // Clean phone number (remove non-digits)
        $phone = preg_replace('/\D/', '', $phone);
        
        $url = "https://{$this->api_host}/v1/sendText";
        
        $data = array(
            'chatId' => $phone,
            'text' => $message,
            'session' => $this->session
        );
        
        $args = array(
            'headers' => array(
                'X-RapidAPI-Key' => $this->api_key,
                'X-RapidAPI-Host' => $this->api_host,
                'Content-Type' => 'application/json'
            ),
            'body' => json_encode($data),
            'timeout' => 15
        );
        
        $response = wp_remote_post($url, $args);
        
        if (is_wp_error($response)) {
            error_log('WhatsApp API Error: ' . $response->get_error_message());
            return false;
        }
        
        $body = json_decode(wp_remote_retrieve_body($response), true);
        error_log('WhatsApp message sent to ' . $phone . ' for order notification');
        
        return true;
    }
    
    public function add_admin_menu() {
        add_options_page(
            'WhatsApp Notifications',
            'WhatsApp Notifications',
            'manage_options',
            'whatsapp-notifications',
            array($this, 'settings_page')
        );
    }
    
    public function register_settings() {
        register_setting('whatsapp_notifications', 'whatsapp_rapidapi_key');
    }
    
    public function settings_page() {
        ?>
        <div class="wrap">
            <h1>WhatsApp Notifications Settings</h1>
            <form method="post" action="options.php">
                <?php settings_fields('whatsapp_notifications'); ?>
                <table class="form-table">
                    <tr>
                        <th>RapidAPI Key</th>
                        <td>
                            <input type="text" name="whatsapp_rapidapi_key" 
                                   value="<?php echo esc_attr(get_option('whatsapp_rapidapi_key')); ?>" 
                                   class="regular-text" />
                            <p class="description">
                                Get your API key from 
                                <a href="https://rapidapi.com/jevil257/api/whatsapp-messaging-bot" target="_blank">
                                    RapidAPI
                                </a>
                            </p>
                        </td>
                    </tr>
                </table>
                <?php submit_button(); ?>
            </form>
        </div>
        <?php
    }
}

new WhatsApp_Notifications();

// Generic order notification sender
async function sendOrderNotification(orderData) {
  const message = formatOrderMessage(orderData);
  
  return await fetch(`https://whatsapp-messaging-bot.p.rapidapi.com/v1/sendText`, {
    method: 'POST',
    headers: {
      'X-RapidAPI-Key': process.env.RAPIDAPI_KEY,
      'X-RapidAPI-Host': 'whatsapp-messaging-bot.p.rapidapi.com',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      chatId: orderData.customerPhone.replace(/\D/g, ''),
      text: message,
      session: 'default'
    })
  });
}

function formatOrderMessage(order) {
  return `
🎉 *Order Confirmed!*

Hi ${order.customerName}!

*Order:* #${order.orderNumber}
*Total:* ${order.total}

*Items:*
${order.items.map(item => `• ${item.quantity}x ${item.name}`).join('\n')}

Track your order: ${order.trackingUrl}

Questions? Reply anytime! 😊
  `.trim();
}

// Usage in your e-commerce backend
app.post('/api/orders', async (req, res) => {
  try {
    // Create order in your database
    const order = await createOrder(req.body);
    
    // Send WhatsApp notification
    await sendOrderNotification({
      customerName: order.customer.name,
      customerPhone: order.customer.phone,
      orderNumber: order.id,
      total: order.total,
      items: order.items,
      trackingUrl: `https://yourstore.com/orders/${order.id}`
    });
    
    res.json({ success: true, order });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

🎉 *Order Confirmed!*

Hi [NAME]! Thanks for your order.

*Order:* #[ORDER_NUMBER]
*Total:* $[AMOUNT]
*ETA:* [DELIVERY_DATE]

*Items:*
[ITEM_LIST]

Track: [TRACKING_URL]

Reply with questions! 😊

📦 *Package Shipped!*

Hi [NAME]!

Your order #[ORDER_NUMBER] is on the way!

*Carrier:* [CARRIER]
*Tracking:* [TRACKING_NUMBER]
*ETA:* [DELIVERY_DATE]

Track: [TRACKING_URL]

✅ *Delivered!*

Hi [NAME]!

Your order #[ORDER_NUMBER] was delivered.

Love it? Leave a review: [REVIEW_URL]

Thanks for shopping with us! 💚

// Integrate with shipping carriers
const tracking = require('tracking'); // Use shipping tracking library

async function checkDeliveryStatus(trackingNumber) {
  const status = await tracking.track(trackingNumber);
  
  if (status.isOutForDelivery) {
    await whatsapp.sendMessage(
      customer.phone,
      `🚚 Your order #${orderNumber} is out for delivery TODAY! 📦`
    );
  }
  
  if (status.isDelivered) {
    await whatsapp.sendMessage(
      customer.phone,
      `✅ Order #${orderNumber} delivered! Please confirm receipt. Thanks! 💚`
    );
  }
}

// Send order confirmation with product image
async function sendOrderWithImage(order) {
  const productImage = order.items[0].imageUrl;
  
  await whatsapp.sendImage(
    order.customerPhone,
    productImage,
    `🎉 Order #${order.number} confirmed! Total: ${order.total}. Thanks for shopping with us!`
  );
}

// Multi-step cart abandonment campaign
async function sendCartAbandonmentSequence(cart) {
  // Message 1: 30 minutes after abandonment
  setTimeout(async () => {
    await sendMessage(cart.phone, "👋 You left items in your cart! Complete your order: " + cart.url);
  }, 30 * 60 * 1000);
  
  // Message 2: 24 hours later (with discount)
  setTimeout(async () => {
    await sendMessage(cart.phone, "🎁 Still interested? Get 10% OFF with code COMEBACK10: " + cart.url);
  }, 24 * 60 * 60 * 1000);
  
  // Message 3: 3 days later (final reminder)
  setTimeout(async () => {
    await sendMessage(cart.phone, "⏰ Last chance! Your cart expires soon. Order now: " + cart.url);
  }, 3 * 24 * 60 * 60 * 1000);
}

// Add analytics to your notifications
const analytics = {
  messagesSent: 0,
  messagesDelivered: 0,
  messagesRead: 0,
  clickThroughRate: 0
};

async function sendTrackedMessage(phone, message, orderNumber) {
  try {
    const result = await whatsapp.sendMessage(phone, message);
    
    // Track in database
    await db.notifications.create({
      orderNumber,
      phone,
      message,
      sentAt: new Date(),
      status: 'sent'
    });
    
    analytics.messagesSent++;
    
    return result;
  } catch (error) {
    console.error('Failed to send notification:', error);
    analytics.messagesFailed = (analytics.messagesFailed || 0) + 1;
  }
}

Current SMS Volume: 10,000 messages/month
SMS Cost: $0.01/message = $100/month

WhatsApp Cost: $0.003/message = $30/month

Monthly Savings: $70
Annual Savings: $840

ROI: 70% cost reduction

function calculateSavings(monthlyVolume) {
  const smsCost = monthlyVolume * 0.01;
  const whatsappCost = monthlyVolume * 0.003;
  const monthlySavings = smsCost - whatsappCost;
  const annualSavings = monthlySavings * 12;
  const roi = ((smsCost - whatsappCost) / smsCost * 100).toFixed(1);
  
  return {
    smsCost,
    whatsappCost,
    monthlySavings,
    annualSavings,
    roi: `${roi}%`
  };
}

console.log(calculateSavings(10000));
// Output: { smsCost: 100, whatsappCost: 30, monthlySavings: 70, annualSavings: 840, roi: '70.0%' }

// Check consent before sending
async function sendNotificationWithConsent(order) {
  const customer = await db.customers.findOne({ phone: order.customerPhone });
  
  if (!customer.whatsappOptIn) {
    console.log('Customer has not opted in to WhatsApp notifications');
    return;
  }
  
  await whatsapp.sendMessage(order.customerPhone, formatOrderMessage(order));
}