LiteLLM alternatives for AI apps: gateway control, billing and margin

Choose LiteLLM alternatives by the responsibility your AI application needs to change. Compare Portkey, Cloudflare AI Gateway and OpenRouter for selected gateway or managed-access requirements; compare Lago when the missing layer is usage billing. Evaluate ShareAI when an existing app wants eligible inference paid through an approved Builder arrangement, with an allowed app surcharge and attributed earnings.

Reviewed 23 October 2026. ShareAI publishes this comparison and operates one program discussed. Current official references support features; screenshots are actual captures. The executed code is an offline synthetic ledger. No production proxy migration, key provisioning, exploit test, customer invoice, payment or performance benchmark was performed.

LiteLLM already documents custom model costs, provider margins, virtual keys and billing integration. A comparison that reduces it to a provider-name adapter misses the commercial and control surface teams may already use. Identify the actual proxy version, license scope, configuration and surrounding payment arrangement before deciding what an alternative must preserve.

What LiteLLM already supports for commercialization

The custom-pricing reference describes cost overrides, discounts and provider-price mapping. The margin guide documents percentage or fixed-amount fees for internal billing and cost recovery. Reasons to keep it: evaluate those existing controls when the app needs its own price mapping and has an appropriate operating model. Configurable inference margins are not exclusive ShareAI capabilities.

The billing guide describes a Lago callback for internal or external usage billing, with selectable customer, user or team attribution. That is an existing integration path, not proof of an automatically completed invoice or payment. Compare the actual event mapping, plan and payment connection instead of claiming LiteLLM cannot participate in customer billing.

The current repository license distinguishes the separately licensed enterprise directory from MIT-licensed content outside its specified restrictions. Check the actual selected version and features. A broad open-source label does not establish that every enterprise control or commercial service is included, and a license fee is only one part of operating cost.

A multi-tenant writing app changes its custom-model price

Consider a hypothetical writing app with existing customer workspaces. Its gateway issues access keys for each workspace, routes between providers and includes a private model with a custom price. Finance wants to allocate infrastructure overhead and evaluate a permitted app margin on eligible inference. Product also needs a clear rule for requests that fail after generating part of a draft.

The difficult change is a new private model whose price mapping is incomplete. The app still produces drafts, but the gateway records zero cost and the configured budget does not stop further work. Separately, a customer-controlled request field can claim another customer’s identity if the billing integration trusts it without validation. A successful draft and a plausible cost chart do not resolve those two failures.

Compare the whole journey: trusted workspace admission, actual model usage, configured price, accepted customer charge and collection. Preserve the original draft task and repeated attempts. A retry can generate more provider consumption without delivering another useful draft. An explicit correction should change the commercial record without erasing what ran or silently assigning it to another workspace.

Compare alternatives by operating and commercial ownership

The writing app can keep a working gateway while evaluating another billing or approved inference journey. That requires actual integration and a clear user explanation. No automatically synchronized budget, shared wallet or native connector among the products is implied. Assign a single owner to each admission decision, measured usage item, customer charge and correction.

Trace one draft from workspace admission to payment

Keep those observations linked without treating them as one success flag. A key can authorize a model without establishing a customer purchase. A configured margin can be calculated without being collected. A correct final balance can hide a missing event or wrong workspace. Support and finance should be able to reconstruct the same original draft and its explicit adjustment.

Portkey: compare gateway operations and request evidence

The Portkey documentation describes gateway, observability, guardrail and administration capabilities, with separate deployment references. Pros: evaluate the selected scope when the writing app wants to compare operational controls and the evidence around model requests. Start from actual policies and failure behavior rather than a model-count ranking.

Tradeoffs: qualify the exact edition, hosting, retained data, pricing configuration and customer payment arrangement. A spend control and a trace do different work from collecting an accepted charge. A self-hosting reference does not automatically include every hosted dashboard or enterprise service. Compare the actual selected implementation and support responsibilities.

For the private writing model, inspect a known nonzero request and the customer mapping before changing production routing. Rehearse a partial draft and retry. Preserve what the user saw, what the provider consumed and what the app’s commercial policy charges, rather than treating a matching request count as proof that the whole workflow survived migration.

Cloudflare AI Gateway: compare funding and custom endpoints

The Cloudflare unified-billing reference describes provider-key and credit-funded model access. Its custom-provider guide covers HTTPS endpoints, including self-hosted model examples. Pros: compare these existing capabilities when the app wants to evaluate a different gateway and funding arrangement for the selected models.

Tradeoffs: qualify request format, credential priority, controls and actual customer pricing. A unified compatibility path and a provider-specific path have different requirements. Analytics cost mapping does not by itself establish an accepted resale charge. A successful response using a different funding source can still create an unexpected app-owner bill.

For the writing app, compare the private model and a missing production credential together. Inspect which account funds the result and which record describes the customer charge. Preserve your policy for a cached or interrupted draft. A different gateway does not automatically inherit every budget, model permission and billing callback configured in LiteLLM.

OpenRouter: compare managed access and user-funded requests

The OpenRouter quickstart describes managed model access. Its OAuth guide explicitly lets users authorize an app with a user-controlled key and fund requests from their own OpenRouter credits. Pros: compare this journey when the writing app wants the customer to fund eligible inference rather than charge every request to the app owner.

Tradeoffs: qualify model availability, provider policy, key handling and the actual app commercial agreement. The app-attribution guide describes usage association and rankings. That alone does not establish an approved app surcharge or received earnings. User-funded model access is not unique to ShareAI; compare the complete approved commercial path.

For the writer, rehearse a disconnected user account, exhausted credit and a failed final draft after earlier work succeeded. Preserve the trusted customer and expected payer. A model-access change should not silently charge the app owner or imply that its separate writing subscription, support duties and private-model infrastructure moved with the credential.

Lago: compare the usage-billing layer explicitly

The Lago introduction describes usage billing, while the official repository provides an open-source deployment path. Pros: compare the selected edition when the writing app’s missing responsibility is converting trusted usage and commercial terms into billing records. LiteLLM’s own billing guide already identifies a Lago integration path.

Tradeoffs: qualify actual deployment, required edition features, event mapping and payment integration. Operating a self-hosted implementation requires updates, availability and recovery. A usage-billing system does not automatically replace the gateway that admits model calls or establish the merchant-of-record relationship. Preserve the owner of each technical and financial step.

For the private model, compare a trusted workspace identifier, the agreed billable unit and an explicit correction. Reconcile gateway-calculated cost with the plan actually sold. A published callback example does not prove that a delayed event, replay or customer dispute will produce the intended invoice and received payment in the app’s selected deployment.

ShareAI: compare an approved app surcharge and settlement

The ShareAI Builder Program concerns an app that already exists with its own users. Eligible traffic routes through ShareAI, the Builder configures a permitted surcharge or margin, and the end customer pays ShareAI for that inference. App-attributed earnings follow the program. Pros: compare this arrangement when the writing app wants an approved inference payment and attribution journey.

Tradeoffs: app approval, eligible traffic, actual model access and account terms matter. Validated company Builders have a 45-day review period before payout. Individuals currently accumulate inference value for ShareAI use, without cash-out or account transfers. The app remains built, hosted, distributed and maintained elsewhere. Its writing subscription, support and other commercial duties remain explicit responsibilities.

Providing infrastructure or a custom endpoint belongs to applicable Provider or Prosumer onboarding, separately from Builder attribution. LiteLLM already documents custom prices and margins; custom endpoints also exist elsewhere. Compare actual acceptance, routing, payer and release. ShareAI does not establish a universal billing replacement, a general merchant-of-record service or automatic migration of existing gateway keys and permissions.

A margin calculation needs an accepted commercial policy

The margin reference describes applying a margin after a configured discount, with provider-specific settings overriding the global margin. Preserve the calculation version used for each draft. A later global configuration change should not erase the explanation of an earlier accepted charge. Internal cost recovery and an approved external app price can have different contractual treatment.

The billing reference offers customer, internal-user and team attribution choices. Select the identity from a trusted application context rather than accepting an arbitrary client-provided customer claim. Preserve the logical work and original adjustment. The existence of a callback does not prove that replayed events cannot double-charge or that a generated invoice has been paid.

Qualify zero-cost mappings and the whole key lifecycle

The pricing guide explicitly notes that zero input and output costs bypass budget checks and that pricing-provider mapping matters when routing and pricing providers differ. The virtual-key guide documents different permission inheritance surfaces. Compare the exact key owner, team and model configuration instead of treating the person who created a key as proof of its effective permissions.

The same key guide distinguishes a create-only custom hook from update enforcement and a broader effective-state policy hook. A key that meets an expiry rule at creation can be edited later unless the actual chosen policy covers that operation. Rehearse the selected version’s create, edit, rotate and revoke paths. Review its current official release and advisory information before deployment; this comparison does not test security or recommend an unqualified old package version.

For arithmetic only, 1000 USD of inference plus a hypothetical 15% surcharge produces 150 USD gross surcharge and 1150 USD total. These synthetic amounts are not LiteLLM or ShareAI fees, received earnings, net profit or a tax result. Actual infrastructure, provider and billing costs, corrections and eligibility affect the outcome.

Check arithmetic before accepting the live commercial path

The executed fixture below deduplicates identical activity, rejects a conflicting duplicate and records an explicit adjustment in integer USD cents. It does not deploy a proxy, provision a key, call a billing callback or collect payment. Those outcomes require actual runtime and commercial evidence around the calculation.

import assert from "node:assert/strict";
const records = [
  {id: "usage-a", customer: "demo", cents: 60000n, kind: "usage"},
  {id: "usage-b", customer: "demo", cents: 50000n, kind: "usage"},
  {id: "usage-a", customer: "demo", cents: 60000n, kind: "usage"},
  {id: "adjustment-b", customer: "demo", cents: -10000n, kind: "adjustment"}
];
function netCents(rows) {
  const seen = new Map();
  let total = 0n;
  for (const row of rows) {
    assert.equal(row.customer, "demo");
    const fingerprint = [row.customer, row.cents.toString(), row.kind].join("|");
    if (seen.has(row.id)) {
      if (seen.get(row.id) !== fingerprint) throw new Error("Conflicting duplicate");
      continue;
    }
    if (row.cents < 0n && row.kind !== "adjustment") throw new Error("Invalid sign");
    seen.set(row.id, fingerprint);
    total += row.cents;
  }
  return total;
}
const base = netCents(records);
assert.equal(base, 100000n);
assert.throws(() => netCents([...records,
  {id: "usage-a", customer: "demo", cents: 1n, kind: "usage"}
]));
const numerator = base * 1500n; // Hypothetical 15 percent in basis points.
if (numerator % 10000n !== 0n) throw new Error("Define contractual rounding first");
const surcharge = numerator / 10000n;
assert.equal(surcharge, 15000n);
const usd = cents => `${cents / 100n}.${(cents % 100n).toString().padStart(2, "0")}`;
console.log(JSON.stringify({baseUSD: usd(base), grossSurchargeUSD: usd(surcharge),
  totalUSD: usd(base + surcharge), paidReceiptVerified: false}));

Observed output is 1000 USD illustrative inference, 150 USD gross surcharge and 1150 USD total, with no verified paid receipt. Preserve trusted workspace identity, original drafts, actual usage and accepted corrections in production. A correct sum cannot prove enforced permissions, a correct invoice or received money.

Move one model, workspace and correction path first

• Identify actual gateway version, license scope, keys and billing integration.
• Select the operational or commercial responsibility that needs to change.
• Preserve trusted customer identity and versioned model-price mappings.
• Rehearse nonzero usage, zero-cost mapping, key edits and an explicit correction.
• Verify actual payment evidence without duplicate live collection.
• Retain original records and rollback until the complete customer journey is qualified.

Keep LiteLLM when its current implementation fits. Compare gateway alternatives for their actual operating boundary, Lago for selected billing requirements and ShareAI for approved customer-paid inference. Begin with one draft whose admission, consumption, price, delivery and financial correction remain explainable together.

Frequently asked questions