For AI agents: a documentation index is available at the root level at /llms.txt and /llms-full.txt. Append /llms.txt to any URL for a page-level index, or .md for the markdown version of any page.
Sign inTry it free
DocsGuidesSDKsIntegrationsAPI docsTutorialsFlagship blog
DocsGuidesSDKsIntegrationsAPI docsTutorialsFlagship blog
  • Get started
    • Overview
    • Onboarding
    • Get started
      • Developer tools
      • Setting up an SDK
      • Joining an account
      • Using feature management
      • Getting started in different roles
    • Launch Insights
    • LaunchDarkly architecture
    • LaunchDarkly vocabulary
  • AgentControl
    • AgentControl
    • Manage AgentControl
  • Feature flags
    • Create flags
    • Target with flags
    • Flag templates
    • Manage flags
    • Code references
    • Contexts
    • Segments
  • Releases
    • Releasing features with LaunchDarkly
    • Release policies
    • Percentage rollouts
    • Progressive rollouts
    • Guarded rollouts
    • Feature monitoring
    • Release pipelines
    • Engineering insights
    • Release management tools
    • Applications and app versions
    • Change history
    • Restoring previous flag versions
  • Observability
    • Observability
    • Session replay
    • Error monitoring
    • Logs
    • Traces
    • Observability metrics
    • Product analytics events
    • LLM observability
    • Alerts
    • Dashboards
    • Service map
    • Vega for auto-remediation
    • Observability MCP server
    • Search specification
    • Observability settings
    • Observability integrations
  • Experimentation
    • Experimentation
    • Experiment metric types
    • Experiment configuration
    • Managing experiments
    • Analyzing experiments
    • Multi-armed bandits
    • Holdouts
  • Metrics and events
    • Metrics in LaunchDarkly
    • Creating metrics
    • Metric groups
    • Events
    • Autogenerated metrics
  • Warehouse native
    • Warehouse native metrics
    • Setting up external warehouses
    • Creating experiments using warehouse native metrics
  • Infrastructure
    • Connect apps and services to LaunchDarkly
    • LaunchDarkly in China and Pakistan
    • LaunchDarkly in the European Union (EU)
    • LaunchDarkly in federal environments
    • Public IP list
  • Your account
    • Projects
    • Views
    • Environments
    • Tags
    • Teams
    • Members
    • Roles
    • Account security
    • Feature previews
    • Billing and usage
    • Changelog
Sign inTry it free
LogoLogo
On this page
  • Overview
  • Setting up an SDK
  • Editor support
  • Flag evaluations are always available
  • Next steps
Get startedGet started

Setting up an SDK

Was this page helpful?
Previous

Joining an account

Next
Built with

Overview

This topic explains how to set up an SDK to begin using LaunchDarkly.

Prefer to set up your SDK interactively?

Try our Quickstart guide or CLI to set up your first flag, SDK, and sample application.

Setting up an SDK

The steps to integrate your application with LaunchDarkly are similar across all SDKs. We provide a variety of server-side, client-side, mobile, and edge SDKs to choose from. To learn more about choosing an SDK, read Choosing an SDK type.

We provide reference documentation for all SDKs under SDKs, including how to get started with each SDK and where to find SDK API documentation, sample applications, public GitHub repositories, and published modules.

Setting up an SDK is similar no matter which SDK you choose. Find specifics in the reference documentation for each SDK. You can also go quickly through an abbreviated setup process in the LaunchDarkly quickstart.

To incorporate a LaunchDarkly SDK into your application:

  1. Install the LaunchDarkly SDK in your application using your project’s dependency manager. This lets your application access the LaunchDarkly SDK.
  1. Initialize the LaunchDarkly client in your application code. This client is the primary way your application uses the SDK and communicates with LaunchDarkly.
  2. Configure the LaunchDarkly client with the appropriate key for your environment. Your SDK key, client-side ID, and mobile key uniquely identify your project and environment, and they authorize your application to connect to LaunchDarkly. In most SDKs, you set this configuration during the initialization step. To learn how to find the appropriate SDK credential, read SDK credentials.
  3. Evaluate each feature flag for a specific context. A context is a generalized way of referring to the people, services, machines, or other resources that encounter feature flags in your product. You can set the attributes for each context in your application. Every feature flag is uniquely identified by a feature flag key. Each SDK provides methods to take the flag key and context and determine which flag variation each context should receive.
Adding contexts to LaunchDarkly

You don’t have to send contexts to LaunchDarkly in advance. After you create contexts in your SDK, you can target them with feature flags before they appear on your Contexts list. Contexts that exist in your SDK appear in the Contexts list automatically after they encounter feature flags.

  1. Shut down the LaunchDarkly client when your application is about to terminate. The client releases the resources it is using and sends pending analytics events to LaunchDarkly, if any. If your application quits without this shutdown step, requests and the Contexts list may not be populated, because they are derived from analytics events.

Editor support

SDK documentation appears in your editor if the editor supports surfacing doc comments. LaunchDarkly offers further integrations for VSCode or IntelliJ IDEA.

These integrations have extended functionality based on Code References aliases. If your team uses aliases to find all flag usage throughout your codebase, you will also have hover documentation wherever those aliases appear. To learn more, read Code references.

Flag evaluations are always available

If the SDK you use loses the connection with LaunchDarkly, your feature flags will still work. The SDK relies on its stored state to evaluate flags. No network communication is required when you evaluate a flag.

By default, an SDK initializes with an empty state. When the SDK first initializes, it opens a streaming connection to LaunchDarkly. The response from LaunchDarkly contains the SDK’s current state, which your SDK uses to make any necessary changes to feature flags. After the initial update, the SDK keeps a streaming connection open to LaunchDarkly. If you make a change in the Flags list or with the REST API, LaunchDarkly sends these changes to all connected SDKs automatically.

If you evaluate a flag before the SDK receives its initial state, or if you try to fetch a flag which otherwise doesn’t exist, or if the SDK is unable to initialize, then the SDK returns a fallback value. You can specify the fallback value in your flag evaluation code. To increase connection resiliency for server-side SDKs, multiple options are available. They are:

  • use a persistent feature store,
  • use the Relay Proxy, or
  • use daemon mode.

SDKs may periodically drop streaming connections. When an SDK loses connectivity to LaunchDarkly, it continues to try to reestablish a streaming connection until it succeeds. If an SDK had a connection to LaunchDarkly at some point, it retains its last known flag values if LaunchDarkly is unavailable.

To learn more about how SDKs handle receiving updates, read Receiving updates from LaunchDarkly.

All SDKs provide synchronous and asynchronous ways of waiting for the SDK’s state to initialize.

Next steps

After you have set up an SDK, you can manage features on your Flags list. To learn more, read The Flags list.

When you’re ready to test your application, use the Live events page to get a real-time view of your feature flag requests as they’re received. To learn more, read Live events.

As you begin using feature flags, here are some useful features you can use without re-deploying your application:

  • Target with flags
  • Percentage rollouts
  • Experimentation