Identifying and changing contexts

You can use the Identify or IdentifyAsync method to switch contexts. This loads any saved flag values for the next context, and tells the client to change the current context and obtain the feature flag values for the new context.

In some situations, the new context may be an updated version of the existing context. For example, on a sign-in page in a single-page app, you could represent the same person as an anonymous user before they log in, and a different user after they log in. After the person logs in, you can call Identify() or IdentifyAsync() so that the person receives the correct feature flag settings for their account.

In other situations, the new context may be a multi-context, that is, a set of several different contexts that you want to evaluate together. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of "device." When the end user logs in, you now also have their user and organization information. You can call Identify() with a multi-context that contains the "device," "user," and "organization" contexts for the end user.

You may want to wait until the flag values for the new context have been loaded before proceeding. You can do this either by calling the synchronous method Identify with a timeout, or by calling the asynchronous method IdentifyAsync and awaiting the result.

Here's how:

var updatedContext = Context.Builder("context-key-123abc")
    .Set("email", "sandy@example.com")
    .Build();
// Synchronous method
client.Identify(updatedContext, TimeSpan.FromSeconds(5));
// Asynchronous method
await client.IdentifyAsync(updatedContext);
COPY

To learn more, read Identify and IdentifyAsync.

The identify() method tells the client to change the current context and obtain the feature flag values for the new context.

In some situations, the new context may be an updated version of the existing context. For example, on a sign-in page in a single-page app, you could represent the same person as an anonymous user before they log in, and a different user after they log in. You can initialize the client with an anonymous context with a context kind of "user." After the person logs in, you can update the user context and call identify() so that the person receives the correct feature flag settings for their account.

In other situations, the new context may be a multi-context, that is, a set of several different contexts that you want to evaluate together. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of "device." When the end user logs in, you now also have their user and organization information. You can call identify() with a multi-context that contains the "device," "user," and "organization" contexts for the end user.

Here's how:

LDContext updatedContext = LDContext.builderFromContext(context)
    .email("sandy@example.com")
    .build();
client.identify(updatedContext);
COPY

The identify() call loads any saved flag values for the new user context and immediately triggers an update of the latest flags from LaunchDarkly.

identify() returns a Future to indicate completion. If you want to be sure subsequent code is using the latest values from the server, you can wait for the Future using get.

To learn more, read identify.

The Identify() method tells the client to change the current user and obtain the feature flag values for the new user.

In some situations, the new user may be an updated version of the existing user. For example, on a sign-in page in a single-page app, you could represent the same person as an anonymous user before they log in, and a different user after they log in. After the person logs in, you can call Identify so that the person receives the correct feature flag settings for their account.

You can use the LDClientIdentify method to switch users:

LDClientIdentify(client, newUser);
COPY

The LDClientIdentify() call loads any saved flag values for the new user and immediately trigger an update of the latest flags from LaunchDarkly. Because this method re-fetches flag settings for the new user, you should should not call it at high frequency. The intended use case for switching user contexts is the login/logout flow. To learn more, read LDClientIdentify.

The identify() method tells the client to change the current user and obtain the feature flag values for the new user.

In some situations, the new user may be an updated version of the existing user. For example, on a sign-in page in a single-page app, you could represent the same person as an anonymous user before they log in, and a different user after they log in. After the person logs in, you can call identify() so that the person receives the correct feature flag settings for their account.

Here's how:

const newUser = { key: 'user-key-123abc', name: 'Sandy' };
client.identify(newUser, (newFlags) => {
  console.log('value of flag for this user is: ' + newFlags['flag-key-123abc']);
  console.log('this should be the same: ' + client.variation('flag-key-123abc'));
});
// or:
client.identify(newUser).then((newFlags) => {
  // as above
});
COPY

To learn more, read identify.

The identify() method tells the client to change the current user and obtain the feature flag values for the new user.

In some situations, the new user may be an updated version of the existing user. For example, on a sign-in page in a single-page app, you could represent the same person as an anonymous user before they log in, and a different user after they log in. After the person logs in, you can call identify() so that the person receives the correct feature flag settings for their account.

Here's how:

LDUser updatedUser = LDUserBuilder('user key')
    .email('sandy@example.com')
    .build();
await LDClient.identify(updatedUser);
COPY

To learn more, read identify method.

The identify() method tells the client to change the current context and obtain the feature flag values for the new context.

In some situations, the new context may be an updated version of the existing context. For example, on a sign-in page in a single-page app, you could represent the same person as an anonymous user before they log in, and a different user after they log in. You can initialize the client with an anonymous context with a context kind of "user." After the person logs in, you can update the user context and call identify() so that the person receives the correct feature flag settings for their account.

In other situations, the new context may be a multi-context, that is, a set of several different contexts that you want to evaluate together. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of "device." When the end user logs in, you now also have their user and organization information. You can call identify() with a multi-context that contains the "device," "user," and "organization" contexts for the end user.

If the client app does not identify an LDContext, LDClient creates an anonymous default context, which can affect which feature flags LaunchDarkly delivers to the LDClient. Client apps should follow the Apple Privacy Policy when collecting end user information.

Here's how:

let newContext = try LDContextBuilder(key: "context-key-123abc").build().get();
// You can also call identify with a completion
LDClient.get()!.identify(context: newContext) {
    // Flags have been retrieved for the new context
}
COPY

To learn more, read identify.

The identify() method tells the client to change the current context and obtain the feature flag values for the new context.

In some situations, the new context may be an updated version of the existing context. For example, on a sign-in page in a single-page app, you could represent the same person as an anonymous user before they log in, and a different user after they log in. You can initialize the client with an anonymous context with a context kind of "user." After the person logs in, you can update the user context and call identify() so that the person receives the correct feature flag settings for their account.

In other situations, the new context may be a multi-context, that is, a set of several different contexts that you want to evaluate together. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of "device." When the end user logs in, you now also have their user and organization information. You can call identify() with a multi-context that contains the "device," "user," and "organization" contexts for the end user.

If you provide a callback function, it is called with a map of flag keys and values after the flag values for the new context are available. After that point, variation() uses the new values. You can also use a Promise for the same purpose.

Here's how:

client.identify(newContext, hash, function() {
  console.log("New context's flags available");
});
COPY

To learn more, read identify.

If your contexts are extraordinarily large, you may need to configure the JavaScript SDK to send the evaluation context as a request body. To learn more, read Using REPORT in the JavaScript SDK.

The identify() method tells the client to change the current user and obtain the feature flag values for the new user.

In some situations, the new user may be an updated version of the existing user. For example, on a sign-in page in a single-page app, you could represent the same person as an anonymous user before they log in, and a different user after they log in. After the person logs in, you can call identify() so that the person receives the correct feature flag settings for their account.

In other situations, the new context may be a multi-context, that is, a set of several different contexts that you want to evaluate together. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of "device." When the end user logs in, you now also have their user information. You can call identify() with a multi-context that contains the "device" and "user" contexts for the end user.

Here's how:

client.identify(newContext, () => {
  console.log("New context's flags available");
});
// or, with a Promise:
client.identify(newContext).then(() => {
  console.log("New context's flags available");
});
COPY

To learn more, read identify.

The identify() method tells the client to change the current context and obtain the feature flag values for the new context.

In some situations, the new context may be an updated version of the existing context. For example, on a sign-in page in a single-page app, you could represent the same person as an anonymous user before they log in, and a different user after they log in. You can initialize the client with an anonymous context with a context kind of "user." After the person logs in, you can update the user context and call identify() so that the person receives the correct feature flag settings for their account.

In other situations, the new context may be a multi-context, that is, a set of several different contexts that you want to evaluate together. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of "device." When the end user logs in, you now also have their user and organization information. You can call identify() with a multi-context that contains the "device," "user," and "organization" contexts for the end user.

Here's how:

import { useLDClient } from 'launchdarkly-react-client-sdk';
let ldClient = useLDClient();
ldClient.identify(newContext, null, () => {
  console.log("New context's flags available");
});
COPY

To learn more, read identify.

If multiple customers use your app on a single device, you may want to change contexts and have separate flag settings for each one. To do this, the SDK stores the last five user contexts on a single device, and supports switching between different user contexts. You can use the identify method to switch user contexts. identify loads any saved flag values for the new context and immediately triggers an update of the latest flags from LaunchDarkly.

In other situations, the new context may be a multi-context, that is, a set of several different contexts that you want to evaluate together. For example, as soon as an end user visits your app, you may initialize the client with a context using a context kind of "device." When the end user logs in, you now also have their user and organization information. You can call identify() with a multi-context that contains the "device," "user," and "organization" contexts for the end user.

Here's how:

let context = {'key': 'user-key-123abc', 'kind': 'user'};
await client.identify(context); // promise resolves to null
Alert.alert('identify', 'success');
COPY

The identify() method tells the client to change the current user and obtain the feature flag values for the new user.

In some situations, the new user may be an updated version of the existing user. For example, on a sign-in page in a single-page app, you could represent the same person as an anonymous user before they log in, and a different user after they log in. After the person logs in, you can call identify() so that the person receives the correct feature flag settings for their account.

To do this:

user = LaunchDarklyUser("abc")
launchDarkly.identify(user)
COPY

Identify creates or updates contexts on LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call Identify. The Variation methods automatically create contexts on the Contexts list for you. Identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use Identify:

client.Identify(context);
COPY

To learn more, read Identify.

identify creates or updates users in LaunchDarkly, which makes them available for targeting and autocomplete on the Users list.

To use identify:

client.identify(user);
COPY

To learn more, read Other methods.

LDClientIdentify creates or updates users in LaunchDarkly, which makes them available for targeting and autocomplete on the Users list.

In most cases, you do not need to call LDClientIdentify. The variation call automatically creates users on the Users list for you. LDClientIdentify is useful if you want to pre-populate your Users list before you launch any features.

To use identify:

LDClientIdentify(client, user);
COPY

To learn more, read LDClientIdentify.

identify creates or updates contexts in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call identify. The variation methods automatically create contexts on the Contexts list for you. identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use identify:

ldclient:identify(#{key => <<"context-key-123abc">>})
COPY

To learn more, read identify.

Identify creates or updates contexts in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call Identify. The Variation method automatically creates contexts on the Contexts list for you. Identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use Identify:

client.Identify(context)
COPY

To learn more, read Identify.

identify creates or updates contexts in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call identify. The Variation methods automatically create contexts on the Contexts list for you. identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use identify:

identify client context
COPY

To learn more, read identify.

identify creates or updates contexts in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call identify. The variation methods automatically create contexts on the Contexts list for you. identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use identify:

client.identify(context);
COPY

To learn more, read identify.

identify creates or updates users in LaunchDarkly, which makes them available for targeting and autocomplete on the Users list.

In most cases, you do not need to call identify. The variation methods automatically create users on the Users list for you. identify is useful if you want to pre-populate your Users list before you launch any features.

To use identify:

client:identify(user)
COPY

To learn more, read identify.

identify creates or updates contexts in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call identify. The variation call automatically creates users on the Contexts list for you. identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use identify:

client.identify(context);
COPY

To learn more, read identify.

identify creates or updates users in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call identify. The variation call automatically creates contexts on the Contexts list for you. identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use identify:

$client->identify($context);
COPY

To learn more, read identify.

identify creates or updates contexts in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call identify. The variation method automatically creates contexts on the Contexts list for you. identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use identify:

ldclient.get().identify(context)
COPY

To learn more, read identify.

identify creates or updates contexts in LaunchDarkly, which makes them available for targeting and autocomplete on the Contexts list.

In most cases, you do not need to call identify. The variation call automatically creates contexts on the Contexts list for you. identify is useful if you want to pre-populate your Contexts list before you launch any features.

To use identify:

client.identify(context)
COPY

To learn more, read identify.

identify creates or updates users in LaunchDarkly, which makes them available for targeting and autocomplete on the Users list.

In most cases, you do not need to call identify. The variation methods automatically create users or contexts on the Users or Contexts list for you. identify is useful if you want to pre-populate your Users or Contexts list before you launch any features.

To use identify:

client.identify(context);
COPY

To learn more, read identify.