Anonymous Users

npm i --save @descope/node-sdk

pip3 install descope

go get github.com/descope/go-sdk

import DescopeClient from '@descope/node-sdk';

const managementKey = "xxxx"

try{
    //  baseUrl="<URL>" // When initializing the Descope clientyou can also configure the baseUrl ex: https://auth.company.com  - this is useful when you utilize a custom domain within your Descope project.
    const descopeClient = DescopeClient({ projectId: '__ProjectID__', managementKey: managementKey });
} catch (error) {
    // handle the error
    console.log("failed to initialize: " + error)
}

from descope import (
    REFRESH_SESSION_TOKEN_NAME,
    SESSION_TOKEN_NAME,
    AuthException,
    DeliveryMethod,
    DescopeClient,
    AssociatedTenant,
    RoleMapping,
    AttributeMapping
)

management_key = "xxxx"

try:
    # You can configure the baseURL by setting the env variable Ex: export DESCOPE_BASE_URI="https://auth.company.com  - this is useful when you utilize a custom domain within your Descope project."
    descope_client = DescopeClient(project_id='__ProjectID__', management_key=management_key)
except Exception as error:
    # handle the error
    print ("failed to initialize. Error:")
    print (error)

import "github.com/descope/go-sdk/descope"
import "github.com/descope/go-sdk/descope/client"
import "fmt"

// Utilizing the context package allows for the transmission of context capabilities like cancellation
//      signals during the function call. In cases where context is absent, the context.Background()
//      function serves as a viable alternative.
//      Utilizing context within the Descope GO SDK is supported within versions 1.6.0 and higher.
import (
	"context"
)

managementKey = "xxxx"

// DescopeBaseURL // within the client.Config, you can also configure the baseUrl ex: https://auth.company.com  - this is useful when you utilize a custom domain within your Descope project.
descopeClient, err := client.NewWithConfig(&client.Config{ProjectID:"__ProjectID__", managementKey:managementKey})
if err != nil {
    // handle the error
    log.Println("failed to initialize: " + err.Error())
}

 // Args:
//  customClaims (Record<string, any>, optional): A dictionary of custom claims to include in the JWT.
//     These claims can be used to store additional user information.
//  selectedTenant (string, optional): The ID of the tenant to associate with the JWT.
//     This is useful for multi-tenant applications.

const customClaims = {
    role: "guest",
    permissions: ["read"]
};

const selectedTenant = "tenant_123";

const resp = await descopeClient.management.jwt.anonymous(customClaims, selectedTenant);
if (!resp.ok) {
    console.log("Failed to generate JWT for anonymous user.");
    console.log("Status Code: " + resp.code);
    console.log("Error Code: " + resp.error.errorCode);
    console.log("Error Description: " + resp.error.errorDescription);
    console.log("Error Message: " + resp.error.errorMessage);
} else {
    console.log("Successfully generated JWT for anonymous user.");
    console.log(resp.data);
}

# Args:
#  custom_claims (dict, optional): A dictionary of custom claims to include in the JWT.
#     These claims can be used to store additional user information.
#  tenant_id (str, optional): The ID of the tenant to associate with the JWT.
#     This is useful for multi-tenant applications.

custom_claims = {
    "role": "guest",
    "permissions": ["read"]
}
tenant_id = "tenant_123"

try:
    jwt_response = descope_client.mgmt.jwt.anonymous(custom_claims=custom_claims, tenant_id=tenant_id)
    print("Successfully generated JWT for anonymous user")
    print(json.dumps(jwt_response, indent=4))
except AuthException as error:
    print("Failed to generate JWT")
    print("Status Code: " + str(error.status_code))
    print("Error: " + str(error.error_message))

// Args:
//  ctx (context.Context): Application context for the transmission of context capabilities like
//     cancellation signals during the function call. If no context is available,
//     use context.Background() as an alternative.
//  customClaims (map[string]any, optional): A map of custom claims to include in the JWT. These claims
//     can be used to store additional user information.
//  selectedTenant (string, optional): The ID of the tenant to associate with the JWT. This is useful
//     for multi-tenant applications.

ctx := context.Background()
customClaims := map[string]any{
	"role": "guest",
	"permissions": []string{"read"},
}
selectedTenant := "tenant_123"

res, err := descopeClient.JWT().Anonymous(ctx, customClaims, selectedTenant)
if err != nil {
	fmt.Println("Failed to generate JWT for anonymous user:", err)
} else {
	fmt.Println("Successfully generated JWT for anonymous user:")
	fmt.Printf("Session Token: %s\n", res.SessionToken)
	fmt.Printf("Refresh Token: %s\n", res.RefreshToken)
}