> ## 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.

# Contexts

<View title="Developer" />

<View title="Federal docs" />

<View title="EU docs" />

Contexts are people, services, machines, or other resources that encounter feature flags in your product. Contexts are identified by their `kind`, which describes the type of resources encountering flags, and by their `key`. Each unique combination of one or more contexts that have encountered a feature flag in your product is called a context instance.

When you use the LaunchDarkly SDK to evaluate a flag, you provide a context to that call. LaunchDarkly records the key and attributes of each context. You can view these in the LaunchDarkly user interface from the **Contexts** list, or use the Context APIs. To learn more, read [Contexts](/docs/home/flags/contexts).

LaunchDarkly provides APIs for you to:

* retrieve contexts and context attribute names and values
* search for contexts
* fetch context kinds
* create and update context kinds

To learn more about context kinds, read [Context kinds](/docs/home/flags/context-kinds).

Contexts are always scoped within a project and an environment. Each environment has its own set of context records. Context records reflect the contexts that LaunchDarkly has received within the last 30 days.

Some of the endpoints in the contexts API accept an application ID. The application ID is returned as the `applicationId` field of each element in the `items` array of the [Get contexts](/docs/api/contexts/get-contexts) response. By default, the application ID is set to the SDK you are using. In the LaunchDarkly UI, the application ID and application version appear on the context details page in the "From source" field. You can change the application ID as part of your SDK configuration. To learn more, read [Application metadata configuration](/docs/sdk/features/app-config).

### Filtering contexts

When you [search for contexts](/docs/api/contexts/search-for-contexts), you can filter the results using fields and operators with the `filter` parameter. Specify `filter` either as a query parameter or as a request body parameter.

The `filter` parameter supports the following operators: `after`, `anyOf`, `before`, `contains`, `equals`, `exists`, `notEquals`, `startsWith`.

<details>
  <summary>Expand for details on operators and syntax</summary>

  #### after

  Returns contexts if the field's date value occurs after the specified time. Provide an RFC 3339 timestamp or Unix epoch milliseconds. For example:

  * `myField after "2022-09-21T19:03:15+00:00"`

  #### anyOf

  Returns contexts if the field value matches any of the provided values. The `anyOf` operator is supported for the `applicationId`, `key`, `kind`, `kindKey`, `kindKeys`, and `kinds` fields only. To match an attribute against multiple values, use `equals` with an array value instead. For example:

  * `kind anyOf ["user","device"]`
  * `key anyOf ["user-key-123abc","user-key-456def"]`

  #### before

  Returns contexts if the field's date value occurs before the provided time. Provide an RFC 3339 timestamp or Unix epoch milliseconds. For example:

  * `myField before "2022-09-21T19:03:15+00:00"`

  #### contains

  Returns contexts whose kind or kind and key match the provided value. The `contains` operator is supported for the `kinds` and `kindKeys` fields only, and accepts exactly one value. For example:

  * `kinds contains ["user"]`
  * `kindKeys contains ["user:user-key-123abc"]`

  #### equals

  Returns contexts only if the field value exactly matches the provided value. If you provide an array, the filter matches if the field value equals any element of the array. For example:

  * `myField equals 44`
  * `myField equals "device"`
  * `myField equals true`
  * `myField equals [1,2,3,4]`
  * `myField equals ["hello","goodbye"]`

  #### exists

  Returns contexts based on whether the specified field exists. The `exists` operator is supported for the `name` field and attribute fields only. For example:

  * `myField exists true`
  * `myField exists false`
  * `*.name exists true`

  #### notEquals

  Returns contexts if the field value does not exactly match the provided value. If you provide an array, the filter matches if the field value does not equal any element of the array. For example:

  * `myField notEquals 44`
  * `myField notEquals "device"`
  * `myField notEquals true`
  * `myField notEquals [1,2,3,4]`
  * `myField notEquals ["hello","goodbye"]`

  #### startsWith

  Returns contexts if a singular string field value begins with the provided substring. The substring can be at most 500 characters. Matching is case-sensitive. For example:

  * `myField startsWith "do"`
</details>

You can also combine filters in the following ways:

* Use a comma (`,`) as an AND operator
* Use a vertical bar (`|`) as an OR operator
* Use parentheses `()` to group filters

For example:

* `myField notEquals 0, myField notEquals 1` returns contexts where `myField` is not 0 and is not 1
* `myFirstField equals "device",(mySecondField equals "iPhone"|mySecondField equals "iPad")` returns contexts where `myFirstField` is equal to "device" and `mySecondField` is equal to either "iPhone" or "iPad"

#### Supported fields and operators

You can only filter some fields using certain operators.

When you search for [contexts](/docs/api/contexts/search-for-contexts), the `filter` parameter supports the following fields and operators:

| <div style={{ width: '120px' }}>Field</div> | Description | Supported operators |
| - | - | - |
| `applicationId` | An identifier that represents the application where the LaunchDarkly SDK is running. | `equals`, `notEquals`, `anyOf`, `startsWith` |
| `key` | The context key. | `equals`, `notEquals`, `anyOf`, `startsWith` |
| `kind` | The context kind. | `equals`, `notEquals`, `anyOf`, `startsWith` |
| `kinds` | The context's kind. Supply a list of strings to the operator. The filter matches contexts whose kind is any of the provided values. The `contains` operator accepts exactly one value. | `equals`, `anyOf`, `contains` |
| `kindKey` | The kind and key for the context, joined with a `:`. For example, `user:user-key-abc123`. | `equals`, `notEquals`, `anyOf` |
| `kindKeys` | The kind and key for the context, joined with a `:`. For example, `user:user-key-abc123`. Supply a list of strings to the operator. The filter matches contexts whose kind and key match any of the provided values. The `contains` operator accepts exactly one value. | `equals`, `anyOf`, `contains` |
| `q` | A prefix search across the context key and the `name`, `firstName`, `lastName`, and `email` attributes. Supply a single string to the operator. | `equals` |
| `name` | The name for the context. | `equals`, `notEquals`, `exists`, `startsWith` |
| `<a kind>.<an attribute name>` | A kind and the name of any attribute that appears in a context of that kind, for example, `user.email`. To filter all kinds use `*` in place of the kind. For example, `*.email`. Reference a nested attribute by joining path segments with periods. For example, `user.address.city` filters on the `city` field within the `address` attribute of a user context. Each path segment may contain letters, numbers, underscores, and hyphens, and may not start with a number. JSON pointer escaping (`~0`, `~1`) is not supported. If the value includes whitespace, enclose it in double quotes. A filter may include at most 10 attribute clauses. | `equals`, `notEquals`, `exists`, `startsWith`, `before`, `after`. |