LaunchDarkly Pricing in 2026: The Real 30-Day Bill

LaunchDarkly stopped charging per seat. If your mental model of the bill is "developers times a seat price," it is two years out of date, and the search results are still full of guides that quote $10 a seat. In 2026 the paid plan meters two things that have nothing to do with how many people log in: server connections and client-side monthly active users. This is the worked 30-day bill on the new meter, the trap that inflates it, and the one lever that cuts it.

What does LaunchDarkly cost in 2026?

There are four tiers. Two have public numbers; two are "call us."

Source: LaunchDarkly pricing page, July 2026, re-verified October 7, 2026. The free Developer tier is genuinely generous on seats and flags, which is why small teams rarely see a bill. It is not generous on traffic: Developer caps client-side MAU at 1,000 a month and service connections at 5, and LaunchDarkly's billing documentation says a Developer plan that keeps exceeding its entitlements converts to read-only mode rather than issuing an invoice. On that tier the ceiling is a wall, not a charge. The pain starts at Foundation, and it scales with traffic, not headcount.

How LaunchDarkly bills you now: usage meters, not seats

Foundation charges on usage lines, not headcount, and there are more than two of them. LaunchDarkly's billing documentation lists the full Foundation set as monthly entitlements for "monthly active users (MAU), service connections, AI runs, observability, and Experimentation" (LaunchDarkly, Calculating billing, 2026), and the pricing page prices the extra ones for self-serve: AgentControl includes 5,000 AI runs a month and bills $5 per additional 1,000, and observability includes 5,000 session replays, 5,000 errors, 10M logs and 10M traces a month with "usage beyond that bills as you go." Experimentation carries 100,000 experimentation MAU at no additional charge. Two of those lines decide a feature-flag bill, and they are the two worked below. If flags are all you run, service connections and client-side MAU are the whole invoice. If you also run AgentControl, ingest observability data, or experiment past the included block, those lines stack on top.

Service connections, first 5 included, then $10 each per month. Foundation includes five service connections a month; LaunchDarkly bills $10 each per month beyond that, and its billing docs describe the same structure as prepaid monthly entitlements with overage billed the following month. A service connection is one server-side SDK instance connected to one environment, measured in minutes. In plain terms: every running copy of your backend that talks to LaunchDarkly, in every environment, is a billable connection. Three replicas of one service in production plus one in staging is four connections, not one. Autoscaling multiplies this quietly.

Client-side MAU, $8.33 per 1,000 on annual billing. That $8.33 sits on the plan card under a Billed yearly toggle and works out to $99.96 a year per 1,000; LaunchDarkly's own compare-all-features table lists Foundation client-side MAU at $10 per 1,000 a month, so budget the higher figure if you are not paying yearly. MAU is the count of unique monthly active contexts evaluated by client-side, AI, and edge SDKs. LaunchDarkly counts unique context keys, and here is the part that catches teams: it bills on the single context kind with the highest volume. If you evaluate both a user context and a device context, and you have 300,000 users but 500,000 devices, your MAU is 500,000, not 300,000. You pay for the bigger number even if you only ever target on users.

Seats are free and unlimited on every tier. The meter that hurts is client-side MAU, and it is driven by your app's reach, not your team's size.

> "LaunchDarkly no longer charges per seat. They've switched to service connections and MAU-based pricing, moving closer to an infrastructure-like model." (Schematic, 2025)

The real 30-day bill: three worked cohorts

Numbers below use the public Foundation rates: the first 5 service connections included and $10 each per month beyond, plus $8.33 per 1,000 client-side MAU on annual billing. They are flag-only bills: no AI runs past the included 5,000, no observability ingestion past the included blocks, and no experimentation past the included 100,000 MAU. Enterprise deals are negotiated off these.

The seed team pays about $308 a month, roughly $3,699 a year. Even at this size two thirds of it is the MAU line, not the connections. Reasonable.

The growth consumer app is where the model bites. Its bill is $4,515 a month, about $54,180 a year, and 92% of that flag-only bill is the MAU meter. Worse, the app has 300,000 logged-in users but registers a device context for anonymous sessions that peaks at 500,000. LaunchDarkly bills the higher kind, so this team pays for 200,000 contexts it never targets a flag on.

The scale-up's self-serve math lands near $17,410 a month, about $208,900 a year. Nobody actually pays list at that volume. This is the point where LaunchDarkly moves you onto a custom Enterprise contract. Spendflo pegs real Enterprise deals at $20,000 to $120,000 a year (Spendflo, March 2025), which is a steep discount off self-serve list, and a range wide enough that you should treat the first quote as an opening bid.

The one lever that cuts the bill

For the growth consumer app, the dominant meter is client-side MAU, and it is inflated by a context kind the team does not need for targeting. The fix is to stop evaluating the high-volume device context and collapse to a single user context (or an anonymous-session strategy that dedupes to one key per real person).

• Before: 500 units x $8.33 = $4,165.00 / mo
• After: 300 units x $8.33 = $2,499.00 / mo
• Saved: $1,666.00 / mo, or $19,992 a year

That is a 40% cut to the biggest line on the invoice, and it changes nothing about which flags exist or how they behave. Audit which context kinds your client SDKs send before you audit anything else.

Same app, four meters: what the alternatives actually charge

The reason LaunchDarkly can feel expensive is not that its price is high in the abstract. It is that its meter, client-side MAU, is tied to the thing that grows fastest: your users. Competitors meter different things, so the same app pays wildly different amounts.

We priced one workload (100,000 client-side MAU, 20 service connections, 8 developers, roughly 1.5M flag evaluations a month) on four tools: Statsig, ConfigCat, Unleash, and LaunchDarkly.

LaunchDarkly Foundation on this app is 15 billable connections (20 minus the 5 included) x $10 plus 100 x $8.33, which is $150 plus $833, so $983 a month. Statsig leaves flag and config checks unmetered and gives you 2M analytics events free, so a flag-only workload can sit at $0 (its Pro plan is $150 a month once you lean on analytics past 5M events). ConfigCat ignores MAU entirely and meters config-JSON downloads, so this app rides the $110-a-month Pro tier with unlimited seats. Unleash is open source: self-host for infrastructure cost only, or take its Cloud pay-as-you-go at $75 a seat with a 5-seat minimum, which is $600 a month for this team.

Same app. $0, $110, $600, or $983, decided almost entirely by which meter the vendor picked. If you already run PostHog for analytics, its feature flags are free up to 1M requests a month, a fifth meter again; we broke that one down in posthog-pricing-2026. (All figures from each vendor's pricing page, July 2026.)

Is LaunchDarkly worth it in 2026?

Yes, for a specific buyer. If you need governed progressive delivery at scale, approval workflows, SAML and SCIM, guardrail metrics that automatically pause or roll back a bad release (the Guardian tier), and an audit trail your security team will accept, LaunchDarkly is the most mature option and the MAU premium buys real capability.

No, if flags are the whole job. A consumer app that just needs to toggle features behind a boolean is buying the most expensive possible switch when its bill is driven by a client-side MAU meter. ConfigCat's flat download-metered tiers, Statsig's free flag checks, or a self-hosted Unleash instance deliver the core feature-flag job for a fraction of the cost. Pick LaunchDarkly for high-stakes, regulated, or large-team release engineering. Pick a flat-fee or open-source tool when the switch is all you need.

Math check: on a flag-only workload, client-side MAU is the line that decides your LaunchDarkly bill. At $8.33 per 1,000, every 120,000 extra contexts adds about $1,000 a month, so the cheapest optimization you will ever run is collapsing to a single context kind.

Correction, September 6, 2026

This page originally billed every service connection at $10 a month with no allowance. LaunchDarkly's pricing page states that the first 5 service connections each month are included on Foundation, and its billing documentation describes those as prepaid monthly entitlements with only the excess billed. Applying the allowance lowers the three worked bills: the seed cohort from $358.25 to $308.25 a month, the growth consumer app from $4,565.00 to $4,515.00, and the scale-up from $17,460.00 to $17,410.00. The alternatives comparison moved from $1,033 to $983 a month for the same workload. The per-unit rates themselves are unchanged. The MAU line was also re-scoped: $8.33 per 1,000 is the annual-billed rate shown under a Billed yearly toggle, and LaunchDarkly's compare-all-features table lists $10 per 1,000 a month.

Correction, October 7, 2026

This page originally described the Foundation plan as metering two independent lines, service connections and client-side MAU, and presented the three worked totals as the whole bill. That meter count is short. LaunchDarkly's billing documentation states that Foundation plans can include monthly entitlements for "monthly active users (MAU), service connections, AI runs, observability, and Experimentation," and the pricing page publishes self-serve rates for two of the three we omitted: AgentControl at $5 per additional 1,000 AI runs beyond 5,000 included, and observability usage beyond 5,000 session replays, 5,000 errors, 10M logs and 10M traces billing as you go. Experimentation includes 100,000 experimentation MAU. Every rate previously published here is unchanged and re-verified: $10 per service connection beyond the first 5 included, $8.33 per 1,000 client-side MAU on annual billing, $10 per 1,000 a month on the compare-all-features table, and the three worked totals of $308.25, $4,515.00 and $17,410.00. What changed is their scope. Those totals are flag-only bills, and a Foundation account that runs AgentControl past its included runs, ingests observability data past its included blocks, or experiments past 100,000 MAU pays more than they show. The error direction was understatement. The Developer row has also been corrected: it omitted that the free tier caps client-side MAU at 1,000 a month, service connections at 5, and projects at 1 with 3 environments, and that exceeding those entitlements converts the plan to read-only rather than producing a charge.