Access tokens

const privy = createPrivyClient({
  appId: '<your-privy-app-id>',
  clientId: '<your-privy-app-client-id>'
});
const accessToken = await privy.getAccessToken();

// Check if user is authenticated
guard let user = privy.user else {
  // If user is nil, user is not authenticated
  return
}

// Get the access token
do {
  let accessToken = try await user.getAccessToken()
  print("Access token: \(accessToken)")
} catch {
  // Handle error appropriately
}

// Check if user is authenticated
val user = privy.user
if (user != null) {

  // Get the access token
  val result: Result<String> = user.getAccessToken()

  // Handle the result with fold method
  result.fold(
      onSuccess = { accessToken ->
          println("Access token: $accessToken")
      },
      onFailure = { error ->
          // Handle error appropriately
      },
  )
}

// Check if user is authenticated
final user = privy.user;
if (user != null) {

  // Get the access token
  final result = await privy.user.getAccessToken();

  // Handle the result with fold method
  result.fold(
    onSuccess: (accessToken) {
      print('Access token: $accessToken');
    },
    onError: (error) {
      // Handle error appropriately
    },
  );
}

// User will be null if no user is authenticated
PrivyUser user = PrivyManager.Instance.User;
if (user != null) {
  string accessToken = await user.GetAccessToken();
  Debug.Log(accessToken);
}

import axios from 'axios';

// For bearer token approach (when using local storage)
const accessToken = await getAccessToken();
const response = await axios({
  method: 'post',
  url: '<your-api-endpoint>',
  headers: {
    'Authorization': `Bearer ${accessToken}`
  },
  data: data
});

// For HTTP-only cookies approach
const response = await axios({
  method: 'post',
  url: '<your-api-endpoint>',
  withCredentials: true, // This includes cookies automatically
  data: data
});

import { ofetch } from 'ofetch';

// For bearer token approach (when using local storage)
const accessToken = await getAccessToken();
const response = await ofetch('<your-api-endpoint>', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${accessToken}`
  },
  body: data
});

// For HTTP-only cookies approach
const response = await ofetch('<your-api-endpoint>', {
  method: 'POST',
  credentials: 'include', // This includes cookies automatically
  body: data
});

go get -u github.com/golang-jwt/jwt/v5

verificationKey := "insert-your-privy-verification-key"
appId := "insert-your-privy-app-id"

accessToken := "insert-the-users-access-token"

// Defining a Go type for Privy JWTs
type PrivyClaims struct {
  AppId      string `json:"aud,omitempty"`
  Expiration uint64 `json:"exp,omitempty"`
  Issuer     string `json:"iss,omitempty"`
  UserId     string `json:"sub,omitempty"`
}

// This method will be used to check the token's claims later
func (c *PrivyClaims) Valid() error {
  if c.AppId != appId {
    return errors.New("aud claim must be your Privy App ID.")
  }
  if c.Issuer != "privy.io" {
    return errors.New("iss claim must be 'privy.io'")
  }
  if c.Expiration < uint64(time.Now().Unix()) {
    return errors.New("Token is expired.");
  }

  return nil
}

// This method will be used to load the verification key in the required format later
func keyFunc(token *jwt.Token) (interface{}, error) {
  if token.Method.Alg() != "ES256" {
    return nil, fmt.Errorf("Unexpected JWT signing method=%v", token.Header["alg"])
  }
    // https://pkg.go.dev/github.com/dgrijalva/jwt-go#ParseECPublicKeyFromPEM
  return jwt.ParseECPublicKeyFromPEM([]byte(verificationKey)), nil
}

// Check the JWT signature and decode claims
// https://pkg.go.dev/github.com/dgrijalva/jwt-go#ParseWithClaims
token, err := jwt.ParseWithClaims(accessToken, &PrivyClaims{}, keyFunc)
if err != nil {
    fmt.Println("JWT signature is invalid.")
}

// Parse the JWT claims into your custom struct
privyClaim, ok := token.Claims.(*PrivyClaims)
if !ok {
    fmt.Println("JWT does not have all the necessary claims.")
}

// Check the JWT claims
err = Valid(privyClaim);
if err {
    fmt.Printf("JWT claims are invalid, with error=%v.", err);
    fmt.Println();
} else {
    fmt.Println("JWT is valid.")
    fmt.Printf("%v", privyClaim)
}

[dependencies]
jsonwebtoken = "9"
serde = { version = "1.0", features = ["derive"] }

let verification_key = "insert-your-privy-verification-key";
let app_id = "insert-your-privy-app-id";

use jsonwebtoken::{decode, DecodingKey, Validation, Algorithm};
use serde::{Deserialize, Serialize};

let access_token = "insert-the-users-access-token";

// Defining a Rust struct for Privy JWTs
#[derive(Debug, Serialize, Deserialize)]
struct PrivyClaims {
    aud: String, // App ID
    exp: u64,    // Expiration timestamp
    iss: String, // Issuer
    sub: String, // User ID (Privy DID)
    sid: String, // Session ID
    iat: u64,    // Issued at timestamp
}

// Configure validation settings
let mut validation = Validation::new(Algorithm::ES256);
validation.set_issuer(&["privy.io"]);
validation.set_audience(&[app_id]);

// Parse the verification key
let decoding_key = DecodingKey::from_ec_pem(verification_key.as_bytes())?;

// Verify the JWT and decode claims
match decode::<PrivyClaims>(&access_token, &decoding_key, &validation) {
    Ok(token_data) => {
        let claims = token_data.claims;
        println!("JWT is valid");
        println!("User ID: {}", claims.sub);
        println!("App ID: {}", claims.aud);
        println!("Session ID: {}", claims.sid);

        // Use the claims for your application logic
    }
    Err(err) => {
        eprintln!("JWT verification failed: {}", err);
        // Handle invalid token
    }
}

from privy import PrivyAPI

client = PrivyAPI(app_id="your-privy-app-id", app_secret="your-privy-api-key")
try:
    user = client.users.verify_access_token(access_token)
    print(user)
except Exception as e:
    print(e)