Get Access Token

 
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Text.Json.Serialization;

public class TokenApiResponse
{
    public bool IsSuccessful { get; set; } = false;

    public string Scope { get; set; }

    [JsonPropertyName("token_type")]
    public string TokenType { get; set; }

    [JsonPropertyName("expires_in")]
    public int ExpiresIn { get; set; }

    [JsonPropertyName("access_token")]
    public string AccessToken { get; set; }
}

class Program
{
    static async Task Main(string[] args)
    {
        // Replace with your actual values
        var clientId = "YOUR_CLIENT_ID";
        var clientSecret = "YOUR_CLIENT_SECRET";
        var tokenUrl = "{{tokenUrl}}";

        using var client = new HttpClient();

        // Encode credentials (clientId:clientSecret) in Base64
        var credentials = $"{clientId}:{clientSecret}";
        var base64Credentials = Convert.ToBase64String(
            Encoding.UTF8.GetBytes(credentials)
        );

        // Set headers
        client.DefaultRequestHeaders.Authorization =
            new AuthenticationHeaderValue("Basic", base64Credentials);

        try
        {
            var data = new[]
            {
                new KeyValuePair<string, string>("grant_type", "client_credentials"),
            };

            var response = await client.PostAsync(
                tokenUrl,
                new FormUrlEncodedContent(data)
            );

            if (!response.IsSuccessStatusCode)
            {
                throw new Exception($"HTTP error: {response.StatusCode}");
            }

            var responseContent = await response.Content.ReadAsStringAsync();

            // Deserialize JSON into DTO
            var tokenResponse = JsonSerializer.Deserialize<TokenApiResponse>(
                responseContent,
                new JsonSerializerOptions
                {
                    PropertyNameCaseInsensitive = true
                }
            );

            if (tokenResponse == null)
            {
                throw new Exception("Failed to deserialize token response.");
            }

            tokenResponse.IsSuccessful = true;

            Console.WriteLine($"Access token: {tokenResponse.AccessToken}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error fetching token: {ex.Message}");
        }
    }
}

 
// If using Node <18, install node-fetch:
// npm install node-fetch
// const fetch = require("node-fetch");

const clientId = "YOUR_CLIENT_ID";
const clientSecret = "YOUR_CLIENT_SECRET";
const tokenUrl = "{{tokenUrl}}";

// DTO-style structure
class TokenApiResponse {
  constructor(data) {
    this.isSuccessful = false;
    this.scope = data.scope;
    this.token_type = data.token_type;
    this.expires_in = data.expires_in;
    this.access_token = data.access_token;
  }
}

async function fetchToken() {
  try {
    // Encode credentials (clientId:clientSecret) in Base64
    const credentials = Buffer.from(`${clientId}:${clientSecret}`).toString("base64");

    const response = await fetch(tokenUrl, {
      method: "POST",
      headers: {
        "Content-Type": "application/x-www-form-urlencoded",
        "Authorization": `Basic ${credentials}`,
      },
      body: new URLSearchParams({
        grant_type: "client_credentials",
      }),
    });

    if (!response.ok) {
      throw new Error(`HTTP error: ${response.status}`);
    }

    const json = await response.json();

    // Map response to DTO
    const tokenResponse = new TokenApiResponse(json);
    tokenResponse.isSuccessful = true;

    console.log("Access token:", tokenResponse.access_token);

    return tokenResponse;
  } catch (error) {
    console.error("Error fetching token:", error.message);
    return null;
  }
}

// Execute
fetchToken();