https://www.flipt.io/

Fully Managed Feature Flags, Synced to your Git Repositories - Check
out Flipt Cloud!
[65955c826d]
[6594816605]
Star
BlogDocumentationPricing
Cloud Login
 
 

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.

 
Sign Up For Flipt Cloud
 
Flipt Open Source
[65957727f4][65959415f5]

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.

 
Discover Flipt Cloud
 
Flipt Open Source
[65957727f4][65959415f5]
See Flipt in Action
1 minute

Trusted by Innovative Teams Worldwide

[6595902eac]
[6595902ea9]
[6595902dc0]
[6595902d00]
[66d390ebcb]
[6600459668]
[66685ab8cf]

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.

 
Learn More
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.

 
Learn More
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.

 
Learn More
Transparency You can trust

Built on Open Source

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

 
Learn more
[6604358dd8][65966a42bf]

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
[65f2447c1f]

"Flipt has allowed Rokt to dynamically turn on features, enable
bulkheads for failure recovery, test experiments in production, and
maintain low latency and high availability throughout the course of
operations."

Dan Piet

Director of Engineering

Rokt
[65968eb703]

"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
[65f1dcdced]

"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
[662d364372]

"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
[666753727a]

"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
[66d4868a0e]
[6597dfea04]

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!

Server Side SDKs
Client Side SDKs
OpenFeature SDKs
Node
Go
Python
Java
Rust
PHP

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

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

VariantEvaluationResponse 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
}

Node
Go
Python
Web
Java
Ruby

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' });

FliptEvaluationClient fliptClient = FliptEvaluationClient.builder()
                    .build();

Map<String, String> context = new HashMap<>();
context.put("platform", "web");

Result<VariantEvaluationResponse> result =
    fliptClient.evaluateVariant("ui-color", "user-123", context);

client = Flipt::EvaluationClient.new()

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

Node
Go
Web
Java

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);

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

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

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

Flipt Integrations[65966a42bf]
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.

Learn more

Enterprise-Grade
Speed, Security, And Scale

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

[659677f821]

GitOps-First

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

[6596780add]

Auditable

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

[6596782067]

Easy Integration

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

[6596783a3d]

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.

[6596786047]

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.

[66d70d4cf9]

1-1 Support

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

[659679c93a]

Git Started Today
With Flipt Cloud

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

 
Discover Flipt Cloud
 
Star on Github
[6597ee0365]
(c) 2024 Flipt Software Inc. All rights reserved.
[6597f2baa4]
 
 
 
 
[6597f4a1b8]
 
Watch Demo