Most lists of LaunchDarkly alternatives compare features and then wave at pricing with a “starts at” number. That number is rarely what you pay, because every vendor meters something different: LaunchDarkly counts service connections and client-side users, Unleash counts seats, ConfigCat counts config downloads, and PostHog counts requests. This post is for the engineering lead or platform engineer who has to put a feature flag bill in a budget and wants the monthly total for their team shape, not a feature grid.
To get there, eight public pricing pages were read on 12 November 2026. A short script then turns three stated team sizes into each vendor’s billing unit and prints the monthly bill. Both the script and its raw output are below, so you can swap in your own instance count and user numbers when you compare.
Prices read 2026-11-12, USD, before tax, monthly billing unless marked yearly
LaunchDarkly https://launchdarkly.com/pricing/
Flagsmith https://www.flagsmith.com/pricing
ConfigCat https://configcat.com/pricing/
Unleash https://www.getunleash.io/pricing
GrowthBook https://www.growthbook.io/pricing
PostHog https://posthog.com/pricing (tiers from billing.posthog.com/api/products-v2)
Statsig https://www.statsig.com/pricing
DevCycle https://www.devcycle.com/pricing
Month: 730 hours (43,800 minutes)
Not priced: Enterprise tiers marked "contact sales", self-hosted infrastructure,
experiment event volumes, taxes, startup and non-profit discounts
The Short Answer
For a team that only needs feature flags, Statsig’s free tier and PostHog’s usage pricing cost the least at all three sizes, and ConfigCat is the cheapest flat-priced paid plan. LaunchDarkly is competitive for a small team at $150 a month. However, it becomes the most expensive option once client-side users grow, because client-side MAU makes up $990 of its $1,530 mid-size bill and $9,990 of its $12,330 large bill.
In practice, the right question is not “which tool is cheapest” but “which unit grows with my business”. Seat pricing grows with headcount, MAU pricing grows with users, and request pricing grows with how often your SDKs poll.
What Each LaunchDarkly Alternative Bills For
Before any totals make sense, the billing units need to be lined up. This table is the quick answer to “how does each feature flag tool charge”.
| Vendor | Paid plan used here | Base price | What is metered | Seats |
|---|---|---|---|---|
| LaunchDarkly | Foundation | $0 | Service connections ($12 each after 5), client MAU ($10 per 1K after 1K) | Unlimited, no fee |
| Flagsmith | Start-Up / Scale-Up | $45 / $300 | API requests (1M / 5M included) | 3 / 5 included, then $60 each to 20 |
| ConfigCat | Pro / Smart | $110 / $325 | Config JSON downloads (25M / 250M), network traffic | Unlimited |
| Unleash | Pay-As-You-Go | $75 per seat | API requests (53M included, then $5 per million) | Billed per seat |
| GrowthBook | Pro (Cloud) | $40 per seat | CDN requests (2M, then $10 per million), bandwidth (20 GB, then $1 per GB) | Up to 30 |
| PostHog | Pay-as-you-go | $0 | Flag requests (1M free, then tiered from $0.0001) | No seat fee |
| Statsig | Developer (free) / Pro | $0 / $150 | Metered events; flag checks are free unless Metric Lifts are on | Unlimited |
| DevCycle | Business | $625 ($500 yearly) | Client MAU, cloud config requests, server config requests, events | Unlimited |
Two details in this table catch people out. First, LaunchDarkly no longer charges per seat at all. Its pricing page says “Unlimited seats, no per-seat fees”, yet several comparison pages that rank for this query still describe it as seat-based. Second, Unleash and GrowthBook are the seat-priced ones, so their bills track your headcount rather than your traffic. Also note that DevCycle’s pricing page now carries the banner “DevCycle is Now Part of Dynatrace”, which is worth a question about the roadmap before a long contract.
How LaunchDarkly Counts a Service Connection
In particular, the service connection is the unit most teams underestimate. LaunchDarkly’s pricing page defines it as “One server-side SDK connected to one environment, counted by time and averaged over the month. Every replica, worker and dev or staging environment counts.” The service connections documentation adds that each application instance across production and pre-production counts.
In other words, a service running three replicas in production plus one in staging is four connections, not one. Consequently, autoscaling, preview environments and background workers all move the bill.
Where the Vendor Pages Disagree With Themselves
Three pages contradict their own fine print, and none of the contradictions changes a total below. Still, they are worth knowing before you sign anything:
- Flagsmith lists “Additional API calls start at $50 per million” on each plan card, while its FAQ says Start-Up overage is “$7/100k requests”, which is $70 per million.
- Unleash includes 53 million API requests on its pricing page, but its fair use policy still says 50 million for Pay-As-You-Go.
- PostHog‘s local evaluation docs say a definitions poll counts “as 10 flag requests when the definitions changed, and 1 when they didn’t”. A few lines later, the same page says an unchanged poll gets a 304 response and “That poll is free.” The script follows the second statement.
The Three Team Sizes
A price comparison is only as honest as its workload, so every assumption is stated here. Each one maps to the unit a vendor bills for.
| Assumption | Small | Mid | Large |
|---|---|---|---|
| People who log in to the flag tool (seats) | 5 | 20 | 60 |
| Server SDK instances running 24/7, all environments | 10 | 50 | 200 |
| Client-side monthly active users | 10,000 | 100,000 | 1,000,000 |
| Sessions per user per month | 8 | 8 | 8 |
| Minutes a session stays open | 15 | 15 | 15 |
| Flag definition changes per month | 100 | 100 | 100 |
| Config payload on a full download | 10 KB | 10 KB | 10 KB |
For example, the small team is five services with one production and one staging instance each. The mid team runs twenty services with roughly two production replicas and some staging. Meanwhile, the large team has sixty services and about three replicas each once workers and pre-production are counted.
SDK Defaults Behind the Request Counts
Request-metered vendors bill for how often SDKs fetch configuration, so the script uses each vendor’s documented default rather than a guess:
- Flagsmith server SDKs in local evaluation mode refresh the environment every 60 seconds, per the server-side SDK docs. Browser apps make one request per session, which is the pattern the pricing FAQ describes for a single page app.
- ConfigCat SDKs auto-poll every 60 seconds on servers and in the browser. Their config JSON download guide uses exactly this “active minutes divided by polling interval” method.
- Unleash server SDKs poll every 15 seconds, as the pricing FAQ states, and the browser SDK refreshes every 30 seconds.
- GrowthBook treats cached features as stale after 60 seconds by default, according to the JavaScript SDK docs, so busy servers refetch about once a minute.
- PostHog browser SDKs call
/flagson initialization and again on identify, so the script counts two per session. Server polls only bill when definitions change. - DevCycle server SDKs poll every 10 seconds by default, per the Node.js SDK initialization docs.
The Cost Script
The calculator is one awk program, so it runs in any Bash, including Git Bash on Windows, with nothing to install. Every rate and assumption sits in a named variable at the top of its block:
#!/usr/bin/env bash
# flag-cost.sh: monthly bill for eight feature flag services at three team sizes.
# Rates read from each vendor's public pricing page on 2026-11-12, monthly billing, USD.
awk 'BEGIN {
MIN = 43800 # minutes in a 730-hour month
# Workloads: small, mid, large
split("small mid large", NAME, " ")
split("5 20 60", SEATS, " ") # people who log in to the flag tool
split("10 50 200", INST, " ") # server SDK instances running 24/7, all environments
split("10000 100000 1000000", MAU, " ") # client-side monthly active users
SESS = 8; SESS_MIN = 15 # sessions per MAU, minutes open per session
CHANGES = 100 # flag definition changes per month
CFG_KB = 10 # config payload size on a full download
printf "%-6s %8s %8s %8s %8s %8s %8s %8s %8s\n", "team", "LD", "Flagsm", "CfgCat",
"Unleash", "GrowthB", "PostHog", "Statsig", "DevCycle"
for (w = 1; w <= 3; w++) {
s = SEATS[w]; n = INST[w]; m = MAU[w]
sessions = m * SESS; open_min = sessions * SESS_MIN
# LaunchDarkly Foundation: 5 connections and 1K MAU free, then $12 each and $10 per 1K
ld = (n > 5 ? n - 5 : 0) * 12 + (m > 1000 ? (m - 1000) / 1000 : 0) * 10
# Flagsmith: server local evaluation polls every 60 s, one request per client session
fs_req = n * MIN + sessions
if (s <= 3 && fs_req <= 1000000) fs = 45 # Start-Up
else if (s <= 20) fs = 300 + (s > 5 ? s - 5 : 0) * 60 # Scale-Up, 5M requests
else fs = -1 # Enterprise, not public
# ConfigCat: 60 s auto poll on servers and in the browser, plus one download per session
cc_req = n * MIN + open_min + sessions
cc = (cc_req <= 25e6 ? 110 : (cc_req <= 250e6 ? 325 : (cc_req <= 1e9 ? 900 : 4500)))
cc_gb = (sessions * CFG_KB * 1000 + (cc_req - sessions) * 65) / 1e9
# Unleash Pay-As-You-Go: $75 per seat, 53M requests, then $5 per million
# servers poll every 15 s, browsers every 30 s while open, plus one fetch per session
un_req = n * MIN * 4 + open_min * 2 + sessions
un = s * 75 + (un_req > 53e6 ? (un_req - 53e6) / 1e6 * 5 : 0)
# GrowthBook Cloud: free up to 3 users, Pro $40 per seat up to 30 users
# servers refetch after the 60 s staleTTL, browsers fetch once per session
gb_req = n * MIN + sessions; gb_gb = gb_req * CFG_KB * 1000 / 1e9
if (s <= 3) gb = (gb_req <= 1e6 && gb_gb <= 5 ? 0 : -1)
else if (s <= 30) gb = s * 40 + (gb_req > 2e6 ? (gb_req - 2e6) / 1e6 * 10 : 0) \
+ (gb_gb > 20 ? gb_gb - 20 : 0)
else gb = -1 # Enterprise, not public
# PostHog: two /flags calls per session (init + identify); a server poll that returns
# changed definitions bills as 10 requests, a 304 poll is free
ph_req = sessions * 2 + n * CHANGES * 10
ph = tier(ph_req, 2e6, 1e6) * 0.0001 \
+ tier(ph_req, 10e6, 2e6) * 0.000045 + tier(ph_req, 50e6, 10e6) * 0.000025 \
+ tier(ph_req, 1e15, 50e6) * 0.00001
# Statsig: flag checks are unmetered unless Metric Lifts are on; free tier
st = 0
# DevCycle Business (any team over 1K MAU): $625, 100K MAU, 1M cloud, 10M server requests
dc_srv = n * MIN * 6 # server SDK polls every 10 s
dc_cloud = sessions # one client initialization per session
dc = 625 + (m > 1e5 ? (m - 1e5) / 1000 * 2.5 : 0) \
+ (dc_cloud > 1e6 ? (dc_cloud - 1e6) / 1e4 * 2 : 0) \
+ (dc_srv > 1e7 ? (dc_srv - 1e7) / 1e5 * 2 : 0)
printf "%-6s %8s %8s %8s %8s %8s %8s %8s %8s\n", NAME[w], usd(ld), usd(fs), usd(cc),
usd(un), usd(gb), usd(ph), usd(st), usd(dc)
B[w] = sprintf("%-6s LD connections %8.2f LD client MAU %9.2f Unleash seats %8.2f Unleash requests %8.2f",
NAME[w], (n > 5 ? n - 5 : 0) * 12, (m > 1000 ? (m - 1000) / 1000 : 0) * 10, s * 75, un - s * 75)
# Annual billing, per month, for the three vendors that publish an annual rate
ld_y = (n > 5 ? n - 5 : 0) * 10 + (m > 1000 ? (m - 1000) / 1000 : 0) * 8.33
fs_y = (fs == 45 ? 40 : (fs < 0 ? -1 : 250 + (s > 5 ? s - 5 : 0) * 50))
dc_y = dc - 125
Y[w] = sprintf("%-6s LD %9s Flagsmith %9s DevCycle %9s", NAME[w], usd(ld_y), usd(fs_y), usd(dc_y))
U[w] = sprintf("%-6s FS %11d CC %11d (%.1f GB) UN %11d GB %11d (%.1f GB) PH %10d DCsrv %11d DCcloud %9d",
NAME[w], fs_req, cc_req, cc_gb, un_req, gb_req, gb_gb, ph_req, dc_srv, dc_cloud)
}
print "\nMetered units per month:"
for (w = 1; w <= 3; w++) print U[w]
print "\nWhere the two biggest bills come from:"
for (w = 1; w <= 3; w++) print B[w]
print "\nBilled yearly, per month:"
for (w = 1; w <= 3; w++) print Y[w]
}
function tier(q, hi, lo) { return q <= lo ? 0 : (q < hi ? q : hi) - lo }
function usd(x) { return x < 0 ? "quote" : sprintf("%.2f", x) }'
As a sanity check, the LaunchDarkly formula reproduces the vendor’s own worked example. Its pricing page prices 10 connections and 2K MAU at $58.33 a month billed yearly, and the yearly rates in the script give the same figure.
Raw Output
Pasted unedited from a run in Git Bash on Windows 11:
team LD Flagsm CfgCat Unleash GrowthB PostHog Statsig DevCycle
small 150.00 300.00 110.00 375.00 200.00 0.00 0.00 625.00
mid 1530.00 1200.00 110.00 1500.00 819.80 65.00 0.00 687.80
large 12330.00 quote 325.00 5650.20 quote 615.00 0.00 5126.20
Metered units per month:
small FS 518000 CC 1718000 (0.9 GB) UN 4232000 GB 518000 (5.2 GB) PH 170000 DCsrv 2628000 DCcloud 80000
mid FS 2990000 CC 14990000 (8.9 GB) UN 33560000 GB 2990000 (29.9 GB) PH 1650000 DCsrv 13140000 DCcloud 800000
large FS 16760000 CC 136760000 (88.4 GB) UN 283040000 GB 16760000 (167.6 GB) PH 16200000 DCsrv 52560000 DCcloud 8000000
Where the two biggest bills come from:
small LD connections 60.00 LD client MAU 90.00 Unleash seats 375.00 Unleash requests 0.00
mid LD connections 540.00 LD client MAU 990.00 Unleash seats 1500.00 Unleash requests 0.00
large LD connections 2340.00 LD client MAU 9990.00 Unleash seats 4500.00 Unleash requests 1150.20
Billed yearly, per month:
small LD 124.97 Flagsmith 250.00 DevCycle 500.00
mid LD 1274.67 Flagsmith 1000.00 DevCycle 562.80
large LD 10271.67 Flagsmith quote DevCycle 5001.20
Monthly Cost of LaunchDarkly Alternatives by Team Size
Overall, here is the same output as one table, monthly billing, in US dollars. “Quote” means the team size forces an Enterprise plan with no public price.
| Vendor | Small (5 seats, 10K MAU) | Mid (20 seats, 100K MAU) | Large (60 seats, 1M MAU) |
|---|---|---|---|
| LaunchDarkly | 150.00 | 1,530.00 | 12,330.00 |
| Flagsmith | 300.00 | 1,200.00 | quote |
| ConfigCat | 110.00 | 110.00 | 325.00 |
| Unleash | 375.00 | 1,500.00 | 5,650.20 |
| GrowthBook | 200.00 | 819.80 | quote |
| PostHog | 0.00 | 65.00 | 615.00 |
| Statsig | 0.00 | 0.00 | 0.00 |
| DevCycle | 625.00 | 687.80 | 5,126.20 |
Reading the Small Team Column
At five seats, LaunchDarkly’s $150 sits in the middle of the pack. Flagsmith lands at $300 only because its $45 Start-Up plan stops at three team members, so five people push the team onto Scale-Up. Similarly, GrowthBook’s free Starter plan caps at three users, which is why five seats cost $200. ConfigCat’s free plan would cover the traffic, but it allows only 10 flags and 2 environments, so $110 Pro is the realistic floor.
Reading the Mid Team Column
The mid-size team is where the pricing models separate. ConfigCat stays at $110 because 15 million downloads still fit inside Pro’s 25 million. Conversely, LaunchDarkly reaches $1,530, and the breakdown shows $990 of that is client-side MAU. A team that evaluates flags only on the server would pay the $540 connection line alone. DevCycle is the first to hit overage here: 50 servers polling every 10 seconds make 13.14 million config requests against 10 million included, which adds $62.80.
Reading the Large Team Column
At a million client users, LaunchDarkly’s bill is $12,330, and Unleash’s request allowance finally runs out. Browsers polling every 30 seconds generate 283 million requests, which adds $1,150.20 in overage on top of $4,500 in seats. Two vendors drop out entirely: Flagsmith Scale-Up stops at 20 team members and GrowthBook Pro at 30 users, so both require a sales call.
Does Annual Billing Change the Ranking?
Annual billing lowers three of the bills but does not reorder them. LaunchDarkly drops from $1,530 to $1,274.67 for the mid team, Flagsmith from $1,200 to $1,000, and DevCycle from $687.80 to $562.80. ConfigCat advertises “save up to 10%” without a per-plan figure, so the script does not apply it. The other four vendors publish no annual rate for these plans.
Keep in mind that DevCycle overages are billed “subject to applicable annual discounts”, a phrase the page does not quantify. The script therefore removes only the $125 base price difference.
Self-Hosted LaunchDarkly Alternatives: What the License Covers
Additionally, four of these vendors publish their core as open source, which matters when compliance rules out a hosted service. The license itself is free, but you run the servers, the database and the upgrades. Licenses below were read from each GitHub repository on 12 November 2026.
| Project | License | Free self-hosted limits stated by the vendor |
|---|---|---|
| Flagsmith | BSD-3-Clause | Core flags; Enterprise self-hosting is a sales plan |
| Unleash | AGPL-3.0 | 1 project, 2 environments, 5,000 flags; no SSO, RBAC or change requests |
| GrowthBook | MIT core, enterprise directories under a separate license | Unlimited users |
| PostHog | MIT core, enterprise directory under a separate license | Not priced here |
Note, however, that none of these totals includes infrastructure, because it depends on your cloud and your redundancy needs. Most of these servers need PostgreSQL or MongoDB, so the managed Postgres pricing comparison is a sensible starting point for the database line. For the operational side of running flags yourself, the earlier guide to LaunchDarkly and open source feature flagging covers setup and day-to-day use.
Keeping a Switch Cheap With OpenFeature
Whichever vendor you choose, the most expensive part of switching later is rewriting every flag call. OpenFeature is a CNCF specification that puts a vendor-neutral API in front of the SDK. This Node.js setup, adapted from the LaunchDarkly OpenFeature provider README, creates one provider per process:
import { OpenFeature } from '@openfeature/server-sdk';
import { LaunchDarklyProvider } from '@launchdarkly/openfeature-node-server';
// One provider per process: each SDK instance per environment is a billed service connection
const provider = new LaunchDarklyProvider(process.env.LD_SDK_KEY);
export async function initFlags() {
try {
await OpenFeature.setProviderAndWait(provider);
} catch (err) {
// Keep serving with code defaults rather than failing startup on a flag outage
console.error('Flag provider failed to initialize, using defaults', err);
}
}
const flags = OpenFeature.getClient();
export async function isNewCheckoutEnabled(userId) {
// targetingKey maps to the vendor's user or context key
return flags.getBooleanValue('new-checkout', false, { targetingKey: userId });
}
// Flush pending analytics events on shutdown
process.on('SIGTERM', () => OpenFeature.close());
As a result, application code calls only flags.getBooleanValue, so moving vendors means swapping the provider import and key. That said, OpenFeature does not migrate targeting rules or segments, which still need an export and import. The module-level provider is also a cost control: creating a client per request inflates connection counts on LaunchDarkly and poll counts everywhere else.
When to Use a LaunchDarkly Alternative
- Your product has a large client-side audience and modest server footprint. MAU pricing made up $9,990 of LaunchDarkly’s large-team bill.
- You need flags only, without experimentation or observability. Statsig’s free tier and ConfigCat’s flat plans cover that for a fraction of the cost.
- Headcount is small but traffic is huge. Seat-priced tools such as Unleash keep the bill flat while traffic grows, apart from request overage.
- Compliance requires the flag service inside your network. Flagsmith, Unleash and GrowthBook all have self-hosted options.
- You already pay for PostHog analytics and want flags evaluated against the same user data.
When NOT to Switch Away From LaunchDarkly
- Your team flags mostly on the server with few replicas. At small sizes LaunchDarkly’s $150 is not the expensive line in anyone’s budget.
- You use the parts of LaunchDarkly that are not flags, such as its observability, AgentControl or Release Autopilot. The flag-focused tools above do not replace them.
- The migration itself costs more than a year of savings. Hundreds of flags with complex targeting rules take real engineering time to move and verify.
- Your contract already includes negotiated volume discounts, which public list prices here do not reflect.
Common Mistakes With Feature Flag Pricing
- Counting services instead of instances. LaunchDarkly bills every replica, worker and staging environment as a separate connection.
- Leaving browser polling on its default. On Unleash, the 30-second browser refresh produced most of the 283 million large-team requests.
- Using remote evaluation on the server. PostHog and Flagsmith bill per evaluation request in that mode, so a busy API pays per inbound request instead of per poll.
- Comparing “starts at” prices. Flagsmith’s $45 plan and GrowthBook’s free plan both stop at three users, which most teams pass on day one.
- Turning on experiment metrics for every rollout. Statsig is free for plain flags, but exposures with Metric Lifts become metered events.
- Treating Enterprise as a known price. Several of these vendors require a quote at 60 seats, so budget a range rather than a number.
A Realistic Scenario: The Mobile Launch That Moved the Bill
Consider a mid-sized SaaS team of around twenty engineers on LaunchDarkly Foundation. Their flags live mostly in a backend API and a web dashboard, and the bill sits comfortably in the hundreds. Then the company ships a consumer mobile app and wires the client-side SDK into it so product managers can stage features by app version.
Within a couple of months, client-side MAU grows from tens of thousands to several hundred thousand. Nothing about the flag count changed, and no new engineers joined. Even so, at $10 per thousand MAU the bill climbs by thousands of dollars a month, which is exactly the shape of this post’s large-team column. The team’s real options are to evaluate mobile flags through their own backend, which converts MAU into a handful of server connections, or to move client flags to a request-priced or flat-priced vendor.
However, neither option is free. Routing flags through the backend adds a network hop and couples app startup to the API. Splitting vendors means two dashboards and two sets of targeting rules. Still, a team that sees the MAU line before the launch can choose deliberately instead of reacting to an invoice.
How Flag Costs Fit Into Your Release Process
Flag tooling cost is one line in a wider release strategy. If flags are mainly there to support short-lived branches, the comparison of GitFlow and trunk-based development explains why trunk-based teams lean on them most. For gradual rollouts, compare flag-based targeting with infrastructure-level traffic shifting in the blue-green vs canary deployments guide.
Moreover, some of these vendors also sell observability, LaunchDarkly and PostHog included. If you are weighing a bundle, check the separate lines in the observability cost comparison before assuming the bundle saves money.
Conclusion
Priced on the same day for the same three teams, LaunchDarkly alternatives range from free to well over ten thousand dollars a month, and the gap comes almost entirely from the billing unit. ConfigCat, PostHog and Statsig stay cheap because they meter downloads, requests or analytics events rather than users. LaunchDarkly stays reasonable while client-side MAU is low, while Unleash and GrowthBook track headcount.
Before choosing, run the script with your own instance count, client users and seats, because those three numbers decide the ranking. Prices were read on 12 November 2026 and vendors change them often, so check the linked pages again before quoting a figure.
