If your team ships JavaScript or TypeScript, Supaship is the better feature flag platform - full stop. Faster setup, unlimited flags from day one, full TypeScript inference, first-class Next.js App Router support, and pricing that doesn't gate basic functionality behind a $325/month plan.

ConfigCat is a mature platform with broad language support - over 20 SDKs covering mobile, game engines, and non-JS backends. For teams that ship beyond the JavaScript ecosystem, that breadth matters. For web-focused JS/TS teams, ConfigCat's pricing model and limited modern JS support make it a poor fit.

This article breaks down where each platform excels and why Supaship wins for the majority of developer teams.

Quick comparison

Pricing: ConfigCat's unusual model

This is the most important difference between the two platforms, and the one most likely to catch teams off guard.

ConfigCat charges by the number of feature flags

Almost every feature flag platform charges based on usage - requests, MAUs, or events. ConfigCat's primary pricing dimension is the number of feature flags you create. This is unique in the industry and has real consequences:

• Forever Free: 10 feature flags - enough for a proof of concept, not a production app
• Pro ($110/month): 100 feature flags, 3 environments, 3 products
• Smart ($325/month): Unlimited flags, unlimited environments, 10 products
• Enterprise ($900/month): Unlimited, 20 products

A team actively using feature flags for gradual rollouts, kill switches, per-environment config, and beta features will exhaust 10 flags within their first project. Exhausting 100 flags across a growing product is a matter of months, not years.

The practical result: you need the $325/month Smart plan to use feature flags normally. At that price point, most teams should be evaluating whether they need what the Smart plan offers versus what a lower-cost alternative provides.

ConfigCat also charges based on config JSON downloads (5M/month on free, 25M on Pro, 250M on Smart) - these represent SDK polling calls, not individual flag evaluations. At high traffic this becomes a secondary cost driver.

Supaship charges per event, with unlimited flags always

Supaship has no flag count limits on any tier:

• Free forever: 1 million events/month - unlimited flags, unlimited environments, unlimited team members, unlimited projects
• Pro: $30/month for your entire workspace - 3 million events included, then $0.03/1k events

One event = one flag evaluation. Create as many flags as your product needs. The pricing grows with your traffic, not with how aggressively you use feature flags.

Concrete comparison - a team with 3 projects and moderate traffic:

At low-to-moderate scale Supaship is dramatically cheaper because you don't need to buy a $325/month plan just to create more than 100 flags. At very high scale (50M+ evaluations), the gap narrows depending on your Config JSON download volume vs raw flag evaluations - the models measure different things. But for most growing web apps, Supaship is the better value.

SDK coverage: ConfigCat's niche advantage

ConfigCat supports over 20 languages and platforms: JavaScript, Node.js, React, Angular, Vue, .NET, Java, Go, Python, Ruby, PHP, Elixir, Android (Kotlin/Java), iOS (Swift/Objective-C), Flutter (Dart), Kotlin Multiplatform, C++, Rust, Unity, and Unreal Engine.

If you're shipping a Unity game, a Flutter mobile app, or a Go backend with no JavaScript layer anywhere in your stack, that breadth is genuinely useful. The CDN-based config polling model also provides offline flag evaluation once the config is cached - relevant for mobile and desktop apps where connectivity isn't guaranteed.

// ConfigCat iOS SDK
let client = ConfigCatClient.get(sdkKey: "YOUR-SDK-KEY")
let value = await client.getValue(for: "my-feature", defaultValue: false)

This is a narrow profile. The vast majority of modern web products are built on JavaScript or TypeScript - React, Next.js, Vue, Node.js, edge runtimes. If that describes your stack, ConfigCat's language breadth adds nothing while its pricing model costs significantly more. Supaship's JavaScript-native SDKs were built precisely for this common case: better TypeScript ergonomics, first-class Next.js App Router support, and a consistent API across every JS framework.

It's also worth noting: Supaship isn't limited to JavaScript. It exposes a REST API that works from any language or runtime. A Python service, a Go microservice, or a Ruby backend can evaluate flags with a single HTTP call - no SDK install required:

curl -X POST "https://edge.supaship.com/v1/features" \
  -H "Content-Type: application/json" \
  -d '{
    "apiKey": "YOUR_API_KEY",
    "environment": "production",
    "features": ["new-dashboard", "theme-config"],
    "context": {
      "userId": "user-123",
      "email": "user@example.com"
    }
  }'

ConfigCat's advantage is native SDKs with offline caching for mobile and game engines; Supaship's REST API covers server-side polyglot usage just fine.

Developer experience for JavaScript teams

For teams working exclusively in JavaScript and TypeScript, Supaship's developer experience is meaningfully better.

TypeScript type safety

ConfigCat's TypeScript SDK returns values typed as the SDK's generic SettingValue type. You know a flag exists because you check it by string key, but the return type is not inferred from a central definition:

// ConfigCat  -  no type inference from flag definitions
const client = new ConfigCatClient('YOUR-SDK-KEY')
const value = await client.getValueAsync('new-dashboard', false) // boolean (manually cast)

Supaship's type system flows from a single flag definition to every call site:

// Supaship  -  full TypeScript inference
const FEATURE_FLAGS = {
  'new-dashboard': false,
  'ui-config': { theme: 'light' as 'light' | 'dark', sidebarOpen: true },
} satisfies FeaturesWithFallbacks

declare module '@supashiphq/react-sdk' {
  interface Features extends InferFeatures<typeof FEATURE_FLAGS> {}
}

// TypeScript knows the exact return type, catches typos, enables autocomplete
const { feature: newDashboard } = useFeature('new-dashboard') // ComputedRef<boolean>
const { feature: uiConfig } = useFeature('ui-config') // ComputedRef<{ theme: 'light' | 'dark', sidebarOpen: boolean }>
const { feature } = useFeature('new-dashbord') // ❌ TypeScript error: property does not exist

This matters during flag cleanup. Delete a flag from FEATURE_FLAGS and every useFeature('that-flag') call becomes a compile error - the TypeScript compiler guides you to every place that needs updating.

Next.js App Router

ConfigCat has Next.js documentation but no first-class support for the App Router patterns that define how Next.js apps are built today: Server Components, Edge Middleware rewrites, and the server-to-client prop pattern.

Supaship's SDK was built around these patterns. See the full Next.js guide and the Next.js SDK reference for the complete walkthrough including hydration safety and Edge Middleware.

// Supaship  -  native Server Component support, no hydration workarounds needed
import { createClient } from '@supashiphq/js-sdk'

const client = createClient({
  apiKey: process.env.SUPASHIP_API_KEY!,
  environment: 'production',
})

export default async function Page() {
  const features = await client.getFeatures(['new-hero', 'show-banner'])
  return features['new-hero'] ? <NewHero /> : <LegacyHero />
}

// Supaship  -  Edge Middleware for route-level gating
import { createClient } from '@supashiphq/js-sdk'

export async function middleware(request: NextRequest) {
  const betaAccess = await client.getFeature('beta-access', {
    context: { userId: request.cookies.get('userId')?.value },
  })
  if (!betaAccess) return NextResponse.redirect(new URL('/404', request.url))
  return NextResponse.next()
}

Vue and modern JS frameworks

Supaship ships a dedicated @supashiphq/vue-sdk with createSupaship (a standard Vue plugin), useFeature, useFeatures, and useFeatureContext composables. ConfigCat has a Vue example in its docs but no purpose-built Vue package. See the Vue guide and Vue SDK reference for the full setup.

Development toolbar

Both platforms offer a way to override flags locally. Supaship ships a built-in toolbar that appears automatically in development. ConfigCat offers a browser extension for overriding config values.

Feature comparison

Who should choose what

Choose ConfigCat if:

• You ship to native mobile (iOS/Android), Flutter, or game engines (Unity/Unreal) and need a native SDK with offline/cached flag support - Supaship's REST API works in these environments but doesn't offer the same offline-first guarantees
• You specifically need CDN-based offline flag evaluation for a mobile or desktop app in a low-connectivity environment

Choose Supaship if:

• Your stack is JavaScript or TypeScript - React, Next.js, Vue, or Node.js (which describes the vast majority of modern web products)
• You want unlimited flags without paying $325/month just to create more than 100 of them
• You want workspace-level pricing covering all your projects for $30/month flat
• You need IP targeting, browser/OS/device targeting, or other targeting rules ConfigCat doesn't support
• You're building on Next.js App Router and need first-class Server Component and Middleware support
• You want full TypeScript type inference that flows from a central flag definition to every call site
• You want a built-in dev toolbar for overriding flags without leaving your app
• You want the fastest SDK setup in the market - flags in production in under 5 minutes
• You have a mixed stack with some non-JS services - Supaship's REST API covers Python, Go, Ruby, and any other backend with a simple HTTP call, no extra platform needed

For any team building a modern web product, Supaship is the clear choice. Better developer experience, more targeting capabilities, unlimited flags on the free tier, and a $30/month Pro plan that covers your entire workspace. Got a Python service or Go backend alongside your React frontend? Supaship's REST API has you covered - no need to split platforms. ConfigCat's advantage is specifically native offline SDKs for mobile and game engines; outside that profile, it's a more expensive tool with a worse JS developer experience.

---

Ready to try Supaship? Sign up for free - unlimited flags, 1 million events/month, no credit card required. Pro plan is $30/month for your entire workspace.

Get started with your framework: Next.js · React · Vue · Node.js

More comparisons: Supaship vs LaunchDarkly · Supaship vs Statsig · Best Feature Flag Platforms 2026