outcome-based billing for LLMs — built for LLM startups shipping customer-facing agents

Stop margin leakage from unpredictable per-call spend

If you're shipping a customer-facing LLM agent, every billable run has to make margin sense. Rev gives you per-task cost caps, outcome-priced tiers, agent margin tracking, and Stripe-native monetization — no spreadsheet math, no surprise refunds.

One email from the LLM billing track. Day 1 quickstart, Day 3 outcome deep-dive.
Read the developer guide Rev vs Helicone vs Langfuse
Built for LLM startups

Four primitives that fix the LLM billing problem

Each one closes a margin gap that observability-only tools can't. Wire them in once and your agent platform has commercial superpowers from day one.

$

Per-task cost caps

Set a hard ceiling on every agent run — base fee + token rate + outcome bonus. Over-cap runs are rejected before they bill, so your LLM costs stop being a surprise at the end of the month.

↗

Agent margin tracking

Every meter event records the customer charge and your cost side-by-side. The dashboard groups margin by agent, by customer, by time window — see unit economics before your CFO asks.

★

Outcome-priced tiers

Charge only when the agent delivers: a successful booked meeting, qualified lead, resolved ticket. Failed outcomes or expired pending events automatically refund the bonus — the customer only pays for results.

→

Quickstart onboarding

From signup to first billable outcome in under 10 minutes. SDK installs in one line, your agent emits meter events, and the outcome pricing rules are configured from the dashboard — no five-week integration project.

Code-first

Per-task cost cap in one POST

Out-of-the-box SDK in Node.js and Python. Configure the cap once per agent — Rev rejects over-cap runs and reports the cost side-by-side with the outcome bonus.

agent.js
Node.js 
// Configure a per-task cost cap on the agent tier
const tier = await rev.pricing.createTier({
  agent_id: 'sales-outbound-v3',
  base_fee: 0.05,          // $0.05 per agent run
  token_rate: 0.000002,     // per token
  outcome_bonus: 1.50,      // $1.50 per booked meeting
  cost_cap_usd: 0.10,       // per-task ceiling
  currency: 'USD',
});

// Meter every agent run — returns the OK billable event
const event = await rev.meter.emit({
  agent_id: 'sales-outbound-v3',
  customer_id: cus.id,
  tokens: tokenCount,
  outcome: 'pending',
});

// Resolve the outcome — bonus posts or refunds automatically
if (meetingBooked) {
  await rev.outcomes.resolve(event.id, 'success');
} else {
  await rev.outcomes.resolve(event.id, 'failure');
}
Side-by-side comparison

Rev vs observability-only tools

Helicone and Langfuse are excellent tracing tools. They are not billing infrastructure. This is the gap Rev fills for LLM startups.

Capability Rev Helicone Langfuse
Outcome-based billing for LLMsCharge only when the agent task succeeds — booked meetings, qualified leads, resolved tickets Built-in Not supported Not supported
Per-task cost capsHard ceiling per agent run — over-cap meter events rejected before billing Built-in Not supported Not supported
Agent margin trackingPer-agent and per-customer margin dashboard showing cost vs revenue Built-in Cost only Cost only
Deferred outcome resolutionPending → success/failure/expired with bonus reconciliation First-class Not supported Not supported
Stripe-native monetizationPush outcome events directly into Stripe Checkout / subscriptions Built-in Not supported Not supported
Request-level traces & observabilityFull LLM request traces for debugging prompts, retries, and tool calls
Metered events via Rev SDK
Request-level Full traces

The common pattern: keep Helicone or Langfuse for tracing, wire Rev for billing. The services compose — neither replaces the other. See the full Rev vs Helicone, LangSmith, Phoenix, Langfuse comparison for the wider table.

From first meter event to first bill in under 10 minutes

Free tier, no Stripe required to start, dashboard updates the moment you resolve your first outcome. Built for LLM startups that need usage-based AI billing wired to Stripe today.

Read the developer guide → Get Your Free API Key

Frequently asked questions — LLM startup billing

How does Rev stop margin leakage for LLM startups?
Rev decouples per-task cost from outcome. You set a per-task cost cap (e.g. $0.10/api call), an outcome bonus (e.g. +$1.50 per successful task), and a token rate — the SDK reports tokens and outcome state, Rev computes the billable amount and pushes it to Stripe. Failed or expired outcomes automatically refund the bonus, so margin leakage from unpredictable per-call spend stops at the pricing layer, not after the fact.
What's a per-task cost cap and how do I set one?
A per-task cost cap is a ceiling you set on each agent run — base fee + token rate + outcome bonus. Rev enforces it at meter-time: an over-cap run is rejected before it bills, and the event is logged as pending for review. You pick the cap per agent_id from the dashboard or the API.
How does agent margin tracking work?
Every meter event records the customer charge and your cost side-by-side — token spend, base fee, outcome bonus, refunded bonuses. The dashboard groups margin by agent, customer, and time window, so LLM startup founders see unit economics per customer-facing agent in real time.
Why use outcome pricing instead of observability tools like Helicone or Langfuse?
Helicone and Langfuse log traces and token counts — invaluable for debugging, but they can't bill your customer per successful task. Rev is the commercial layer on top: it takes the same agent emit, records the outcome the agent produced, and routes it through a pricing engine into Stripe. The common pattern is Helicone or Langfuse for observability, Rev for billing.
How long does the quickstart onboarding take?
Most LLM startup teams go from signup to first billable outcome in under 10 minutes: create an API key, install the Node.js or Python SDK, send one /v1/meter call, configure a pricing tier, resolve an outcome, and the event is showing up on the dashboard and in Stripe.
Do I need Stripe to use outcome-priced tiers?
Only for charging customers. The metering, outcome resolution, pricing engine, and margin dashboard work without Stripe — useful if you're prototyping or if billing flows through your own PSP. To monetize, connect Stripe via the dashboard; Rev pushes metered events into Stripe checkout sessions automatically.
Building an LLM agent? Join the LLM billing track.