◉ AI Models/2026-04-28Advanced

Monetize Rork AI Agents as SaaS — Three-Layer Revenue Model (Subscriptions + API Metering + Affiliate)

Field notes on running a Rork-built AI agent as a SaaS: how to reconcile two billing sources (Stripe and RevenueCat) into one entitlement, make webhooks idempotent, and automate recovery before a cancellation lands.

Rork⁵⁸⁵AI-agentSaaS³ monetization⁴⁷ Stripe¹⁸ RevenueCat³⁰ subscription²⁸API-billingaffiliate

✦ Premium Article

Shipping apps solo, the part that takes the most care isn't adding features — it's guaranteeing that money moves correctly. Features are fun; billing breaks quietly. One month a user cancelled their subscription but kept their access for a while afterward. The cause was a dropped webhook.

Getting an agent assembled in Rork is genuinely quick. The hard part comes after: turning a working thing into a service you can run confidently once money is involved. Pricing, the billing engine, customer management, API key rotation — all unglamorous, and all places where sloppiness costs you a user's trust later.

This article walks through the setup I actually built to run a Rork agent as a SaaS, focused on the places I got stuck. The foundation is a three-layer revenue model:

Subscription Layer — Recurring monthly revenue (Free / Pro / Enterprise)
Metered Billing Layer — Per-request overages for power users
Affiliate Layer — Partner resale with automatic commission payouts

The SaaS Agent Architecture

Your Rork agent needs a clean API boundary, billing integration, and customer dashboard. Here's the stack:

┌─────────────────────────────────────┐
│    Rork Agent (LLM + Tools)        │
│    Claude / Gemini / Mixtral       │
└──────────────┬──────────────────────┘
               │ REST API
┌──────────────▼──────────────────────┐
│   API Gateway (Express / Hono)     │
│   Auth, Rate Limits, Usage Tracking │
└──────────────┬──────────────────────┘
               │
┌──────────────▼──────────────────────┐
│  Billing (Stripe + RevenueCat)     │
│  Subscriptions & Metered Charges    │
└──────────────┬──────────────────────┘
               │
┌──────────────▼──────────────────────┐
│   Dashboard (Next.js + Vercel)     │
│   Keys, Usage, Invoices             │
└─────────────────────────────────────┘

Step 1: Expose the Rork Agent as an API

Your first job is making the Rork agent callable from code. Use the Rork SDK:

// lib/rork-agent.ts
import { RorkClient } from '@rork/sdk';
 
const client = new RorkClient({
  apiKey: process.env.RORK_API_KEY,
  agentId: 'my-saas-agent',
});
 
export async function callAgent(input: string) {
  const response = await client.chat.completions.create({
    messages: [{ role: 'user', content: input }],
    maxTokens: 2000,
  });
 
  return {
    text: response.choices[0].message.content,
    tokensUsed: response.usage.total_tokens,
    costUsd: calculateTokenCost(response.usage),
  };
}
 
function calculateTokenCost(usage: TokenUsage): number {
  const inputCost = (usage.prompt_tokens / 1000) * 0.003;
  const outputCost = (usage.completion_tokens / 1000) * 0.015;
  return inputCost + outputCost;
}

Wrap it in a REST endpoint:

// app/api/agent/chat/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { callAgent } from '@/lib/rork-agent';
import { validateApiKey, trackUsage } from '@/lib/billing';
 
export async function POST(req: NextRequest) {
  const authHeader = req.headers.get('Authorization');
  const apiKey = authHeader?.replace('Bearer ', '');
 
  if (!apiKey) {
    return NextResponse.json(
      { error: 'Missing API key' },
      { status: 401 }
    );
  }
 
  const customer = await validateApiKey(apiKey);
  if (!customer) {
    return NextResponse.json(
      { error: 'Invalid API key' },
      { status: 401 }
    );
  }
 
  const { message } = await req.json();
 
  try {
    const result = await callAgent(message);
 
    await trackUsage({
      customerId: customer.id,
      tokensUsed: result.tokensUsed,
      costUsd: result.costUsd,
    });
 
    return NextResponse.json({
      response: result.text,
      tokens: result.tokensUsed,
      cost_usd: result.costUsd,
    });
  } catch (error: any) {
    return NextResponse.json(
      { error: error.message },
      { status: 500 }
    );
  }
}

✦

Thank you for reading this far.

Continue Reading

What follows includes implementation code, benchmarks, and practical content we hope you'll find useful. This site runs without ads — server and development costs are supported entirely by members like you. If it's been helpful, we'd be truly grateful for your support.

WHAT YOU'LL LEARN

✦How to reconcile two billing sources (Stripe and RevenueCat) into a single server-side entitlement

✦An idempotent webhook pattern that prevents double-charges and dropped entitlement state

✦An automated grace-period and win-back flow that turns failed payments into recoveries

Secure payment via Stripe · Cancel anytime

✦

Unlock This Article

Get full access to the rest of this article. Buy once, read anytime. This site is ad-free — your support goes directly toward keeping it running.

Unlock all articles with Membership →

Step 2: Stripe Subscription Tiers

Define your pricing in one place:

// src/config/pricing.ts
export const PLANS = {
  free: {
    name: 'Free',
    price: 0,
    monthlyRequests: 100,
    stripePrice: null,
    features: ['Basic access', '100 req/mo', 'Docs'],
  },
  pro: {
    name: 'Pro',
    price: 99,
    monthlyRequests: 10000,
    stripePrice: 'price_1KxH9bA7e5Wg8nQr0000',
    features: ['Everything Free', '10K req/mo', 'Priority support'],
  },
  enterprise: {
    name: 'Enterprise',
    price: null,
    monthlyRequests: null,
    stripePrice: null, // Contact sales
    features: ['Unlimited', 'SLA', 'Dedicated support'],
  },
};

Create a Stripe Checkout session:

// app/api/billing/checkout/route.ts
import Stripe from 'stripe';
import { NextRequest, NextResponse } from 'next/server';
 
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
 
export async function POST(req: NextRequest) {
  const { customerId, plan } = await req.json();
  const customer = await getCustomer(customerId);
 
  try {
    const session = await stripe.checkout.sessions.create({
      customer: customer.stripeCustomerId,
      payment_method_types: ['card'],
      mode: 'subscription',
      line_items: [
        {
          price: PLANS[plan].stripePrice,
          quantity: 1,
        },
      ],
      success_url: `${process.env.NEXT_PUBLIC_APP_URL}/dashboard?success=true`,
      cancel_url: `${process.env.NEXT_PUBLIC_APP_URL}/pricing`,
    });
 
    return NextResponse.json({ sessionId: session.id });
  } catch (error: any) {
    return NextResponse.json(
      { error: error.message },
      { status: 500 }
    );
  }
}

Handle subscription webhooks:

// app/api/webhooks/stripe/route.ts
import Stripe from 'stripe';
import { NextRequest, NextResponse } from 'next/server';
 
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
 
export async function POST(req: NextRequest) {
  const body = await req.text();
  const sig = req.headers.get('stripe-signature')!;
 
  let event: Stripe.Event;
 
  try {
    event = stripe.webhooks.constructEvent(
      body,
      sig,
      process.env.STRIPE_WEBHOOK_SECRET!
    );
  } catch (err: any) {
    return NextResponse.json({ error: 'Bad signature' }, { status: 400 });
  }
 
  if (event.type === 'customer.subscription.updated') {
    const sub = event.data.object as Stripe.Subscription;
    const planId = getPlanFromPriceId(sub.items.data[0].price.id);
 
    await updateCustomerPlan(sub.customer as string, planId);
  }
 
  return NextResponse.json({ ok: true });
}

Step 3: API Keys and Rate Limiting

Generate unique keys for each customer:

// lib/api-keys.ts
import crypto from 'crypto';
 
export function generateKey(): string {
  return 'rk_' + crypto.randomBytes(24).toString('hex');
}
 
export async function createKeyForCustomer(
  customerId: string
): Promise<string> {
  const key = generateKey();
 
  await db.apiKeys.create({
    customerId,
    hash: hashKey(key),
  });
 
  return key; // Return plaintext once
}
 
function hashKey(key: string): string {
  return crypto.createHash('sha256').update(key).digest('hex');
}

Implement rate limiting with Upstash:

// lib/rate-limit.ts
import { Ratelimit } from '@upstash/ratelimit';
import { Redis } from '@upstash/redis';
 
const redis = new Redis({
  url: process.env.UPSTASH_REDIS_REST_URL!,
  token: process.env.UPSTASH_REDIS_REST_TOKEN!,
});
 
const limits = {
  free: Ratelimit.slidingWindow(100, '30 d'),
  pro: Ratelimit.slidingWindow(10000, '30 d'),
  enterprise: Ratelimit.slidingWindow(1000000, '30 d'),
};
 
export async function checkLimit(
  customerId: string,
  plan: string
): Promise<boolean> {
  const limit = limits[plan] || limits.free;
  const result = await limit.limit(customerId);
  return result.success;
}

Step 4: Metered Billing for Overages

When customers exceed their plan limit, bill them for additional usage:

// lib/metered-billing.ts
import Stripe from 'stripe';
 
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
 
export async function recordUsage(
  customerId: string,
  quantity: number
): Promise<void> {
  const customer = await getCustomer(customerId);
 
  await stripe.billing.meterEvents.create({
    event_name: 'api_requests',
    customer_id: customer.stripeCustomerId,
    value: quantity,
  });
}
 
export async function chargeOverage(
  customerId: string,
  amountUsd: number,
  description: string
): Promise<void> {
  const customer = await getCustomer(customerId);
 
  await stripe.invoiceItems.create({
    customer: customer.stripeCustomerId,
    amount: Math.round(amountUsd * 100),
    currency: 'usd',
    description,
  });
}

When handling API requests, check for overages:

// app/api/agent/chat/route.ts (updated)
const monthlyUsage = await getMonthlyUsage(customer.id);
const plan = PLANS[customer.plan];
 
if (monthlyUsage > plan.monthlyRequests) {
  const overage = monthlyUsage - plan.monthlyRequests;
  const overageCost = (overage / 1000) * 0.02; // $0.02 per 1K requests
 
  await chargeOverage(
    customer.id,
    overageCost,
    `API overage: ${overage} requests`
  );
}

Step 5: Affiliate Program

Let partners resell your API and earn commission:

// lib/affiliates.ts
export async function createAffiliateLink(
  partnerId: string,
  commissionRate: number = 0.20
): Promise<string> {
  const code = generateCode();
 
  await db.affiliates.create({
    code,
    partnerId,
    commissionRate,
  });
 
  return code;
}
 
export async function trackSignup(
  affiliateCode: string,
  newCustomerId: string
): Promise<void> {
  const affiliate = await db.affiliates.findUnique({
    where: { code: affiliateCode },
  });
 
  if (affiliate) {
    await db.affiliateCommissions.create({
      affiliateId: affiliate.id,
      customerId: newCustomerId,
      amount: 0, // Will update on first subscription charge
      status: 'pending',
    });
  }
}
 
export async function calculateCommission(
  customerId: string,
  revenue: number
): Promise<void> {
  const commission = await db.affiliateCommissions.findFirst({
    where: { customerId },
    include: { affiliate: true },
  });
 
  if (commission) {
    const amount = revenue * commission.affiliate.commissionRate;
 
    await db.affiliateCommissions.update({
      where: { id: commission.id },
      data: { amount },
    });
 
    // Pay out via Stripe Connect
    await payoutCommission(
      commission.affiliate.stripeConnectId,
      amount
    );
  }
}

Affiliate dashboard:

// app/dashboard/affiliate/page.tsx
export default function AffiliatePage() {
  const [stats, setStats] = useState({
    referredCount: 0,
    monthlyEarnings: 0,
    totalEarnings: 0,
  });
 
  return (
    <div className="max-w-4xl mx-auto p-6">
      <h1 className="text-4xl font-bold mb-8">Your Affiliate Program</h1>
 
      <div className="grid grid-cols-3 gap-4 mb-8">
        <Card>
          <div className="text-4xl font-bold">{stats.referredCount}</div>
          <p className="text-gray-600">Customers Referred</p>
        </Card>
        <Card>
          <div className="text-4xl font-bold">${stats.monthlyEarnings}</div>
          <p className="text-gray-600">This Month</p>
        </Card>
        <Card>
          <div className="text-4xl font-bold">${stats.totalEarnings}</div>
          <p className="text-gray-600">Total Earned</p>
        </Card>
      </div>
 
      <div className="bg-blue-50 p-6 rounded-lg">
        <h2 className="font-bold text-lg mb-3">Your Referral Link</h2>
        <input
          type="text"
          value={`${process.env.NEXT_PUBLIC_APP_URL}?ref=AFFILIATE_CODE`}
          readOnly
          className="w-full px-4 py-2 border rounded mb-3"
        />
        <p className="text-sm text-gray-600">
          You earn 20% of every referred customer's monthly subscription.
        </p>
      </div>
    </div>
  );
}

Step 6: Customer Dashboard

Customers manage keys, usage, and billing in one place:

// app/dashboard/page.tsx
export default function Dashboard() {
  const [account, setAccount] = useState({
    plan: 'pro',
    monthlyRequests: 5234,
    monthlyLimit: 10000,
    monthlyBill: 99,
    apiKey: 'rk_****...****',
  });
 
  return (
    <div className="max-w-4xl mx-auto p-6">
      <h1 className="text-3xl font-bold mb-8">Account Dashboard</h1>
 
      {/* Plan Section */}
      <section className="mb-6 p-6 border rounded-lg">
        <div className="flex justify-between items-center">
          <div>
            <p className="text-3xl font-bold capitalize">{account.plan}</p>
            <p className="text-gray-600">${account.monthlyBill}/month</p>
          </div>
          <a href="/pricing" className="text-blue-600 hover:underline">
            Change Plan
          </a>
        </div>
      </section>
 
      {/* Usage Section */}
      <section className="mb-6 p-6 border rounded-lg">
        <h2 className="font-bold text-lg mb-4">Monthly Usage</h2>
        <div className="mb-4">
          <div className="flex justify-between text-sm mb-2">
            <span>{account.monthlyRequests} / {account.monthlyLimit}</span>
            <span>{Math.round((account.monthlyRequests / account.monthlyLimit) * 100)}%</span>
          </div>
          <div className="w-full bg-gray-200 rounded h-2">
            <div
              className="bg-blue-600 h-2 rounded"
              style={{ width: `${(account.monthlyRequests / account.monthlyLimit) * 100}%` }}
            />
          </div>
        </div>
      </section>
 
      {/* API Key Section */}
      <section className="p-6 border rounded-lg">
        <h2 className="font-bold text-lg mb-3">API Key</h2>
        <div className="flex gap-2 mb-3">
          <code className="flex-1 bg-gray-100 p-3 rounded font-mono text-xs">
            {account.apiKey}
          </code>
          <button className="bg-blue-600 text-white px-4 rounded">Copy</button>
        </div>
        <button className="text-red-600 text-sm">Rotate Key</button>
      </section>
    </div>
  );
}

Make Webhooks Idempotent — Stop Double-Charging and Dropped State

This is where billing first bit me in production. Stripe re-sends the same webhook event to guarantee delivery — a brief network hiccup is enough to trigger a retry. If your handler isn't built so that "processing the same event twice yields the same result as once," you'll either grant entitlements twice or, worse, overwrite fresh state with a stale, out-of-order event.

I learned that a single "processed events" table prevents most of this.

// app/api/webhooks/stripe/route.ts (idempotent version)
import Stripe from 'stripe';
import { NextRequest, NextResponse } from 'next/server';
import { db } from '@/lib/db';
 
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
 
export async function POST(req: NextRequest) {
  const body = await req.text();
  const sig = req.headers.get('stripe-signature')!;
 
  let event: Stripe.Event;
  try {
    event = stripe.webhooks.constructEvent(
      body, sig, process.env.STRIPE_WEBHOOK_SECRET!
    );
  } catch {
    return NextResponse.json({ error: 'Invalid signature' }, { status: 400 });
  }
 
  // 1) Use event.id's unique constraint as a lock: only the first INSERT wins
  const firstTime = await db.processedEvents
    .create({ data: { id: event.id, type: event.type } })
    .then(() => true)
    .catch(() => false); // unique violation = already processed
 
  if (!firstTime) {
    return NextResponse.json({ received: true, duplicate: true });
  }
 
  if (event.type === 'customer.subscription.updated') {
    const sub = event.data.object as Stripe.Subscription;
    const customerId = sub.customer as string;
    const planId = getPlanIdFromPriceId(sub.items.data[0].price.id);
 
    // 2) Guard against reordering: only apply if newer than current state
    await db.$transaction(async (tx) => {
      const cur = await tx.subscriptions.findUnique({ where: { customerId } });
      if (cur && cur.periodEnd && cur.periodEnd > sub.current_period_end) {
        return; // stale event, ignore
      }
      await tx.subscriptions.update({
        where: { customerId },
        data: { plan: planId, status: sub.status, periodEnd: sub.current_period_end },
      });
    });
  }
 
  return NextResponse.json({ received: true });
}

Two ideas matter here: use event.id as a de-facto lock, and compare current_period_end to drop stale events. Retries and reordering are separate problems — solving one isn't enough. I had only built the first guard; it passed every test and only surfaced under real production load.

Keep One Source of Truth for Entitlements — Reconciling Stripe and RevenueCat

Once you sell subscriptions through both the web (Stripe) and in-app purchases (App Store / Google Play via RevenueCat), the answer to "what plan is this user on right now?" lives in two places. Stripe says Pro, RevenueCat says Free — that mismatch happens routinely, because the same user can subscribe in both or cancel in one.

My conclusion: you can have multiple billing sources, but entitlements must have exactly one source of truth. Each webhook writes only "the state at its own source." The final entitlement is resolved server-side, once, at read time.

// lib/entitlement.ts
type Source = 'stripe' | 'revenuecat';
 
interface SourceState {
  source: Source;
  plan: 'free' | 'pro' | 'enterprise';
  active: boolean;
  periodEnd: number; // unix seconds
}
 
async function readSourceStates(userId: string): Promise<SourceState[]> {
  return db.entitlementSources.findMany({ where: { userId } });
}
 
const PLAN_RANK = { free: 0, pro: 1, enterprise: 2 } as const;
 
// Truth is computed once, at read time
export async function resolveEntitlement(userId: string) {
  const states = await readSourceStates(userId);
  const now = Math.floor(Date.now() / 1000);
 
  const valid = states.filter((s) => s.active && s.periodEnd > now);
  if (valid.length === 0) return { plan: 'free' as const, source: null };
 
  const top = valid.reduce((a, b) =>
    PLAN_RANK[b.plan] > PLAN_RANK[a.plan] ? b : a
  );
  return { plan: top.plan, source: top.source };
}

Picking the highest plan as the winner is deliberate: a user who happens to be billed in two places should never be under-served. Refund and cancellation cleanup happen separately — but the user's access should never suffer first. That's a trust-over-revenue call, and the longer you run a product, the more it pays off.

To catch drift, a daily job that scans entitlementSources for users whose plans disagree across sources — and surfaces them on a dashboard — was enough. Don't try to auto-correct everything; make it visible first, then fix by hand. That caused far fewer accidents.

Stop Churn Before It Starts — Automating Dunning and Win-back

Most cancellations weren't "I want to quit" — they were expired cards. Ignore invoice.payment_failed and you'll lose users who actually wanted to stay. I lean on Stripe Smart Retries, but add a grace period so access doesn't drop the instant a charge fails.

// On payment failure: don't cancel — treat as past_due with grace
if (event.type === 'invoice.payment_failed') {
  const invoice = event.data.object as Stripe.Invoice;
  const customerId = invoice.customer as string;
 
  await db.subscriptions.update({
    where: { customerId },
    data: {
      status: 'past_due',
      // Keep access for 3 days; if Stripe's retry succeeds, it returns to active
      graceUntil: Math.floor(Date.now() / 1000) + 3 * 24 * 60 * 60,
    },
  });
 
  await sendDunningEmail(customerId); // "Please update your card"
}

Your access check then treats both active and "past_due within graceUntil" as valid. That one change visibly increased natural recoveries from card updates. For genuinely cancelled users, I keep win-back minimal: a time-limited offer code on customer.subscription.deleted. In my experience, aggressive retention nags make people less likely to return.

Your Next Step

The three-layer model matters less, day to day, than the plumbing that keeps billing from quietly breaking. If you do one thing today, make your webhooks idempotent. Adding a processed-events table keyed on event.id defends against the two most common production failures at once: double-grants and reordering.

Thanks for reading. If this saved one detour for someone else wiring up billing solo, that's a good outcome.

Thank You for Reading

Rork Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.

✦Copy-paste ready implementation code
✦New advanced guides published daily
✦$5/mo or $10 for lifetime access

View Membership →