BYOLLM Pricing — impact on your revenue

What "BYOLLM" means

Imperal users have two LLM modes:

When a user brings their own LLM key, the platform fee drops to zero everywhere a charge could occur — this is a guaranteed platform behavior: platform_fee → 0. You never have to handle it yourself.

What this means for your extension

Your base_price (the price you set in Dev Portal) is unchanged in both modes — and your share is computed on base_price, never on the platform_fee. So your earnings per call are the same in both modes. What differs is the platform_fee component on top: the user pays it (platform LLM) or they don't (BYOLLM), and the platform — not you — absorbs that difference.

Example: your summarize_text tool at base_price=5 (indie tier, 80%)

Non-BYOLLM user calls it (economy model → platform_fee=60):

base_price        = 5   (your pricing)
platform_fee      = 60  (Imperal's LLM cost — model-tier-derived; economy here)
─────────────────────
total user cost   = 65 credits
developer_share   = floor(5 × 0.80) = 4 credits   ← you earn 4 (off base_price only)
platform_share    = 65 − 4 = 61 credits           ← Imperal keeps platform_fee + its cut of base

BYOLLM user calls it:

base_price        = 5   (unchanged)
platform_fee      = 0   ← BYOLLM exclusion
─────────────────────
total user cost   = 5 credits
developer_share   = floor(5 × 0.80) = 4 credits   ← still 4 — your share is off base_price
platform_share    = 5 − 4 = 1 credit

(Replace 0.80 with 0.70 for explorer tier, 0.85 for studio, 0.95 for partner — see Developer Tiers.)

You earn the same 4 credits either way. The BYOLLM discount is borne entirely by the boundary between the user (who pays 65 vs 5) and the platform (which keeps 61 vs 1) — your earnings don't move. This is by design: the platform_fee covers Imperal's LLM-provider cost and is retained 100% by the platform, so your revenue never depends on which LLM mode the user picked. See Revenue & Earnings for the formula.

Platform fee scales with model tier

The platform_fee is sized to the real model cost (roughly 3× the provider's LLM cost for a typical turn), so heavier models cost the user more — but again, this only moves the user's total and the platform's cut, never your earnings:

If your extension is typically invoked with a premium model (heavy reasoning), a BYOLLM user saves a lot more on their total (they skip a 2,200-credit fee instead of a 60-credit one) — but you still earn floor(base_price × your_split) in both cases. The savings are the user's; your share is constant.

Where BYOLLM users pay nothing at all

Two situations short-circuit to zero, even before your base_price applies:

1. Plain conversational turns

When a user just chats with Webbee without invoking any extension (no @chat.function triggered, only a free-form response), the platform charges its own conversational fee — the model-tier platform_fee — not your app. For BYOLLM users this is zero.

This doesn't affect your extension's revenue — conversational turns that don't call your extension are billed to the platform, not your app — but it's why BYOLLM users see far fewer wallet decrements in their history.

2. Chain-step reserve (the chain itself, not your individual handlers)

When a user fires off a multi-step request like "send John an email AND create a note", the platform reserves a chain-wide budget for orchestrating the steps. For BYOLLM users this reserve is zero.

Your individual extension calls within that chain still charge base_price, so your per-handler earnings are unchanged. The reserve is a platform-side component you never shared in.

Doing your own LLM calls in a handler

If your extension does its own LLM calls inside a handler (e.g. content generation), you don't branch on BYOLLM at all — it's transparent. There is no BYOLLM flag to inspect. Make a single call and the platform routes it to the user's own provider when they've configured one, and zeroes the platform fee automatically:

from imperal_sdk import sdl, ActionResult
from pydantic import BaseModel, Field

class SummarizeParams(BaseModel):
    text: str = Field(description="The text to summarize.")

# SDL entity: sdl.Excerptable carries the content.summary role.
class Summary(sdl.Entity, sdl.Excerptable):
    pass

@chat.function("summarize", action_type="read", data_model=Summary)
async def summarize(ctx, params: SummarizeParams) -> ActionResult:
    # One call, whether or not the user brought their own key.
    # The platform routes the request and applies the BYOLLM fee
    # exclusion for you — no branching needed.
    result = await ctx.ai.complete(prompt=params.text, model="claude-sonnet-4-6")
    return ActionResult.success(
        Summary(id="summary", title="Summary", summary=result.text),
        summary="Summarized the text",
    )

Either way, the wallet deduct happens automatically based on your registered pricing. Your handler doesn't need to compute the price or know which provider ran the request — the platform does that before dispatch. See BYOLLM-aware extension recipe for a full example.

Pricing recommendations

1. Price on the value your tool delivers, not the LLM mode. Your earnings are identical on BYOLLM and platform-LLM calls, so there is nothing to compensate for. A summarize_text is worth ~5 credits whether it ran on Haiku or Opus, and whether or not the user brought their own key.
2. Don't price by Imperal's platform_fee. Platform_fee is the platform's component — it changes with model rates, tier reassignment, and BYOLLM, and none of it flows to you. Your base_price should be self-sufficient.
3. Use per-function pricing when some tools are LLM-heavy and others aren't. A tool that internally makes 5 LLM calls deserves higher base_price than a single-DB-query tool.
4. Set prices for the long run. Users on BYOLLM are usually power users who chose Imperal specifically for the marketplace — they'll notice and uninstall if you over-charge. A fair, value-based base_price earns you the most over time.

A guaranteed platform behavior

When a user brings their own LLM key, the platform fee is zero — applied uniformly everywhere a charge could occur (single actions, chain reserves, and plain conversational turns). This is a guaranteed platform behavior; you never have to detect it or handle it.

You can rely on this behaviour staying consistent — if it ever changes, it'll go through Imperal's review process and you'll be notified well in advance.