> This page is for version V3 - Beta (default).
> For other versions, use one of these documentation indexes:
> - V3 - Beta (default): https://docs.authlyx.dev/v3/llms.txt
> - V2 - Legacy: https://docs.authlyx.dev/v2/llms.txt
> - V1 - End of support: https://docs.authlyx.dev/v1/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.authlyx.dev/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.authlyx.dev/_mcp/server.

# Read and check features

> Read plan features and check whether one is enabled.

Features describe what an identity is allowed to use. The app can read every effective feature, request one value, or check whether a named Bool feature is enabled. Plan defaults and identity overrides are resolved by AuthlyX.

For example, a plan might give customers `videoQuality = "4K"` and enable the Bool feature `exportPdf`. `getFeature` reads a value. `checkFeature` asks whether a Bool feature is enabled. In every example below, the callback or local variable receives the SDK's reply. Print or inspect that reply before using its data.

**SDK version:** V3 Beta. These examples use the current downloads. V1 and V2 use different APIs; choose them in the version selector.

Each example assumes `app` is the AuthlyX client you created in [Connect your app](/v3/guides/quickstart). When a method takes a callback, AuthlyX calls it after the reply arrives. A name such as `result` inside that callback is created there; you do not declare it at the top of your file. For C++ futures, Python or JavaScript `await`, Java futures, Go errors and Rust `?`, read [Results](/v3/sdks/methods/results).

#### C\#

```csharp
app.getFeatures(result => Console.WriteLine(result.ok ? result.data.ToString() : result.message));
app.getFeature("videoQuality", result => Console.WriteLine(result.ok ? result.data.ToString() : result.message));
app.checkFeature("exportPdf", result =>
{
    if (result.ok)
        Console.WriteLine(result.data.ToString());
    else
        Console.WriteLine(result.code + ": " + result.message);
});
```

#### C++

```cpp
auto quality = app.getFeature("videoQuality").get();
if (quality.ok())
    std::cout << quality.data.dump() << '\n';

auto exportAccess = app.checkFeature("exportPdf").get();
if (exportAccess.ok())
    std::cout << exportAccess.data.dump() << '\n';
```

Each method returns a `std::future`. `.get()` waits for the request and gives you the reply. Keep that wait off a graphics or UI thread.

#### Python

```python
app.getFeatures(completed=lambda result: print(result.data if result.ok else result.message))
app.getFeature("videoQuality", completed=lambda result: print(result.data if result.ok else result.message))
app.checkFeature("exportPdf", completed=lambda result: print(result.data if result.ok else result.message))
```

#### JavaScript / Node.js

```javascript
app.getFeatures(result => console.log(result.ok ? result.data : result.message));
app.getFeature("videoQuality", result => console.log(result.ok ? result.data : result.message));
app.checkFeature("exportPdf", result => console.log(result.ok ? result.data : result.message));
```

#### TypeScript

```typescript
app.getFeatures(result => console.log(result.ok ? result.data : result.message));
app.getFeature("videoQuality", result => console.log(result.ok ? result.data : result.message));
app.checkFeature("exportPdf", result => console.log(result.ok ? result.data : result.message));
```

#### Java

```java
app.getFeatures().thenAccept(result -> System.out.println(result.ok() ? result.data() : result.message()));
app.getFeature("videoQuality").thenAccept(result -> System.out.println(result.ok() ? result.data() : result.message()));
app.checkFeature("exportPdf").thenAccept(result -> System.out.println(result.ok() ? result.data() : result.message()));
```

#### Go

```go
all, err := app.GetFeatures(ctx)
if err != nil {
    return err
}
fmt.Println(all.Data)

value, err := app.GetFeature(ctx, "videoQuality")
if err != nil {
    return err
}
fmt.Println(value.Data)

enabled, err := app.CheckFeature(ctx, "exportPdf")
if err != nil {
    return err
}
fmt.Println(enabled.Data)
```

#### Rust

```rust
let all = app.getFeatures().await?;
let value = app.getFeature("videoQuality").await?;
let enabled = app.checkFeature("exportPdf").await?;
println!("{all:?}");
println!("{value:?}");
println!("{enabled:?}");
```

A client-side feature check can control what the interface shows. Your own trusted server must enforce any action that needs protection from a modified client.