Revenue & Earnings

Revenue and earnings for Imperal Cloud developers — see how your share accrues in real time on every user action, and how Webbee usage turns into payouts.

The revenue split

Every paid action call generates earnings split between you (the developer) and the Imperal platform:

total_cost          = base_price + platform_fee     (what the user pays)
developer_share     = floor(base_price × revenue_split_dev / 100)   ← your % is of YOUR base_price only
platform_share      = total_cost − developer_share                  (Imperal keeps 100% of platform_fee)

Your share is computed on your base_price — the price you set for the function — not on the platform_fee. The platform_fee covers Imperal's LLM-provider cost and is retained 100% by the platform, so that cost is always recovered. This is what keeps the platform profitable on every paid call regardless of your tier (a higher split takes more of your base_price, never the LLM cost).

The split depends on your developer tier (see Developer Tiers for caps + break-even math):

Tier	Split (dev / platform)	Annual cost
explorer (default, free)	70 / 30	0 — automatic at signup
indie	80 / 20	9,000 credits / year
studio	85 / 15	29,000 credits / year
partner	95 / 5	79,000 credits / year (admin-promoted)

Existing apps keep their currently-set revenue_split_dev even after tier upgrade — to bump an active app, Pause → Edit pricing → admin re-approval.

Example calculations

Non-BYOLLM user, paid extension at base_price=5, platform_fee=60 (economy tier — see BYOLLM Pricing for the per-tier scale: economy 60 / standard 250 / premium 2200). Numbers depend on your tier:

Explorer tier (70%):

total_cost      = 5 + 60 = 65 credits
developer_share = floor(5 × 70 / 100) = 3 credits   ← 70% of YOUR base_price (5), not the total
platform_share  = 65 - 3 = 62 credits               ← Imperal keeps platform_fee (60) + 30% of base

Indie tier (80%):

total_cost      = 5 + 60 = 65 credits
developer_share = floor(5 × 80 / 100) = 4 credits   ← 1 more per call vs explorer
platform_share  = 65 - 4 = 61 credits               ← platform_fee (60) is always retained

Same setup, BYOLLM user (platform_fee zeroed), explorer tier:

total_cost      = 5 + 0 = 5 credits
developer_share = floor(5 × 70 / 100) = 3 credits   ← base_price = total when platform_fee is 0
platform_share  = 5 - 3 = 2 credits

See BYOLLM Pricing for the full impact on your revenue mix.

What happens when a user calls your extension

Each call records the charge atomically — in one consistent step:

The user's credit wallet is debited immediately.
The charge is appended to the audit trail.
Your developer earnings are credited with your share of the charge.

Every charge is idempotent — a retry or a transient restart never double-charges the user or double-credits you.

When you DON'T earn

Scenario	Why
Your `pricing_model == 'free'`	`developer_share = 0` is recorded for usage analytics, but no credits flow
Your app `status != 'active'` (draft/suspended/pending_review)	No earnings are recorded
User invokes a `@ext.skeleton` handler	Skeletons are free, web-kernel-driven; not billed
User invokes a `@ext.panel` handler	Same — panel renders are free
The action is an internal platform `read` (the `__system__` actor)	Not your extension — web-kernel-internal
The action's wallet deduct returns -1 (insufficient balance)	Call rejected before reaching your handler
A failed top-up is auto-refunded before the credits were spent	The reversal is recorded in the credit audit trail

Viewing your earnings

Dev Portal → My App → Earnings tab

Shows:

Total earned (all time) — the sum of your developer share across every charge
Total platform share — for transparency on Imperal's cut
Pending payout — what you've earned minus what's already been paid or approved
Paid out — the total credits already approved or paid to you

Dev Portal → My App → Analytics tab

Per-app, configurable time window (7d / 30d / all):

Actions count
Revenue (developer_share sum)
Unique users (DISTINCT user_id)

API: `GET /v1/developer/earnings`

curl -H "Authorization: Bearer $YOUR_JWT" \
  https://auth.imperal.io/v1/developer/earnings

Response:

{
  "total_earnings": 12450,
  "total_platform_share": 0,
  "pending_payout": 9450,
  "paid_out": 3000
}

API: `GET /v1/developer/apps/{app_id}/analytics?days=30`

curl -H "Authorization: Bearer $YOUR_JWT" \
  https://auth.imperal.io/v1/developer/apps/my_app/analytics?days=30

Response:

{
  "app_id": "my_app",
  "period_days": 30,
  "actions": 1234,
  "revenue": 9450,
  "unique_users": 87
}

Currency conversion

Earnings are in credits, not USD directly. Credit-to-USD conversion happens at payout time, using the plan's topup_rate (default $0.001 per credit = $1 per 1,000 credits). So:

9450 credits × $0.001 = $9.45 USD payout

The conversion rate is fixed at the moment you request the payout — fluctuations in pricing after that don't affect already-requested payouts.

What happens when a user refunds a top-up

Top-up refund flow: if Stripe captures funds but Imperal can't credit the wallet (e.g. a transient platform outage), the platform auto-refunds Stripe. Your earnings that consumed those credits are NOT clawed back — they were earned legitimately for actions actually performed; the user just lost the top-up that hadn't been spent yet.

For Stripe disputes / chargebacks (user disputes after spending), admin intervenes manually — your earnings may be adjusted with an admin note. Rare but documented.

Revenue & Earnings

On this page