Get started

Features

Everything you need to
control your releases

Flags, targeting rules, environments, remote config, and gradual rollouts in one tool. The primitives a release manager reaches for every week.

Flagify AI · built-in

Your copilot for every flag, every environment.

Flagify AI understands your project. It knows your flags, your environments, your audit log, and your docs — and it turns plain English into safe, audited changes.

⚡

Act on flags

List, create, toggle — by key or by a natural-language description. Every action is audited with actor and timestamp.

🛡️

Production guardrails

Dev and staging changes apply instantly. Production changes always require an explicit confirmation before the tool runs.

📚

Docs-aware

Ask how SDKs, targeting, or the CLI work. The assistant searches the live Flagify docs and answers with citations — not guesses.

🔁

Honest about limits

The AI only does what its tools can do. When a request is out of scope, it says so — no made-up answers, no phantom changes.

Included on every plan. Start chatting the moment you create a project.

Start free

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.

Flags

Feature flags that just work

Boolean, multivariate, and value flags. The SDK evaluates locally in under a millisecond and syncs rules in the background, so no flag check ever touches the network on the hot path.

  • Boolean on/off toggles
  • Multivariate string variants
  • Typed value flags (number, JSON)
  • Sub-millisecond evaluation
flags.ts 
const enabled = flagify.isEnabled(
  'new-checkout'
);

const variant = flagify.getValue<string>(
  'pricing-page'
);
// 'control' | 'variant-a' | 'variant-b'
Targeting

Target the right users

Define rules based on any user attribute. Combine conditions with AND/OR logic, layer a percentage rollout on top, or save the filter as a reusable segment. All from the dashboard, none of it needs a deploy.

  • Attribute-based rules
  • Percentage rollouts with consistent hashing
  • Reusable user segments
  • AND / OR condition logic
targeting.ts 
// User context is set at init time
// Targeting rules evaluate automatically

const showBeta = flagify.isEnabled(
  'beta-dashboard'
);

if (showBeta) {
  renderBetaDashboard();
}
Environments

Ship across environments safely

Every environment has its own flag state, its own targeting rules, and its own API keys. Toggle something in development without worrying about staging, validate in staging without touching production.

  • Isolated dev / staging / prod
  • Per-environment API keys
  • Promote config between environments
  • Custom environments (canary, preview)
environments.ts 
const flagify = new Flagify({
  projectKey: 'my-project',
  // Key prefix determines env: pk_prod_
  publicKey: process.env.FLAGIFY_PUBLIC_KEY,
});

// Same flag, different rules per env
const enabled = flagify.isEnabled(
  'new-onboarding'
);
Remote config

Change behavior at runtime

Store typed values as flags: numbers, strings, or JSON objects. Update configuration from the dashboard without touching code or waiting for the next deploy window.

  • Typed values (string, number, JSON)
  • Fallback defaults in code
  • Real-time updates via streaming
  • No deploy required
config.ts 
const maxRetries = flagify.getValue<number>(
  'api-max-retries',
  3 // fallback
);

const config = flagify.getValue<OnboardingConfig>(
  'onboarding-steps',
  { steps: ['welcome', 'profile'] }
);
Rollouts

Roll out gradually, roll back instantly

Release to 1% of users, watch your metrics, then ramp to 100%. If something breaks, kill the flag from the dashboard. No deploy, no downtime.

  • Percentage-based rollouts
  • Consistent user assignment
  • Instant kill switch
  • Pair with metrics for data-driven decisions
rollouts.ts 
// Dashboard: "new-search" → 25% of users
// Same user always gets the same result

const useNewSearch = flagify.isEnabled(
  'new-search-engine'
);

const results = useNewSearch
  ? await elasticSearch(query)
  : await legacySearch(query);
SDKs

First-class SDK support

TypeScript-first SDKs for Node.js and React. Typed APIs, local caching, background sync. Most integrations take under five minutes end to end.

  • Node.js / TypeScript SDK
  • React hooks & provider
  • Streaming + polling refresh
  • Works with any JS runtime
App.tsx 
// React — reactive flag evaluation
import { useFlag, useVariant } from '@flagify/react';

function Navbar() {
  const showNew = useFlag('new-navbar');

  return showNew
    ? <NewNavbar />
    : <ClassicNavbar />;
}

And more

Built for production

Audit log

Every flag change is stamped with the user, the action, the timestamp, and the environment. Exportable when an auditor asks.

API-first

A REST API for every flag, environment, and targeting rule. Everything the dashboard does, your scripts can do too.

Streaming sync

Flags update in real time over SSE. No polling interval to tune, no stale cache to invalidate.

CLI tooling

Manage flags from the terminal. List, create, and toggle flags from a CI/CD job or a local shell — same commands, same output.

Type safety

TypeScript generics on every SDK call. Your editor knows whether a flag is a boolean, a string, a number, or a JSON shape before you run the code.

Local dev mode

Override flags locally during development without affecting other environments.

AI Ready

First-class AI tooling

Flagify ships with Claude Code skills, a .cursorrules file, copilot-instructions, and .windsurfrules out of the box. Whichever AI tool you already use picks up the Flagify SDK patterns on day one.

Claude Code

Slash commands & skills

Slash commands that create flags, toggle environments, and promote rollouts from inside Claude Code.

Cursor

.cursorrules

A .cursorrules file that teaches Cursor the Flagify SDK patterns and kebab-case naming rules your flags expect.

GitHub Copilot

Instructions & prompts

copilot-instructions that keep completions inside the Flagify SDK patterns and per-environment key handling.

Windsurf

.windsurfrules

Windsurf rules that describe how to evaluate flags, promote configs, and handle rollouts the Flagify way.

flagify-create.md 
# .claude/commands/flagify-create.md

Create a new feature flag "$FLAG_NAME"
in the "$ENVIRONMENT" environment.

# Uses the Flagify CLI:
npx flagify flags create $FLAG_NAME \
  --env $ENVIRONMENT \
  --type boolean \
  --default false

# Verify:
npx flagify flags list --env $ENVIRONMENT
terminal 
# Generate AI tool configs for your project
npx flagify ai-setup

# Or pick a specific tool
npx flagify ai-setup --tool cursor
npx flagify ai-setup --tool claude
npx flagify ai-setup --tool copilot
npx flagify ai-setup --tool windsurf

# Include current flags in context
npx flagify ai-setup --include-flags

One CLI command generates the right config files for every tool in your stack.

Read the guide

See it in action

Every feature, one-line away

Pick a plan, skim the SDK docs, and ship your first flag before the next standup. Every capability on this page is live on the free tier.

View pricing Read the docs

Free forever plan · No credit card · Works with every SDK on this page