Migrate between protocols, providers, and from other feature flag platforms

Migration Guide

Guides for common migration scenarios when working with Flaggr.

REST to gRPC

Switch from REST evaluation to gRPC for lower latency and streaming updates.

Install gRPC dependencies

Ensure your environment supports HTTP/2 and gRPC. No additional packages needed — the Flaggr client includes gRPC support.

Update provider configuration

Replace FlaggrProvider with GrpcProvider:

// Before: REST
const provider = new FlaggrProvider({
  apiUrl: 'https://flaggr.dev',
  apiToken: 'flg_your_token',
  serviceId: 'my-service',
})
 
// After: gRPC
const provider = new GrpcProvider({
  grpcAddress: 'flaggr.dev:50051',
  apiToken: 'flg_your_token',
  serviceId: 'my-service',
  localEvaluation: true,
  enableFallback: true, // Falls back to REST if gRPC unavailable
})

Enable fallback (recommended)

Keep enableFallback: true during migration. If gRPC has issues, the provider silently falls back to REST evaluation.

Monitor and remove fallback

Once gRPC is stable, you can optionally disable fallback for stricter error handling.

SSE to gRPC Streaming

Switch from Server-Sent Events to gRPC streaming for bidirectional communication.

Replace EventSource with gRPC provider

// Before: SSE via Web Provider
const provider = new FlaggrWebProvider({
  enableStreaming: true,
  serviceId: 'my-service',
})
 
// After: gRPC streaming
const provider = new GrpcProvider({
  grpcAddress: 'flaggr.dev:50051',
  serviceId: 'my-service',
  localEvaluation: true,
})

Update connection monitoring

Both providers emit the same ConnectionState events, so your monitoring code works unchanged.

Update event handlers

Flag change events have the same shape regardless of transport. No handler changes needed.

Note

gRPC streaming is for server-side use. In browsers, continue using SSE via FlaggrWebProvider — gRPC-Web doesn't support true server-side streaming in all browsers.

Polling to Streaming

Replace periodic API polling with real-time updates.

Enable streaming on the web provider

// Before: Polling (default)
const provider = new FlaggrWebProvider({
  serviceId: 'web-app',
  // Polls every 5s by default
})
 
// After: SSE streaming
const provider = new FlaggrWebProvider({
  serviceId: 'web-app',
  enableStreaming: true, // Switches to SSE
})

Remove custom polling logic

If you implemented custom polling with setInterval, remove it. The provider handles updates automatically.

Add connection state monitoring

provider.onConnectionStateChange((state) => {
  if (state === 'DISCONNECTED') {
    // Optional: show user notification
  }
})

From Other Platforms

From LaunchDarkly

Export flag configuration

Export your flag configurations from LaunchDarkly and reformat for Flaggr's import format.

Map concepts

LaunchDarkly	Flaggr
Project	Project
Environment	Environment
Feature Flag	Feature Flag
Targeting Rule	Targeting Rule
User Segment	Condition Group
Variation	Variant
SDK Key	API Token

Replace SDK

// Before: LaunchDarkly
import { init } from 'launchdarkly-js-client-sdk'
const client = init('sdk-key', { key: 'user-123' })
const value = client.variation('my-flag', false)
 
// After: Flaggr
import { createFlaggr } from '@flaggr/sdk'
const client = createFlaggr({
  serviceId: 'web-app',
  apiKey: 'flg_your_token',
})
const value = await client.getBooleanValue('my-flag', false)

Import flags

Use the bulk import endpoint to create flags in Flaggr:

POST /api/flags/import

From Split.io

Map concepts

Split.io	Flaggr
Workspace	Project
Environment	Environment
Split	Feature Flag
Treatment	Variant
Targeting Rule	Targeting Rule
Traffic Type	Service

Replace SDK

// Before: Split
import { SplitFactory } from '@splitsoftware/splitio'
const factory = SplitFactory({ core: { authorizationKey: 'key' } })
const client = factory.client()
const treatment = client.getTreatment('user-123', 'my-split')
 
// After: Flaggr
import { createFlaggr } from '@flaggr/sdk'
const client = createFlaggr({
  serviceId: 'web-app',
  apiKey: 'flg_your_token',
})
const value = await client.getStringValue('my-split', 'off')

Using OpenFeature for Migration

Smooth Migration

Use the OpenFeature SDK as an abstraction layer. Switch providers without changing your evaluation code.

import { OpenFeature } from '@openfeature/server-sdk'
 
// Step 1: Start with your current provider
OpenFeature.setProvider(currentProvider)
 
// Step 2: Switch to Flaggr provider
import { FlaggrProvider } from '@flaggr/client'
OpenFeature.setProvider(new FlaggrProvider({
  apiUrl: 'https://flaggr.dev',
  serviceId: 'my-service',
  apiToken: 'flg_your_token',
}))
 
// Your evaluation code stays the same
const client = OpenFeature.getClient()
const value = await client.getBooleanValue('my-flag', false)