Get started
New · Flagify AI

Manage flags by just asking.

The built-in AI copilot lives inside Flagify. Toggle a flag, find the one you half-remember by describing it, or ask what rolled out yesterday. Plain English in, real operations out. Production changes always ask before they run.

Start for free View documentation

No credit card required

⚡
10× faster No clicking through dashboards.
🛡️
Prod-safe Confirms before touching production.
🔎
No memorizing Find flags by what they do, not their key.
<1ms Flag evaluation
CLI-first Developer workflow
API-first Architecture
Tools the AI can call
list_flags scan_flags get_flag_state inspect_flag create_flag toggle_flag list_environments get_targeting_rules get_audit_log list_members search_docs

CLI · v1.7.0 · AI tool ready

Never ship a typo into a flag check again.

One command, one generated file. Every flag key in your project becomes a typed constant. Your editor autocompletes them. Your compiler rejects typos. Your AI coding tool reads the same file and stops hallucinating flag names that were never created. No other feature-flag platform ships this in the box for both TypeScript and Go.

zsh 
$ ✓ Generated flagify.ts (12 flags)→ export const FLAG_KEYS · export type FlagKey
Before raw string · ships silently 
if (flagify.isEnabled('new-checkot-flow')) {
  renderNewCheckout()
}
// ❌ typo. flag never evaluates. silent prod bug.
After typed constant · compile-time safe 
import { FLAG_KEYS } from './flagify'

if (flagify.isEnabled(FLAG_KEYS['new-checkout-flow'])) {
  renderNewCheckout()
}
// ✓ compile error if the key is wrong
The DX win

You shouldn't have to remember flag names.

Your teammate shipped a flag yesterday. You need to check it behind a button. You don't know the exact kebab-case name, so now it's a dashboard tab, a grep, or a Slack message. Skip all that. Type FLAG_KEYS. in your editor. Every flag in the repo shows up in the autocomplete popup, sorted alphabetically, ready to tab-complete.

  • → Every flag in scope. No memorization, no dashboard trips.
  • → Regenerate once. Every flag your team added shows up the same day.
  • → Rename a flag in the dashboard. TypeScript lists every call site you need to update before the next build passes.

Typos fail at compile time

Your IDE underlines the wrong flag name in red while you type. CI rejects the commit. Your users never see the silent-default bug.

Stop memorizing flag names

Type FLAG_KEYS. and see every flag in the project. Including the one your teammate shipped last week and forgot to tell you about.

AI assistants get it right

Claude, Cursor, and Copilot read FLAG_KEYS as the source of truth. No more hallucinated flag names in AI-generated diffs. The Flagify ai-setup templates steer them here on day one.

See the command

Works with @flagify/node, @flagify/react, @flagify/astro, and @flagify/nestjs. Requires CLI v1.7.0 or later — run flagify version to check.

How it works

From a blank slate to a flag in production, in three moves.

  1. Define your flags

    Create flags from the CLI, the API, or the dashboard. Add targeting rules and rollout percentages per environment, with a default value for everyone else.

    terminal 
                      # Create a flag from the CLI
flagify flags create new-checkout \
  --type boolean \
  --project my-app

  2. Deploy safely across environments

    Promote flag configurations from staging to production with a single command. Environments are isolated, so a change in staging stays in staging until you push it.

    terminal 
                      # Promote config to production
flagify promote \
  --from staging \
  --to production

  3. Control behavior in real time

    Toggle a feature, adjust who sees it, or roll it back without a deploy. Connected SDKs pick up the change in milliseconds.

    terminal 
                      # Toggle a flag instantly
flagify flags toggle new-checkout \
  --env production \
  --enabled false

Frameworks

Build with SDKs for
every stack.

TypeScript-first SDKs with local evaluation, streaming sync, and typed flag values. Drop in the one that matches your runtime.

All frameworks

Integrations

Fits the tools
you already ship with.

Gate deploys from CI, sync incidents from your monitoring, and get every flag change in the channel your team actually watches.

All integrations

Built for production

Not a key-value store with marketing.

Real isolation, real auditing, real key management. The primitives you actually reach for on a release day, and nothing else pretending to be a primitive.

01 · Core primitive

Feature flags

Toggle features per environment without a redeploy. Boolean flags, multivariate variants, and percentage rollouts are first-class.

Performance

<1ms evaluation

The SDK caches flags locally and updates them over a streaming connection. Evaluations hit memory; nothing waits on a network round-trip.

User targeting

Serve different values per user by plan, role, geography, or any custom attribute your app forwards.

Remote config

Change runtime values — thresholds, limits, copy — from the dashboard. No deploy.

Environment isolation

Staging, preview, and production are separated at every layer. A change stays where you put it until you promote it.

Audit trail

Every flag change, promotion, and key rotation is logged with user, action, and timestamp. Exportable when an auditor asks.

Scoped keys, short-lived JWTs, multi-tenant by default

API keys are scoped to one project + one environment, signed with HMAC-SHA256, rotated on demand. Requests carry short-lived JWTs — no long-lived secret in your repo. Workspaces, projects, and environments never share a query, a cache, or a row.

Why Flagify

Most flag tools try to do everything. We pick four things and do them well.

On simplicity

Five minutes from zero to a flag in production.

No 200-page setup guide. No mandatory enterprise onboarding call. Install the CLI, create a flag, evaluate it from your code. That is the entire story.

On workflow

CLI-first, because dashboards interrupt thinking.

Create flags, promote configs, manage environments — from the terminal you already have open. The dashboard is there when you want it. Most days you will not need it.

On pricing

Four plans with published limits. No per-seat tax.

You know what you pay before you commit. Adding a teammate does not raise your bill. Hitting a usage cap does not trigger a sales call.

On environments

Real isolation, not a tag on a row.

Staging, preview, and production each have their own flag state, their own keys, and their own targeting rules. Nothing leaks between them — by design, not by convention.

Developer experience

Integrate in minutes, not days

Initialize the SDK once and evaluate flags anywhere in your app. There is no config file to maintain and nothing running in the background.

flagify.config.ts 
import { Flagify } from '@flagify/node';

export const flagify = new Flagify({
  projectKey: 'my-project',
  publicKey: process.env.FLAGIFY_PUBLIC_KEY,
  // Flags are cached locally and synced
  // in real time via SSE
  options: { realtime: true },
});
checkout.ts 
import { flagify } from './flagify.config';

function getCheckoutVariant() {
  const variant = flagify.getValue<string>(
    'checkout-redesign'
  );

  return variant === 'v2'
    ? renderCheckoutV2()
    : renderCheckoutV1();
}
AI-NATIVE

Your editor already
speaks Flagify

Two layers. Static context so AI-generated code follows your flag conventions, and runtime control so the agent can actually change flag state.

Runtime New Model Context Protocol

@flagify/mcp

Stdio MCP server · 12 tools

Any MCP-compatible host can call list_flags, create_flag, toggle_flag, update_targeting_rules, and get_audit_log. Mutations carry destructiveHint: true so the host highlights them in the consent prompt. Every change lands in your audit log with source: "mcp".

Works with
  • Claude Desktop
  • Claude Code
  • Cursor
  • Zed
  • Windsurf
Setup guide flagifyhq/flagify-mcp
Static context flagify ai-setup

Claude Code

.claude/

Slash commands + CLAUDE.md so the agent uses the right SDK patterns and kebab-case keys.

Cursor

.cursorrules

SDK patterns, flag-naming rules, and snippets baked into the editor context.

Copilot

copilot-instructions.md

Keeps completions inside the Flagify SDK and away from raw string flag checks.

Windsurf

.windsurfrules

Rules for evaluating flags, promoting configs, and handling rollouts safely.

Set up in 30 seconds All integrations

Pricing

Predictable pricing, no surprises

Start free. Scale with transparent, usage-based pricing.

Free

$ 0 /mo, billed yearly

For side projects and small teams getting started.

Start for free
  • 1 workspace
  • 2 projects per workspace
  • Unlimited flags
  • 3 environments
  • 3 seats
  • 75,000 evaluations / month
  • 50 AI messages / month
  • CLI + SDK access
  • Community support
Most popular

Pro

$ 79 /mo, billed yearly

For teams shipping to production with confidence.

Get started
  • 3 workspaces
  • 5 projects per workspace
  • Unlimited flags
  • 5 environments
  • 10 seats
  • 1M evaluations / month
  • 1,000 AI messages / month
  • Config promotion
  • Advanced targeting
  • Audit logs
  • RBAC
  • Full API access

Growth

$ 239 /mo, billed yearly

For scaling teams that need more capacity and control.

Get started
  • 10 workspaces
  • 20 projects per workspace
  • Unlimited flags
  • 15 environments
  • 50 seats
  • 25M evaluations / month
  • 5,000 AI messages / month
  • Everything in Pro
  • Priority support
  • Advanced audit logs

Need more evaluations? Additional usage billed at $20 per 1M evaluations.

Enterprise

Unlimited everything, dedicated infrastructure, SSO, SLA, and region deployment.

Talk to sales

Get started

Wire up Flagify in five minutes

Install the SDK, create your first flag, and ship a toggle before lunch. No credit card, no sales call.

Start for free Talk to us

Free forever plan · No credit card · 5-minute setup