Feature Management
Without Limits

Flipt is an open-source feature management platform you can truly own.
It's easy to set up, has no seat limits, and is built for developers from scale-ups to enterprises.

Feature Flags
Meet Git

Flipt Cloud is a fully managed feature flag solution that enables you to keep your feature flags and remote config next to your code.

See Flipt in Action
1 minute

Feature Flags That Live
Alongside Your Code

Feature flags are mission critical to facilitate continuous delivery and safe deployments. They should reside alongside your existing configurations within your codebase.

INTEGRATED WITH YOUR WORKFLOW

Release, Rollback, and Audit
Using Familiar Tooling

Harness the power of Git to effectively manage feature flags in a declarative, auditable and version controlled format.

WORKS WHERE YOU DO

Synchronize Development And Production

Flipt Cloud enables your local and CI environments to stay in sync with your production feature flags, ensuring smooth releases.

Enterprise ready

Managed Access Control

Define custom roles and permissions for your team members or use our built-in roles. Integrate with your existing SSO or SCIM provider for effortless user management.

Transparency You can trust

Built on Open Source

Flipt Cloud is built with the same fundamentals and commitment to quality as Flipt Open source.

Trusted by Developers, Proven in Production

Learn how leading engineering teams use Flipt to gain better control over feature releases and improve their continuous delivery practices.

"At Paradigm, we prioritize speed, security, and simplicity in our release operations, and Flipt empowers us to achieve these by being co-located within our infrastructure. Flipt offers a straightforward yet robust flagging solution, streamlining the development of our new features and ensuring their successful rollout."

Michael Hintz

Software Architect

Paradigm

"Flipt has allowed us to control every aspect of our product with a fine tooth comb, ensuring that features experiencing issues are properly handled, or features that need a timed rollout are done so with precision."

Connor Wright

Lead Developer

AsphaltBot

"Flipt is a performance-focused and self-hostable feature flag platform with an intuitive flag model that's flexible enough to support multiple feature-management use cases across Allocate's stack.  As a startup, it was an easy choice compared to the other vendor offerings out there and their dev team has been a joy to collaborate with."

Jeremy Caron

VP of Engineering

Allocate

"We’ve been using Flipt for 9 months now and have been very happy with it. What I like most is that it’s clearly developed according to very high engineering standards. Great docs, clear APIs, easy setup, removes roadblocks without creating new ones. They also have been very receptive to suggestions and code contributions."

Paul Grau

Lead Product Engineer

Alvin

"Flipt is such a perfect representation of how feature flags should work. No question. Flipt is the way to go. As soon as I get people bought in, and understanding the idea, they freaking love it."

Jameel Al-Aziz

Founding Engineer

Bastion

"This is cool as f*ck."

David Flanagan

Founder/CEO

Rawkode Academy

We Speak Your
Language

Flipt maintains server-side, client-side, and OpenFeature SDKs for most popular programming language. Let us know if your language is missing!

const resp = await flipt.evaluation.variant({
  namespaceKey: "production",

  flagKey: "ui-color",

  entityId: "user-123",

  context: {

    platform: "web",

  },
});

if (resp.variantKey === "dark") {

  // show dark UI

}

resp, _ := flipt.Variant(ctx, &evaluation.EvaluationRequest{
 NamespaceKey: "production",
 FlagKey: "ui-color",
 EntityId: "user-123",
 Context: map[string]string{
   "platform": "web",
 },
})

if resp.VariantKey == "dark" {
 // show dark UI
}

resp = flipt.evaluation.variant(
  namespace_key="production",
  flag_key="ui-color",
  entity_id="user-123",
  context={    
    "platform": "web",
  }
)

if resp.variant_key == "dark":
 # show dark UI

var req = EvaluationRequest.builder().
   namespaceKey("production").
   flagKey("ui-color").
   entityId("user-123").
   context(Map.of("platform", "web")).
   build();

var resp = flipt.evaluation().variant(req);

if (resp.getVariantKey().equals("dark")) {
 // show dark UI
}

let resp = flipt.variant(&evaluation::EvaluateRequest {
       namespace_key: String::from("production"),
       flag_key: String::from("ui-color"),
       entity_id: String::from("user-123"),
       context: std::collections::HashMap::from([(
           String::from("platform"),
           String::from("web"),
       )]),
       ..Default::default()
   })    
    .await

if resp.variant_key == "dark" {
   // show dark UI
}

$resp = $flipt->variant('ui-color', ['platform' => 'web'], 'user-123');

if ($resp->getVariantKey() === 'dark') {
   // show dark UI
}

const fliptEvaluationClient = new FliptEvaluationClient();

const variant = fliptEvaluationClient.evaluateVariant("ui-color", "user-123", { platform: "web" });

evaluationClient, _ := flipt.NewClient()

defer evaluationClient.Close()

variantResult, err := evaluationClient.EvaluateVariant(context.Background(), "ui-color", "user-123",   map[string]string{
    "platform": "web",
  }
)

flipt_evaluation_client = FliptEvaluationClient()

variant_result = flipt_evaluation_client.evaluate_variant(flag_key="ui-color", entity_id="user-123", context={"platform": "web"})

const fliptClient = await FliptEvaluationClient.init();

const variant = fliptClient.evaluateVariant('ui-color', 'user-123', { platform: 'web' });

var client = FliptEvaluationClient.builder().build();

var response = client.evaluateVariant("ui-color", "user-123", Map.of("platform", "web"));

client = Flipt::EvaluationClient.new()

resp = client.evaluate_variant({ flag_key: 'ui-color', entity_id: 'user-123',
    context: { platform: 'web' }
})

const provider = new FliptProvider();
OpenFeature.setProvider(provider);

const client = OpenFeature.getClient();
const value = await client.getBooleanValue('new-ui-enabled', false, {
  targetingKey: 'user-123',
});

openfeature.SetProvider(flipt.NewProvider())

client := openfeature.NewClient("sync")

value, err := client.BooleanValue(
  context.Background(), "new-ui-enabled", false, openfeature.NewEvaluationContext("user-123"),
)

const provider = new FliptWebProvider();
await OpenFeature.setProviderAndWait(provider);

const evaluationCtx: EvaluationContext = {
  targetingKey: 'user-123',
  platform: 'web',
};

await OpenFeature.setContext(evaluationCtx);
const client = await OpenFeature.getClient();

const value = client.getBooleanDetails('ui-color', false);

OpenFeatureAPI.getInstance().setProviderAndWait("sync", fliptProvider);

var client = OpenFeatureAPI.getInstance().getClient("sync");

var evaluationContext = new MutableContext();
evaluationContext.setTargetingKey("user-123");

var value = fliptProvider.getBooleanEvaluation("new-ui-enabled", false, evaluationContext).getValue());

Flipt Integrations
Built On Open Source

Fits In Your Stack

Flipt Cloud ensures your data remains secure within your organization’s Git repositories while seamlessly integrating with Flipt Open Source.

Continue leveraging Flipt Open Source to deploy in your infrastructure for limitless scaling and integration with your existing stack.

Enterprise-Grade
Speed, Security, And Scale

All the features developers need to manage feature flags within their existing workflows at scale.

GitOps-First

Manage features through Flipt Cloud and have your changes flow directory into Git repositories that you own.

Auditable

Automatically keep an audit trail using Git commits to see who made changes and remain compliant.

Easy Integration

Supports OpenFeature and SDKs for languages like JavaScript, Go, Ruby, Rust, Java, Python and more.

Secure

Login with GitHub, Google, and more. Easily configure Single Sign On and SAML authentication. Use our built in RBAC roles for authorization, or create your own.

Fully Managed or Self-Hosted

Self hosted Flipt works along side Flipt Cloud to integrate with your existing services over REST or gRPC to enable low latency at scale.

1-1 Support

Our Team plan includes a dedicated Slack support channel to ask questions and get help directly from a Flipt engineer.

Git Started Today
With Flipt Cloud

Experience the power of our enterprise-grade, Git-native feature management platform built for developers.

Watch Demo