Claude API × Stripe で SaaS を構築 — AI サブスクリプションサービスの収益化

// lib/claudeClient.ts
import Anthropic from '@anthropic-ai/sdk';
 
const client = new Anthropic();
 
export async function callClaudeWithTracking(
  userId: string,
  message: string
): Promise<{ response: string; cost: number }> {
  const response = await client.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 1024,
    messages: [{ role: 'user', content: message }],
  });
 
  const inputTokens = response.usage.input_tokens;
  const outputTokens = response.usage.output_tokens;
 
  // トークン単価（2024年3月時点）
  const inputCost = (inputTokens / 1000) * 0.003;
  const outputCost = (outputTokens / 1000) * 0.015;
  const totalCost = inputCost + outputCost;
 
  // データベースにコストを記録
  await logApiUsage(userId, {
    inputTokens,
    outputTokens,
    cost: totalCost,
    timestamp: new Date(),
  });
 
  return {
    response: response.content[0].type === 'text' ? response.content[0].text : '',
    cost: totalCost,
  };
}
 
async function logApiUsage(userId: string, usage: any) {
  // Supabase、Firebase、MongoDB など任意のデータベースに記録
  // 例：await db.insertOne('api_usage', { userId, ...usage })
}

// lib/cache.ts
import Redis from 'redis';
 
const redis = Redis.createClient();
 
export async function getOrCallClaude(
  userId: string,
  prompt: string
): Promise<string> {
  const cacheKey = `claude:${userId}:${hashPrompt(prompt)}`;
 
  // キャッシュを確認
  const cached = await redis.get(cacheKey);
  if (cached) {
    return cached;
  }
 
  // Claude API を呼び出す
  const { response, cost } = await callClaudeWithTracking(userId, prompt);
 
  // 結果をキャッシュ（24時間有効）
  await redis.setex(cacheKey, 86400, response);
 
  // ユーザーの月間コストが上限に達していないか確認
  const monthlyUsage = await getMonthlyUsage(userId);
  const plan = await getUserPlan(userId);
 
  if (monthlyUsage + cost > plan.monthlyTokenBudget) {
    throw new Error('API token budget exceeded');
  }
 
  return response;
}
 
function hashPrompt(prompt: string): string {
  return require('crypto').createHash('sha256').update(prompt).digest('hex');
}

// pages/api/webhooks/stripe.ts
import Stripe from 'stripe';
import { buffer } from 'micro';
import type { NextApiRequest, NextApiResponse } from 'next';
 
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET!;
 
export const config = {
  api: {
    bodyParser: false,
  },
};
 
export default async function handler(
  req: NextApiRequest,
  res: NextApiResponse
) {
  if (req.method !== 'POST') {
    return res.status(405).end();
  }
 
  const buf = await buffer(req);
  const sig = req.headers['stripe-signature'] as string;
 
  let event: Stripe.Event;
 
  try {
    event = stripe.webhooks.constructEvent(buf, sig, webhookSecret);
  } catch (err) {
    return res.status(400).send(`Webhook Error: ${(err as Error).message}`);
  }
 
  try {
    switch (event.type) {
      case 'customer.subscription.created':
        await handleSubscriptionCreated(event.data.object as Stripe.Subscription);
        break;
 
      case 'customer.subscription.updated':
        await handleSubscriptionUpdated(event.data.object as Stripe.Subscription);
        break;
 
      case 'customer.subscription.deleted':
        await handleSubscriptionDeleted(event.data.object as Stripe.Subscription);
        break;
 
      case 'invoice.payment_succeeded':
        await handlePaymentSucceeded(event.data.object as Stripe.Invoice);
        break;
 
      case 'invoice.payment_failed':
        await handlePaymentFailed(event.data.object as Stripe.Invoice);
        break;
    }
 
    res.json({ received: true });
  } catch (err) {
    console.error('Webhook processing error:', err);
    res.status(500).json({ error: 'Webhook processing failed' });
  }
}
 
async function handleSubscriptionCreated(subscription: Stripe.Subscription) {
  const userId = subscription.client_reference_id;
  const planId = subscription.items.data[0].price.product;
 
  // ユーザーのサブスク情報をデータベースに保存
  await db.updateUser(userId, {
    stripeCustomerId: subscription.customer,
    stripeSubscriptionId: subscription.id,
    planId: planId,
    planStatus: 'active',
    renewalDate: new Date(subscription.current_period_end * 1000),
  });
}
 
async function handleSubscriptionUpdated(subscription: Stripe.Subscription) {
  const userId = subscription.client_reference_id;
 
  if (subscription.cancel_at_period_end) {
    // 次の更新タイミングで自動キャンセル予定
    await db.updateUser(userId, {
      cancellationScheduled: true,
      cancellationDate: new Date(subscription.current_period_end * 1000),
    });
  } else {
    // キャンセル予定をクリア
    await db.updateUser(userId, {
      cancellationScheduled: false,
      cancellationDate: null,
    });
  }
}
 
async function handleSubscriptionDeleted(subscription: Stripe.Subscription) {
  const userId = subscription.client_reference_id;
 
  // ユーザーアクセス権限を無効化
  await db.updateUser(userId, {
    planStatus: 'inactive',
    planId: null,
  });
 
  // 解約分析用にデータを記録
  await logChurn(userId, {
    cancelledAt: new Date(),
    planDuration: Math.floor(
      (subscription.ended_at! - subscription.created) / (24 * 60 * 60)
    ),
  });
}

// components/ChurnPrevention.tsx
import { useUser } from '@/hooks/useUser';
import { useEffect, useState } from 'react';
 
export default function ChurnPrevention() {
  const { user } = useUser();
  const [shouldShowOffer, setShouldShowOffer] = useState(false);
 
  useEffect(() => {
    // 条件1：API 使用率が低い（非アクティブユーザー）
    if (user.monthlyApiUsage < user.plan.monthlyTokenBudget * 0.1) {
      setShouldShowOffer(true);
      return;
    }
 
    // 条件2：過去7日間のアクティビティがない
    const lastActivity = new Date(user.lastApiCall).getTime();
    const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
    if (lastActivity < sevenDaysAgo) {
      setShouldShowOffer(true);
      return;
    }
 
    // 条件3：ダウングレードプランへの移動を検討中
    if (user.hasViewedDowngradePage) {
      setShouldShowOffer(true);
    }
  }, [user]);
 
  if (!shouldShowOffer) return null;
 
  return (
    <div className="fixed bottom-4 right-4 bg-blue-50 border border-blue-200 rounded-lg p-4 max-w-sm">
      <h3 className="font-semibold text-blue-900">Pro プランをお試しください</h3>
      <p className="text-sm text-blue-700 mt-2">
        Premium AI 機能にアクセスして、生産性を 3 倍向上させましょう。
      </p>
      <button className="mt-3 w-full bg-blue-600 text-white py-2 rounded hover:bg-blue-700">
        Pro にアップグレード
      </button>
    </div>
  );
}

// lib/emailSequence.ts
import nodemailer from 'nodemailer';
 
const mailer = nodemailer.createTransport({
  service: 'sendgrid',
  auth: {
    user: 'apikey',
    pass: process.env.SENDGRID_API_KEY,
  },
});
 
export async function sendChurnWinbackEmail(userId: string, email: string) {
  const couponCode = generateCouponCode(userId);
 
  await mailer.sendMail({
    to: email,
    subject: '戻ってきてください！30% 割引オファー',
    html: `
      <h2>AI アシスタントを再度ご利用ください</h2>
      <p>お客様のご利用ありがとうございました。次の 30 日間、30% 割引でプロプランをご提供します。</p>
      <p><strong>クーポンコード：${couponCode}</strong></p>
      <p>以下のリンクから再開できます：</p>
      <a href="https://app.example.com/reactivate?code=${couponCode}">
        プランを再開する
      </a>
    `,
  });
}
 
function generateCouponCode(userId: string): string {
  return `WELCOME30_${userId}_${Date.now()}`;
}

// prisma/schema.prisma
model User {
  id                    String @id @default(cuid())
  email                 String @unique
  stripeCustomerId      String?
  stripeSubscriptionId  String?
  plan                  String @default("free") // "free", "basic", "pro"
  monthlyTokenBudget    Int @default(50000)
  monthlyTokenUsed      Int @default(0)
  renewalDate           DateTime?
  createdAt             DateTime @default(now())
 
  apiUsage              ApiUsage[]
  subscriptions         Subscription[]
}
 
model ApiUsage {
  id                String @id @default(cuid())
  userId            String
  user              User @relation(fields: [userId], references: [id])
  inputTokens       Int
  outputTokens      Int
  cost              Float
  month             Int
  year              Int
  createdAt         DateTime @default(now())
 
  @@unique([userId, month, year])
}
 
model Subscription {
  id                String @id @default(cuid())
  userId            String
  user              User @relation(fields: [userId], references: [id])
  stripeSubscriptionId String @unique
  stripeCustomerId  String
  plan              String
  status            String
  renewalDate       DateTime
  cancelledAt       DateTime?
  createdAt         DateTime @default(now())
}

// lib/aiService.ts
import Anthropic from '@anthropic-ai/sdk';
import { prisma } from '@/lib/prisma';
 
const anthropic = new Anthropic({
  apiKey: process.env.CLAUDE_API_KEY,
});
 
interface ProcessResult {
  text: string;
  tokensUsed: number;
  costJpy: number;
}
 
export async function processWithClaude(
  userId: string,
  userMessage: string
): Promise<ProcessResult> {
  // ユーザーの月間トークン使用量を確認
  const user = await prisma.user.findUnique({ where: { id: userId } });
 
  if (!user) throw new Error('User not found');
  if (user.monthlyTokenUsed >= user.monthlyTokenBudget) {
    throw new Error('Monthly token budget exceeded');
  }
 
  try {
    const message = await anthropic.messages.create({
      model: 'claude-3-5-sonnet-20241022',
      max_tokens: 1024,
      system: 'You are a helpful assistant for business users.',
      messages: [
        {
          role: 'user',
          content: userMessage,
        },
      ],
    });
 
    const inputTokens = message.usage.input_tokens;
    const outputTokens = message.usage.output_tokens;
 
    // USD をJPY に変換（1 USD = 150 JPY と仮定）
    const inputCostUsd = (inputTokens / 1000) * 0.003;
    const outputCostUsd = (outputTokens / 1000) * 0.015;
    const costJpy = (inputCostUsd + outputCostUsd) * 150;
 
    // ユーザーの使用量を更新
    await prisma.user.update({
      where: { id: userId },
      data: {
        monthlyTokenUsed: user.monthlyTokenUsed + inputTokens + outputTokens,
      },
    });
 
    // API 使用ログを記録
    const now = new Date();
    await prisma.apiUsage.upsert({
      where: {
        userId_month_year: {
          userId,
          month: now.getMonth() + 1,
          year: now.getFullYear(),
        },
      },
      create: {
        userId,
        inputTokens,
        outputTokens,
        cost: costJpy / 150, // USD で保存
        month: now.getMonth() + 1,
        year: now.getFullYear(),
      },
      update: {
        inputTokens: {
          increment: inputTokens,
        },
        outputTokens: {
          increment: outputTokens,
        },
        cost: {
          increment: costJpy / 150,
        },
      },
    });
 
    const responseText =
      message.content[0].type === 'text' ? message.content[0].text : '';
 
    return {
      text: responseText,
      tokensUsed: inputTokens + outputTokens,
      costJpy,
    };
  } catch (error) {
    throw new Error(`Claude API error: ${(error as Error).message}`);
  }
}