ConfigCat vs Flagsmith vs BetterConfig: an honest comparison

If you are choosing between ConfigCat and Flagsmith, the decision comes down to what you are optimizing for. Pick ConfigCat if you want flat pricing with unlimited seats and the simplest possible integration. Pick Flagsmith if you need open source, self-hosting, or control over where your data lives. Both are real feature-flag platforms with mature targeting, and either one is a sound choice for the flag-and-rollout problem.

There is a third answer that the existing comparisons skip. If what you actually need is structured runtime config rather than targeting rules, a config-first tool fits better than either flag platform. That is what BetterConfig is, and we will say plainly below where it is the wrong tool. This article serves the ConfigCat versus Flagsmith comparison first and fully, then explains when neither one is the right shape for your problem.

The short version

The full breakdown is below, but here is the head-to-head across the rows that usually decide it. Numbers are from each vendor's public pricing and docs as of June 2026.

ConfigCat in detail

ConfigCat is a hosted feature-flag and remote config service. The core is closed source, but the SDKs and the self-hostable Proxy are open source. Its hierarchy is Organization, Product, Config, Environment. The thing that sets it apart is its pricing model.

What ConfigCat does well

• Flat pricing, unlimited seats. Every plan, including Free, allows unlimited team members. On the ConfigCat pricing page you pay for flags and traffic, not per user. For a large org this can be the deciding factor.
• Polling with local evaluation. SDKs poll a CDN-served config.json on a default 60-second auto-poll interval and evaluate flags locally, so a flag check does not make a network round trip. The requests documentation covers the polling modes.
• EU data residency. There is an EU-only CDN option for teams that need it.
• Self-hostable proxy. The open-source Proxy runs in Docker and can stream changes over SSE or gRPC, which closes some of the gap with platforms that self-host the whole stack.
• Mature targeting. Config V2 (GA by mid-2024) has targeting rules with AND conditions, text, array, date, and semver comparators, prerequisite flags, segments, and percentage rollouts.

Where it gets in the way

• The $0 to $110 cliff. There is no plan between Forever Free and Pro at $110 per month. The next tiers, per the pricing page, are Smart at $325, Enterprise at $900, and Dedicated at $4,500 per month. If you outgrow Free, the first paid step is steep.
• Polling is metered as downloads.Every CDN fetch counts against your quota. ConfigCat's own example in the requests docs puts 15,000 web users at the default 60-second poll at about 4.5 million downloads per month, which is nearly the entire 5 million Free quota. Heavy client traffic pushes you toward a paid plan on traffic alone.
• Tight Free limits. Free allows 10 flags and 2 environments. The full caps are in the subscription plan limits.
• No native JSON. Value types are boolean, text string (up to 100,000 characters), integer, and double, per the main concepts docs. For structured config you serialize JSON into a text setting and parse it yourself.

// ConfigCat stores JSON as a text setting, not a native type.
// You write the string in the dashboard and parse it in code.
const raw = configCatClient.getValueSync("checkout_config", "{}");
const config = JSON.parse(raw); // a plain text setting holding 100k chars max

• Short Free audit retention. The audit log keeps 7 days on Free, 35 days on Pro, and reaches roughly 2 years (750 days) only on Enterprise and Dedicated.
• No approvals or scheduled changes yet. A Review Changes diff component shipped in May 2026 as part of ongoing approval-flow work, but full approval workflows and scheduled changes are not shipped as of June 2026.

Flagsmith in detail

Flagsmith takes the opposite stance. The core is open source under BSD-3-Clause, and you can run it as SaaS, in a private cloud, or fully self-hosted on Docker, Kubernetes, or Helm, including air-gapped. Its flag model is also different: a flag is a boolean state plus an optional typed value.

What Flagsmith does well

• Open source, no request limits self-hosted. The self-hosting FAQ confirms the open-source self-hosted build has no API request limits. You own the data and the infrastructure.
• Typed value on every flag. Each flag carries a string, number, boolean, or JSON value up to 20,000 bytes alongside its on/off state, per the managing features docs. That dual state-plus-value model is closer to config than ConfigCat's flat types.
• Unlimited environments on Free. Every plan, including Free, allows unlimited environments.
• Multivariate flags, identities, and segments. Multivariate flags return weighted variants deterministically per identity, and segments are rules over identity traits, including a percentage split operator for rollouts.

// Flagsmith: a flag carries an on/off state plus an optional typed value.
const flags = await flagsmith.getFlags();
const enabled = flags.isFeatureEnabled("checkout_v2"); // the boolean state
const value = flags.getFeatureValue("checkout_v2");    // string, number, bool, or JSON (max 20 KB)

Where it gets in the way

• One seat on Free. The Flagsmith pricing page puts Free at 1 seat and 50,000 API requests per month. Start-Up at $45 per month adds 2 more seats and 1 million requests.
• The $45 to $300 jump for governance. Audit logs, change requests and approvals, RBAC, and SAML all sit on Scale-Up at $300 per month. If you need any of those, the cheap plan does not cover you.
• No built-in analytics. Measuring an A/B test needs a third-party analytics tool; Flagsmith does not report results itself.
• Remote evaluation latency. The default mode is remote evaluation, which is an API call per evaluation. Server SDKs can do local evaluation, and a self-hosted Edge Proxy polls every 10 seconds by default, but the low-latency path is opt-in. The Edge API docs cover the 8-region SaaS Edge API and the routing.
• Real-time SSE is Enterprise-only. Push updates over SSE are gated to the Enterprise tier.
• Scheduled flags are gated. Per the pricing page, scheduled flags are available from Start-Up and up on SaaS; if you self-host, they are Enterprise-only.

Feature flags or remote config: which problem do you actually have

ConfigCat and Flagsmith are both flag-first tools. They model a boolean that you turn on or off, then wrap it in targeting: rules, segments, percentage rollouts. Config values are bolted onto that model. ConfigCat stores JSON as a string in a text setting. Flagsmith attaches a value to a flag. Both work, but the flag is the primary object and the value rides along.

That is the right shape when your core question is "who sees this, and what fraction of them." It is the wrong shape when your core question is "what is the current value of this setting in this environment." Consider what you actually edit week to week:

• API endpoints and timeouts
• Theme objects and layout tokens
• Price tables and tier limits
• Copy, banner text, and empty-state messages
• Kill switches for flaky integrations

If most of your changes are structured config like that, edited per environment, the flag model is friction. You end up packing objects into text settings, or treating a flag's attached JSON as the real payload while the on/off state sits unused. The targeting engine you are paying for goes mostly idle. We wrote a longer head-to-head on this category split in the BetterConfig versus Firebase Remote Config comparison, and the broader Firebase Remote Config limitations reference covers where a mobile-first config tool runs out of room.

Where BetterConfig fits

Honesty first, because comparison readers can smell a fudged row. BetterConfig is the right tool only for a specific shape of problem, and here is what it does not do today:

• No targeting rules, no percentage rollouts, no A/B testing. These are on the roadmap, not in the product. If you need to ship a flag to 5 percent of users, both ConfigCat and Flagsmith do that today and BetterConfig does not.
• No native SDKs yet. A React SDK is in development. Today you read config over plain HTTPS from any language. That is simple, but it is not the typed-client experience the flag platforms ship.
• Reads are hard-capped per plan. Past your quota the read API returns 429 with {"error":"reads_limit_exceeded"} (the cap is checked roughly every 15 minutes). There are never overage charges. Upgrading unblocks reads immediately, and the cap resets at the start of each month. This is a real hard limit; ConfigCat keeps serving and contacts you, and Firebase reads are free and uncapped.
• No published SLA. The product is pre-launch, so there is no uptime commitment yet.

With that on the table, here is what you do get, and why it fits the structured-config problem the flag tools handle awkwardly:

• JSON-native typed values in a real editor. Every key has a type definition: boolean, number, string, object, or array. You edit objects and arrays directly, not as escaped strings in a text field.
• Per-environment versioning with one-click rollback. Every change is versioned per environment with full history, a project audit log, and a one-click rollback, with no history retention cap on any plan, including Free. ConfigCat's Free audit log keeps 7 days; Flagsmith puts audit logs on Scale-Up.
• Scoped read-only tokens. Tokens are read-only and scoped to a project (reads any environment) or to a single environment, created in Settings under API tokens.
• Roles on every plan. Owner, editor, and viewer roles with email invites, on Free as well as paid.
• Free at $0. One project, one environment, 3 members per project, and 200k reads per month. Pro at $19 per month raises it to 5 projects, unlimited environments, 10 members, and 2 million reads.
• One-upload Firebase import. Upload a Firebase Remote Config template or a flat JSON object and the format is auto-detected. The migration guide walks through it, and the import documentation covers the formats.

Reading config is a single authenticated GET against an edge-cached API on Cloudflare Workers:

curl "https://api-public.betterconfig.dev/v1/config?project=acme-web&env=prod" \
  -H "Authorization: Bearer $BC_READ_TOKEN"

The response is a small JSON document:

{
  "projectSlug": "acme-web",
  "environmentKey": "prod",
  "version": 14,
  "fetchedAt": 1749480000000,
  "values": {
    "checkout_v2": false,
    "max_upload_mb": 50,
    "pricing_table": { "pro": 19, "ultra": 79 },
    "promo_banner_text": "Summer sale: 20% off"
  }
}

The API sends an ETag of "v<version>" and Cache-Control: public, max-age=30, stale-while-revalidate=300, so repeat reads are cheap and a conditional request with If-None-Match returns a 304. Published changes are typically live at the edge in under a minute: a 30-second HTTP cache on top of Cloudflare KV, which propagates worldwide within about a minute. That is not faster than ConfigCat's 60-second poll or Flagsmith's edge delivery; it is in the same range. For wiring this into a React app, the React integration guide has a Next.js App Router pattern and a plain client-only fetch.

Verdict

Pick ConfigCat if

• You want flat pricing with unlimited team seats and can absorb the $110 first paid step.
• You need full targeting, segments, and percentage rollouts with local SDK evaluation.
• EU data residency or a self-hosted proxy matters, but you do not want to run the whole backend.
• Your client read traffic is modest enough that download-metered polling stays inside quota.

Pick Flagsmith if

• You need open source and the option to self-host with full data control and no request limits.
• You want a typed value (including JSON up to 20 KB) attached to every flag, not a separate config product.
• You need multivariate flags, identities, and trait-based segments.
• You can budget for Scale-Up at $300 when you need audit logs, RBAC, SAML, and change requests.

Pick BetterConfig if

• Your real workload is structured JSON config edited per environment, not booleans with targeting.
• You want native typed objects and arrays in a real editor, not JSON stuffed into a text field.
• You want full version history and one-click rollback with no retention cap, including on the Free plan.
• You can live without targeting, percentage rollouts, and native SDKs today, and you read config over plain HTTPS.