Multi-Tenant Billing with pymthouse

Your App
  ↓ POST /api/v1/oidc/token (token exchange for end-user)
Pymthouse
  ↓ access_token (scoped, short-lived)
Your App
  ↓ AI inference request with access_token
Pymthouse
  ↓ Validates token, checks billing plan
  ↓ Forwards to signer (signs payment ticket)
  ↓ Forwards to Livepeer Gateway
Livepeer Gateway
  ↓ Inference result
Pymthouse (records usage to ledger)
  ↓ Returns result
Your App

const PYMTHOUSE_URL = process.env.PYMTHOUSE_URL!;
const CLIENT_ID = process.env.PYMTHOUSE_CLIENT_ID!;
const CLIENT_SECRET = process.env.PYMTHOUSE_CLIENT_SECRET!;

interface AdminToken {
  access_token: string;
  expires_in: number;
}

let cachedAdminToken: { token: string; expiresAt: number } | null = null;

async function getAdminToken(): Promise<string> {
  if (cachedAdminToken && cachedAdminToken.expiresAt > Date.now() + 60_000) {
    return cachedAdminToken.token;
  }

  const res = await fetch(`${PYMTHOUSE_URL}/api/v1/oidc/token`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'client_credentials',
      client_id: CLIENT_ID,
      client_secret: CLIENT_SECRET,
      scope: 'admin',
    }),
  });

  if (!res.ok) {
    throw new Error(`Admin token request failed: ${res.status}`);
  }

  const data = (await res.json()) as AdminToken;
  cachedAdminToken = {
    token: data.access_token,
    expiresAt: Date.now() + data.expires_in * 1000,
  };
  return data.access_token;
}

export async function provisionUser(externalUserId: string, email: string) {
  const token = await getAdminToken();
  const res = await fetch(
    `${PYMTHOUSE_URL}/api/v1/apps/${CLIENT_ID}/users`,
    {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ external_id: externalUserId, email }),
    },
  );

  if (!res.ok) {
    throw new Error(`User provisioning failed: ${res.status}`);
  }

  return (await res.json()) as { user_id: string; external_id: string };
}

export async function mintUserToken(userId: string) {
  const token = await getAdminToken();
  const res = await fetch(
    `${PYMTHOUSE_URL}/api/v1/apps/${CLIENT_ID}/users/${userId}/token`,
    {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ scope: 'inference' }),
    },
  );

  if (!res.ok) {
    throw new Error(`User token mint failed: ${res.status}`);
  }

  return (await res.json()) as { access_token: string; expires_in: number };
}

import { provisionUser, mintUserToken } from '@/lib/pymthouse';

export async function POST(req: Request) {
  const { externalUserId, email, prompt } = (await req.json()) as {
    externalUserId: string;
    email: string;
    prompt: string;
  };

  // Ensure the user exists in pymthouse (idempotent).
  const user = await provisionUser(externalUserId, email);

  // Mint a short-lived token scoped to this user.
  const userToken = await mintUserToken(user.user_id);

  // Call the AI Jobs API through pymthouse's signer proxy.
  const inferenceRes = await fetch(
    `${process.env.PYMTHOUSE_URL}/api/v1/inference/text-to-image`,
    {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${userToken.access_token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        model_id: 'ByteDance/SDXL-Lightning',
        prompt,
        width: 1024,
        height: 1024,
      }),
    },
  );

  if (!inferenceRes.ok) {
    return Response.json(
      { error: `Inference call failed: ${inferenceRes.status}` },
      { status: 502 },
    );
  }

  const data = await inferenceRes.json();
  return Response.json(data);
}

import { provisionUser } from '@/lib/pymthouse';

interface UsageRecord {
  user_id: string;
  external_id: string;
  email: string;
  total_wei: string; // decimal string; parse with BigInt
  request_count: number;
  last_used_at: string;
}

export async function GET() {
  const token = await getAdminTokenForRead();
  const res = await fetch(
    `${process.env.PYMTHOUSE_URL}/api/v1/apps/${process.env.PYMTHOUSE_CLIENT_ID}/usage`,
    {
      headers: { Authorization: `Bearer ${token}` },
    },
  );

  if (!res.ok) {
    return Response.json({ error: 'Usage fetch failed' }, { status: 502 });
  }

  const data = (await res.json()) as { users: UsageRecord[] };

  // Convert wei to ETH for display.
  const enriched = data.users.map((u) => ({
    ...u,
    total_eth: (Number(BigInt(u.total_wei)) / 1e18).toFixed(8),
  }));

  return Response.json({ users: enriched });
}

async function getAdminTokenForRead() {
  // Same admin-token helper from lib/pymthouse.ts;
  // imported here for brevity.
  const res = await fetch(`${process.env.PYMTHOUSE_URL}/api/v1/oidc/token`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'client_credentials',
      client_id: process.env.PYMTHOUSE_CLIENT_ID!,
      client_secret: process.env.PYMTHOUSE_CLIENT_SECRET!,
      scope: 'read',
    }),
  });
  const data = (await res.json()) as { access_token: string };
  return data.access_token;
}

// src/app/dashboard/page.tsx
export default async function Dashboard() {
  const res = await fetch('http://localhost:3000/api/usage', {
    cache: 'no-store',
  });
  const data = await res.json();

  return (
    <main className="max-w-4xl mx-auto p-8">
      <h1 className="text-2xl font-bold mb-4">Per-User Usage</h1>
      <table className="w-full border-collapse">
        <thead>
          <tr className="border-b">
            <th className="text-left p-2">User</th>
            <th className="text-left p-2">Requests</th>
            <th className="text-left p-2">Total (ETH)</th>
            <th className="text-left p-2">Last Used</th>
          </tr>
        </thead>
        <tbody>
          {data.users.map((u: any) => (
            <tr key={u.user_id} className="border-b">
              <td className="p-2">{u.email}</td>
              <td className="p-2">{u.request_count}</td>
              <td className="p-2 font-mono">{u.total_eth}</td>
              <td className="p-2 text-sm text-gray-500">{u.last_used_at}</td>
            </tr>
          ))}
        </tbody>
      </table>
    </main>
  );
}

Build the "Multi-Tenant Billing with pymthouse" tutorial as a Next.js app backed by pymthouse. Verify current pymthouse docs and repository metadata first, then create a TypeScript app with placeholders PYMTHOUSE_URL=https://pymthouse.com, PYMTHOUSE_CLIENT_ID=<client ID>, PYMTHOUSE_CLIENT_SECRET=<client secret>, PYMTHOUSE_SIGNER_URL=<signer proxy URL>, and LIVEPEER_GATEWAY_URL=<gateway routed through pymthouse>. Implement lib/pymthouse.ts for client credentials, user provisioning, and user-token minting; add an inference route that forwards requests through pymthouse with the user token; and build a dashboard that shows per-user usage. Include local run commands, a seeded test user, one inference verification call, and a note that pymthouse credentials are not Livepeer Studio keys.