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 bills Cloud usage in “units” — the sum of traces, observations, and scores — with 50,000 free per month and graduated overage from $8 down to $6 per 100,000; HoneyHive defines an event as a single trace span or metric-label combination sent via OTLP or JSON, with 10,000 free per month; Galileo meters whole traces, 5,000 free and 50,000 on its $100/month Pro tier.

The second group is usage-billing infrastructure — and here the unit gets pleasantly recursive. Metronome, m3ter, Orb, Lago, OpenMeter, and Togai sell the metering and rating that powers everyone else’s usage-based pricing, and they price themselves on the events they process. m3ter is the cleanest statement of the recursion: 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 interesting is that an “event” is a vendor-defined abstraction, not a thing the buyer can count on their fingers. Whether one request becomes one event or six, whether eval scores count, whether reads count alongside writes — those definitional choices move real bills by multiples, which is why the definition section of an event-metered pricing page deserves more scrutiny than the rate.

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. Orb made the same move explicit when it added billings (total invoice value issued) as a primary metric alongside events; its ingestion is stress-tested past 250,000 events per second, but its revenue compounds with its customers’ revenue, not just their traffic. 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 and Galileo 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.” The event is still the meter — it’s just expressed as tier boundaries rather than a rate card, the same quota-first pattern that dominates per-request pricing.

Companies using this

11 in-corpus companies meter events, split across two tight clusters: LLM observability and evaluation (Langfuse, HoneyHive, Galileo, Athina AI) and usage-billing infrastructure (Metronome, m3ter, Orb, Lago, OpenMeter, Togai) — plus Apify, whose marketplace Actors can charge buyers per event delivered.

Patterns observed

• Composite event definitions make bills a multiple of request counts. Langfuse sums traces, observations, and scores — one agentic request can be 6+ units, and units created by Langfuse’s own features (LLM-as-a-judge, annotation queues) count too. HoneyHive counts every trace span and metric-label combination. The deeper the call tree, the faster the meter spins — the unit prices instrumentation depth, not user traffic.

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

• The billing-infrastructure cluster pairs events with a money meter. Events alone undercount the value a billing platform delivers, so a second dimension rides along: Orb bills on billings (invoice value) plus events plus a platform fee, Togai’s platform fee scales with metered events and cumulative invoice value, m3ter bundles allowances for data ingested and bill calculations performed, and pre-acquisition OpenMeter layered a 0.4% billing-volume fee on its $249/month Pro plan.

• Price opacity is the billing-infra house style. All six billing vendors gate their numbers: m3ter describes a four-step custom quote with no dollar amounts, Metronome shows a free Starter and a “Talk to an expert” Custom plan, Lago’s entire managed product is quote-only, Togai routes Enterprise to “Get Custom Quote,” and Orb deleted its briefly published $1,750/month Core price by early 2025. The observability cluster, by contrast, publishes rates — Langfuse down to the graduated overage curve.

• Seat-free tiers follow the unit. Because the meter is ingestion volume, seats stop mattering: Langfuse’s paid tiers include unlimited users from $29/month, Galileo keeps users and custom evals unlimited on Free and Pro, and Togai’s FAQ states outright that pricing “is not dependent on the number of users.” Event-metered products want to spread across the whole engineering org; a seat tax would fight the meter.

• The category consolidated at extraordinary speed. Five of the eleven companies were acquired within roughly two years: Stripe closed on Metronome in January 2026 (~$1B reported), ClickHouse acquired Langfuse the same month, Kong took OpenMeter in September 2025, Zuora bought Togai in 2024, and Cisco closed on Galileo in May 2026. 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 Orb billed purely on monthly event volume and explicitly 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, with a platform fee 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 with no numbers at all.

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, and 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 — a reminder that “events in” and “work done” are different value metrics, and a vendor can meter either.

Apify stretches the unit in a third direction: pay-per-event there isn’t platform ingestion at all but a marketplace pricing model, where Actor developers charge buyers per event delivered — typically per result scraped — with creators keeping 80% of pay-per-event revenue net of platform costs, and buyers able to cap a run with ACTOR_MAX_TOTAL_CHARGE_USD so it terminates before exceeding the budget. Apify’s own platform meter, meanwhile, is the compute unit (1 GB RAM × 1 hour), which belongs to a different story entirely. And the observability tools that meter whole traces rather than events — Galileo’s 5,000-trace free tier, or LangSmith’s per-trace billing that Langfuse’s composite units pointedly diverge from — show the same telemetry priced at very different granularities: per-trace flatters agentic workloads, per-span/unit charges them for their depth.

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. On Langfuse an agentic request fans out into 6+ units; on HoneyHive every span and metric counts; on Galileo the same workload meters as whole traces. Run a week of production-shaped traffic through the free tier and read the actual meter before choosing a plan. For the billing-infrastructure vendors, ask three procurement questions: what is the effective rate per million events at my volume (you’ll have to ask — m3ter, Metronome, and Lago publish no numbers); is there a percentage-of-billings component, which scales with your revenue rather than your traffic (Orb, Togai); and 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.

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 an acquisition untouched. Three corpus-tested rules follow. First, publish the definition with worked examples and build the forecasting calculator before launch; composite units without forecasting tooling trade pricing elegance for bill shock, and the usage-event tracking pipeline has to be in place to count the unit defensibly. 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. Design the aggregation rules — what rolls up, what samples, what counts — as carefully as the rate, because in this unit the definition is the price.