The Short Answer on ConfigCat vs LaunchDarkly
On ConfigCat vs LaunchDarkly, pick ConfigCat if you want feature flags and remote config at a flat monthly price, with unlimited seats and no user data leaving your app. Pick LaunchDarkly if you need experiments, instant flag updates over a streaming connection, a React Native SDK, or approval workflows for a large engineering team, and you accept a bill that grows with your users. For a founder with a small team and a first product, I would start on ConfigCat and move to LaunchDarkly when you hire someone whose job is running experiments.
Both tools do the basic job well. You wrap a feature in a flag, ship the code dark, and turn it on for 5% of users before everyone gets it. The differences are in how the flag value reaches your app, what the vendor learns about your users along the way, and what the invoice counts.
Every price and feature below comes from ConfigCat's and LaunchDarkly's own pricing pages and docs, which I checked on November 18, 2026. LaunchDarkly has dropped per-seat pricing since our earlier comparison, so the numbers in older posts, ours included, are out of date. If you are also weighing Statsig or Unleash, our LaunchDarkly vs Statsig vs Unleash comparison covers the wider field.
How Each One Bills You
The two vendors count different things, and that matters more than the entry price.
ConfigCat plans
ConfigCat sells flat tiers. Every tier has unlimited seats, unlimited monthly active users and unlimited flag reads. What separates the tiers is the number of flags and environments you can create, and how many times a month your apps download the config file.
- Free: $0. 10 flags, 2 environments, 5 million config downloads a month.
- Pro: $110 a month. 100 flags, 3 environments, 25 million downloads.
- Smart: $325 a month. Unlimited flags and environments, 250 million downloads.
- Enterprise: $900 a month. 1 billion downloads, a 99.99% uptime SLA and two years of audit log.
- Dedicated: $4,500 a month for a private cloud with 6 billion downloads or more.
Annual billing saves up to 10%. A config download is one fetch of the config JSON from ConfigCat's CDN. Reading a flag from the cached copy does not count, so the number depends on how many app instances you run and how often each one polls. If you pass your limit, ConfigCat's docs say they keep your app running and contact you about a bigger plan or an add-on.
LaunchDarkly plans
LaunchDarkly now has three plans, and none of them charge per seat.
- Developer: $0. 5 service connections, 1,000 client-side monthly active users, 1 project and 3 environments.
- Foundation: pay as you go past the free amounts. $12 per service connection and $10 per 1,000 client-side MAU when billed monthly, or $10 and $8.33 when billed yearly.
- Enterprise: custom pricing.
A service connection is one server-side SDK instance connected to one environment. Client-side MAU is the number of unique context keys that your web, mobile, AI and edge SDKs evaluate in a month. Three API servers in production plus one in staging is four connections. Every logged-in user who opens your React app is one MAU.
LaunchDarkly's own example is 10 connections and 2,000 MAU for $70 a month billed monthly. The same pricing page meters session replays, errors, traces, logs and AI runs separately, each with a free allowance.
The line that surprises founders is the Enterprise column. SSO, SCIM, custom roles, audit logging, flag scheduling and required approvals are all listed there and nowhere else. ConfigCat's plan limits page gives every tier, Free included, at least one verified SAML domain, and its audit log runs from 7 days on Free to 2 years on Enterprise.
What It Costs at Three Sizes
These are my own estimates from the list prices above, billed monthly. For ConfigCat I used the assumption in its docs: a browser user who spends about five hours a month in your app, polling every 60 seconds, makes roughly 300 config downloads.
A first version with 1,000 users
Two API servers, production and staging, a thousand people using the web app.
- ConfigCat: $0. About 300,000 downloads against a 5 million allowance. The limit you will hit first is 10 flags.
- LaunchDarkly: $0 on Developer. Four connections fit under the free five, and 1,000 MAU is the whole free allowance. A Developer account that stays over its limits moves to read-only mode.
A growing product with 20,000 users
Ten service connections across environments, 20,000 monthly active users on web.
- ConfigCat: $110 on Pro. Roughly 6 to 7 million downloads, well inside 25 million.
- LaunchDarkly: about $250 on Foundation. That is 19 thousand MAU past the free thousand at $10 each, plus 5 extra connections at $12. Billed yearly it is closer to $210.
A product with 200,000 users
Thirty service connections, 200,000 monthly active users.
- ConfigCat: $325 on Smart, at around 60 million downloads. If your users stay in the app for 40 hours a month instead of five, the same math lands near 480 million and you are on Enterprise at $900, unless you lengthen the polling interval.
- LaunchDarkly: about $2,290 at Foundation list price, or roughly $1,900 billed yearly. At this size most teams are on an Enterprise contract, and I cannot tell you what that number will be.
So the gap is nothing at launch, a little over two times at 20,000 users and about seven times at 200,000. The reason is simple. LaunchDarkly's bill follows your user count. ConfigCat's follows your polling settings, which you control. A backend-only setup narrows the gap a lot, because server-side flags on LaunchDarkly cost $12 a connection no matter how many users you have.
How Flags Reach Your App
This is the real technical difference, and it explains the pricing.
ConfigCat downloads a file and decides locally
A ConfigCat SDK downloads one config JSON from a CDN, which runs on Cloudflare, and keeps it in memory. When your code asks for a flag, the SDK evaluates the rules on the device or server using the user object you passed in. ConfigCat's architecture page says the SDK serves the value without uploading any user information. That holds in the browser and on a phone, as well as on your servers.
The SDK refreshes the file by polling. Auto polling is the default and checks every 60 seconds. Lazy loading fetches only when the cache has expired, and manual polling leaves it to you. The cost of this design is delay: a flag you flip can take up to a minute to reach a running app, unless you shorten the interval and pay for the extra downloads.
One thing to know for frontend apps. Because the whole config file is on the device, a curious user can read your targeting rules. ConfigCat's React docs say as much and suggest keeping sensitive flags on the backend.
LaunchDarkly streams
LaunchDarkly's server-side SDKs open a streaming connection, receive the full ruleset and evaluate in process, so your users' attributes stay on your servers. Flag changes arrive as they happen. LaunchDarkly's pricing page lists a config delivery target under 200 milliseconds on the paid plans.
The client-side SDKs work differently. For security they do not download the ruleset. Your app sends the user's context to LaunchDarkly, LaunchDarkly evaluates the flags on its side, and the SDK stores the results. Rules stay private, and LaunchDarkly sees the context of every user. That is also why it can count MAU and run experiments, and why ConfigCat cannot do either.
If a kill switch that works within a second matters to you, such as a payments flow or a live event, streaming is worth paying for. For a settings page redesign, a minute is fine.
Targeting, Segments and Experiments
For plain rollouts the two are close. Both let you target by user attribute, serve a percentage of users, reuse a saved segment and make one flag depend on another.
ConfigCat builds a targeting rule from conditions on the user, on a segment or on a prerequisite flag, then splits whoever is left with percentage options. The limits are on the plan: 4 targeting rules per flag on Free, 8 on Pro, unlimited from Smart up. Segments go from 2 on Free to 3 per product on Pro. A serious B2B product with per-customer rules will want Smart.
LaunchDarkly goes further with segments. Rule-based segments and lists of up to 15,000 contexts are standard. Larger lists and segments synced from an outside tool exist too, and its docs say those are for customers on select plans. If marketing keeps a customer list in another system and wants flags to follow it, that is a LaunchDarkly feature.
Experiments
Here the two split cleanly. ConfigCat's own migration guide says it cannot provide A/B testing, experiments or analytics out of the box, because it never receives user data. You can still split traffic with percentage options, send the variant to Amplitude, Mixpanel, Google Analytics or Segment, and read the result there. Plenty of teams work this way and are happy with it.
LaunchDarkly includes experimentation on every plan, the free one too. It runs A/B/n tests and multi-armed bandits, reports with frequentist or Bayesian statistics, and can pull metric events from a warehouse such as Snowflake. Guarded releases, which watch a metric during a rollout, are free on Foundation until February 2027, so expect a charge after that.
My rule: if nobody on your team will open the experiment results every week, do not pay for an experiment platform yet.
SDKs, Mobile and OpenFeature
Both cover the common backend languages. Mobile is where you should check the list before you choose.
- iOS: both. ConfigCat has a Swift SDK, LaunchDarkly an iOS SDK.
- Android: both. ConfigCat also ships a Kotlin Multiplatform SDK.
- Flutter: both.
- React Native: LaunchDarkly lists a React Native SDK. ConfigCat's SDK overview does not. Its unified JavaScript SDK includes a React Native sample app, and React Native is missing from that SDK's list of supported platforms.
- React on the web: both.
- Games: ConfigCat has Unity and Unreal Engine SDKs.
- Edge: LaunchDarkly has SDKs for Cloudflare, Vercel, Fastly and Akamai. ConfigCat's JavaScript SDK runs in Cloudflare Workers.
If your product is a React Native app, that one line can settle the decision. Ask ConfigCat support how they treat React Native before you build on a sample.
OpenFeature
OpenFeature is a vendor-neutral API for flags. You code against it once and plug in a provider for whichever vendor you pay.
ConfigCat is the stronger of the two here. Its docs list 14 providers, including Swift, Kotlin Multiplatform, React and Angular, so you can stay vendor-neutral on the client too. LaunchDarkly maintains server-side providers for .NET, Java, Node.js, PHP, Python, Ruby and Cloudflare. Its docs mark the Go provider and the client-side JavaScript provider as community projects that LaunchDarkly does not officially support.
If you care about leaving later, use OpenFeature on the backend from day one. It costs an afternoon.
Data Residency, Compliance and Self-Hosting
If you sell to European customers or regulated buyers, read this part before the pricing.
ConfigCat's terms say it operates its services from Hungary. A dashboard setting switches the CDN from Global to EU Only, which publishes your config files only to EU nodes. Since evaluation happens in your app, there is no user data at ConfigCat to locate in the first place. Its policies page shows ISO 27001:2022 certification and GDPR compliance. I did not find SOC 2 on that page, so ask for the Trust Center documents if your buyers require it.
LaunchDarkly has an EU instance in AWS Frankfurt. Its docs say it is open only to new Enterprise accounts and trials, that monitoring and CDN delivery still run from the United States, and that Experimentation, session replay and the edge SDKs are not available there. LaunchDarkly also runs a federal instance that its docs describe as FedRAMP compliant. ConfigCat has no equivalent that I could find, so a US government buyer points you to LaunchDarkly.
Running it yourself
ConfigCat sells a self-hosted edition: the dashboard, the API and the CDN nodes as Docker containers on your own servers, priced by quote. Short of that, the ConfigCat Proxy is a small Go service you run inside your network. It caches config files and serves flags over HTTP, server-sent events, gRPC and the OpenFeature remote evaluation protocol.
LaunchDarkly's control plane stays with LaunchDarkly. I found no self-hosted edition in its docs. What you can run is the Relay Proxy, an open source Go service that holds one stream for many servers. Its docs are clear that it reduces outbound connections and does not reduce the service connections you are billed for.
AI Features
LaunchDarkly has built a product for this and ConfigCat has not.
LaunchDarkly's is called AgentControl. A config holds a prompt or agent instructions plus model settings, outside your code. Each config has variations, and the same targeting rules that drive flags decide which user gets which variation. The AI SDKs, available for Python, Node.js, Go, .NET and Ruby, report token usage, latency, errors and evaluation scores, and you can attach judges to score outputs. LaunchDarkly does not call the model for you. Your app still does that with its own keys. The pricing page gives 5,000 AI runs free and charges $5 per 1,000 after that. The docs also describe AgentControl as an add-on that depends on your plan, so confirm access before you design around it.
ConfigCat's AI feature is an MCP server. It wraps the management API so an assistant in Cursor or Claude can create flags, edit segments and list stale flags for you. It does not evaluate flags, and I found nothing in ConfigCat's docs for versioning prompts or tracking model metrics.
You can still run AI rollouts on ConfigCat. A flag can carry a model name, and a percentage rule can send 10% of users to the new model. You bring your own tracing and cost tracking. We walk through that pattern in our guide to feature flags for AI and LLM rollouts.
Moving Between Them
Leaving LaunchDarkly for ConfigCat is the easier direction, because ConfigCat built a tool for it. The importer in the ConfigCat dashboard connects to a LaunchDarkly project, creates matching products and environments, and copies flags and segments. ConfigCat calls the translation best effort and gives you a report of what did not map. LaunchDarkly's per-flag targeting switch has no direct equivalent, so you pick how to handle it during import.
The tool does not touch your code. You swap the SDK, turn LaunchDarkly contexts into ConfigCat user objects, and rebuild teams and roles as permission groups by hand. Any experiments stay behind.
Going from ConfigCat to LaunchDarkly has no shortcut. LaunchDarkly's built-in importer covers Split and Unleash only. For anything else its migration guide says to recreate flags by hand or through the REST API, and to put a wrapper around flag calls so you can move one flag at a time.
In both directions the work scales with the number of flags in your code. My estimate is a week for one engineer at forty flags. Four hundred is a project, and half of them should have been deleted months ago. Clean up first, then migrate.
Which One for Your Product
Here is how I would match real situations to a pick.
- A first SaaS version with two or three engineers: ConfigCat Free, then Pro at $110 when you pass 10 flags.
- A consumer app with 100,000 or more monthly users and client-side flags: ConfigCat. The bill does not follow your user count.
- A React Native app: LaunchDarkly, unless ConfigCat confirms support for your setup in writing.
- A backend-only product with a handful of services: either one. LaunchDarkly's Developer plan covers 5 connections for free and gives you streaming.
- A growth team that ships an experiment every week: LaunchDarkly, for experiments tied to the same flags.
- A health or fintech product that wants no user attributes at a third party: ConfigCat. Evaluation stays in your app on every platform.
- An EU company below enterprise budget: ConfigCat with the EU Only setting.
- A product sold to US federal agencies: LaunchDarkly's federal instance.
- Forty engineers who need approvals before a production flag changes: LaunchDarkly Enterprise.
- An AI product testing prompts and models on live traffic: LaunchDarkly with AgentControl, if the add-on is on your plan.
- A team that has to host everything itself: ConfigCat's self-hosted edition.
Staged rollouts matter most where a bad release is expensive. Take Vybes, the members-only dating app we built for iOS and Android, where a first date is a live video call. A change to that call is one you would want a few members to see before everyone does. The Vybes case study covers the product and what happened after launch.
A flag tool is one line in a longer list that includes your database, your auth and your hosting. If you are still putting that list together, our guide on how to build a SaaS platform is the next read. Kanopy helps founders pick a stack and build the product on it. The first conversation is free, and you can bring the flag question with you. Book a free strategy call


