Advanced RevenueCat Guide — Win-Back Campaigns, Offer Codes & Churn Prevention to Maximize LTV

import Purchases, { PromotionalOffer } from 'react-native-purchases';
 
const checkWinBackEligibility = async (): Promise<boolean> => {
  const customerInfo = await Purchases.getCustomerInfo();
 
  const hasActiveSubscription =
    Object.keys(customerInfo.entitlements.active).length > 0;
 
  const hadPreviousSubscription =
    customerInfo.allPurchasedProductIdentifiers.some(id =>
      ['premium_monthly', 'premium_yearly'].includes(id)
    );
 
  return !hasActiveSubscription && hadPreviousSubscription;
};
 
const presentWinBackOffer = async () => {
  try {
    const offerings = await Purchases.getOfferings();
    const winBackOffering = offerings.all['win_back'];
 
    if (!winBackOffering?.monthly) {
      presentStandardOffering();
      return;
    }
 
    const pkg = winBackOffering.monthly;
    const discount = pkg.product.discounts?.[0];
 
    if (!discount) {
      presentStandardOffering();
      return;
    }
 
    const promotionalOffer = await Purchases.getPromotionalOffer(
      pkg.product,
      discount
    );
 
    if (promotionalOffer) {
      const { customerInfo } = await Purchases.purchaseDiscountedPackage(
        pkg,
        promotionalOffer
      );
 
      if (customerInfo.entitlements.active['premium']) {
        navigation.replace('WelcomeBack');
      }
    }
  } catch (e: any) {
    if (!e.userCancelled) {
      console.error('Win-Back purchase error:', e);
    }
  }
};

// Backend (Hono on Cloudflare Workers)
app.post('/webhooks/revenuecat', async (c) => {
  const { event } = await c.req.json();
 
  switch (event.type) {
    case 'EXPIRATION': {
      const userId = event.app_user_id;
 
      // Day 1: Graceful "we'll miss you" email — no hard sell
      await scheduleEmail(userId, 'expiration_day1');
 
      // Day 7: Feedback request + 30% discount offer
      await scheduleEmail(userId, 'expiration_day7', {
        offerCode: 'COMEBACK30',
        expiresAt: addDays(new Date(), 14),
      });
 
      // Day 30: Win-Back push notification — "We have a special offer for you"
      await schedulePushNotification(userId, 'winback_day30');
 
      // Day 90: Final deep-discount offer (50% off, 2 months)
      await scheduleEmail(userId, 'expiration_day90', {
        offerCode: 'WINBACK50',
        isLastOffer: true,
      });
      break;
    }
    case 'RENEWAL': {
      // User resubscribed — cancel all pending Win-Back messages
      await cancelScheduledMessages(event.app_user_id);
      break;
    }
  }
 
  return c.json({ received: true });
});

const checkSubscriptionStatus = async () => {
  const customerInfo = await Purchases.getCustomerInfo();
  const entitlement = customerInfo.entitlements.all['premium'];
 
  if (!entitlement) return { status: 'free' };
 
  const { isActive, willRenew, billingIssueDetectedAt, gracePeriodExpiresDate } =
    entitlement;
 
  if (isActive && billingIssueDetectedAt) {
    return {
      status: 'grace_period',
      expiresAt: gracePeriodExpiresDate,
      daysRemaining: Math.ceil(
        (new Date(gracePeriodExpiresDate!).getTime() - Date.now()) /
        (1000 * 60 * 60 * 24)
      ),
    };
  }
 
  if (isActive && !willRenew) return { status: 'cancelling' };
  if (isActive) return { status: 'active' };
  return { status: 'expired' };
};
 
const GracePeriodBanner = ({ daysRemaining }: { daysRemaining: number }) => (
  <View style={styles.warningBanner}>
    <Ionicons name="warning-outline" size={20} color="#FF9500" />
    <Text style={styles.warningText}>
      Your payment couldn't be processed. Update your payment info within{' '}
      {daysRemaining} day{daysRemaining !== 1 ? 's' : ''} to keep your access.
    </Text>
    <TouchableOpacity
      onPress={() =>
        Linking.openURL('https://apps.apple.com/account/subscriptions')
      }
    >
      <Text style={styles.updateLink}>Update Now</Text>
    </TouchableOpacity>
  </View>
);

type CancellationReason =
  | 'too_expensive'
  | 'not_using_enough'
  | 'missing_features'
  | 'technical_issues'
  | 'temporary_break'
  | 'other';
 
const RETENTION_OFFERS = {
  too_expensive: { type: 'discount', discount: 50 },
  not_using_enough: { type: 'pause', pauseDays: 30 },
  missing_features: { type: 'feedback' },
  technical_issues: { type: 'support' },
  temporary_break: { type: 'pause', pauseDays: 30 },
  other: { type: 'discount', discount: 30 },
};
 
export const CancellationFlowScreen = () => {
  const [step, setStep] = useState<'survey' | 'offer' | 'confirmed'>('survey');
  const [reason, setReason] = useState<CancellationReason | null>(null);
 
  const reasons = [
    { key: 'too_expensive' as const, label: "It's too expensive" },
    { key: 'not_using_enough' as const, label: "I'm not using it enough" },
    { key: 'missing_features' as const, label: "Missing features I need" },
    { key: 'technical_issues' as const, label: "I'm having technical issues" },
    { key: 'temporary_break' as const, label: "I need a break" },
    { key: 'other' as const, label: "Other" },
  ];
 
  if (step === 'survey') {
    return (
      <View style={styles.container}>
        <Text style={styles.title}>
          Before you go — what's the reason?
        </Text>
        {reasons.map(({ key, label }) => (
          <TouchableOpacity
            key={key}
            style={styles.reasonRow}
            onPress={() => { setReason(key); setStep('offer'); }}
          >
            <Text style={styles.reasonText}>{label}</Text>
            <Ionicons name="chevron-forward" size={16} color="#999" />
          </TouchableOpacity>
        ))}
      </View>
    );
  }
 
  // Render tailored offer card based on reason...
  return (
    <RetentionOfferCard
      offer={RETENTION_OFFERS[reason!]}
      onAccept={() => applyRetentionOffer(reason!)}
      onDecline={() => openSubscriptionManagement()}
    />
  );
};

// Deterministically split target users into two groups.
// Bucket by a hash of user.id so groups stay stable across re-runs.
const assignWinbackGroup = (userId: string): 'treatment' | 'holdout' => {
  // Simple but stable hash (a small FNV-1a variant)
  let hash = 2166136261;
  for (let i = 0; i < userId.length; i++) {
    hash ^= userId.charCodeAt(i);
    hash = Math.imul(hash, 16777619);
  }
  // Route 15% to holdout (offer goes to the remaining 85%)
  return (hash >>> 0) % 100 < 15 ? 'holdout' : 'treatment';
};
 
// When running the campaign
const runWinbackCampaign = async (lapsedUsers: LapsedUser[]) => {
  for (const user of lapsedUsers) {
    const group = assignWinbackGroup(user.id);
 
    // Record the assignment so you can reconcile rates later
    await recordCampaignAssignment({
      userId: user.id,
      campaign: 'winback_2026q3',
      group,
      assignedAt: new Date().toISOString(),
    });
 
    // Send the offer only to the treatment group
    if (group === 'treatment') {
      await sendWinbackOffer(user);
    }
  }
};

// Compute incremental lift
const measureIncrementalLift = (results: {
  treatmentReactivated: number;
  treatmentTotal: number;
  holdoutReactivated: number;
  holdoutTotal: number;
}) => {
  const treatmentRate = results.treatmentReactivated / results.treatmentTotal;
  const holdoutRate = results.holdoutReactivated / results.holdoutTotal;
 
  // The reactivation the offer genuinely drove
  const incrementalLift = treatmentRate - holdoutRate;
 
  return {
    treatmentRate: (treatmentRate * 100).toFixed(1) + '%',
    holdoutRate: (holdoutRate * 100).toFixed(1) + '%',
    incrementalLift: (incrementalLift * 100).toFixed(1) + 'pt',
    // Whether the discount is worth it comes from this increment x LTV
  };
};

const fetchRevenueCatMetrics = async () => {
  const headers = {
    Authorization: `Bearer ${process.env.REVENUECAT_SECRET_KEY}`,
    'Content-Type': 'application/json',
  };
 
  const [mrrRes, churnRes, conversionRes] = await Promise.all([
    fetch('https://api.revenuecat.com/v1/charts/mrr', { headers }),
    fetch('https://api.revenuecat.com/v1/charts/churned_subscribers', { headers }),
    fetch('https://api.revenuecat.com/v1/charts/trial_conversion', { headers }),
  ]);
 
  return {
    mrr: await mrrRes.json(),
    churn: await churnRes.json(),
    conversion: await conversionRes.json(),
  };
};