> ## Documentation Index
> Fetch the complete documentation index at: https://launchdarkly.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Anonymous contexts

<View title="Developer" />

<View title="Federal docs" />

<View title="EU docs" />

This topic explains how to configure contexts as anonymous in LaunchDarkly SDKs. These features are available for all SDKs.

Each SDK lets you designate anonymous contexts. Anonymous contexts don't appear on your **Contexts** list, so you can't search for them, and you can't search for or autocomplete by their keys. If you use multi-contexts, you can choose to make only some contexts anonymous. To learn more, read [Multi-contexts](/docs/home/flags/multi-contexts).

In some client-side SDKs, if you don't provide a key or set it to null, and set `anonymous` to `true`, then the SDK generates a random key for you. If you generate keys for anonymous contexts, session IDs or UUIDs work best.

To learn more, read [Anonymous contexts](/docs/home/flags/anonymous-contexts).

Details about each SDK's configuration are available in the SDK-specific sections below.

* [Client-side SDKs](#client-side-sdks)
* [Server-side SDKs](#server-side-sdks)
* [Edge SDKs](#edge-sdks)
* [AI SDKs](#ai-sdks)

<Note>
  **Newer versions of LaunchDarkly SDKs replace users with contexts**

  A context is a generalized way of referring to the people, services, machines, or other resources that encounter feature flags in your product. Contexts replace another data object in LaunchDarkly: "users." To learn more, read [Contexts](/docs/home/flags/contexts).
</Note>

## Client-side SDKs

Here are the configuration options for anonymous contexts in client-side SDKs.

* [.NET (client-side)](#net-client-side)
* [Android](#android)
* [C++ (client-side)](#c++-client-side)
* [Electron](#electron)
* [Flutter](#flutter)
* [iOS](#ios)
* [JavaScript](#javascript)
* [Node.js (client-side)](#node-js-client-side)
* [React Native](#react-native)
* [React Web](#javascript): The React Web SDK relies on the JavaScript SDK for context-related functionality.
* [Roku](#roku)
* [Vue](#javascript): The Vue SDK relies on the JavaScript SDK for context-related functionality.

### .NET (client-side)

<Accordion title="Expand .NET (client-side) code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```csharp title=".NET SDK v5.0+ (C#)" lines wrap theme={null}
    Context context = Context.Builder("example-context-key")
        .Anonymous(true)
        .Build();
    ```
  </CodeGroup>

  To auto-generate a key for any context whose `anonymous` attribute is true:

  <CodeGroup>
    ```csharp title=".NET SDK v5.0+ (C#)" lines wrap theme={null}
    var config = Configuration
        .Builder("example-mobile-key", ConfigurationBuilder.AutoEnvAttributes.Enabled)
        .GenerateAnonymousKeys(true)
        .Build();
    ```
  </CodeGroup>

  If you set this option, you must still specify a non-null key as a placeholder when you construct the `Context`, because the SDK does not allow a `Context` to exist with a null key. When you pass this context to SDK methods like `Init` or `Identify`, the SDK replaces the placeholder key with a generated key.

  In this example, the placeholder key is "placeholder-key", but it could be any non-empty string:

  <CodeGroup>
    ```csharp title=".NET SDK v3.0+ (C#)" lines wrap theme={null}
    Context context = Context.Builder("placeholder-key")
        .Anonymous(true)
        .Build();
    ```
  </CodeGroup>
</Accordion>

### Android

<Accordion title="Expand Android code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```java title="Android SDK v4.0+ (Java)" lines wrap theme={null}
    LDContext context = LDContext.builder("example-context-key")
        .anonymous(true)
        .build();
    ```

    ```kotlin title="Android SDK v4.0+ (Kotlin)" lines wrap theme={null}
    val context: LDContext = LDContext.builder("example-context-key")
        .anonymous(true)
        .build()
    ```
  </CodeGroup>

  If you set this option, you must still specify a non-null key as a placeholder when you construct the `LDContext`, because this SDK does not allow a Context to exist with a null key. When you pass this context to SDK methods like `Init` or `Identify`, the SDK replaces the placeholder key with a LaunchDarkly-specific, device-unique string that is consistent between app restarts and device reboots.
</Accordion>

### C++ (client-side)

<Accordion title="Expand C++ (client-side) code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```cpp title="C++ SDK v3.0 (native)" lines wrap theme={null}
    auto context = ContextBuilder()
      .Kind("user", "example-user-key")
      .Anonymous(true)
      .Build();
    ```

    ```c title="C++ SDK v3.0 (C binding)" lines wrap theme={null}
    LDContextBuilder builder = LDContextBuilder_New();

    LDContextBuilder_AddKind(builder, "user", "example-user-key");
    LDContextBuilder_Attributes_SetAnonymous(builder, "user", true);

    LDContext context = LDContextBuilder_Build(builder);
    ```
  </CodeGroup>

  To learn more, read [`ContextBuilder`](https://launchdarkly.github.io/cpp-sdks/libs/client-sdk/docs/html/classlaunchdarkly_1_1ContextBuilder.html).
</Accordion>

### Electron

<Accordion title="Expand Electron code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```js title="JavaScript" lines wrap theme={null}
    const anonymousUser = { key: 'example-user-key', anonymous: true };
    ```

    ```ts title="TypeScript" lines wrap theme={null}
    import * as LDElectron from 'launchdarkly-electron-client-sdk';

    const anonymousUser: LDElectron.LDUser = { key: 'example-user-key', anonymous: true };
    ```
  </CodeGroup>

  To create an anonymous user with an auto-generated key, specify the "anonymous" property and omit the "key" property. The LaunchDarkly client creates a unique key for this user and caches it locally:

  <CodeGroup>
    ```js title="JavaScript" lines wrap theme={null}
    const anonymousUser = { anonymous: true };
    ```

    ```ts title="TypeScript" lines wrap theme={null}
    import * as LDElectron from 'launchdarkly-electron-client-sdk';

    const anonymousUser: LDElectron.LDUser = { anonymous: true };
    ```
  </CodeGroup>
</Accordion>

### Flutter

<Accordion title="Expand Flutter code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```dart title="Flutter SDK v4" lines wrap theme={null}
    final context = LDContextBuilder()
      .kind('user', 'example-user-key')
      .anonymous(true)
      .build();
    ```

    ```dart title="Flutter SDK v2.x+" lines wrap theme={null}
    LDContextBuilder builder = LDContextBuilder();
    builder.kind('user', 'example-user-key')
        .anonymous(true);
    LDContext context = builder.build();

    ```
  </CodeGroup>

  To learn more, read [`anonymous`](https://pub.dev/documentation/launchdarkly_flutter_client_sdk/latest/launchdarkly_flutter_client_sdk/LDAttributesBuilder/anonymous.html).
</Accordion>

### iOS

<Accordion title="Expand iOS code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```swift title="iOS SDK v8.0+ (Swift)" lines wrap theme={null}
    var contextBuilder = LDContextBuilder(key: "example-context-key")
    contextBuilder.anonymous(true)

    let context = try contextBuilder.build().get()
    ```

    ```objectivec title="iOS SDK v8.0+ (Objective-C)" lines wrap theme={null}
    LDContextBuilder *builder = [[LDContextBuilder alloc] initWithKey:@"example-context-key"];
    [builder trySetValueWithName:@"anonymous" value:[LDValue ofBool:true]];

    LDContext *context = builder.build.success;
    ```
  </CodeGroup>

  Alternatively, you can omit the key parameter. The client will automatically set the `isAnonymous` property for the context, and set the key to a LaunchDarkly-specific, device-unique string that is consistent between app restarts and device reboots.

  Here's how:

  <CodeGroup>
    ```swift title="iOS SDK v8.0+ (Swift)" lines wrap theme={null}
    // Have the SDK use a device persistent key.
    // This sets `isAnonymous` by default.
    let context = try LDContextBuilder().build().get()
    ```

    ```objectivec title="iOS SDK v8.0+ (Objective-C)" lines wrap theme={null}
    // Have the SDK use a device persistent key.
    // This sets `isAnonymous` by default.
    LDContextBuilder *newThing = [[LDContextBuilder alloc] init];
    ```
  </CodeGroup>
</Accordion>

### JavaScript

<Accordion title="Expand JavaScript code sample">
  To create an anonymous context, specify the `anonymous` property and omit the `key` property. The client will automatically set the key to a LaunchDarkly-specific, device-unique string that is consistent between app restarts and device reboots.

  Here's how:

  <CodeGroup>
    ```js title="JavaScript SDK v3.0" lines wrap theme={null}
    const anonymousUserContext = {
      kind: 'user',
      anonymous: true
    };

    // A multi-context can contain both anonymous and non-anonymous contexts.
    // Here, the organization is not anonymous.
    const multiContext = {
      kind: 'multi',
      user: anonymousUserContext,
      org: {
        key: 'example-organization-key',
        name: 'Acme, Inc.'
      }
    }
    ```

    ```ts title="JavaScript SDK v3.0 (TypeScript)" expandable lines wrap theme={null}
    import * as ld from 'launchdarkly-js-client-sdk';

    const anonymousContext: ld.LDContext = {
      kind: 'user',
      anonymous: true
    };

    // A multi-context can contain both anonymous and non-anonymous contexts.
    // Here, the organization is not anonymous.
    const multiContext: ld.LDContext = {
      kind: 'multi',
      user: anonymousContext,
      org: {
        key: 'example-organization-key',
        name: 'Example organization name'
      }
    }
    ```
  </CodeGroup>
</Accordion>

### Node.js (client-side)

<Accordion title="Expand Node.js (client-side) code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```js title="Node.js SDK v3.0 (JavaScript)" lines wrap theme={null}
    const anonymousContext = { kind: 'user', key: 'example-user-key', anonymous: true };
    ```

    ```ts title="Node.js SDK v3.0 (TypeScript)" lines wrap theme={null}
    import * as ld from 'launchdarkly-node-client-sdk';

    const anonymousContext: ld.LDContext = { kind: 'user', key: 'example-user-key', anonymous: true };
    ```
  </CodeGroup>

  You can also have the SDK generate the key for you. Specify the `anonymous` property and omit the `key` property. The client will automatically set the key to a LaunchDarkly-specific, device-unique string that is consistent between app restarts and device reboots.

  Here's how:

  <CodeGroup>
    ```js title="Node.js SDK v3.0 (JavaScript)" lines wrap theme={null}
    const anonymousContext = { kind: 'user', anonymous: true };
    ```

    ```ts title="Node.js SDK v3.0 (TypeScript)" lines wrap theme={null}
    import * as ld from 'launchdarkly-node-client-sdk';

    const anonymousContext: ld.LDContext = { kind: 'user', anonymous: true };
    ```
  </CodeGroup>
</Accordion>

### React Native

<Accordion title="Expand React Native code sample">
  To create an create an anonymous context, specify the `anonymous` property and set the context `key` to an empty string.

  Here's how:

  <CodeGroup>
    ```js title="React Native SDK v10" maxLines=0 expandable lines wrap theme={null}
    // This device context is anonymous
    const deviceContext = {
      // The key attribute is required and should be empty
      // The SDK will automatically generate a unique, stable key
      key: '',
      kind: 'device',
      deviceId: '12345',
      anonymous: true
    }

    // This user context is not anonymous
    const userContext = {
      kind: 'user',
      key: 'example-user-key'
    }

    // The multi-context contains one anonymous context
    // and one non-anonymous context
    const multiContext = {
      kind: 'multi',
      user: userContext,
      device: deviceContext
    }
    ```
  </CodeGroup>

  In version 10 of the SDK, you must include the `key` attribute when building the anonymous context. If you set the key to an empty string, the client will automatically set the key to a LaunchDarkly-specific, device-unique string that is consistent between app restarts and device reboots. We strongly recommend having the client manage the key for anonymous contexts. If you set the key to a non-empty string, the client uses that value as the key. However, the key may not be stable across restarts or reboots.

  The SDK gives a usage error if you omit the `key` attribute. It also gives a usage error if you set the key to an empty string and do not mark the context as anonymous.

  In versions 7 through 9 of the SDK, you may omit the context key when building an anonymous context, and the client will automatically set it to a LaunchDarkly-specific, device-unique string that is consistent between app restarts and device reboots.

  #### Using a shared key between anonymous contexts in React Native for Android

  It is possible to use one, shared key between anonymous contexts. However, we do not recommend this. Using a shared key between anonymous contexts means that some features will be limited or will not work as expected. To learn more, read [Use a shared key between anonymous contexts](/docs/home/flags/anonymous-contexts#use-a-shared-key-between-anonymous-contexts).

  If you are using an older version of the React Native SDK on Android, there is some additional configuration required if you want to use a shared key between anonymous contexts.

  <Accordion title="Expand React Native v7.x-v9.x for Android code sample">
    If you do choose to use a shared key between anonymous contexts, and you:

    * have an Android application
    * are using the React Native SDK in versions 7.x through 9.x

    then you must also explicitly configure the SDK to allow using a shared key between anonymous contexts. The `generateAnonymousKeysAndroid` configuration option defaults to `true`, which means that the SDK will automatically generate unique keys for anonymous contexts. If you need to use a shared key between anonymous contexts, then you must set this option to `false`.

    To learn more, read [`generateAnonymousKeys`](https://launchdarkly.github.io/android-client-sdk/com/launchdarkly/sdk/android/LDConfig.Builder.html#generateAnonymousKeys\(boolean\)).

    The React Native SDK for iOS generates a context key for anonymous contexts only if you do not supply one. No additional SDK configuration is required if you are using a shared key for anonymous contexts with the React Native SDK for iOS.
  </Accordion>
</Accordion>

### React Web

All context-related functionality provided by the [JavaScript SDK](#javascript) is also available in the React Web SDK.

### Roku

<Accordion title="Expand Roku code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```brightscript title="Roku SDK v2.0 (BrightScript)" lines wrap theme={null}
    context = LaunchDarklyCreateContext({"key": "example-user-key", "kind": "user", "anonymous": true})
    ```
  </CodeGroup>
</Accordion>

### Vue

All context-related functionality provided by the [JavaScript SDK](#javascript) SDK is also available in the Vue SDK.

## Server-side SDKs

Here are the configuration options for anonymous contexts in server-side SDKs:

* [.NET (server-side)](#net-server-side)
* [Apex](#apex)
* [C++ (server-side)](#c++-server-side)
* [Erlang](#erlang)
* [Go](#go)
* [Haskell](#haskell)
* [Java](#java)
* [Lua](#lua)
* [Node.js (server-side)](#node-js-server-side)
* [PHP](#php)
* [Python](#python)
* [Ruby](#ruby)
* [Rust](#rust)

### .NET (server-side)

<Accordion title="Expand .NET (server-side) code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```csharp title=".NET SDK v7.0+ (C#)" lines wrap theme={null}
    var context = Context.Builder("example-context-key")
        .Anonymous(true)
        .Build();
    ```
  </CodeGroup>
</Accordion>

### Apex

<Accordion title="Expand Apex code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```java title="Java" lines wrap theme={null}
    LDUser user = new LDUser.Builder('example-user-key')
        .setAnonymous(true)
        .build();
    ```
  </CodeGroup>
</Accordion>

### C++ (server-side)

<Accordion title="Expand C++ (server-side) code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```cpp title="C++ SDK v3.0 (native)" lines wrap theme={null}
    auto context = ContextBuilder()
      .Kind("user", "example-user-key")
      .Anonymous(true)
      .Build();
    ```

    ```c title="C++ SDK v3.0 (C binding)" lines wrap theme={null}
    LDContextBuilder builder = LDContextBuilder_New();

    LDContextBuilder_AddKind(builder, "user", "example-user-key");
    LDContextBuilder_Attributes_SetAnonymous(builder, "user", true);

    LDContext context = LDContextBuilder_Build(builder);
    ```
  </CodeGroup>

  To learn more, read [`ContextBuilder`](https://launchdarkly.github.io/cpp-sdks/libs/server-sdk/docs/html/classlaunchdarkly_1_1ContextBuilder.html).
</Accordion>

### Erlang

<Accordion title="Expand Erlang code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```erlang title="Erlang SDK v2.0+" lines wrap theme={null}
        Context = ldclient_context:set(anonymous, true,
            ldclient_context:new(<<"example-user-key">>))
    ```
  </CodeGroup>
</Accordion>

### Go

<Accordion title="Expand Go code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```go title="Go SDK v6+" lines wrap theme={null}
    import (
        "github.com/launchdarkly/go-sdk-common/v3/ldcontext"
    )

    // Anonymous context with only a key
    context1 := ldcontext.NewBuilder("example-context-key").Anonymous(true).Build()

    // Anonymous context with a key plus other attributes
    context2 := ldcontext.NewBuilder("context-key-456def").
        Anonymous(true).
        SetString("country", "Canada").
        Build()
    ```
  </CodeGroup>

  Anonymous contexts do not appear on the **Contexts** list. Optionally, you can configure the SDK to omit data from anonymous contexts when sending related [events](/docs/sdk/concepts/events#omit-anonymous-contexts-from-events) to LaunchDarkly. Depending on how your application uses contexts, this can significantly decrease the amount of data your application sends to LaunchDarkly. To learn more, read [`EventsConfiguration`](https://pkg.go.dev/github.com/launchdarkly/go-sdk-events/v3#EventsConfiguration).
</Accordion>

### Haskell

<Accordion title="Expand Haskell code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```haskell title="Haskell SDK v4.0" lines wrap theme={null}
    makeContext "example-user-key" "user"
      & withAnonymous True
    ```
  </CodeGroup>

  Anonymous contexts do not appear on the **Contexts** list. Optionally, you can configure the SDK to omit data from anonymous contexts when sending related [events](/docs/sdk/concepts/events#omit-anonymous-contexts-from-events) to LaunchDarkly. Depending on how your application uses contexts, this can significantly decrease the amount of data your application sends to LaunchDarkly. To learn more, read [`configSetOmitAnonymousContexts`](https://launchdarkly.github.io/haskell-server-sdk/LaunchDarkly-Server-Config.html#v:configSetOmitAnonymousContexts).
</Accordion>

### Java

<Accordion title="Expand Java code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```java title="Java SDK v6.0+" lines wrap theme={null}
    LDContext context = LDContext.builder("example-context-key")
      .anonymous(true)
      .build();
    ```
  </CodeGroup>
</Accordion>

### Lua

<Accordion title="Expand Lua code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```lua title="Lua SDK v2" expandable lines wrap theme={null}
    -- to create an anonymous user context
    local userContext = ld.makeContext({
        user = {
          key       = "example-user-key",
          anonymous = true
        }
    })

    -- to create an anonymous context of a different kind
    local deviceContext = ld.makeContext({
        device    = {
          key       = "example-device-key",
          anonymous = true
        }
    })

    ```
  </CodeGroup>

  To learn more, read [`makeContext`](https://launchdarkly.github.io/lua-server-sdk/modules/launchdarkly-server-sdk.html#makeContext).
</Accordion>

### Node.js (server-side)

<Accordion title="Expand Node.js (server-side) code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```ts title="Node.js SDK v8.x+ (TypeScript)" lines wrap theme={null}
    import * as ld from '@launchdarkly/node-server-sdk';

    const context: ld.LDContext = {
      kind: 'user',
      key: 'example-user-key',
      anonymous: true,
    }
    ```
  </CodeGroup>
</Accordion>

### PHP

<Accordion title="Expand PHP code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```php title="PHP SDK v5.0+" lines wrap theme={null}
    $context = LDContext::builder("example-context-key")->anonymous(true)->build();
    ```
  </CodeGroup>
</Accordion>

### Python

<Accordion title="Expand Python code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```python title="Python SDK v8.0+" lines wrap theme={null}
    context = Context.builder("example-context-key").anonymous(True).build()
    ```
  </CodeGroup>

  Anonymous contexts do not appear on the **Contexts** list. Optionally, you can configure the SDK to omit data from anonymous contexts when sending related [events](/docs/sdk/concepts/events#omit-anonymous-contexts-from-events) to LaunchDarkly. Depending on how your application uses contexts, this can significantly decrease the amount of data your application sends to LaunchDarkly. To learn more, read [`omit_anonymous_contexts`](https://launchdarkly-python-sdk.readthedocs.io/en/latest/api-main.html#ldclient.config.Config.omit_anonymous_contexts).
</Accordion>

### Ruby

<Accordion title="Expand Ruby code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```ruby title="Ruby SDK v7.0+" lines wrap theme={null}
    context = LaunchDarkly::LDContext.create({ key: "example-context-key", anonymous: true })
    ```
  </CodeGroup>

  Anonymous contexts do not appear on the **Contexts** list. Optionally, you can configure the SDK to omit data from anonymous contexts when sending related [events](/docs/sdk/concepts/events#omit-anonymous-contexts-from-events) to LaunchDarkly. Depending on how your application uses contexts, this can significantly decrease the amount of data your application sends to LaunchDarkly. To learn more, read [`omit_anonymous_contexts`](https://launchdarkly.github.io/ruby-server-sdk/LaunchDarkly/Config.html#omit_anonymous_contexts-instance_method).
</Accordion>

### Rust

<Accordion title="Expand Rust code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```rust title="Rust SDK v1+" lines wrap theme={null}
    // Anonymous context with only a key
    let context = ContextBuilder::new("example-context-key").anonymous(true).build();

    // Anonymous context with a key plus other attributes
    let context = ContextBuilder::new("example-context-key").
        anonymous(true).
        set_value("country", "US".into()).
        build();
    ```
  </CodeGroup>

  Anonymous contexts do not appear on the **Contexts** list. Optionally, you can configure the SDK to omit data from anonymous contexts when sending related [events](/docs/sdk/concepts/events#omit-anonymous-contexts-from-events) to LaunchDarkly. Depending on how your application uses contexts, this can significantly decrease the amount of data your application sends to LaunchDarkly. To learn more, read [`omit_anonymous_contexts`](https://docs.rs/launchdarkly-server-sdk/latest/launchdarkly_server_sdk/struct.EventProcessorBuilder.html#method.omit_anonymous_contexts).
</Accordion>

## Edge SDKs

Here are the configuration options for anonymous contexts in edge SDKs.

* [Akamai](#akamai)
* [Cloudflare](#cloudflare)
* [Fastly](#fastly)
* [Vercel](#vercel)

### Akamai

<Accordion title="Expand Akamai code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```ts title="TypeScript" lines wrap theme={null}
    import type { LDContext } from '@launchdarkly/akamai-server-edgekv-sdk';

    const anonymousContext: LDContext = { kind: 'user', key: 'example-user-key', anonymous: true };
    ```
  </CodeGroup>
</Accordion>

### Cloudflare

<Accordion title="Expand Cloudflare code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```ts title="TypeScript" lines wrap theme={null}
    import type { LDContext } from '@launchdarkly/cloudflare-server-sdk';

    const anonymousContext: LDContext = { kind: 'user', key: 'example-user-key', anonymous: true };
    ```
  </CodeGroup>
</Accordion>

### Fastly

<Accordion title="Expand Fastly code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```ts title="TypeScript" lines wrap theme={null}
    import type { LDContext } from '@launchdarkly/fastly-server-sdk';

    const anonymousContext: LDContext = { kind: 'user', key: 'example-user-key', anonymous: true };
    ```
  </CodeGroup>
</Accordion>

### Vercel

<Accordion title="Expand Vercel code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```ts title="TypeScript" lines wrap theme={null}
    import type { LDContext } from '@launchdarkly/vercel-server-sdk';

    const anonymousContext: LDContext = { kind: 'user', key: 'example-user-key', anonymous: true };
    ```
  </CodeGroup>
</Accordion>

## AI SDKs

Here are the configuration options for anonymous contexts in AI SDKs.

* [.NET AI](#net-ai)
* [Go AI](#go-ai)
* [Node.js (server-side) AI](#node-js-server-side-ai)
* [Python AI](#python-ai)
* [Ruby AI](#ruby-ai)

### .NET AI

<Accordion title="Expand .NET AI SDK code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```csharp title=".NET AI SDK" lines wrap theme={null}
    var context = Context.Builder("example-context-key")
        .Anonymous(true)
        .Build();
    ```
  </CodeGroup>
</Accordion>

### Go AI

<Accordion title="Expand Go AI SDK code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```go title="Go AI SDK" lines wrap theme={null}
    import (
        "github.com/launchdarkly/go-sdk-common/v3/ldcontext"
    )

    // Anonymous context with only a key
    context1 := ldcontext.NewBuilder("example-context-key").Anonymous(true).Build()

    // Anonymous context with a key plus other attributes
    context2 := ldcontext.NewBuilder("context-key-456def").
        Anonymous(true).
        SetString("country", "Canada").
        Build()
    ```
  </CodeGroup>
</Accordion>

### Java AI

<Accordion title="Expand Java AI SDK code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```java title="Java AI SDK" lines wrap theme={null}
    LDContext context = LDContext.builder("example-context-key")
      .anonymous(true)
      .build();
    ```
  </CodeGroup>
</Accordion>

### Node.js (server-side) AI

<Accordion title="Expand Node.js (server-side) AI SDK code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```ts title="Node.js (server-side) AI SDK (TypeScript)" lines wrap theme={null}
    const context: LDContext = {
      kind: 'user',
      key: 'example-user-key',
      anonymous: true,
    }
    ```

    ```js title="Node.js (server-side) AI SDK (JavaScript)" lines wrap theme={null}
    const context = {
      kind: 'user',
      key: 'example-user-key',
      anonymous: true,
    }
    ```
  </CodeGroup>

  Anonymous contexts do not appear on the **Contexts** list.
</Accordion>

### Python AI

<Accordion title="Expand Python AI SDK code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```python title="Python AI SDK" lines wrap theme={null}
    context = Context.builder("example-context-key").anonymous(True).build()
    ```
  </CodeGroup>

  Anonymous contexts do not appear on the **Contexts** list. Optionally, you can configure the SDK to omit data from anonymous contexts when sending related [events](/docs/sdk/concepts/events#omit-anonymous-contexts-from-events) to LaunchDarkly. Depending on how your application uses contexts, this can significantly decrease the amount of data your application sends to LaunchDarkly. To learn more, read [`omit_anonymous_contexts`](https://launchdarkly-python-sdk.readthedocs.io/en/latest/api-main.html#ldclient.config.Config.omit_anonymous_contexts).
</Accordion>

### Ruby AI

<Accordion title="Expand Ruby AI SDK code sample">
  To distinguish logged-in end users from anonymous end users in the SDK:

  <CodeGroup>
    ```ruby title="Ruby AI SDK" lines wrap theme={null}
    context = LaunchDarkly::LDContext.create({ key: "example-context-key", anonymous: true })
    ```
  </CodeGroup>

  Anonymous contexts do not appear on the **Contexts** list. Optionally, you can configure the SDK to omit data from anonymous contexts when sending related [events](/docs/sdk/concepts/events#omit-anonymous-contexts-from-events) to LaunchDarkly. Depending on how your application uses contexts, this can significantly decrease the amount of data your application sends to LaunchDarkly. To learn more, read [`omit_anonymous_contexts`](https://launchdarkly.github.io/ruby-server-sdk/LaunchDarkly/Config.html#omit_anonymous_contexts-instance_method).
</Accordion>