Per-Event Pricing: Examples & Companies

What is it

Per-Event Pricing is a billing unit where customers are charged per event ingested — the native meter of observability and billing-infrastructure platforms. The event is whatever crosses the ingestion boundary: a trace from an LLM app, a span inside that trace, an evaluation score, or a raw usage record on its way to becoming a line item on an invoice. The bill is event volume in, times a rate — or, more often, event volume measured against a tier’s included quota.

Two adjacent categories share the unit. LLM observability platforms meter the telemetry they store — Langfuse sums traces, observations, and scores into “units,” HoneyHive counts each trace span or metric-label combination, Galileo meters whole traces. The second is usage-billing infrastructure, where the unit turns pleasantly recursive: Metronome, m3ter, Orb, Lago, OpenMeter, Flexprice, Hyperline, Maxio, and Togai sell the metering that powers everyone else’s usage pricing and price themselves on the events they process. m3ter is the cleanest statement of it — its platform fee bundles allowances for exactly the two dimensions it meters for customers: usage data ingested and bill calculations performed.

What makes the unit slippery is that an “event” is a vendor-defined abstraction, not a thing a buyer counts on their fingers. Whether one request becomes one event or six, whether eval scores count, whether reads count alongside writes — those choices move real bills by multiples, which is why the definition section of an event-metered pricing page deserves more scrutiny than the rate. Choosing the right unit is the subject of the choosing the right usage metric guide.

How it works

The base formula is bill = base fee + max(0, events − included quota) × overage rate. The design work is in how vendors define the event, size the quota, and shape the overage curve:

Worked example — composite-unit fan-out. A team instruments an agent on Langfuse Cloud’s Core plan ($29/month, 100,000 units included). Each user request fires three LLM calls and two LLM-as-a-judge scores: six units per request. At 170,000 requests a month that’s roughly 1M units — $29 base, the first 100k included, then ~900k of overage at $8 per 100k ≈ $72, for a ~$101 bill. A team that modeled the same workload on request count would have budgeted for one-sixth the volume. This fan-out is exactly why the tracking and metering usage events guide insists on instrumenting the meter before pricing against it.

Worked example — the two-meter billing-infra bill. Before Kong acquired it, OpenMeter’s public Pro plan ran $249/month plus charges on ingested events plus 0.4% of billing volume processed. A customer pushing modest event volume but invoicing $500,000/month through the platform owed ~$2,000 from the billing-volume fee alone — five times what the event meter saw. Flexprice formalizes the same dual gate transparently: its $500/month Build tier includes 1M events and caps cumulative billings at $250K, so a team invoicing $600K crosses to the $1,000 Scale tier even while under the event ceiling. And Hyperline makes the money meter the headline — $199/month plus 0.6% of billed revenue, rising to $299/month plus 0.7% when usage-based billing is switched on. How raw events get rolled up into those billable aggregates is the subject of the aggregation methods and patterns guide.

Worked example — events as quota, not rate. HoneyHive, Galileo, and Schematic never publish a per-event price. HoneyHive’s free Developer tier carries 10,000 events/month and a 1,000 requests-per-minute cap, with everything above quoted by sales; Galileo’s $100 Pro tier carries 50,000 traces with a footnote that “pricing scales based on the number of traces”; Schematic bounds its free ($0) and $200/month Growth tiers by monetized subscriptions and monthly events (500k → 10M) but charges no per-event overage — you simply move up a tier. The event is still the meter, just expressed as tier boundaries rather than a rate card — the same quota-first pattern that dominates per-request pricing.

Companies using this

19 in-corpus companies meter events, concentrated in two clusters: LLM observability and evaluation (Langfuse, HoneyHive, Galileo, Athina AI) and usage-billing / monetization infrastructure (Metronome, m3ter, Orb, Lago, OpenMeter, Flexprice, Hyperline, Maxio, Alguna, Sequence, Zenskar, Schematic, Togai, and Stripe Billing) — plus Apify, whose marketplace Actors can charge buyers per event delivered. The table below sorts by pricing model, billing units, and free-tier availability.

Patterns observed

• Composite definitions price instrumentation depth, not traffic. Beyond the request fan-out above, units created by a platform’s own features count too — Langfuse bills its LLM-as-a-judge scores and annotation queues, so turning on more observability spins the meter faster even at flat user volume. The deeper the call tree, the higher the bill.

• Generous free quotas are the acquisition funnel. Langfuse gives 50,000 units/month free, HoneyHive 10,000 events with the full suite ungated, Galileo 5,000 traces, Athina AI 10,000 logs plus 500 execution credits, Flexprice 100,000 events, and Schematic 500,000 — while Metronome, Maxio, and Togai ship free starter tiers. Event exhaust only becomes valuable at production volume, so vendors price the on-ramp at zero.

• The billing-infra cluster pairs events with a money meter. Events alone undercount the value a billing platform delivers, so a second dimension rides along — a percentage of invoice value. Stripe Billing meters 0.7% of billing volume (100M events/month included) rather than seats; Orb, Hyperline, and Flexprice each carry a revenue component too. The money meter compounds with the customer’s success, not just its traffic.

• Price opacity is the house style — but cracks are appearing. The heavyweights still gate their numbers: m3ter walks a four-step custom quote, Metronome shows a free Starter and a “Talk to an expert” plan, Lago’s managed product is quote-only, Zenskar runs three custom-quoted tiers, and Togai routes Enterprise to “Get Custom Quote.” The developer-first entrants publish instead — Flexprice ($500 / $1,000), Maxio ($599/mo Grow), Hyperline ($199/mo + 0.6%), Stripe Billing (0.7%) — as does the entire observability cluster.

• Seat-free tiers follow the unit. Because the meter is ingestion volume, seats stop mattering: Langfuse includes unlimited users from $29/month, Galileo keeps users and custom evals unlimited on Free and Pro, Schematic prices on “monetized subscriptions,” Alguna ships unlimited seats across tiers, and Togai’s FAQ states outright that pricing “is not dependent on the number of users.” A seat tax would fight the meter’s job of spreading across the whole engineering org.

• The category consolidated at extraordinary speed. Several adopters were acquired inside roughly two years: Stripe closed on Metronome on January 14, 2026 (press reported ~$1B, terms undisclosed), ClickHouse acquired Langfuse the same month, Kong took OpenMeter in September 2025, Zuora bought Togai, and Cisco closed on Galileo. Event pipelines, it turns out, are infrastructure worth buying.

Counterexamples & variants

The sharpest counterexample is Orb abandoning the pure event meter on its own product. Through mid-2024 it billed purely on monthly event volume and advertised that it invoiced “without charging a percentage of billings.” Then it reversed: billings — a cut of invoice value — became a primary metric alongside events, a platform fee appeared on upper tiers, and the briefly published $1,750/month Core price vanished into full “Custom pricing.” The lesson cuts at the unit itself — for a billing platform, event volume is a cost proxy, not a value proxy, and the vendor that knew the unit best concluded events alone couldn’t carry the model. OpenMeter traced the same arc in miniature: per-event in 2023, flat $249–$349/month in 2024, usage-based with a billing-volume fee by mid-2025, then a pricing page reduced to a Kong migration notice.

A cleaner variant keeps events as a meter but refuses to let them stand alone. Flexprice meters two things from the start — a monthly events allowance (100k / 1M / 5M) and a cumulative-billings cap ($250K on Build, $1.2M on Scale) — so a customer is never billed on events without also being scored on revenue processed. Hyperline goes further and makes money the headline: a small $199–$299/month platform fee and a real charge of 0.6–0.7% of billed revenue. Alguna is the outright inversion — its billing_units include events, but it explicitly does not meter usage: unlimited event ingestion and unlimited seats across a free Starter, a $699/month Growth tier, and quoted Enterprise, priced on features and scale. Same category, opposite conclusion about whether the event should carry the bill.

Athina AI is the variant where the ingested event is deliberately not the paid meter. Logs, online evals, and annotations consume nothing; the credit meter fires only on executions — prompt runs, flow steps, offline evals, dataset cells — at one credit each regardless of token count (a dynamic column over a 50-row dataset burns 50 credits at once). Athina charges for compute it initiates, not telemetry it receives. Apify stretches the unit the other way, into a marketplace: Actor developers charge buyers per event delivered (typically per result scraped), creators keep 80% of pay-per-event revenue, and buyers cap a run with ACTOR_MAX_TOTAL_CHARGE_USD so it terminates before exceeding budget. Together they show “events in” and “work done” are different value metrics — a vendor can meter either, both, or neither.

What this means for buyers vs vendors

For buyers

Read the event definition before the rate card — it moves the bill more than the price does. The same workload meters as one whole trace on Galileo but every span and metric on HoneyHive, and fans out on Langfuse. Run a week of production-shaped traffic through a free tier and read the actual meter before choosing a plan.

For the billing-infrastructure vendors, ask three procurement questions. First, what is the effective rate at my volume — you may have to ask, since m3ter, Metronome, Lago, and Zenskar publish no numbers. Second, is there a percentage-of-billings component that scales with your revenue rather than traffic — Stripe Billing’s 0.7% stacks on top of ~2.9% processing, and at scale a percentage can quietly exceed a flat-fee competitor. Third, what happens when event volume spikes — sampling, throttling, or uncapped overage.

Retention is the quiet second axis: Langfuse jumps from 90 days to 3 years only at the $199 Pro tier, and on every platform here keeping events costs more than ingesting them. Watch too for a hidden non-event gate — Flexprice’s $250K billings cap upgrades you even while you sit under the 1M-event ceiling.

For vendors

Per-event pricing fits when your marginal cost genuinely is rows ingested — Langfuse’s unit maps almost 1:1 to ClickHouse rows, which is why the model survived acquisition untouched. Three corpus-tested rules follow.

First, publish the definition with worked examples and build the forecasting tooling before launch; composite units without forecasting support trade pricing elegance for bill shock, and the usage-event tracking pipeline has to be in place to count the unit defensibly. Schematic shows how to keep the meter’s presence without the anxiety of per-unit overage.

Second, make the free quota generous and the paid tiers seat-free — the event meter monetizes scale, so don’t tax the adoption that creates it.

Third, if events are a cost proxy rather than a value proxy for your product, add the second meter early rather than reversing later: Orb’s billings pivot and OpenMeter’s three models in two years both happened in public and buyers noticed, whereas Hyperline and Stripe Billing led with revenue-share from day one and never had to reprice around it. Design the aggregation rules as carefully as the rate — in this unit the definition is the price.

Explore this theme in the knowledge graph →