Universal API — Pricing Strategy

Last Updated: March 29, 2026

1. Current State & Problems

What Exists Today

Component	Current Value	Source
Lambda compute rate	$0.0000166667/GB-s (AWS at-cost)	`billing_utils.py:24`
API Gateway rate	$0.0000035/request (AWS at-cost)	`billing_utils.py:21`
Bedrock Sonnet 4	$3/$15 per 1M input/output tokens (AWS at-cost)	`billing_utils.py:35-38`
Platform markup on AWS costs	0%	—
Platform cut of author revenue	6%	`billing_utils.py:27`
Credit value	1 credit = $0.01	`billing_utils.py:235`
Minimum charge	1 credit per invocation	`billing_utils.py:236-237`
Free credits	100 per new user, replenish monthly	`user_operations.py:23-24`

Problems

0% margin on infrastructure. AWS costs passed through at cost. Platform earns $0 on non-authored invocations.
500× markup on cheap calls. Minimum 1 credit ($0.01) on a $0.00002 MCP call. Contradicts "aligned with AWS."
6% author cut is below market. Industry is 15-30%.
No way to buy credits. Free tier only.
No author pricing caps. Unlimited pricing allowed.
No pre-flight credit check. Users can go negative.
No knowledge/storage billing.

2. Pricing Strategy Evaluation

Before settling on the final model, we evaluated three approaches:

Option A: Flat Percentage Fee (10% on AWS costs only)

Every invocation costs AWS × 1.20. Simple, universal, but doesn't capture marketplace value from the author ecosystem.

Option B: At-Cost + Subscription

All invocations at AWS cost, revenue from monthly subscription tiers. Rejected — a paywall before first value is the #1 growth killer for developer platforms. Stripe, Twilio, and AWS itself are all usage-based first, subscriptions later. Investors in 2025-2026 prefer usage-based models for AI infrastructure (OpenAI, Anthropic, Replicate, Together AI — all usage-based).

Option C: Varying % Fees (different rates per dimension)

10% on Lambda, 15% on Bedrock, 20% on author revenue, etc. Rejected — confusing for users and authors, hard to explain in a pitch, creates billing disputes for marginal revenue gain.

✅ Chosen: Two-Revenue-Stream Model

Split infrastructure fees (compute at 200% markup, LLM at 20% markup) + Marketplace Fee (20%) on author revenue, charged to the user (not deducted from the author).

Rationale for the split:

Compute (100%): A very high fraction of invocations are MCP pings, health checks, and protocol overhead — pure Lambda with no LLM. These would generate near-zero margin at a flat rate. Compute is our infrastructure pricing, not benchmarked to AWS rates.
LLM (20%): Bedrock prices match Anthropic's direct API prices exactly. We can be transparent: "AWS cost + 20%." This is competitive, clear, and still profitable on every token.
Marketplace (20%): Pure margin on author revenue. Authors keep 100% of their set price; the fee is additive on top. This separates platform economics from author incentives cleanly.

3. Credit Value Analysis

The Core Constraint

The minimum floor is 1 credit per invocation. The credit value determines the minimum cost per call, the granularity for expensive calls, and the psychological perception of credit numbers.

Side-by-Side Comparison

Scenario	AWS Cost (with 10% fee)	$0.01/credit	$0.001/credit	$0.0001/credit
MCP tool (no LLM)	$0.0000066	1 cr ($0.01) 1,515×	1 cr ($0.001) 152×	1 cr ($0.0001) 15×
Light agent (500 tokens)	$0.005	1 cr ($0.01) 2×	5 cr ($0.005) ≈ cost	50 cr ($0.005) ≈ cost
Medium agent (3K tokens)	$0.023	3 cr ($0.03) 30% over	24 cr ($0.024) ≈ cost	232 cr ($0.0253) ≈ cost
Heavy agent (15K tokens)	$0.116	12 cr ($0.12) 3% over	117 cr ($0.117) ≈ cost	1,161 cr ($0.1161) ≈ cost
Multi-turn (50K tokens)	$0.331	34 cr ($0.34) ≈ cost	332 cr ($0.332) ≈ cost	3,315 cr ($0.3315) ≈ cost

Evaluation

$0.01/credit:

❌ MCP tools cost 1,515× actual — hidden tax frustrates power users
❌ Light agents cost 2× actual — noticeable overcharge
❌ Only 3 credits for a medium agent — insufficient granularity
✅ Small credit numbers, $1 = 100 credits

$0.001/credit (CHOSEN):

⚠️ MCP tools cost 152× actual — but at $0.001/call, nobody cares (a tenth of a cent)
✅ Light agents: 5 credits — clearly differentiated from medium (24 credits)
✅ Medium agents: 24 credits — good granularity
✅ Heavy agents: 117 credits — precise cost tracking
✅ $1 = 1,000 credits (clean, psychologically generous)
✅ Free tier of 2,000 credits = $2.00 (feels substantial)

$0.0001/credit:

✅ Most accurate for MCP tools (15× markup)
❌ Unwieldy numbers: 1,161 credits for heavy agent, 3,315 for multi-turn
❌ $1 = 10,000 credits — feels like mobile game currency (devalued perception)
❌ "Buy 500,000 credits for $50" — meaningless numbers
❌ Harder to mentally convert credits ↔ dollars

Why $0.001 Wins

The 152× markup on standalone MCP tools sounds bad in theory, but:

$0.001 is a tenth of a cent. No user will complain about $0.001 per API call.
MCP tools called via agents are bundled into the agent invocation — the 1-credit minimum only applies to standalone calls.
Standalone MCP calls are ~5% of invocations and <1% of revenue.
$0.0001 creates 10× larger numbers everywhere for marginal accuracy on a call type that generates negligible revenue.

Decision: 1 credit = $0.001

4. How a User Gets Charged

Every invocation has exactly three cost components. This is the entire pricing model:

┌─────────────────────────────────────────────────────────────────┐
│                                                                 │
│   WHAT THE USER PAYS PER INVOCATION                            │
│                                                                 │
│   ┌──────────────────────────────────────────────────────────┐  │
│   │  1. INFRASTRUCTURE COST                                 │  │
│   │                                                          │  │
│   │     Compute (Lambda + API GW) × 3.00  (200% markup)     │  │
│   │     • Lambda: $0.0000166667/GB-s                         │  │
│   │     • API Gateway: $0.0000035/request                    │  │
│   │                                                          │  │
│   │     LLM tokens (Bedrock) × 1.20  (20% markup)           │  │
│   │     • Only charged when using Platform Bedrock           │  │
│   │     • Bedrock prices = Anthropic direct API prices       │  │
│   │     • e.g. Sonnet 4: $3/$15 per 1M input/output tokens  │  │
│   │                                                          │  │
│   │     → This goes to UAPI                                  │  │
│   └──────────────────────────────────────────────────────────┘  │
│                           +                                     │
│   ┌──────────────────────────────────────────────────────────┐  │
│   │  2. AUTHOR PRICE         (set by the resource author)    │  │
│   │                                                          │  │
│   │     4 optional dimensions (all default to $0):           │  │
│   │     • pricePerInvocation  (flat fee per call)            │  │
│   │     • pricePerGbSecond    (compute time)                 │  │
│   │     • pricePerInputToken  (LLM input)                    │  │
│   │     • pricePerOutputToken (LLM output)                   │  │
│   │                                                          │  │
│   │     → 100% goes to the author (they get what they set)   │  │
│   └──────────────────────────────────────────────────────────┘  │
│                           +                                     │
│   ┌──────────────────────────────────────────────────────────┐  │
│   │  3. MARKETPLACE FEE      (20% of author price)           │  │
│   │                                                          │  │
│   │     Charged to the USER on top of the author's price.    │  │
│   │     The author receives exactly what they priced.        │  │
│   │     The 20% comes from the user, not the author's share. │  │
│   │                                                          │  │
│   │     → 100% goes to UAPI (pure margin)                   │  │
│   └──────────────────────────────────────────────────────────┘  │
│                           =                                     │
│   Total = Infrastructure Cost + Author Price + Marketplace Fee  │
│   Credits = max(1, ceil(Total × 1000))                          │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Concrete Examples

Example A: Agent call, NO author pricing (most common early on)

User calls a platform agent (2K input, 1K output tokens, Sonnet 4, 512MB, 10s):

  Compute (Lambda + API GW):   $0.0001035    ($0.0001 + $0.0000035)
  × 3.00 compute fee:          $0.0003105
  Bedrock tokens:              $0.021        (2K×$0.003 + 1K×$0.015 per 1K)
  × 1.20 LLM fee:              $0.0252
  ─────────────────────────────────────
  Infrastructure total:        $0.025407
  Author price:                $0.00         (no author pricing)
  Marketplace fee:             $0.00
  ─────────────────────────────────────
  User pays:                   $0.025407  →  26 credits ($0.026)

  Where it goes:
    AWS:    $0.0211035  (pass-through)
    UAPI:   $0.004303   (compute margin $0.0001035 + LLM margin $0.0042)

Example B: Agent call, WITH author pricing

User calls an authored agent (same tokens, author set $0.05/invocation):

  Infrastructure cost:   $0.025407      (same as above)
  Author price:          $0.05
  Marketplace fee:       $0.01          (20% of $0.05)
  ─────────────────────────────────────
  User pays:             $0.085407  →  86 credits ($0.086)

  Where it goes:
    AWS:     $0.0211035  (pass-through)
    UAPI:    $0.004303 (infra margin) + $0.010 (marketplace fee) = $0.014303
    Author:  $0.050    (exactly what they priced)

Example C: Standalone MCP tool call, no author pricing

User calls an MCP tool directly (no LLM, 256MB, 500ms):

  Lambda (256MB, 0.5s):  $0.0000021    (0.125 GB-s × $0.0000166667)
  API Gateway:           $0.0000035
  × 3.00 compute fee:    $0.0000168    (($0.0000021 + $0.0000035) × 3.00)
  Bedrock tokens:        $0.00         (no LLM)
  ─────────────────────────────────────
  Calculated cost:       $0.0000112  →  0.011 credits (rounds up)
  Minimum floor:         1 credit
  User pays:             1 credit ($0.001)

  Where it goes:
    AWS:    $0.0000056
    UAPI:   $0.0009944  (nearly all is margin — but <1% of total profit)

Example D: MCP ping / health check (pure protocol overhead)

MCP initialize or ping (128MB, 50ms):

  Lambda (128MB, 0.05s): $0.00000010   (0.00625 GB-s × $0.0000166667)
  API Gateway:           $0.0000035
  × 3.00 compute fee:    $0.0000108    (($0.00000010 + $0.0000035) × 3.00)
  ─────────────────────────────────────
  Calculated cost:       0.0072 credits
  is_tool_call = False → no minimum floor
  User pays:             0.0072 credits (~$0.0000072)

Summary Table

Scenario	AWS Cost	Infra charged	Author Price	Mktplace Fee	Total	Credits
MCP ping (no LLM, no author)	$0.0000036	$0.0000072	—	—	$0.001	1 (floor)
MCP tool (no LLM, no author)	$0.0000056	$0.0000112	—	—	$0.001	1 (floor)
Agent light (no author)	$0.0045	$0.0055	—	—	$0.006	6
Agent medium (no author)	$0.0211	$0.025407	—	—	$0.025	26
Agent heavy (no author)	$0.1055	$0.1269	—	—	$0.127	127
Agent multi-turn (no author)	$0.3010	$0.3617	—	—	$0.362	362
Agent medium + $0.05 author	$0.0211	$0.025407	$0.05	$0.01	$0.085	86
Agent heavy + $0.10 author	$0.1055	$0.1269	$0.10	$0.02	$0.247	247

5. Platform Bedrock Credentials

Overview

Users without AWS credentials automatically use Universal API's own Bedrock access (Platform Bedrock). This is an auto-fallback — no opt-in or configuration needed. When Platform Bedrock is used, the Bedrock token cost becomes a real infrastructure cost (instead of informational) and the 20% LLM fee applies. There is no separate "Bedrock fee" — it's just the standard LLM markup.

How auto-fallback works:

Agent runtime checks if user has AWS credentials stored in KeysTable
If found → use user's credentials (user pays their own AWS bill)
If NOT found → automatically use Lambda IAM role for Bedrock (Platform Bedrock)
- Pre-check: user must have ≥ 5 credits
- Bedrock token costs charged to credits with 20% infrastructure fee

How It Works

Scenario	Who pays AWS	Bedrock cost in billing	Credits charged
User's own AWS credentials	User's AWS account	Informational only (not charged)	Lambda + API GW + author pricing
Platform Bedrock	Universal API's AWS account	Real cost to recover	Lambda + API GW + Bedrock × 1.20 + author pricing

Why Same 10% (Not a Separate Fee)

Simplicity: One rule — "all AWS costs + 10%" — no exceptions
Transparency: Users can verify against AWS pricing pages
No confusion: Users don't need to understand which percentage applies to which cost dimension
Competitive: 10% on Bedrock is very low compared to alternatives (OpenAI charges ~40% margin on GPT-4)

Transparency (Implemented)

When Platform Bedrock is used, the system indicates this via:

Streaming: __META__ marker includes bedrockProvider: 'platform' so frontend can show a badge
Logs: bedrock_credential_source field in RequestTable records whether 'platform' or 'user' credentials were used
Billing: calculate_platform_costs() conditionally includes Bedrock cost in credits only when bedrock_credential_source='platform'

Future transparency enhancements:

Frontend badge: "Using Platform Bedrock" in agent chat
Logs page: "Bedrock: Platform" vs "Bedrock: Your Account" per invocation
Cost breakdown in __METRICS__ marker after completion

6. Credit System

6.1 Credit Value: 1 Credit = $0.001

	Value
1 credit	$0.001
$1	1,000 credits
$10	10,000 credits

See Section 3 for the full analysis of why $0.001 was chosen over $0.01 and $0.0001.

6.2 Minimum: 1 Credit per Invocation

Purpose: abuse prevention, not revenue. Prevents scripting millions of free no-LLM calls. Contributes <1% of profit in agent-dominated usage. For agents (the majority of invocations), the minimum never applies — real costs always exceed 1 credit.

6.3 Billing Formula

infra_cost     = (lambda + api_gateway + bedrock) × 1.20
author_total   = author_price                               # author gets 100%
marketplace    = author_price × 0.20                         # UAPI gets 20% from user
total          = infra_cost + author_total + marketplace
credits        = max(1, ceil(total × 1000))

Implementation (billing_utils.py):

python

INFRASTRUCTURE_FEE = Decimal('1.10')    # 10% on all AWS costs
MARKETPLACE_FEE_RATE = Decimal('0.20')  # 20% of author price, charged to user
CREDITS_PER_DOLLAR = Decimal('1000')    # 1 credit = $0.001

7. Revenue Architecture

7.1 How UAPI Makes Money

There are exactly two revenue sources (plus a negligible floor):

┌──────────────────────────────────────────────────────────┐
│  REVENUE SOURCE 1: Infrastructure Fee                     │
│                                                          │
│  What:  20% of AWS costs on every invocation             │
│  When:  Every single call (agent, MCP, action)           │
│  Size:  $0.002/medium agent, $0.011/heavy agent          │
│  Margin: 10% at launch → 50% at scale (AWS discounts)   │
│                                                          │
│  This is 56% of profit at launch.                        │
│  Scales linearly with usage.                             │
└──────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────┐
│  REVENUE SOURCE 2: Marketplace Fee                        │
│                                                          │
│  What:  20% of author-priced revenue (charged to user)   │
│  When:  Only on authored resources (growing share)       │
│  Size:  $0.010 per call at $0.05 author price            │
│  Margin: ~100% (zero marginal cost)                      │
│                                                          │
│  This is 21% of profit early, growing to dominant.       │
│  Scales with author ecosystem.                           │
└──────────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────────┐
│  REVENUE SOURCE 3: Subscription Revenue (Recurring)       │
│                                                          │
│  What:  $29/mo (Starter) or $575/mo (Professional)       │
│  Includes: Monthly credits + Knowledge storage capacity  │
│  Margin: ~96% on storage, ~17% on included credits       │
│                                                          │
│  Predictable MRR. Complements usage-based revenue.       │
└──────────────────────────────────────────────────────────┘

(Minimum charge floor: <1% of profit. Abuse prevention only.)

7.2 Where Every Dollar Goes

For a medium authored agent call ($0.084 user spend):

$0.084 user spend
├── $0.021  → AWS            (infrastructure pass-through)
├── $0.004  → UAPI           (infrastructure fee — 20% of AWS)
├── $0.050  → Author         (author's price, paid in full)
└── $0.010  → UAPI           (marketplace fee — 20% of author price)
    ─────
    $0.012 UAPI total margin  (14% of user spend, but 53% of UAPI revenue)

7.3 Expected Usage Mix

Resource Type	Share	LLM?	Revenue Driver
Agents	~70%	Yes	Infrastructure fee (Bedrock tokens are 99% of AWS cost)
MCP tools (standalone)	~15%	No	Minimum floor (negligible)
Actions	~5%	No	Minimum floor (negligible)
MCP tools (via agent)	Bundled	Bundled	Included in agent invocation
Knowledge	Ongoing	On upload	Recurring storage fees

7.4 Profit Breakdown (Per 1,000 Invocations, Agent-Dominated Mix)

5% standalone MCP, 85% agents (avg medium), 10% authored agents ($0.05/inv):

UAPI Revenue Source	Amount	% of Profit
Infrastructure fee (20% of AWS)	$2.67	56%
Marketplace fee (20% of author)	$1.00	21%
Credit rounding surplus	$1.08	22%
Minimum charge floor	$0.05	1%
Total UAPI profit	$4.80	100%

8. Scaling Economics

8.1 How Margins Improve Without Changing Prices

The 20% user-facing infrastructure fee stays fixed. But AWS volume discounts reduce UAPI's actual costs:

AWS Optimization	When	Savings	UAPI Effective Margin
On-demand pricing	Launch	—	10%
Compute Savings Plans	~Year 1	~17% on Lambda	~27%
Bedrock Provisioned Throughput	Year 2+	up to 50% on tokens	~60%
Combined optimizations	Year 3+	~40% blended	~50%

A medium agent call at scale:

User pays:                $0.024  (unchanged)
AWS cost (on-demand):     $0.0211
AWS cost (with discounts): $0.0127  (40% savings, mostly Bedrock)
UAPI keeps:               $0.024 - $0.0127 = $0.0113
Effective margin:          47%  (was 12.5% at launch)

8.2 Blended Margins by Stage

Stage	Mix (MCP:Agent:Authored)	Blended Margin	Platform Rev Margin	Knowledge Rev
Launch	15:80:5	19%	~50%	~$5/mo
Growth	10:60:30	41%	~54%	~$250/mo
Mature	10:40:50	52%	~57%	~$2,500/mo
Mature + AWS discounts	10:40:50	70%	~72%	~$25,000/mo

Platform Revenue Margin (excludes author pass-through) stays 50%+ from day one.

8.3 Margin Improvement Story (for Investors)

Year 1:  19% blended  →  50% platform margin  →  10% effective AWS markup
Year 2:  42% blended  →  54% platform margin  →  25% effective (Savings Plans)
Year 3:  52% blended  →  57% platform margin  →  40% effective (+ Provisioned)
Year 3+: 70% blended  →  72% platform margin  →  50% effective (full optimization)

Users never see a price increase. Margins expand purely from operational efficiency.

9. Pricing Parameters

9.1 Author Pricing Guardrails

Dimension	Max Allowed
`pricePerInvocation`	$1.00
`pricePerGbSecond`	$0.50
`pricePerInputToken`	$0.001 (= $1/1K tokens)
`pricePerOutputToken`	$0.005 (= $5/1K tokens)

9.2 Author Pricing Guidance (Shown in UI)

Resource Type	Suggested `pricePerInvocation`
MCP server tool	$0.005 - $0.05
Agent (per message)	$0.01 - $0.25

Token Dimension	Suggested Range
`pricePerInputToken`	$0 - $0.0001
`pricePerOutputToken`	$0 - $0.0005

9.3 Author Payouts

Authors receive exactly what they priced (the 20% marketplace fee is charged to the user, not deducted from the author)
Minimum payout: $10.00
Payout frequency: Monthly (net-30)
Payment method: Stripe Connect Express
Holdback: 10% held 30 days for disputes

10. Knowledge Storage (Tier-Based)

Knowledge storage (S3-backed file storage for agent knowledge bases, documents, and user data) is included as a subscription tier perk, not billed per-GB. This keeps the user experience simple and creates a natural upgrade path.

10.1 Storage Limits by Tier

Tier	Knowledge Storage	AWS Cost to UAPI	Margin
Free	100 MB	~$0.002/mo	~100%
Starter ($29/mo)	50 GB	~$1.15/mo	~96%
Professional ($575/mo)	1 TB	~$23/mo	~96%

Storage is enforced at upload time — knowledgeHandler.py checks storageUsedMb < tierStorageLimit before generating presigned upload URLs. A weekly EventBridge job updates storageUsedMb per user via S3 ListObjectsV2.

10.2 Download Egress Limits by Tier

Knowledge downloads (presigned S3 URLs) incur AWS data transfer charges at $0.09/GB. Each tier includes a monthly download egress allowance:

Tier	Download Egress Included	Overage	AWS Cost to UAPI
Free	1 GB/mo	Blocked (HTTP 429)	~$0.09/mo max
Starter ($29/mo)	100 GB/mo	$0.09/GB	~$9/mo max included
Professional ($575/mo)	1 TB/mo	$0.09/GB	~$90/mo max included

Egress is tracked per user per month via downloadEgressMb on UniUserTable. The knowledgeHandler.py download endpoint checks remaining egress allowance before generating presigned URLs. API response egress (agent responses, action results) is negligible (~2-5 KB per response) and is absorbed by the 20% infrastructure fee — no separate limit needed.

10.3 Why Tier-Based (Not Per-GB Billing)

Simpler UX — no surprise storage bills, no daily metering complexity
Natural upgrade trigger — "You've used 48 GB of 50 GB. Upgrade to Professional for 1 TB."
Near-zero COGS — S3 storage is $0.023/GB/month. Even 1 TB costs AWS only $23/mo vs. $575/mo subscription price
Predictable for users — storage is a plan feature, not a variable cost

11. Subscription Tiers & Credit Purchases

11.1 Subscription Tiers

	Free	Starter	Professional
Monthly price	$0	$29/mo	$575/mo
Annual price	—	$27.55/mo ($330.60/yr)	$546.25/mo ($6,555/yr)
Annual discount	—	5%	5%
Credits included/mo	100 (one-time)	30,000/mo	600,000/mo
Credit replenishment	100/mo (if < 100)	30,000/mo	600,000/mo
Effective credit rate	Free	$0.000967/cr (~3.3% discount)	$0.000958/cr (~4.2% discount)
Knowledge storage	100 MB	50 GB	1 TB
Knowledge download egress	1 GB/mo	100 GB/mo	1 TB/mo
Egress overage	Blocked	$0.09/GB	$0.09/GB
Support	Community	Email (72h SLA)	Email (24h SLA)

Target market: DIY developers and independent creators who use GenAI to build innovative agents, MCP servers, and actions. Subscriptions are consumer-focused — the value proposition is credits, Knowledge storage capacity, and support SLA. All platform features (analytics, webhooks, author payouts via Stripe Connect, API access) are available to all tiers equally.

Unit economics:

Starter: $29/mo for 30,000 credits ($30 face value). AWS pass-through ~$24. UAPI margin ~$5/mo (17%). Storage COGS ~$1.15/mo.
Professional: $575/mo for 600,000 credits ($600 face value). AWS pass-through ~$480. UAPI margin ~$95/mo (16.5%). Storage COGS ~$23/mo. Net margin ~$72/mo (12.5%).
Both tiers are profitable — the slight credit discount (3-4%) is small enough that subscription price always exceeds AWS pass-through cost.

11.2 Extra Credit Packs (À La Carte)

Available to all tiers. Credits only — no storage increase.

Pack	Credits	Price	Per-Credit	Discount
Small	5,000	$5.00	$0.001	Standard
Medium	25,000	$24.25	$0.00097	3% off
Large	100,000	$96.00	$0.00096	4% off

The 20% infrastructure fee and 20% marketplace fee are always calculated on actual costs at billing time, regardless of how credits were purchased.

11.3 Stripe Product Catalog

All subscriptions and credit packs are managed via Stripe:

Subscriptions: Starter (monthly + annual), Professional (monthly + annual)
Credit packs: Small, Medium, Large (one-time purchases)
Subscription billing is monthly; annual billing charges upfront at 5% discount
Credit replenishment happens at the start of each billing cycle
Unused credits roll over (no expiration)

12. Pre-Flight Credit Check

python

estimated_cost = estimate_minimum_cost(resource_type)
user_credits = get_user_credits(user_id)

if user_credits < estimated_cost:
    return {"error": "Insufficient credits", ...}

Resource Type	Estimated Min Credits
MCP tool	1
Agent	5

For resources with cost history, use avgCreditsPerInvocation × 1.5 as the threshold (see Priority 24 in to-do.md for the full design).

13. Revenue Projections

Stage	MAU	Inv/Mo	Mix (MCP:Agt:Auth)	Invocation Rev	Knowledge Rev	Total Rev	Gross Profit
Launch (Mo 1-6)	500	25K	15:80:5	$560	$5	~$565	~$107 (19%)
Traction (Mo 6-12)	5K	500K	10:70:20	$15,500	$250	~$15,750	~$5,500 (35%)
Growth (Yr 2)	25K	5M	10:55:35	$195,000	$2,500	~$197,500	~$82,000 (42%)
Scale (Yr 3)	100K	30M	10:40:50	$1.49M	$25,000	~$1.51M	~$785K (52%)
Scale + AWS	100K	30M	10:40:50	$1.49M	$25,000	~$1.51M	~$1.06M (70%)

14. Investor Narrative

Three-Sentence Pitch

Universal API is the Stripe for AI agents — the infrastructure and marketplace where AI agents discover and use capabilities. We charge AWS cost + 20% for infrastructure — growing to 50%+ effective margin at scale through volume discounts — and take 20% of author revenue as a pure-margin marketplace fee. Platform revenue margins are 50%+ from day one and reach 72% at scale without changing user-facing prices.

Key Signals

Signal	Evidence
Usage-based revenue	Aligns with 85% of SaaS; natural expansion
Two-sided marketplace	Network effects; 15-30× revenue multiples
Expanding margins without repricing	AWS volume discounts flow directly to bottom line
Multiple revenue engines	Infrastructure fee + marketplace fee + knowledge storage
AI infrastructure TAM	$21B → $82B by 2033 (18.4% CAGR)
Platform revenue margin 50%+	From day one, before any AWS optimization

Risks and Mitigations

Risk	Mitigation
19% blended margin at launch	Platform revenue margin is 50%+. Blended includes author pass-through. Frame correctly.
Author cold-start	Seeded with 5 built-in servers + agents. 100% author payout is competitive.
AWS builds a competitor	First-mover. Multi-cloud roadmap. Marketplace network effects.
Bedrock price drops	Reduces COGS. Users benefit from lower costs, increasing volume. Net positive.

Key Metrics

Metric	Why
Marketplace GMV	Commission revenue base. The growth story.
Platform Revenue Margin	True profitability (lead with this, not blended).
ARPU	Should grow as authored share increases.
Author-to-total ratio	% of invocations through authored resources.
AWS effective discount	Tracks how much of the 10% fee is real margin.
Net Revenue Retention	Usage-based should be >110%.
Knowledge storage/user	Recurring revenue growth predictor.

15. Implementation Phases

Phase 1: Core Pricing

billing_utils.py: Change CREDITS_PER_DOLLAR = 1000, add INFRASTRUCTURE_FEE = 1.10, MARKETPLACE_FEE_RATE = 0.20
actionHandler.py, mcpServerHandler.py, agentHandler.py: Add author pricing caps
user_operations.py: Initial credits = 2,000, replenishment threshold = 1,000

Phase 2: Credit Purchases

Stripe integration for credit pack purchases
Purchase history and receipt tracking
Low-balance warnings in UI

Phase 3: Pre-Flight Checks

Synchronous credit check before execution
Estimated cost display in UI (using avgCreditsPerInvocation from resource analytics)
Insufficient-credits error handling (HTTP 402)

Phase 4: Platform Bedrock

bedrockProvider field on UniUserTable and AgentTable
Runtime conditional credential injection in agentRuntimeHandler.py
Bedrock cost included in creditsCharged when using platform credentials
Same 20% infrastructure fee — no separate Bedrock markup
Transparency indicators in streaming, logs, and UI

Phase 5: Subscription Tiers & Knowledge Storage

Stripe product catalog: Starter ($29/mo, $330.60/yr), Professional ($575/mo, $6,555/yr)
Extra Credit packs: Small ($5), Medium ($24.25), Large ($96)
UniUserTable: add subscriptionTier, storageQuotaMb, creditsPerMonth, storageUsedMb fields
Monthly credit replenishment based on tier (30,000 Starter, 600,000 Professional)
knowledgeHandler.py: enforce storage quota before upload (100 MB / 50 GB / 1 TB)
Weekly EventBridge job: S3 ListObjectsV2 per user prefix → update storageUsedMb
Frontend: pricing page, subscription management, storage usage display

Phase 6: Author Payouts

Stripe Connect Express payout automation (already built)
$10 minimum payout, net-30
10% holdback for 30 days

16. Summary of All Changes

Parameter	Current	New
Credit value	$0.01	$0.001
Billing formula	`ceil(cost × 100)`	`ceil(cost × 1000)`
Infrastructure fee (applies to Lambda + API GW + Bedrock)	0%	10%
Marketplace fee (paid by user, on top of author price)	6% (deducted from author)	20% (added to user's bill)
Author receives	94% of their price	100% of their price
Platform Bedrock fee	N/A	Same 20% infrastructure fee
Minimum charge	1 credit = $0.01	1 credit = $0.001
Initial free credits	100 ($1.00)	2,000 ($2.00)
Monthly replenishment	100	1,000 (if < 1,000)
Author pricing caps	None	$1/invocation max
Credit purchases	None	4 tiers ($5-$700)
Pre-flight credit check	None	Yes (avgCreditsPerInvocation × 1.5)
Knowledge storage	None	Tier-based (100 MB / 50 GB / 1 TB)
Subscription: Starter	None	$29/mo (30,000 credits, 50 GB storage)
Subscription: Professional	None	$575/mo (600,000 credits, 1 TB storage)
Annual billing discount	None	5%
Extra Credits: Small	None	5,000 for $5.00 (standard)
Extra Credits: Medium	None	25,000 for $24.25 (3% off)
Extra Credits: Large	None	100,000 for $96.00 (4% off)

17. User-Facing Terminology

To keep messaging clear and professional, use these terms consistently:

Internal Term	User-Facing Term	Context
Platform markup	Infrastructure fee	"20% infrastructure fee covers platform overhead"
Author fee / commission	Marketplace fee	"20% marketplace fee supports the author ecosystem"
Platform Bedrock	Managed Bedrock	"Use Managed Bedrock — no AWS account needed"
Credit floor / minimum	Minimum charge	"1 credit minimum per invocation"
bedrockProvider: platform	Managed Bedrock	Settings UI toggle
bedrockProvider: own	Your AWS Account	Settings UI toggle

Universal API — Pricing Strategy ​

1. Current State & Problems ​

What Exists Today ​

Problems ​

2. Pricing Strategy Evaluation ​

Option A: Flat Percentage Fee (10% on AWS costs only) ​

Option B: At-Cost + Subscription ​

Option C: Varying % Fees (different rates per dimension) ​

✅ Chosen: Two-Revenue-Stream Model ​

3. Credit Value Analysis ​

The Core Constraint ​

Side-by-Side Comparison ​

Evaluation ​

Why $0.001 Wins ​

4. How a User Gets Charged ​

Concrete Examples ​

Summary Table ​

5. Platform Bedrock Credentials ​

Overview ​

How It Works ​

Why Same 10% (Not a Separate Fee) ​

Transparency (Implemented) ​

6. Credit System ​

6.1 Credit Value: 1 Credit = $0.001 ​

6.2 Minimum: 1 Credit per Invocation ​

6.3 Billing Formula ​

7. Revenue Architecture ​

7.1 How UAPI Makes Money ​

7.2 Where Every Dollar Goes ​

7.3 Expected Usage Mix ​

7.4 Profit Breakdown (Per 1,000 Invocations, Agent-Dominated Mix) ​

8. Scaling Economics ​

8.1 How Margins Improve Without Changing Prices ​

8.2 Blended Margins by Stage ​

8.3 Margin Improvement Story (for Investors) ​

9. Pricing Parameters ​

9.1 Author Pricing Guardrails ​

9.2 Author Pricing Guidance (Shown in UI) ​

9.3 Author Payouts ​

10. Knowledge Storage (Tier-Based) ​

10.1 Storage Limits by Tier ​

10.2 Download Egress Limits by Tier ​

10.3 Why Tier-Based (Not Per-GB Billing) ​

11. Subscription Tiers & Credit Purchases ​

11.1 Subscription Tiers ​

11.2 Extra Credit Packs (À La Carte) ​

11.3 Stripe Product Catalog ​

12. Pre-Flight Credit Check ​

13. Revenue Projections ​

14. Investor Narrative ​

Three-Sentence Pitch ​

Key Signals ​

Risks and Mitigations ​

Key Metrics ​

15. Implementation Phases ​

Phase 1: Core Pricing ​

Phase 2: Credit Purchases ​

Phase 3: Pre-Flight Checks ​

Phase 4: Platform Bedrock ​

Phase 5: Subscription Tiers & Knowledge Storage ​

Phase 6: Author Payouts ​

16. Summary of All Changes ​

17. User-Facing Terminology ​