OpenFeature Providers - GrowthBook Documentation

OpenFeature is a CNCF-incubating open standard for feature flagging. GrowthBook provides OpenFeature provider SDKs for JavaScript (Node.js and web), Python, Go, .NET, and Java, listed in the OpenFeature ecosystem.

Prerequisites

A GrowthBook account (cloud or self-hosted)
An SDK Connection key — create one under Settings → SDK Connections in the GrowthBook UI
The API host:
- Cloud: https://cdn.growthbook.io
- Self-hosted: your own GrowthBook URL (e.g. https://growthbook.example.com)

Why Use OpenFeature with GrowthBook?

OpenFeature defines a vendor-neutral interface for evaluating feature flags. Using a GrowthBook OpenFeature provider means:

Vendor portability — Your flag evaluation code is identical regardless of which provider is active. Switching from or to GrowthBook only requires changing the provider bootstrap, not a single flag call.
Standardized API — Teams use the same OpenFeature interface they already know across all services.
Ecosystem compatibility — OpenFeature-aware tooling — including OpenTelemetry hooks and other instrumentation — works automatically with GrowthBook.
Polyglot consistency — The same conceptual API spans JavaScript, Python, Go, .NET, Java (and more), giving teams a single mental model.

When to use the native GrowthBook SDK insteadThe native GrowthBook SDKs expose features that go beyond the OpenFeature interface: Sticky Bucketing, Visual Editor experiments, and inline experiment definitions. If you need those capabilities, use the native SDK for your language instead.

Installation & Setup

JavaScript
Python
Go
.NET
Java

Use @openfeature/growthbook-provider with @openfeature/server-sdk in Node.js. Use @openfeature/growthbook-client-provider with @openfeature/web-sdk in the browser. The two providers are not interchangeable — either one throws if you register it with the wrong SDK.

Unlike the Python, .NET, and Java providers, the JavaScript providers pass the evaluation context to GrowthBook unchanged. targetingKey is not mapped to GrowthBook’s id attribute, so you must set id yourself — see Evaluation Context.

Both packages are published from open-feature/js-sdk-contrib and are currently pre-1.0. Report issues there rather than on the GrowthBook repos.

Node.js (server)
Web (client)

GitHub: js-sdk-contrib/providers/growthbook | npm: @openfeature/growthbook-providerRequirements: Node.js 20+ (set by the current @openfeature/server-sdk)

npm install @openfeature/growthbook-provider @openfeature/server-sdk @growthbook/growthbook

import { OpenFeature } from "@openfeature/server-sdk";
import { GrowthbookProvider } from "@openfeature/growthbook-provider";

const gbClientOptions = {
  apiHost: "https://cdn.growthbook.io",
  clientKey: "sdk-abc123",
  // Only required if you have feature encryption enabled
  // decryptionKey: "key_abc123",
};

// The second argument is optional. `timeout` bounds how long startup can block
// on the initial feature fetch; streaming is already enabled by default.
await OpenFeature.setProviderAndWait(
  new GrowthbookProvider(gbClientOptions, { timeout: 2000 }),
  { region: "us-east" }, // optional global attributes, applied to every evaluation
);

const client = OpenFeature.getClient("my-app");

The provider reads global attributes once, when it initializes. Pass them as the second argument to setProviderAndWait as shown above — calling OpenFeature.setContext() later does not update them on the server SDK.

GitHub: js-sdk-contrib/providers/growthbook-client | npm: @openfeature/growthbook-client-provider

npm install @openfeature/growthbook-client-provider @openfeature/web-sdk @growthbook/growthbook

import { OpenFeature } from "@openfeature/web-sdk";
import { GrowthbookClientProvider } from "@openfeature/growthbook-client-provider";

const gbContext = {
  apiHost: "https://cdn.growthbook.io",
  clientKey: "sdk-abc123",
  // Only required if you have feature encryption enabled
  // decryptionKey: "key_abc123",
};

await OpenFeature.setProviderAndWait(
  new GrowthbookClientProvider(gbContext, { timeout: 2000 }),
);

// Web SDK evaluations read the global context. Await it before evaluating —
// the provider applies the new attributes inside this call.
await OpenFeature.setContext({ targetingKey: "user-123", id: "user-123" });

const client = OpenFeature.getClient("my-app");

GitHub: growthbook-openfeature-provider-python | PyPI: growthbook-openfeature-providerRequirements: Python 3.9+

pip install growthbook-openfeature-provider

Async setup (recommended for async frameworks like FastAPI, aiohttp):

import asyncio
from openfeature.api import OpenFeatureAPI
from openfeature.evaluation_context import EvaluationContext
from growthbook_openfeature_provider import GrowthBookProvider, GrowthBookProviderOptions

async def main():
    provider = GrowthBookProvider(GrowthBookProviderOptions(
        api_host="https://cdn.growthbook.io",
        client_key="sdk-abc123"
    ))
    await provider.initialize()
    OpenFeatureAPI.set_provider(provider)

    client = OpenFeatureAPI.get_client("my-app")
    # ... evaluate flags ...

    await provider.close()

asyncio.run(main())

Synchronous setup:

from openfeature.api import OpenFeatureAPI
from growthbook_openfeature_provider import GrowthBookProvider, GrowthBookProviderOptions

provider = GrowthBookProvider(GrowthBookProviderOptions(
    api_host="https://cdn.growthbook.io",
    client_key="sdk-abc123"
))
provider.initialize_sync()
OpenFeatureAPI.set_provider(provider)

client = OpenFeatureAPI.get_client("my-app")

GitHub: growthbook-openfeature-provider-go | pkg.go.dev: growthbook-openfeature-provider-goRequirements: Go 1.21+

go get github.com/growthbook/growthbook-openfeature-provider-go

import (
    "context"
    "log"
    gb "github.com/growthbook/growthbook-golang"
    gbprovider "github.com/growthbook/growthbook-openfeature-provider-go"
    "github.com/open-feature/go-sdk/openfeature"
)

// Create the underlying GrowthBook client
gbClient, err := gb.NewClient(context.Background(),
    gb.WithAPIHost("https://cdn.growthbook.io"),
    gb.WithClientKey("sdk-abc123"),
)
if err != nil {
    log.Fatal("GrowthBook client initialization failed: ", err)
}
defer gbClient.Close()

// Wrap it in the OpenFeature provider and register it
provider := gbprovider.NewProvider(gbClient)
if err = openfeature.SetProvider(provider); err != nil {
    log.Fatal("Failed to set OpenFeature provider: ", err)
}

client := openfeature.NewClient("my-app")

GitHub: growthbook-openfeature-provider-dot-net | NuGet: GrowthBook.OpenFeatureRequirements: .NET 8+ or .NET Framework 4.6.2+

dotnet add package GrowthBook.OpenFeature

using GrowthBook.OpenFeature;
using OpenFeature;
using OpenFeature.Model;

var provider = new GrowthBookProvider(
    clientKey: "sdk-abc123",
    apiHostUrl: "https://cdn.growthbook.io"
);

Api.Instance.SetProvider(provider);
var client = Api.Instance.GetClient();

GitHub: growthbook-openfeature-provider-java | Maven Central: growthbook-openfeature-provider-javaRequirements: Java 8+

Maven
Gradle

<dependency>
  <groupId>com.github.growthbook</groupId>
  <artifactId>growthbook-openfeature-provider-java</artifactId>
  <version>0.0.1</version>
</dependency>

implementation group: 'com.github.growthbook', name: 'growthbook-openfeature-provider-java', version: '0.0.1'

import io.github.growthbook.GrowthBookProvider;
import io.github.growthbook.Options;
import dev.openfeature.sdk.OpenFeatureAPI;
import dev.openfeature.sdk.Client;

Options options = Options.builder()
    .apiHost("https://cdn.growthbook.io")
    .clientKey("sdk-abc123")
    .build();

GrowthBookProvider provider = new GrowthBookProvider(options);
OpenFeatureAPI.getInstance().setProvider(provider);
Client client = OpenFeatureAPI.getInstance().getClient();

Evaluation Context (Targeting Attributes)

Pass user attributes to the OpenFeature client via an EvaluationContext. These become GrowthBook targeting attributes used for percentage rollouts, feature targeting rules, and experiment bucketing. GrowthBook buckets users on the id attribute by default. The Python, .NET, and Java providers map the OpenFeature targetingKey to id for you. The JavaScript and Go providers do not — they pass the context through unchanged, so you must set id yourself.

If id is missing, GrowthBook has nothing to hash on: percentage rollouts return their default value and experiments never assign a variation. Nothing raises an error, so the flag simply appears to be off. Set targetingKey and id to the same value — id does the bucketing today, and the pair keeps your code portable to providers that read targetingKey.

Additional attributes (e.g. country, plan, email) are matched against your feature flag targeting conditions. The JavaScript examples use the Node.js server SDK, which accepts an invocation-level context. On the web SDK, call await OpenFeature.setContext(context) instead of passing context into each evaluation.

const context = {
  // The JS providers do not map targetingKey — GrowthBook buckets on `id`.
  targetingKey: "user-123",
  id: "user-123",
  country: "US",
  plan: "premium",
  email: "user@example.com",
};

from openfeature.evaluation_context import EvaluationContext

context = EvaluationContext(
    targeting_key="user-123",
    attributes={
        "country": "US",
        "plan": "premium",
        "email": "user@example.com",
    }
)

evalCtx := openfeature.NewEvaluationContext("user-123", map[string]interface{}{
    // The Go provider does not map targetingKey — GrowthBook buckets on `id`.
    "id":      "user-123",
    "country": "US",
    "plan":    "premium",
    "email":   "user@example.com",
})

var context = new EvaluationContext(
    targetingKey: "user-123",
    new Dictionary<string, Value>
    {
        { "country", new Value("US") },
        { "plan",    new Value("premium") },
        { "email",   new Value("user@example.com") },
    }
);

import dev.openfeature.sdk.EvaluationContext;
import dev.openfeature.sdk.MutableContext;

MutableContext context = new MutableContext("user-123");
context.add("country", "US");
context.add("plan", "premium");
context.add("email", "user@example.com");

Evaluating Feature Flags

OpenFeature defines five value types. GrowthBook’s feature flags map to all of them. The JavaScript examples below use the Node.js server SDK, where evaluations are asynchronous and take an invocation-level context. On the web SDK the same calls are synchronous and take no context argument — they read the global context set via await OpenFeature.setContext(...):

// Web SDK equivalent
const enabled = client.getBooleanValue("dark-mode", false);

The JavaScript providers return GrowthBook’s own source string as the evaluation reason (e.g. experiment, force, defaultValue) rather than the standard OpenFeature reasons such as TARGETING_MATCH or STATIC. Code that branches on details.reason is not portable across providers.

Boolean

The most common type — use for on/off feature gates.

// Server SDK (async)
const enabled = await client.getBooleanValue("dark-mode", false, context);

// Returns full evaluation details (value, reason, variant, error)
const details = await client.getBooleanDetails("dark-mode", false, context);

# Synchronous
enabled = client.get_boolean_value("dark-mode", False, context)

# Async (returns FlagEvaluationDetails with value, reason, variant, etc.)
details = await provider.resolve_boolean_details_async("dark-mode", False, context)
enabled = details.value

// Returns the value with a default fallback
enabled, err := client.BooleanValue(context.Background(), "dark-mode", false, evalCtx)

// Returns full evaluation details (value, reason, variant, error)
details, err := client.BooleanValueDetails(context.Background(), "dark-mode", false, evalCtx)
enabled := details.Value

bool enabled = await client.GetBooleanValue("dark-mode", false, context);

boolean enabled = client.getBooleanValue("dark-mode", false, context);

String

Use for multi-variant flags where the value is a string (e.g. button color, layout variant).

const variant = await client.getStringValue("button-color", "blue", context);

variant = client.get_string_value("button-color", "blue", context)

variant, err := client.StringValue(context.Background(), "button-color", "blue", evalCtx)

string variant = await client.GetStringValue("button-color", "blue", context);

String variant = client.getStringValue("button-color", "blue", context);

Integer & Float/Double

Use for numeric feature values such as rate limits, timeouts, or pricing.

const requestLimit = await client.getNumberValue("api-request-limit", 100, context);
const price = await client.getNumberValue("subscription-price", 9.99, context);

request_limit = client.get_integer_value("api-request-limit", 100, context)
price         = client.get_float_value("subscription-price", 9.99, context)

requestLimit, err := client.IntValue(context.Background(), "api-request-limit", 100, evalCtx)
price, err         := client.FloatValue(context.Background(), "subscription-price", 9.99, evalCtx)

int    requestLimit = await client.GetIntegerValue("api-request-limit", 100, context);
double price        = await client.GetDoubleValue("subscription-price", 9.99, context);

int    requestLimit = client.getIntegerValue("api-request-limit", 100, context);
double price        = client.getDoubleValue("subscription-price", 9.99, context);

Object

Use for structured feature values (e.g. configuration payloads, theme objects).

const config = await client.getObjectValue("theme-config", { color: "blue" }, context);

config = client.get_object_value("theme-config", {"color": "blue"}, context)

// Object values are returned as map[string]interface{}
config, err := client.ObjectValue(context.Background(), "theme-config", map[string]interface{}{}, evalCtx)

Value config = await client.GetObjectValue("theme-config",
    new Value(new Dictionary<string, Value>()), context);

Value config = client.getObjectValue("theme-config", new MutableStructure(), context);

Configuration Options

Option	JavaScript	Python	Go	.NET	Java	Description
`api_host` / `apiHost`	✓	✓	✓	✓	✓	GrowthBook CDN or self-hosted URL
`client_key` / `clientKey`	✓	✓	✓	✓	✓	SDK Connection key from GrowthBook
`decryption_key`	✓	✓	—	—	—	Key for encrypted SDK endpoint payloads
`cache_ttl`	✓*	✓	✓	—	—	Seconds before re-fetching features (default: 60)
`enabled`	✓	✓	—	✓	—	Enable/disable the provider entirely
`qa_mode`	✓	✓	—	—	—	Forces all experiments into the control variation

* In JavaScript, cache_ttl lives on the provider’s optional second argument as { cacheSettings: { staleTTL: 60000 } } rather than in the client options object. Every other JavaScript option in this table goes in the client options object.

Shutdown & Cleanup

Always shut down the provider when your application exits to close background connections.

await OpenFeature.close();

await provider.close()       # async
# or
provider.close_sync()        # sync

defer gbClient.Close()

provider.Dispose();

provider.shutdown();

​Prerequisites

​Why Use OpenFeature with GrowthBook?

​Installation & Setup

​Evaluation Context (Targeting Attributes)

​Evaluating Feature Flags

​Boolean

​String

​Integer & Float/Double

​Object

​Configuration Options

​Shutdown & Cleanup

​Further Reading

Prerequisites

Why Use OpenFeature with GrowthBook?

Installation & Setup

Evaluation Context (Targeting Attributes)

Evaluating Feature Flags

Boolean

String

Integer & Float/Double

Object

Configuration Options

Shutdown & Cleanup

Further Reading