Rork × Stripe Meter で AI アプリの使用量課金を実装する — トークン数・API 呼び出し回数で正確に課金する設計ガイド

// cloudflare-workers/src/meter.ts
import Stripe from 'stripe';
 
interface Env {
  STRIPE_SECRET_KEY: string;
}
 
interface MeterEventBody {
  customerId: string;
  eventName: string;
  value?: number; // トークン数など（省略時は1）
}
 
export async function handleMeterEvent(
  request: Request,
  env: Env
): Promise<Response> {
  // リクエストボディのパース
  let body: MeterEventBody;
  try {
    body = await request.json();
  } catch {
    return new Response(JSON.stringify({ error: 'Invalid JSON body' }), {
      status: 400,
      headers: { 'Content-Type': 'application/json' },
    });
  }
 
  // 必須フィールドのバリデーション
  if (!body.customerId || !body.eventName) {
    return new Response(
      JSON.stringify({ error: 'customerId and eventName are required' }),
      {
        status: 400,
        headers: { 'Content-Type': 'application/json' },
      }
    );
  }
 
  const stripe = new Stripe(env.STRIPE_SECRET_KEY, {
    apiVersion: '2024-11-20.acacia',
  });
 
  try {
    // Stripe Meter Event を送信
    const meterEvent = await stripe.billing.meterEvents.create({
      event_name: body.eventName, // 例: 'ai_api_call'
      payload: {
        stripe_customer_id: body.customerId,
        // トークン数など追加データも送れる
        ...(body.value !== undefined && { value: String(body.value) }),
      },
    });
 
    return new Response(
      JSON.stringify({ success: true, identifier: meterEvent.identifier }),
      {
        status: 200,
        headers: { 'Content-Type': 'application/json' },
      }
    );
  } catch (error) {
    // Stripe のエラーを適切に処理する
    if (error instanceof Stripe.errors.StripeInvalidRequestError) {
      return new Response(
        JSON.stringify({ error: 'Invalid Stripe request', details: error.message }),
        {
          status: 400,
          headers: { 'Content-Type': 'application/json' },
        }
      );
    }
 
    // 予期しないエラーはログに記録して 500 を返す
    console.error('Meter event error:', error);
    return new Response(
      JSON.stringify({ error: 'Internal server error' }),
      {
        status: 500,
        headers: { 'Content-Type': 'application/json' },
      }
    );
  }
}

// Rork アプリの AI チャット機能（TypeScript）
 
interface ChatResponse {
  message: string;
  tokensUsed: number;
}
 
async function sendChatMessage(
  userMessage: string,
  stripeCustomerId: string
): Promise<ChatResponse> {
  // 1. AI API を呼び出す（例: Gemini 2.5 Flash）
  const aiResponse = await callGeminiAPI(userMessage);
 
  // 2. 使用量をバックエンドに報告する
  // ※ AI 呼び出しが成功してから報告する（失敗した呼び出しは課金しない）
  try {
    await reportUsage({
      customerId: stripeCustomerId,
      eventName: 'ai_api_call',
      value: aiResponse.tokensUsed,
    });
  } catch (reportError) {
    // 使用量報告に失敗してもユーザーへのレスポンスは返す
    // 失敗はログに記録してリトライキューに積む
    console.warn('Usage report failed, will retry:', reportError);
    await queueRetry({ customerId: stripeCustomerId, tokensUsed: aiResponse.tokensUsed });
  }
 
  return {
    message: aiResponse.content,
    tokensUsed: aiResponse.tokensUsed,
  };
}
 
async function reportUsage(params: {
  customerId: string;
  eventName: string;
  value?: number;
}): Promise<void> {
  const response = await fetch('https://your-workers.your-domain.workers.dev/api/meter-event', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      // 内部APIの認証（環境変数から取得）
      'Authorization': `Bearer ${process.env.EXPO_PUBLIC_INTERNAL_API_KEY}`,
    },
    body: JSON.stringify(params),
  });
 
  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Usage report failed: ${error.error}`);
  }
}

// バックエンド: ハイブリッドサブスクリプションの作成
async function createHybridSubscription(
  stripe: Stripe,
  customerId: string
): Promise<Stripe.Subscription> {
  return await stripe.subscriptions.create({
    customer: customerId,
    items: [
      {
        // 基本料金（固定月額）
        price: 'price_base_monthly_300yen', // 月額 300 円
      },
      {
        // 使用量課金（Meter 連携プライス）
        price: 'price_meter_ai_calls',       // 1 呼び出しあたり ¥0.5
        // Meter Price は quantity 不要（自動集計される）
      },
    ],
    payment_behavior: 'default_incomplete',
    payment_settings: {
      save_default_payment_method: 'on_subscription',
    },
    expand: ['latest_invoice.payment_intent'],
  });
}

// バックエンド: 今月の使用量を取得する
async function getCurrentMonthUsage(
  stripe: Stripe,
  customerId: string,
  meterId: string
): Promise<{ used: number; limit: number | null }> {
  const now = new Date();
  const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
 
  // Stripe Meter Summary からデータを取得
  const meterSummary = await stripe.billing.meters.listEventSummaries(meterId, {
    customer: customerId,
    start_time: Math.floor(startOfMonth.getTime() / 1000),
    end_time: Math.floor(now.getTime() / 1000),
    value_grouping_window: 'month',
  });
 
  const totalUsed = meterSummary.data.reduce(
    (sum, summary) => sum + summary.aggregated_value,
    0
  );
 
  return {
    used: totalUsed,
    limit: null, // スペンドキャップから取得する場合は別途実装
  };
}

// 重複排除のための Idempotency Key 生成
async function reportUsageWithIdempotency(params: {
  customerId: string;
  sessionId: string; // AI セッションごとのユニーク ID
  tokensUsed: number;
}): Promise<void> {
  // sessionId を使って冪等キーを生成する
  const idempotencyKey = `meter_${params.customerId}_${params.sessionId}`;
 
  const stripe = new Stripe(env.STRIPE_SECRET_KEY);
 
  await stripe.billing.meterEvents.create(
    {
      event_name: 'ai_api_call',
      payload: {
        stripe_customer_id: params.customerId,
        value: String(params.tokensUsed),
      },
    },
    {
      idempotencyKey, // これで重複を防ぐ
    }
  );
}

const METER_ID = process.env.NODE_ENV === 'production'
  ? 'mtr_prod_xxxxxxxxxx'
  : 'mtr_test_xxxxxxxxxx';

// サインアップ時の処理（Supabase の例）
async function onUserSignUp(userId: string, email: string): Promise<void> {
  const stripe = new Stripe(env.STRIPE_SECRET_KEY);
 
  // Stripe Customer を作成
  const customer = await stripe.customers.create({
    email,
    metadata: {
      app_user_id: userId, // アプリ内の User ID を紐づける
    },
  });
 
  // Supabase の users テーブルに保存
  await supabase
    .from('users')
    .update({ stripe_customer_id: customer.id })
    .eq('id', userId);
}

# wrangler.toml
[[queues.producers]]
queue = "meter-retry"
binding = "METER_RETRY"
 
[[queues.consumers]]
queue = "meter-retry"
max_batch_size = 10
max_retries = 5
dead_letter_queue = "meter-retry-dlq"

// 送信失敗時にキューへ積む（Step 2 の catch 節から呼ぶ）
await env.METER_RETRY.send({
  customerId: body.customerId,
  eventName: body.eventName,
  value: body.value,
  idempotencyKey, // 初回送信と同じキーを必ず引き継ぐ
  failedAt: Date.now(),
});

interface RetryPayload {
  customerId: string;
  eventName: string;
  value?: number;
  idempotencyKey: string;
  failedAt: number;
}
 
export default {
  async queue(batch: MessageBatch<RetryPayload>, env: Env): Promise<void> {
    const stripe = new Stripe(env.STRIPE_SECRET_KEY);
    for (const msg of batch.messages) {
      try {
        await stripe.billing.meterEvents.create(
          {
            event_name: msg.body.eventName,
            payload: {
              stripe_customer_id: msg.body.customerId,
              ...(msg.body.value !== undefined && { value: String(msg.body.value) }),
            },
          },
          { idempotencyKey: msg.body.idempotencyKey }
        );
        msg.ack();
      } catch {
        msg.retry({ delaySeconds: 300 }); // 5分後に再試行
      }
    }
  },
};

// Durable Object: ユーザーごとの使用量を貯めて、5分ごとにまとめて送る
export class MeterBuffer {
  constructor(
    private state: DurableObjectState,
    private env: Env
  ) {}
 
  async fetch(request: Request): Promise<Response> {
    const { customerId, value } = await request.json<{
      customerId: string;
      value: number;
    }>();
 
    // ストレージ上のカウンタに加算（DO の休止・再起動に耐える）
    const key = `count:${customerId}`;
    const current = (await this.state.storage.get<number>(key)) ?? 0;
    await this.state.storage.put(key, current + value);
 
    // アラーム未設定なら 5 分後の flush を予約
    if ((await this.state.storage.getAlarm()) === null) {
      await this.state.storage.setAlarm(Date.now() + 5 * 60 * 1000);
    }
    return new Response('ok');
  }
 
  async alarm(): Promise<void> {
    const stripe = new Stripe(this.env.STRIPE_SECRET_KEY);
    const windowId = Math.floor(Date.now() / (5 * 60 * 1000)); // 5分窓のID
    const entries = await this.state.storage.list<number>({ prefix: 'count:' });
 
    for (const [key, total] of entries) {
      const customerId = key.slice('count:'.length);
      await stripe.billing.meterEvents.create(
        {
          event_name: 'ai_api_call',
          payload: {
            stripe_customer_id: customerId,
            value: String(total),
          },
        },
        { idempotencyKey: `flush_${customerId}_${windowId}` }
      );
      await this.state.storage.delete(key);
    }
  }
}

// 画像生成の場合は value を 5 に設定
await reportUsage({
  customerId: stripeCustomerId,
  eventName: 'ai_api_call',
  value: 5, // テキスト生成の5倍コストとして換算
});

const durationMinutes = Math.ceil(audioFileDurationSeconds / 60);
await reportUsage({
  customerId: stripeCustomerId,
  eventName: 'ai_api_call',
  value: durationMinutes,
});

// 今月の原価率を計算する（週次バッチで実行）
function costRatio(aiApiCost: number, meteredRevenue: number) {
  const ratio = aiApiCost / meteredRevenue;
  return {
    ratio,
    status: ratio < 0.4 ? 'healthy' : ratio < 0.6 ? 'warning' : 'critical',
  } as const;
}