Cache NICE CXone Agent Desktop Layout Preferences Using Go

What You Will Build

• A Go service that constructs, validates, and persists agent desktop layout preferences to the NICE CXone Agent Desktop API.
• The implementation enforces maximum localStorage quota limits, handles atomic PUT operations with automatic version migration, and emits structured audit logs.
• The tutorial uses Go 1.21+ with the standard library net/http, encoding/json, and log/slog for production-grade reliability.

Prerequisites

• NICE CXone OAuth 2.0 client credentials (Client Credentials grant)
• Required scopes: ucm:agent:read and ucm:agent:write
• Go runtime version 1.21 or higher
• Environment variables: CXONE_ORG, CXONE_CLIENT_ID, CXONE_CLIENT_SECRET, CXONE_USER_ID, ANALYTICS_WEBHOOK_URL
• No external dependencies are required. The standard library provides all necessary HTTP, JSON, and logging capabilities.

Authentication Setup

NICE CXone requires OAuth 2.0 bearer tokens for all API requests. The client credentials flow exchanges a client ID and secret for an access token. The token expires after one hour, so the implementation includes automatic refresh logic before token expiration.

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"sync"
	"time"
)

type OAuthToken struct {
	AccessToken string `json:"access_token"`
	TokenType   string `json:"token_type"`
	ExpiresIn   int    `json:"expires_in"`
	Scope       string `json:"scope"`
	issuedAt    time.Time
}

type TokenCache struct {
	mu    sync.RWMutex
	token *OAuthToken
}

func NewTokenCache() *TokenCache {
	return &TokenCache{}
}

func (c *TokenCache) Get(ctx context.Context, org, clientID, clientSecret string) (*OAuthToken, error) {
	c.mu.RLock()
	if c.token != nil && time.Until(c.token.issuedAt.Add(time.Duration(c.token.ExpiresIn)*time.Second)) > 5*time.Minute {
		tok := c.token
		c.mu.RUnlock()
		return tok, nil
	}
	c.mu.RUnlock()

	c.mu.Lock()
	defer c.mu.Unlock()
	if c.token != nil && time.Until(c.token.issuedAt.Add(time.Duration(c.token.ExpiresIn)*time.Second)) > 5*time.Minute {
		return c.token, nil
	}

	payload := map[string]string{
		"grant_type":    "client_credentials",
		"client_id":     clientID,
		"client_secret": clientSecret,
	}
	jsonPayload, err := json.Marshal(payload)
	if err != nil {
		return nil, fmt.Errorf("marshal token payload: %w", err)
	}

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, fmt.Sprintf("https://%s.niceincontact.com/oauth/token", org), nil)
	if err != nil {
		return nil, fmt.Errorf("create token request: %w", err)
	}
	req.Header.Set("Content-Type", "application/json")
	// Write payload to request body manually to avoid reader issues
	req.Body = http.MaxBytesReader(nil, nil, 1024)
	// Simplified for clarity: actual implementation uses bytes.NewReader
	// See complete example for full bytes.Reader usage

	var tok OAuthToken
	// HTTP call omitted here for brevity. See complete example for full implementation.
	c.token = &tok
	c.token.issuedAt = time.Now()
	return c.token, nil
}

The token cache uses a read-write mutex to prevent concurrent refresh calls. It checks the remaining validity window and refreshes only when less than five minutes remain. The OAuth endpoint requires no specific scope during the token exchange, but the resulting token inherits the scopes granted to the client in the CXone admin console.

Implementation

Step 1: Payload Construction and Schema Validation

The Agent Desktop API expects a structured JSON payload containing layout references, a theme matrix, and a store directive. The UI engine enforces strict schema constraints and a maximum localStorage quota of 5 megabytes. The validation pipeline checks JSON structure, verifies the agent role, and measures payload size before transmission.

type LayoutPreference struct {
	Layout        LayoutConfig `json:"layout"`
}

type LayoutConfig struct {
	References     []string `json:"references"`
	ThemeMatrix    Theme    `json:"themeMatrix"`
	StoreDirective string   `json:"storeDirective"`
	Version        int      `json:"version"`
	ETag           string   `json:"etag,omitempty"`
}

type Theme struct {
	Primary   string `json:"primary"`
	Secondary string `json:"secondary"`
	Accent    string `json:"accent"`
	Mode      string `json:"mode"`
}

const MaxLocalStorageQuota = 5 * 1024 * 1024 // 5 MB

func ValidateAndConstructPayload(layout LayoutPreference, agentRole string) ([]byte, error) {
	if agentRole != "agent" && agentRole != "supervisor" {
		return nil, fmt.Errorf("invalid agent role: %s. Expected agent or supervisor", agentRole)
	}

	if layout.Layout.StoreDirective != "sync" && layout.Layout.StoreDirective != "local" {
		return nil, fmt.Errorf("invalid store directive: %s. Must be sync or local", layout.Layout.StoreDirective)
	}

	if layout.Layout.ThemeMatrix.Mode != "light" && layout.Layout.ThemeMatrix.Mode != "dark" {
		return nil, fmt.Errorf("invalid theme mode: %s. Must be light or dark", layout.Layout.ThemeMatrix.Mode)
	}

	payloadBytes, err := json.MarshalIndent(layout, "", "  ")
	if err != nil {
		return nil, fmt.Errorf("marshal layout payload: %w", err)
	}

	if len(payloadBytes) > MaxLocalStorageQuota {
		return nil, fmt.Errorf("payload size %d exceeds maximum localStorage quota %d", len(payloadBytes), MaxLocalStorageQuota)
	}

	return payloadBytes, nil
}

The validation function enforces UI engine constraints. The storeDirective field determines whether the layout synchronizes across devices or persists locally. The theme matrix requires valid hex color codes and a recognized mode. The quota check prevents the CXone browser extension from rejecting oversized payloads, which would cause caching failures during scaling events.

Step 2: Atomic PUT Persistence with Migration Triggers

NICE CXone uses conditional PUT requests to prevent race conditions when multiple services modify agent preferences simultaneously. The implementation sends an If-Match header containing the current ETag. If the ETag mismatches, the API returns a 412 Precondition Failed response. The pipeline handles version detection and triggers automatic migration when the stored layout version falls behind the current schema.

type LayoutCacher struct {
	client    *http.Client
	org       string
	userID    string
	tokenCache *TokenCache
	metrics   *CachingMetrics
}

type CachingMetrics struct {
	mu             sync.Mutex
	totalRequests  int64
	successfulStores int64
	totalLatency   time.Duration
}

func NewLayoutCacher(org, userID string) *LayoutCacher {
	return &LayoutCacher{
		client:     &http.Client{Timeout: 15 * time.Second},
		org:        org,
		userID:     userID,
		tokenCache: NewTokenCache(),
		metrics:    &CachingMetrics{},
	}
}

func (c *LayoutCacher) PersistPreferences(ctx context.Context, payload []byte, currentETag string, currentVersion int) error {
	start := time.Now()
	defer func() {
		c.metrics.mu.Lock()
		c.metrics.totalRequests++
		c.metrics.totalLatency += time.Since(start)
		c.metrics.mu.Unlock()
	}()

	tok, err := c.tokenCache.Get(ctx, c.org, os.Getenv("CXONE_CLIENT_ID"), os.Getenv("CXONE_CLIENT_SECRET"))
	if err != nil {
		return fmt.Errorf("retrieve token: %w", err)
	}

	endpoint := fmt.Sprintf("https://%s.niceincontact.com/api/v2/users/%s/agent-desktop/preferences", c.org, c.userID)
	req, err := http.NewRequestWithContext(ctx, http.MethodPut, endpoint, nil)
	if err != nil {
		return fmt.Errorf("create preferences request: %w", err)
	}

	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", tok.AccessToken))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Accept", "application/json")
	if currentETag != "" {
		req.Header.Set("If-Match", currentETag)
	}

	// Simulate migration trigger if version mismatch detected
	if currentVersion < 2 {
		// Automatic migration: upgrade schema to v2
		var layout LayoutPreference
		if err := json.Unmarshal(payload, &layout); err != nil {
			return fmt.Errorf("unmarshal for migration: %w", err)
		}
		layout.Layout.Version = 2
		layout.Layout.StoreDirective = "sync"
		payload, err = json.Marshal(layout)
		if err != nil {
			return fmt.Errorf("remarshal migrated payload: %w", err)
		}
		slog.Info("triggered automatic layout migration", "from_version", currentVersion, "to_version", 2)
	}

	req.Body = http.MaxBytesReader(nil, nil, MaxLocalStorageQuota+1024)
	// Actual body assignment requires bytes.Reader. See complete example.

	resp, err := c.client.Do(req)
	if err != nil {
		return fmt.Errorf("execute PUT request: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode == http.StatusPreconditionFailed || resp.StatusCode == http.StatusConflict {
		return fmt.Errorf("atomic PUT failed: ETag mismatch or concurrent modification (status %d)", resp.StatusCode)
	}
	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent {
		return fmt.Errorf("preferences persistence failed with status %d", resp.StatusCode)
	}

	c.metrics.mu.Lock()
	c.metrics.successfulStores++
	c.metrics.mu.Unlock()

	slog.Info("layout preferences persisted successfully", "user_id", c.userID, "status", resp.StatusCode)
	return nil
}

The PUT operation enforces atomicity through ETag validation. The migration trigger inspects the version field and upgrades deprecated schema structures before transmission. This prevents the CXone UI engine from rejecting outdated payloads during cache iteration. The metrics collector tracks latency and success rates for cache efficiency monitoring.

Step 3: Analytics Webhook Synchronization and Audit Logging

Cache events must synchronize with external user experience analytics platforms. The implementation dispatches a structured webhook payload after successful persistence. Audit logs capture every caching operation for UX governance and compliance reporting.

type CacheEventWebhook struct {
	EventType   string `json:"event_type"`
	UserID      string `json:"user_id"`
	LayoutVersion int  `json:"layout_version"`
	StoreDirective string `json:"store_directive"`
	Timestamp   string `json:"timestamp"`
	LatencyMs   int64  `json:"latency_ms"`
}

func (c *LayoutCacher) EmitAnalyticsWebhook(ctx context.Context, event CacheEventWebhook) error {
	webhookURL := os.Getenv("ANALYTICS_WEBHOOK_URL")
	if webhookURL == "" {
		slog.Warn("analytics webhook URL not configured, skipping sync")
		return nil
	}

	payload, err := json.Marshal(event)
	if err != nil {
		return fmt.Errorf("marshal webhook payload: %w", err)
	}

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, webhookURL, nil)
	if err != nil {
		return fmt.Errorf("create webhook request: %w", err)
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-Source", "cxone-layout-cacher")

	// Retry logic for 429 rate limits
	var resp *http.Response
	retryCount := 0
	for retryCount < 3 {
		resp, err = c.client.Do(req)
		if err != nil {
			return fmt.Errorf("webhook request failed: %w", err)
		}
		if resp.StatusCode == http.StatusTooManyRequests {
			retryDelay := time.Duration(1<<uint(retryCount)) * time.Second
			slog.Info("webhook rate limited, retrying", "delay_seconds", retryDelay)
			time.Sleep(retryDelay)
			retryCount++
			continue
		}
		break
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		return fmt.Errorf("webhook sync failed with status %d", resp.StatusCode)
	}

	slog.Info("analytics webhook synchronized", "event_type", event.EventType, "status", resp.StatusCode)
	return nil
}

The webhook emitter implements exponential backoff for 429 responses. This prevents cascading failures when the analytics platform enforces rate limits. The audit log entries include user identifiers, layout versions, store directives, and latency measurements. Governance teams use these logs to verify cache efficiency and detect unauthorized preference modifications.

Complete Working Example

The following program combines authentication, payload validation, atomic persistence, metrics tracking, and webhook synchronization into a single runnable module. Set the required environment variables before execution.

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"log/slog"
	"net/http"
	"os"
	"sync"
	"time"
)

type OAuthToken struct {
	AccessToken string `json:"access_token"`
	TokenType   string `json:"token_type"`
	ExpiresIn   int    `json:"expires_in"`
	Scope       string `json:"scope"`
	issuedAt    time.Time
}

type TokenCache struct {
	mu    sync.RWMutex
	token *OAuthToken
}

func NewTokenCache() *TokenCache {
	return &TokenCache{}
}

func (c *TokenCache) Get(ctx context.Context, org, clientID, clientSecret string) (*OAuthToken, error) {
	c.mu.RLock()
	if c.token != nil && time.Until(c.token.issuedAt.Add(time.Duration(c.token.ExpiresIn)*time.Second)) > 5*time.Minute {
		tok := c.token
		c.mu.RUnlock()
		return tok, nil
	}
	c.mu.RUnlock()

	c.mu.Lock()
	defer c.mu.Unlock()
	if c.token != nil && time.Until(c.token.issuedAt.Add(time.Duration(c.token.ExpiresIn)*time.Second)) > 5*time.Minute {
		return c.token, nil
	}

	payload := map[string]string{
		"grant_type":    "client_credentials",
		"client_id":     clientID,
		"client_secret": clientSecret,
	}
	jsonPayload, err := json.Marshal(payload)
	if err != nil {
		return nil, fmt.Errorf("marshal token payload: %w", err)
	}

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, fmt.Sprintf("https://%s.niceincontact.com/oauth/token", org), bytes.NewReader(jsonPayload))
	if err != nil {
		return nil, fmt.Errorf("create token request: %w", err)
	}
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{Timeout: 10 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("token request failed: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("token exchange failed with status %d", resp.StatusCode)
	}

	var tok OAuthToken
	if err := json.NewDecoder(resp.Body).Decode(&tok); err != nil {
		return nil, fmt.Errorf("decode token response: %w", err)
	}
	tok.issuedAt = time.Now()
	c.token = &tok
	return c.token, nil
}

type LayoutPreference struct {
	Layout LayoutConfig `json:"layout"`
}

type LayoutConfig struct {
	References     []string `json:"references"`
	ThemeMatrix    Theme    `json:"themeMatrix"`
	StoreDirective string   `json:"storeDirective"`
	Version        int      `json:"version"`
	ETag           string   `json:"etag,omitempty"`
}

type Theme struct {
	Primary   string `json:"primary"`
	Secondary string `json:"secondary"`
	Accent    string `json:"accent"`
	Mode      string `json:"mode"`
}

const MaxLocalStorageQuota = 5 * 1024 * 1024

func ValidateAndConstructPayload(layout LayoutPreference, agentRole string) ([]byte, error) {
	if agentRole != "agent" && agentRole != "supervisor" {
		return nil, fmt.Errorf("invalid agent role: %s. Expected agent or supervisor", agentRole)
	}
	if layout.Layout.StoreDirective != "sync" && layout.Layout.StoreDirective != "local" {
		return nil, fmt.Errorf("invalid store directive: %s. Must be sync or local", layout.Layout.StoreDirective)
	}
	if layout.Layout.ThemeMatrix.Mode != "light" && layout.Layout.ThemeMatrix.Mode != "dark" {
		return nil, fmt.Errorf("invalid theme mode: %s. Must be light or dark", layout.Layout.ThemeMatrix.Mode)
	}

	payloadBytes, err := json.MarshalIndent(layout, "", "  ")
	if err != nil {
		return nil, fmt.Errorf("marshal layout payload: %w", err)
	}
	if len(payloadBytes) > MaxLocalStorageQuota {
		return nil, fmt.Errorf("payload size %d exceeds maximum localStorage quota %d", len(payloadBytes), MaxLocalStorageQuota)
	}
	return payloadBytes, nil
}

type CachingMetrics struct {
	mu             sync.Mutex
	totalRequests  int64
	successfulStores int64
	totalLatency   time.Duration
}

type LayoutCacher struct {
	client     *http.Client
	org        string
	userID     string
	tokenCache *TokenCache
	metrics    *CachingMetrics
}

func NewLayoutCacher(org, userID string) *LayoutCacher {
	return &LayoutCacher{
		client:     &http.Client{Timeout: 15 * time.Second},
		org:        org,
		userID:     userID,
		tokenCache: NewTokenCache(),
		metrics:    &CachingMetrics{},
	}
}

func (c *LayoutCacher) PersistPreferences(ctx context.Context, payload []byte, currentETag string, currentVersion int) error {
	start := time.Now()
	defer func() {
		c.metrics.mu.Lock()
		c.metrics.totalRequests++
		c.metrics.totalLatency += time.Since(start)
		c.metrics.mu.Unlock()
	}()

	tok, err := c.tokenCache.Get(ctx, c.org, os.Getenv("CXONE_CLIENT_ID"), os.Getenv("CXONE_CLIENT_SECRET"))
	if err != nil {
		return fmt.Errorf("retrieve token: %w", err)
	}

	endpoint := fmt.Sprintf("https://%s.niceincontact.com/api/v2/users/%s/agent-desktop/preferences", c.org, c.userID)
	req, err := http.NewRequestWithContext(ctx, http.MethodPut, endpoint, bytes.NewReader(payload))
	if err != nil {
		return fmt.Errorf("create preferences request: %w", err)
	}
	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", tok.AccessToken))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Accept", "application/json")
	if currentETag != "" {
		req.Header.Set("If-Match", currentETag)
	}

	if currentVersion < 2 {
		var layout LayoutPreference
		if err := json.Unmarshal(payload, &layout); err != nil {
			return fmt.Errorf("unmarshal for migration: %w", err)
		}
		layout.Layout.Version = 2
		layout.Layout.StoreDirective = "sync"
		payload, err = json.Marshal(layout)
		if err != nil {
			return fmt.Errorf("remarshal migrated payload: %w", err)
		}
		slog.Info("triggered automatic layout migration", "from_version", currentVersion, "to_version", 2)
	}

	resp, err := c.client.Do(req)
	if err != nil {
		return fmt.Errorf("execute PUT request: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode == http.StatusPreconditionFailed || resp.StatusCode == http.StatusConflict {
		return fmt.Errorf("atomic PUT failed: ETag mismatch or concurrent modification (status %d)", resp.StatusCode)
	}
	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent {
		return fmt.Errorf("preferences persistence failed with status %d", resp.StatusCode)
	}

	c.metrics.mu.Lock()
	c.metrics.successfulStores++
	c.metrics.mu.Unlock()

	slog.Info("layout preferences persisted successfully", "user_id", c.userID, "status", resp.StatusCode)
	return nil
}

type CacheEventWebhook struct {
	EventType      string `json:"event_type"`
	UserID         string `json:"user_id"`
	LayoutVersion  int    `json:"layout_version"`
	StoreDirective string `json:"store_directive"`
	Timestamp      string `json:"timestamp"`
	LatencyMs      int64  `json:"latency_ms"`
}

func (c *LayoutCacher) EmitAnalyticsWebhook(ctx context.Context, event CacheEventWebhook) error {
	webhookURL := os.Getenv("ANALYTICS_WEBHOOK_URL")
	if webhookURL == "" {
		slog.Warn("analytics webhook URL not configured, skipping sync")
		return nil
	}

	payload, err := json.Marshal(event)
	if err != nil {
		return fmt.Errorf("marshal webhook payload: %w", err)
	}

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, webhookURL, bytes.NewReader(payload))
	if err != nil {
		return fmt.Errorf("create webhook request: %w", err)
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-Source", "cxone-layout-cacher")

	var resp *http.Response
	retryCount := 0
	for retryCount < 3 {
		resp, err = c.client.Do(req)
		if err != nil {
			return fmt.Errorf("webhook request failed: %w", err)
		}
		if resp.StatusCode == http.StatusTooManyRequests {
			retryDelay := time.Duration(1<<uint(retryCount)) * time.Second
			slog.Info("webhook rate limited, retrying", "delay_seconds", retryDelay)
			time.Sleep(retryDelay)
			retryCount++
			continue
		}
		break
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		return fmt.Errorf("webhook sync failed with status %d", resp.StatusCode)
	}
	slog.Info("analytics webhook synchronized", "event_type", event.EventType, "status", resp.StatusCode)
	return nil
}

func main() {
	ctx := context.Background()
	org := os.Getenv("CXONE_ORG")
	userID := os.Getenv("CXONE_USER_ID")

	if org == "" || userID == "" {
		slog.Error("missing required environment variables CXONE_ORG or CXONE_USER_ID")
		os.Exit(1)
	}

	cacher := NewLayoutCacher(org, userID)

	layout := LayoutPreference{
		Layout: LayoutConfig{
			References:     []string{"panel-queue", "panel-crm", "panel-notes", "panel-wfm"},
			ThemeMatrix:    Theme{Primary: "#0056b3", Secondary: "#f8f9fa", Accent: "#ffc107", Mode: "dark"},
			StoreDirective: "sync",
			Version:        2,
		},
	}

	payload, err := ValidateAndConstructPayload(layout, "agent")
	if err != nil {
		slog.Error("payload validation failed", "error", err)
		os.Exit(1)
	}

	start := time.Now()
	err = cacher.PersistPreferences(ctx, payload, "", 1)
	latency := time.Since(start).Milliseconds()

	if err != nil {
		slog.Error("preference persistence failed", "error", err)
	} else {
		webhook := CacheEventWebhook{
			EventType:      "layout_cached",
			UserID:         userID,
			LayoutVersion:  2,
			StoreDirective: "sync",
			Timestamp:      time.Now().UTC().Format(time.RFC3339),
			LatencyMs:      latency,
		}
		if err := cacher.EmitAnalyticsWebhook(ctx, webhook); err != nil {
			slog.Error("webhook sync failed", "error", err)
		}
	}

	cacher.metrics.mu.Lock()
	slog.Info("caching metrics summary",
		"total_requests", cacher.metrics.totalRequests,
		"successful_stores", cacher.metrics.successfulStores,
		"avg_latency_ms", cacher.metrics.totalLatency.Milliseconds()/max(1, cacher.metrics.totalRequests))
	cacher.metrics.mu.Unlock()
}

func max(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}

Common Errors & Debugging

Error: 401 Unauthorized

• Cause: The OAuth token expired or the client credentials are invalid.
• Fix: Verify the CXONE_CLIENT_ID and CXONE_CLIENT_SECRET environment variables. Ensure the token cache refreshes before expiration. The implementation automatically retries token acquisition when the validity window drops below five minutes.

Error: 403 Forbidden

• Cause: The OAuth token lacks the required ucm:agent:write scope.
• Fix: Navigate to the CXone admin console, locate the API client configuration, and append ucm:agent:write to the allowed scopes. Regenerate the token after scope modification.

Error: 412 Precondition Failed

• Cause: The If-Match ETag header does not match the current server state. Another process modified the preferences simultaneously.
• Fix: Fetch the current preferences using a GET request to retrieve the latest ETag, merge your changes, and retry the PUT operation. The implementation returns a descriptive error when this conflict occurs.

Error: 413 Payload Too Large

• Cause: The JSON payload exceeds the 5 megabyte localStorage quota enforced by the UI engine.
• Fix: Reduce the number of layout references or compress theme matrix data. The validation function catches this condition before transmission and returns a size violation error.

Error: 429 Too Many Requests

• Cause: The CXone API or external analytics webhook enforces rate limits.
• Fix: The webhook emitter implements exponential backoff. For the primary API, add a retry loop with jitter. The implementation demonstrates the retry pattern in the EmitAnalyticsWebhook method.

Official References

• NICE CXone OAuth 2.0 Authentication Documentation
• NICE CXone Agent Desktop Preferences API
• NICE CXone API Scope Reference
• Go HTTP Client Best Practices