OpenFeature Provider (Python)

Overview

This guide covers using Mixpanel’s Feature Flags through the OpenFeature standard with the Mixpanel Python OpenFeature provider. OpenFeature provides a vendor-agnostic API for feature flag evaluation, allowing you to switch between providers without changing your application code.

For the native Mixpanel SDK approach, see the Feature Flags (Python) guide.

Prerequisites

• Enterprise subscription plan with Feature Flags enabled
• Python 3.9 or higher
• Project Token from your Mixpanel Project Settings

Installation

pip install mixpanel-openfeature openfeature-sdk

Quick Start

from mixpanel_openfeature import MixpanelProvider
from mixpanel.flags.types import LocalFlagsConfig
from openfeature import api

# 1. Create and register the provider with local evaluation
provider = MixpanelProvider.from_local_config(
    "YOUR_PROJECT_TOKEN",
    LocalFlagsConfig(token="YOUR_PROJECT_TOKEN"),
)
api.set_provider(provider)

# 2. Get a client and evaluate flags
client = api.get_client()
show_new_feature = client.get_boolean_value("new-feature-flag", False)

if show_new_feature:
    print("New feature is enabled!")

Initialization

The provider supports three initialization methods depending on your evaluation strategy.

Local Evaluation (Recommended)

Evaluates flags locally using cached flag definitions polled from Mixpanel. This minimizes latency since there is no network call at evaluation time.

Targeting by Mixpanel cohorts and sticky variants are not supported in Local Evaluation mode.

from mixpanel_openfeature import MixpanelProvider
from mixpanel.flags.types import LocalFlagsConfig

provider = MixpanelProvider.from_local_config(
    "YOUR_PROJECT_TOKEN",
    LocalFlagsConfig(token="YOUR_PROJECT_TOKEN"),
)

Remote Evaluation

Evaluates flags by making a request to Mixpanel’s servers for each evaluation. Use this when you need real-time flag values or cohort-based targeting.

from mixpanel_openfeature import MixpanelProvider
from mixpanel.flags.types import RemoteFlagsConfig

provider = MixpanelProvider.from_remote_config(
    "YOUR_PROJECT_TOKEN",
    RemoteFlagsConfig(token="YOUR_PROJECT_TOKEN"),
)

Using an Existing Mixpanel Instance

If your application already has a Mixpanel instance configured for tracking, you can wrap its flags provider:

from mixpanel import Mixpanel
from mixpanel.flags.types import LocalFlagsConfig
from mixpanel_openfeature import MixpanelProvider

mp = Mixpanel("YOUR_PROJECT_TOKEN", local_flags_config=LocalFlagsConfig(token="YOUR_PROJECT_TOKEN"))
mp.local_flags.start_polling_for_definitions()

provider = MixpanelProvider(mp.local_flags)

Usage

Flag Types and Evaluation Methods

Mixpanel Flag Type	Variant Values	OpenFeature Method
Feature Gate	True / False	get_boolean_value()
Experiment	boolean, string, number, or JSON object	get_boolean_value(), get_string_value(), get_integer_value(), get_float_value(), or get_object_value()
Dynamic Config	JSON object	get_object_value()

client = api.get_client()

# Feature Gate
is_feature_on = client.get_boolean_value("new-checkout", False)

# Experiment with string variants
button_color = client.get_string_value("button-color-test", "blue")

# Experiment with numeric variants
max_items = client.get_integer_value("max-items", 10)
threshold = client.get_float_value("score-threshold", 0.5)

# Dynamic Config
feature_config = client.get_object_value("homepage-layout", {"layout": "default"})

Evaluation Context

Pass context to provide user attributes for targeting:

from openfeature.evaluation_context import EvaluationContext

context = EvaluationContext(
    targeting_key="user-123",
    attributes={
        "email": "[e-mail]",
        "plan": "premium",
        "beta_tester": True,
    },
)

value = client.get_boolean_value("premium-feature", False, context)

Unlike some providers, targetingKey is not used as a special bucketing key. It is passed as another context property. Mixpanel’s server-side configuration determines which properties are used for targeting and bucketing.

Full Resolution Details

details = client.get_boolean_details("my-feature", False)

print(details.value)        # The resolved value
print(details.variant)      # The variant key from Mixpanel
print(details.reason)       # Why this value was returned
print(details.error_code)   # Error code if evaluation failed

Accessing the Underlying Mixpanel Instance

When using from_local_config or from_remote_config, you can access the Mixpanel instance for tracking:

mp = provider.mixpanel

Shutdown

provider.shutdown()

Error Handling

The provider uses OpenFeature’s standard error codes:

Error Code	When
PROVIDER_NOT_READY	Flags evaluated before local provider has finished loading definitions
FLAG_NOT_FOUND	The requested flag does not exist in Mixpanel
TYPE_MISMATCH	The flag value type does not match the requested type

Troubleshooting

Flags Always Return Default Values

1. Provider not ready (local evaluation): Flag definitions are polled asynchronously. Allow time for the initial fetch to complete.
2. Invalid project token: Verify the token matches your Mixpanel project.
3. Flag not configured: Verify the flag exists and is enabled in your Mixpanel project.

Type Mismatch Errors

1. Verify the flag’s value type in Mixpanel matches your evaluation method (e.g., string "true" requires get_string_value(), not get_boolean_value()).
2. Use get_object_value() for JSON objects.
3. Integer evaluation accepts whole-number float values. Float evaluation accepts any numeric type.