#WhatsApp Surveys: 40% Response Rate vs 5% Email

1. "How likely are you to recommend us to a friend? (0-10)"
2. "What's the main reason for your score?"
3. "One thing we could improve?"

[30 minutes after order confirmation]
"Hi {name}! Quick question about your recent order..."

[Wait 2 seconds]
"How would you rate your experience? Reply with a number:
1 - Poor
2 - Fair
3 - Good
4 - Excellent"

[After they respond]
"Thanks! What did you like most about your experience?"

[After they respond]
"Got it. Anything we could improve?"

[After they respond]
"Appreciate the feedback! We're always working to get better."

import requests
import time

API_BASE = "https://apiv2.waiflow.app/api/v2"
API_TOKEN = "your_api_key_here"
SESSION_NAME = "feedback-bot"

def send_survey(customer_phone, customer_name, order_id):
    """Send NPS survey to customer after purchase"""

    headers = {
        "Authorization": f"Bearer {API_TOKEN}",
        "Content-Type": "application/json"
    }

    # Question 1: NPS score
    payload_q1 = {
        "chatId": f"{customer_phone}@c.us",
        "text": f"Hi {customer_name}! Thanks for your order #{order_id}.\n\nQuick question: How likely are you to recommend us to a friend?\n\nReply with a number from 0-10 (0=Not at all, 10=Extremely likely)"
    }

    response = requests.post(
        f"{API_BASE}/sessions/{SESSION_NAME}/messages",
        headers=headers,
        json=payload_q1
    )

    if response.status_code != 200:
        print(f"Failed to send survey: {response.text}")
        return False

    print(f"Survey sent to {customer_name}")
    return True

# Example: Send survey 30 minutes after purchase
# (In production, trigger this from your order system webhook)
send_survey(
    customer_phone="16505551234",
    customer_name="Sarah",
    order_id="ORD-2026-001"
)

from flask import Flask, request, jsonify
import re

app = Flask(__name__)

# Store responses (use a real database in production)
survey_responses = {}

@app.route('/webhooks/moltflow', methods=['POST'])
def handle_webhook():
    """Process incoming WhatsApp messages for survey responses"""

    event = request.json

    # Only process incoming messages
    if event.get('event') != 'message':
        return jsonify({'status': 'ignored'}), 200

    message = event.get('payload', {}).get('message', {})
    text = message.get('text', {}).get('body', '').strip()
    from_number = message.get('from', '').replace('@c.us', '')

    # Check if this is a survey response
    if from_number in survey_responses:
        response_data = survey_responses[from_number]
        current_step = response_data.get('step', 1)

        if current_step == 1:
            # Parse NPS score (0-10)
            nps_score = parse_nps_score(text)
            if nps_score is not None:
                response_data['nps_score'] = nps_score
                response_data['step'] = 2

                # Send follow-up question
                send_message(
                    from_number,
                    "Thanks! What's the main reason for your score?"
                )
            else:
                # Invalid response, ask again
                send_message(
                    from_number,
                    "Please reply with a number from 0 to 10."
                )

        elif current_step == 2:
            # Capture reason for score
            response_data['reason'] = text
            response_data['step'] = 3

            send_message(
                from_number,
                "Got it. One thing we could improve?"
            )

        elif current_step == 3:
            # Capture improvement suggestion
            response_data['improvement'] = text
            response_data['completed'] = True

            # Thank them
            send_message(
                from_number,
                "Appreciate the feedback! We're always working to get better. 🙏"
            )

            # Save to database
            save_survey_response(response_data)

    return jsonify({'status': 'processed'}), 200

def parse_nps_score(text):
    """Extract numeric score from text response"""
    # Match standalone number or number followed by text
    match = re.search(r'\b([0-9]|10)\b', text)
    if match:
        score = int(match.group(1))
        return score if 0 <= score <= 10 else None
    return None

def send_message(phone, text):
    """Send WhatsApp message via MoltFlow API"""
    # Implementation same as Step 2
    pass

def save_survey_response(response_data):
    """Save completed survey to database"""
    # Save to PostgreSQL, MongoDB, Google Sheets, etc.
    print(f"Survey completed: {response_data}")

if __name__ == '__main__':
    app.run(port=5000)

def calculate_nps(responses):
    """
    Calculate Net Promoter Score from survey responses

    NPS = % Promoters (9-10) - % Detractors (0-6)
    Passives (7-8) don't count toward score
    """
    if not responses:
        return None

    scores = [r['nps_score'] for r in responses if 'nps_score' in r]
    total = len(scores)

    promoters = len([s for s in scores if s >= 9])
    detractors = len([s for s in scores if s <= 6])

    nps = ((promoters - detractors) / total) * 100

    return {
        'nps': round(nps, 1),
        'promoters': promoters,
        'passives': total - promoters - detractors,
        'detractors': detractors,
        'total_responses': total
    }

# Example usage
all_responses = get_recent_surveys(days=30)
nps_data = calculate_nps(all_responses)

print(f"Current NPS: {nps_data['nps']}")
print(f"Promoters: {nps_data['promoters']} ({nps_data['promoters']/nps_data['total_responses']*100:.1f}%)")
print(f"Detractors: {nps_data['detractors']} ({nps_data['detractors']/nps_data['total_responses']*100:.1f}%)")

from collections import Counter
import re

def extract_themes(responses, field='reason'):
    """Find common themes in open-ended responses"""

    # Simple keyword extraction (use NLP for production)
    keywords = []
    for response in responses:
        text = response.get(field, '').lower()
        words = re.findall(r'\b\w+\b', text)
        # Filter stopwords
        keywords.extend([w for w in words if len(w) > 3])

    # Most common themes
    common = Counter(keywords).most_common(10)
    return common

themes = extract_themes(all_responses, field='reason')
print("Most mentioned topics:")
for theme, count in themes:
    print(f"  {theme}: {count} mentions")

def handle_promoter(customer_phone, customer_name):
    """Follow up with promoters for reviews"""

    send_message(
        customer_phone,
        f"Thanks {customer_name}! 🎉\n\nWould you mind sharing your experience on Google? It helps us reach more customers like you.\n\n[Review link]"
    )

def handle_detractor(customer_phone, customer_name, nps_score, reason):
    """Alert support team for detractors"""

    # Send to support channel (Slack, email, etc.)
    alert_support_team({
        'customer': customer_name,
        'phone': customer_phone,
        'score': nps_score,
        'reason': reason,
        'priority': 'high'
    })

    # Send apology message
    send_message(
        customer_phone,
        f"Sorry to hear we fell short, {customer_name}. Our team will reach out within 24 hours to make this right."
    )

def send_weekly_summary():
    """Send NPS summary to team"""

    last_week = get_recent_surveys(days=7)
    nps_data = calculate_nps(last_week)
    themes = extract_themes(last_week)

    summary = f"""
    Weekly NPS Report

    Current NPS: {nps_data['nps']}
    Responses: {nps_data['total_responses']}
    Promoters: {nps_data['promoters']}
    Detractors: {nps_data['detractors']}

    Top Feedback Themes:
    {format_themes(themes)}

    Action Items:
    - {get_action_items(last_week)}
    """

    send_email(to="[email protected]", subject="Weekly NPS", body=summary)