Provider Starters
One Maven module per flag backend: unleash, configcat, datadog, envvar, flagd, flagsmith, flipt, gofeatureflag, jsonlogic, statsig, growthbook, gcp, ofrep, optimizely, launchdarkly, split, devcycle, featbit, featureflip, mixpanel, kameleoon, confidence, octopusdeploy, vwo, superposition, ageris, cloudbees, configdirector, plus multiprovider (features/multi-provider).
The shared pattern
UnleashAutoConfiguration is the reference implementation. Each provider auto-config:
@AutoConfigureBefore({ClientAutoConfiguration.class, MultiProviderAutoConfiguration})— the provider bean must exist before the client is built (flows/startup-flow).@ConditionalOnClass(<Provider>.class)— activates only when the provider library is on the classpath.@ConditionalOnProperty(prefix = ..., name = "enabled", matchIfMissing = true)— opt-out viaspring.openfeature.<provider>.enabled=false.@EnableConfigurationProperties(<Provider>Properties.class)— bindsspring.openfeature.<provider>.*.- Declares
@Bean @ConditionalOnMissingBeanfor the provider's config object and theFeatureProvider.
Provider-specific notes
- Unleash:
UnleashProperties(spring.openfeature.unleash.*) maps toUnleashConfig— API URL, token (sent asAuthorizationheader), app name, environment, optionalbackupFilelocal cache. - EnvVar: reads flags from environment variables via
System.getenv; exposesEnvironmentGatewayandEnvironmentKeyTransformerbeans so consumers can swap them. No customizer interface. - GCP:
GcpProperties(spring.openfeature.gcp.*) points at a Google Secret Manager secret holding a flag config; a fake provider backs the runnablegcp-simpleexample. - OFREP: binds to an OpenFeature Remote Evaluation Protocol endpoint (
spring.openfeature.ofrep.*). The provider has no public constructor — the starter builds it via theconstructProviderfactory, which validates the base URL. - Optimizely:
OptimizelyProperties(spring.openfeature.optimizely.*) assembles the vendor SDK'sConfiguration(datafile or sdk-key). The SDK's config parser importsorg.jsonwithout declaring it, so the BOM managesorg.json:jsonexplicitly. - LaunchDarkly:
LaunchDarklyProperties(spring.openfeature.launchdarkly.*) bindsservice-key(the environment is encoded in the key) andoffline. The LaunchDarkly OpenFeature provider is vendor-published (com.launchdarkly:launchdarkly-openfeature-serverprovider), and its POM ships the LaunchDarkly server SDK inruntimescope, so the module declareslaunchdarkly-java-server-sdkexplicitly to compile againstLDConfig. Data-source selection (streaming/polling/file) goes through theLaunchDarklyCustomizer; the contract tests run credential-free via a file data source +events(Components.noEvents()). - Datadog:
DatadogProperties(spring.openfeature.datadog.*) binds api-key/app-key/site (required, fail-fast) plusinit-timeoutandevaluation-telemetry-opt-outfor the provider'sOptions. The provider has no programmatic credential API, so the starter publishes the bound values asDD_API_KEY/DD_SITE/DD_ENVsystem properties only when not already set — the dd-trace settings then pick them up. The provider constructor is lazy; real initialization requires thedd-java-agent. - Split:
SplitProperties(spring.openfeature.split.*) supplies theauthorization-keyand an optionaldomainendpoint override. The Split SDK's factory is built eagerly, so the starter assembles aSplitProviderOptions(key +SplitClientConfig) and fails fast when the key is unset; finerSplitClientConfigtuning goes through theSplitCustomizerbean. A fake provider backs the runnablesplit-simpleexample. - DevCycle:
DevCycleProperties(spring.openfeature.devcycle.*) bindsserver-side-key(required; must start withdvc_server) andbase-url-override. The OpenFeature provider (com.devcycle.sdk.server.openfeature.DevCycleProvider) ships inside the vendor-publishedcom.devcycle:java-server-sdk; the starter wraps aDevCycleCloudClientaround it. The client constructor is network-lazy (no connection until the first evaluation) and runs no background threads, so the contract tests run credential-free by pointingbase-url-overrideat aMockWebServer. The module pinsdev.openfeature:sdkto the repo'ssdk.versionbecause the DevCycle SDK transitively pulls an older SDK at compile scope. - FeatBit:
FeatBitProperties(spring.openfeature.featbit.*) bindstoken,streaming-urlandevent-url(all required, fail-fast) plusofflineanddisable-events. The vendor-published provider (co.featbit:featbit-openfeature-provider-java-server) has an eager constructor — it always builds anFBClient— so the contract tests run credential-free in offline mode (offline=true), which wires a null data-synchronizer and a null insight processor and opens no connection. The module declaresfeatbit-java-sdkexplicitly and pinsdev.openfeature:sdklockstep. - Featureflip:
FeatureflipProperties(spring.openfeature.featureflip.*) bindsapi-key(required, fail-fast) plus an optionalbase-urlendpoint override; the target environment is encoded in the SDK key itself, so there is no separate environment property. The provider (io.featureflip:featureflip-openfeature) is vendor-published by Canopy Labs, its constructor is lazy (bytecode-verified — no I/O untilinitialize()), and the contract tests run credential-free by stubbingOpenFeatureAPIso the real provider is constructed but never initialized. - Mixpanel:
MixpanelProperties(spring.openfeature.mixpanel.*) bindsproject-token(required, fail-fast) plus optionalapi-hostandrequest-timeout-seconds. The vendor-published provider (com.mixpanel:mixpanel-java-openfeature) is wired in remote-evaluation mode — its constructor is lazy (no network I/O until the first flag evaluation), so the contract tests construct the real provider with a fake token and never open a connection. The module pinsdev.openfeature:sdkto the repo'ssdk.versionbecause the provider transitively pulls an older SDK. - Kameleoon:
KameleoonProperties(spring.openfeature.kameleoon.*) bindssite-code,client-idandclient-secret(all required, fail-fast) plus optionalenvironment,top-level-domain,refresh-interval,session-duration,default-timeoutandtracking-interval. The provider (com.kameleoon:kameleoon-openfeature-java) is vendor-published by Kameleoon and its constructor is eager (it opens a background connection), so the contract tests construct it via a MockitomockConstruction. The module pinsdev.openfeature:sdkto the repo'ssdk.version(the vendor provider transitively declares an older SDK) and declarescom.kameleoon:kameleoon-client-java:${kameleoon-client-java.version}directly; finerKameleoonClientConfig.Buildertuning (e.g. a proxy host) goes through theKameleoonCustomizerbean. - Confidence:
ConfidenceProperties(spring.openfeature.confidence.*) bindsapi-token(required, fail-fast) plus optionalhost/portendpoint overrides (default port 443). The provider (com.spotify.confidence:openfeature-provider) is vendor-published by Spotify as part ofconfidence-sdk-java; the starter assembles aConfidenceProviderOptions(token +Confidence.Builder) and theConfidenceCustomizerbean tunes the builder. The constructor is lazy (bytecode-verified — only a gRPC channel is built, no connection until the first RPC) and the provider does not overrideinitialize(), so the contract tests construct the genuine provider credential-free. The module pinsdev.openfeature:sdkto the repo'ssdk.versionbecause the provider transitively pulls an older SDK at compile scope. - Octopus Deploy:
OctopusDeployProperties(spring.openfeature.octopusdeploy.*) bindsclient-identifier(the API key, required, fail-fast) andproduct-name(required, fail-fast) plus optionalproduct-versionandcache-duration. The provider (com.octopus.openfeature:octopus-openfeature-provider) is vendor-published by Octopus Deploy; its constructor is lazy (no network I/O untilinitialize()), and the contract tests run credential-free. - VWO:
VwoProperties(spring.openfeature.vwo.*) bindsaccount-id(required, fail-fast, must be numeric) andapi-key(required, fail-fast). The provider (com.vwo.sdk:vwo-openfeature-provider-java) is vendor-published by VWO; the starter assembles aVwoProviderOptions(the options map theVWOProvideris built from) and theVwoCustomizerbean tunes it. The provider constructor is eager — it calls the staticVWO.initfactory, which initializes the VWO client against the VWO service — so the contract tests construct it inside a MockitomockStaticofcom.vwo.VWO. The module pinsdev.openfeature:sdkto the repo'ssdk.version(the vendor provider transitively declares an older SDK) and declarescom.vwo.sdk:vwo-fme-java-sdkdirectly (the provider ships it at runtime scope, but the starter compiles againstcom.vwo.VWO). - Superposition:
SuperpositionProperties(spring.openfeature.superposition.*) bindsapi-key,org-idandworkspace-id(all required, fail-fast) plus optionalendpoint(defaulthttps://api.superposition.dev) andrefresh-timeout-millis/refresh-interval-millis(defaults 10000/5000 ms). The provider (io.juspay.superposition:openfeature-provider) is vendor-published by Juspay and its constructor is network-lazy (the config-refresh jobs only start ininitialize()), so the contract tests construct the real provider with fake credentials and never open a connection. The vendor options builder rejects null values with a bareNullPointerException, so the starter validates the credentials before building. The module pinsdev.openfeature:sdkto the repo'ssdk.version(the vendor provider transitively declares an older SDK); finerSuperpositionProviderOptions.Buildertuning (e.g. a fallback config or experimentation options) goes through theSuperpositionCustomizerbean. - Ageris:
AgerisProperties(spring.openfeature.ageris.*) is file-based — Ageris has no API key:application,path(the base directory; the fetcher reads the files from<path>/<application>/) andfeature-flag-files(at least one) are required, fail-fast, plus optionaljson-config-files,targeting-key-type,refresh-intervalandfirst-load-timeout. The vendor-published provider (io.github.lichtsinn:ageris-openfeature) takes the feature-flag manager, the JSON-config manager and a not-yet-startedConfigurationLoader; its constructor is lazy, butinitialize()starts the loader on a non-daemon scheduled executor.AgerisProviderextends the SDK'sEventProvider, whoseattach()touches a final field a Mockito construction mock leaves null, so the contract test that registers the provider with OpenFeature points the real provider at real temp files, asserts a flag lookup, and shuts the provider down; the assembly tests construct the real provider with fake paths and never register it. The provider declaresdev.openfeature:sdkinprovidedscope (built against the repo'ssdk.version), so no lockstep pin is needed. - CloudBees:
CloudbeesProperties(spring.openfeature.cloudbees.*) bindsapi-key(required, fail-fast) and an optionalendpointoverride of the Rox service URL. The provider (com.cloudbees.openfeature:cloudbees-openfeature-provider) is vendor-published by CloudBees; the starter assembles aCloudbeesProviderOptions(theRoxOptionstheCloudbeesProvideris built from) and theCloudbeesCustomizerbean tunes theRoxOptions.Builder. The provider constructor is eager — it calls the staticRox.setupfactory, which initializes the client against the Rox service — so the contract tests construct it inside a MockitomockStaticofio.rollout.rox.server.Rox. The module pinsdev.openfeature:sdkto the repo'ssdk.version(the vendor provider transitively declares an older SDK). - ConfigDirector:
ConfigDirectorProperties(spring.openfeature.configdirector.*) bindsapi-key(required, fail-fast) plus optionalurl(endpoint; the ConfigDirector default applies). The provider (com.configdirector:configdirector-openfeature-server-provider, Central line stops at 1.4.0 — the vendor repo's 1.9.0 line is not on Central) extends the SDK'sEventProvider; its constructor is lazy (no I/O until OpenFeature callsinitialize(), which starts a background eventsource against the endpoint), so the contract tests construct the real provider with a fake key and point the one registered test at a refused localhost port, shutting the provider down afterwards. The provider's transitive OkHttp 5 is the KMP root artifact whose Central jar is empty, so the starter excludes it and declaresokhttp-jvm(version from the repo'sokhttp-bomimport); it also pinsdev.openfeature:sdkto the repo'ssdk.version(the provider transitively declares an older SDK). Connection mode, polling interval, timeouts, metadata and telemetry go through theConfigDirectorCustomizerbean. - Most others (configcat, flagd, flagsmith, flipt, gofeatureflag, jsonlogic, statsig, growthbook) follow the same shape with their own
Properties+Customizer.
Adding a new provider
Copy the Unleash module: properties, customizer, auto-configuration, pom.xml, the AutoConfiguration.imports registration, and ApplicationContextRunner-style tests. Then add the module + version property to the root pom.xml and the BOM.
The full behavioral contract — one FeatureProvider plus one Client, back-off when a
consumer supplies their own provider, declarative enablement, customizer application,
credential-free unit tests — along with the per-provider deltas, the add-a-starter
checklist and the divergences found while consolidating the retired specs, lives in
docs/provider-starter-contract.md. Read that
divergences list before trusting a remembered requirement: the Octopus Deploy and FeatBit
modules require properties the old specs never named. See overview/design-docs.
Extension points: concepts/customizers. Config reference: entities/configuration-properties.
Per-provider documentation
Each provider starter module ships a README.md with its full spring.openfeature.<provider>.* property table, a configuration example, and a short usage snippet. The root README.md links to all of them from the provider table.
Example apps
Every provider starter pairs with a runnable <provider>-simple example in the examples/ reactor (30 modules total including unleash-advanced). Each boots without vendor credentials via a @Primary fake FeatureProvider gated on --example.fake-provider=true; the real provider auto-config backs off entirely. See reference/build-and-modules for the full list.