Feature flags,
without the bloat.

Zero dependencies. Sub-millisecond evaluation. Your user data never leaves your app.

Free to startNo credit cardLive in 2 minutes
Switchbox dashboard — managing feature flags across environments
View on GitHub
$pip install switchbox-flags

Lean by design

0.3ms
p99 evaluation, in-process
0
runtime dependencies
2KB
gzipped SDK
99.99%
edge config uptime

How it works

Configure, publish, evaluate

Set up a flag in the dashboard. It becomes JSON on the edge. Your app reads it instantly.

DashboardInteractive
new_checkout
boolean
Rules
Otherwise
Rollout25%
Published to edgecdn.switchbox.dev
flags.jsonCDN
{
  "version": "2026-03-10T12:00:00Z",
  "flags": {
    "new_checkout": {
      "enabled": true,
      "rollout_pct": 25,
      "default_value": false,
      "rules": [
        {
          "attribute": "email",
          "operator": "ends_with",
          "value": "@company.com"
        }
      ]
    }
  }
}
app.pyYour app
from switchbox import Switchbox

client = Switchbox(sdk_key="your-sdk-key")

user = {"user_id": "42",
        "email": "[email protected]"}

if client.enabled("new_checkout", user):
    show_new_checkout()
$ python app.pystdout
client.enabled(...) True
# matched rule: email ends_with @company.com
show_new_checkout()

The workflow

Roll out with confidence

Target precisely, see exactly how a flag resolves, and keep a full history of who changed what.

Configure

Set a rollout and targeting in seconds

Flip a flag, drag the rollout, and add OR-of-ANDs targeting rules — no YAML, no redeploy. Every change publishes to the edge automatically.

Flag detail — rollout slider + targeting rules

Verify

Trace exactly how a flag resolves

The in-app Playground evaluates a flag against any user context with the real SDK, and shows which rule matched, the rollout bucket, and the final value.

Playground — an evaluation trace

Audit

See who changed what, and when

Every mutation is recorded as a visual before→after diff — the rollout that moved, the rule that was added, and the person who did it.

Audit log — a before→after diff

Why Switchbox?

Built for developers who hate flag bloat

Zero dependencies

Python SDK uses only stdlib. JavaScript SDK uses only browser APIs. `pip install` brings in nothing else. No bloat.

Fail-safe by default

Switchbox down? Reads come straight from the edge. CDN down? The SDK keeps working on cached configs. Your features stay on.

Sub-millisecond evaluation

Rules and rollouts are evaluated locally in the SDK. No network call per flag check.

Private by design

Your user data never leaves your application. The SDK evaluates rules locally — no tracking, no evaluation logs sent to our servers.

No black box

Your config is a static JSON file you can curl, evaluated by open-source SDKs you can read line by line. Verify exactly how every flag resolves.

Served from the edge

Flag configs are served from Cloudflare's edge — never from our API. Your app only ever reads from it.

Priced for builders

Far below enterprise tools — by design

Reads never touch our servers, so Switchbox is genuinely cheap to run — and we price it that way. A free tier with unlimited flag evaluations, forever (they never hit a server), and paid plans at a fraction of what the incumbents charge. The saving is structural, not a promo that disappears at scale.

Resilient by design

Kill the backend. Your flags keep serving.

Switchbox is never in your read path — kill our API, the database, the whole backend, and your flags keep serving from Cloudflare's edge.

Also for AI apps

A model kill switch that can't go down

Ship prompts, model choice, and parameters as edge config instead of a redeploy. Because flags serve from Cloudflare's edge, your model config keeps resolving even if our entire backend is down — the one dependency an AI app can least afford in its hot path.

assistant_config · json flag
{
  "model": "claude-sonnet-4-6",
  "temperature": 0.7,
  "max_tokens": 1024,
  "system_prompt": "You are a concise support agent."
}
  • Model kill switch & fallback

    Disable a model that's erroring or burning money instantly — the change reaches your backend in ~30s.

  • Gradual model migration

    Move gpt-4 → claude at 10% → 100% with a rollout percentage. No redeploy, deterministic per user.

  • Per-tenant prompt & model routing

    Serve a different model or prompt per cohort with targeting rules — enterprise tenants, beta users, a region.

Server-side, and config — not secrets. Flag JSON is world-readable by its key, so use Switchbox for AI config from your backend (never ship the key in a browser bundle), and never put model API keys in a flag. Switchbox is the control plane that delivers the config — pair it with your own eval/analytics tool to measure which variant wins.

Start shipping features

Create a workspace, add your first flag, and ship it in minutes.