> 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 update metadata

> Read app-visible metadata and update fields that allow remote writes.

Metadata stores extra values on a plan, user, license or device. Read only metadata marked app-readable. An app can update a field only when the developer enabled remote updates for that field. Private metadata stays in the dashboard.

For example, a developer might store `customer_note = "Prefers email"` and a Bool field `beta_access = true`. Read fields with `getMetadata`; use `checkMetadata` when you need to test a Bool. `setMetadata` works only for a field the developer marked remotely writable. The examples print the server reply so you can see whether the operation worked.

**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.getAllMetadata(result => Console.WriteLine(result.ok ? result.data.ToString() : result.message));
app.getMetadata("customer_note", result => Console.WriteLine(result.ok ? result.data.ToString() : result.message));
app.checkMetadata("beta_access", result => Console.WriteLine(result.ok ? result.data.ToString() : result.message));
app.setMetadata("display_name", "Alex", result => Console.WriteLine(result.ok ? "Metadata updated" : result.message));
```

#### C++

```cpp
auto value = app.getMetadata("customer_note").get();
if (value.ok())
    std::cout << value.data.dump() << '\n';

auto check = app.checkMetadata("beta_access").get();
if (check.ok())
    std::cout << check.data.dump() << '\n';

auto update = app.setMetadata("display_name", "Alex").get();
std::cout << update.message << '\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
async def read_and_update_metadata():
    all_metadata = await app.getAllMetadata()
    print(all_metadata.data if all_metadata.ok else all_metadata.message)

    note = await app.getMetadata("customer_note")
    print(note.data if note.ok else note.message)

    beta = await app.checkMetadata("beta_access")
    print(beta.data if beta.ok else beta.message)

    updated = await app.setMetadata("display_name", "Alex")
    print("Metadata updated" if updated.ok else updated.message)
```

#### JavaScript / Node.js

```javascript
app.getAllMetadata(result => console.log(result.message));
app.getMetadataValue("customer_note", result => console.log(result.message));
app.checkMetadata("beta_access", result => console.log(result.message));
app.setMetadata("display_name", "Alex").then(result => console.log(result.message));
```

#### TypeScript

```typescript
app.getAllMetadata(result => console.log(result.message));
app.getMetadataValue("customer_note", result => console.log(result.message));
app.checkMetadata("beta_access", result => console.log(result.message));
app.setMetadata("display_name", "Alex").then(result => console.log(result.message));
```

#### Java

```java
app.getAllMetadata().thenAccept(result -> System.out.println(result.message()));
app.getMetadata("customer_note").thenAccept(result -> System.out.println(result.message()));
app.checkMetadata("beta_access").thenAccept(result -> System.out.println(result.message()));
app.setMetadata("display_name", "Alex").thenAccept(result -> System.out.println(result.message()));
```

#### Go

```go
func readAndUpdateMetadata(ctx context.Context, app *authlyx.AuthlyX) error {
    all, err := app.GetAllMetadata(ctx)
    if err != nil {
        return err
    }
    if all.Success {
        fmt.Println(all.Data)
    } else {
        fmt.Println(all.Message)
    }

    note, err := app.GetMetadata(ctx, "customer_note")
    if err != nil {
        return err
    }
    fmt.Println(note.Data)

    beta, err := app.CheckMetadata(ctx, "beta_access")
    if err != nil {
        return err
    }
    fmt.Println(beta.Data)

    updated, err := app.SetMetadata(ctx, "display_name", "Alex")
    if err != nil {
        return err
    }
    fmt.Println(updated.Message)
    return nil
}
```

#### Rust

```rust
let all = app.getAllMetadata().await?;
let value = app.getMetadataValue("customer_note").await?;
let check = app.checkMetadata("beta_access").await?;
let updated = app.setMetadata("display_name", serde_json::json!("Alex")).await?;
println!("{}", all.data);
println!("{}", value.data);
println!("{}", check.data);
println!("{}", updated.message);
```

Writable metadata is still customer-controlled input. Validate it before using it for a trusted operation. The SDK cannot read private metadata.