Per-Use Billing SaaS

npm install @profy-ai/sdk

pip install profy-sdk

import { ProfyApp } from "@profy-ai/sdk";

const profy = new ProfyApp({
  clientId: process.env.PROFY_APP_ID!,
  clientSecret: process.env.PROFY_APP_SECRET!,
});

import os
from profy import ProfyApp

profy = ProfyApp(
    client_id=os.environ["PROFY_APP_ID"],
    client_secret=os.environ["PROFY_APP_SECRET"],
)

async function generateReport(userId: string, token: OAuthToken) {
  const result = await profy.reportEvent("generate_report", {
    token,
    idempotencyKey: `${userId}-generate_report-${crypto.randomUUID()}`,
    onRefresh: (rotated) => saveToken(userId, rotated), // persist the rotated token
  });

  console.log(`Charged: ${result.charged}, Balance: ${result.balance_remaining}`);
  return result;
}

import uuid

async def generate_report(user_id: str, token):
    result = await profy.report_event(
        "generate_report",
        token=token,
        idempotency_key=f"{user_id}-generate_report-{uuid.uuid4()}",
        on_refresh=lambda rotated: save_token(user_id, rotated),  # persist the rotated token
    )
    print(f"Charged: {result['charged']}, Balance: {result['balance_remaining']}")
    return result

// Show the price list (public, no token)
const meters = await profy.listMeters();
for (const m of meters) {
  console.log(`${m.eventName}: ${m.priceCredits} credits — ${m.description ?? ""}`);
}

# Show the price list (public, no token)
meters = await profy.list_meters()
for m in meters:
    print(f"{m.event_name}: {m.price_credits} credits — {m.description or ''}")

import {
  AuthenticationError,      // 401 — token invalid, re-authorize
  InsufficientBalanceError, // 402 — not enough credits
  RateLimitError,           // 429 — rate limited
  ProfyApiError,
} from "@profy-ai/sdk";

async function safeCharge(userId: string, token: OAuthToken, action: string) {
  try {
    return await profy.reportEvent(action, {
      token,
      idempotencyKey: `${userId}-${action}-${crypto.randomUUID()}`,
      onRefresh: (rotated) => saveToken(userId, rotated),
    });
  } catch (err) {
    if (err instanceof InsufficientBalanceError) {
      return { success: false, reason: "balance_insufficient" } as const;
    }
    if (err instanceof AuthenticationError) {
      return { success: false, reason: "auth_expired" } as const;
    }
    if (err instanceof RateLimitError) {
      return { success: false, reason: "rate_limited" } as const;
    }
    if (err instanceof ProfyApiError) {
      return { success: false, reason: "api_error" } as const;
    }
    throw err;
  }
}

from profy import (
    AuthenticationError,       # 401
    InsufficientBalanceError,  # 402
    RateLimitError,            # 429
    ProfyApiError,
)

async def safe_charge(user_id: str, token, action: str):
    try:
        return await profy.report_event(
            action,
            token=token,
            idempotency_key=f"{user_id}-{action}-{uuid.uuid4()}",
            on_refresh=lambda rotated: save_token(user_id, rotated),
        )
    except InsufficientBalanceError:
        return {"success": False, "reason": "balance_insufficient"}
    except AuthenticationError:
        return {"success": False, "reason": "auth_expired"}
    except RateLimitError:
        return {"success": False, "reason": "rate_limited"}
    except ProfyApiError:
        return {"success": False, "reason": "api_error"}

async function chargeWithRetry(
  userId: string,
  token: OAuthToken,
  action: string,
  maxRetries = 3,
) {
  const idempotencyKey = `${userId}-${action}-${crypto.randomUUID()}`;
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      const result = await profy.reportEvent(action, {
        token,
        idempotencyKey, // reuse the same key
        onRefresh: (rotated) => saveToken(userId, rotated),
      });
      if (result.idempotent_replay) console.log("Idempotent replay — no additional charge");
      return result;
    } catch (err) {
      if (err instanceof RateLimitError) {
        await new Promise((r) => setTimeout(r, 2 ** attempt * 1000));
        continue;
      }
      throw err;
    }
  }
  throw new Error("Max retries exceeded");
}

import asyncio

async def charge_with_retry(user_id: str, token, action: str, max_retries: int = 3):
    idempotency_key = f"{user_id}-{action}-{uuid.uuid4()}"  # reuse the same key
    for attempt in range(max_retries + 1):
        try:
            result = await profy.report_event(
                action,
                token=token,
                idempotency_key=idempotency_key,
                on_refresh=lambda rotated: save_token(user_id, rotated),
            )
            if result.get("idempotent_replay"):
                print("Idempotent replay — no additional charge")
            return result
        except RateLimitError:
            await asyncio.sleep(2 ** attempt)
            continue
    raise RuntimeError("Max retries exceeded")