OAuth 2.0

# .env

SAMSARA_CLIENT_ID=<your_client_id>
SAMSARA_CLIENT_SECRET=<your_client_secret>

<a href="https://api.samsara.com/oauth2/authorize?client_id=IEC65XwwV9&state=z3qAr0h5Ud&response_type=code">Connect to Samsara</a>

const clientId = process.env.SAMSARA_OAUTH_CLIENT_ID;
const clientSecret = process.env.SAMSARA_OAUTH_CLIENT_SECRET;

// Base64 encoded authorization string
const auth = Buffer.from(`${clientId}:${clientSecret}`).toString("base64");

// Make the request with header `Authorization: Basic ${auth}`

client_id = os.getenv("SAMSARA_OAUTH_CLIENT_ID")
client_secret = os.getenv("SAMSARA_OAUTH_CLIENT_SECRET")

# Base64 encoded authorization string
auth = base64.b64encode(f"{client_id}:{client_secret}".encode()).decode()

# Make the request with header: `Authorization: Basic ${auth}`

# Note: The `requests` library supports Basic Auth by passing a tuple of (client_id, client_secret) to the `auth` parameter
# E.g.  
#   requests.post(
#     'https://api.samsara.com/oauth2/token', 
#     auth=(SAMSARA_CLIENT_ID, SAMSARA_CLIENT_SECRET), 
#     data={'grant_type': 'refresh_token', 'refresh_token': token })

client_id = ENV['SAMSARA_CLIENT_ID']
client_secret = ENV['SAMSARA_CLIENT_SECRET']
auth = Base64.strict_encode64("#{client_id}:#{client_secret}")

var clientId = Environment.GetEnvironmentVariable("SAMSARA_CLIENT_ID");
var clientSecret = Environment.GetEnvironmentVariable("SAMSARA_CLIENT_SECRET");

var auth = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes($"{clientId}:{clientSecret}"));

// using var client = new HttpClient();
// client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", auth);

// Add basic auth header
clientId := os.Getenv("SAMSARA_CLIENT_ID")
clientSecret := os.Getenv("SAMSARA_CLIENT_SECRET")
combined := clientId + ":" + clientSecret
auth := base64.StdEncoding.EncodeToString([]byte(combined))

// req.Header.Add("Authorization", "Basic "+auth)

String clientId = System.getenv("SAMSARA_CLIENT_ID");
String clientSecret = System.getenv("SAMSARA_CLIENT_SECRET");

String combinedSecrets = clientId + ":" + clientSecret;
String auth = Base64.getEncoder().encodeToString(combinedSecrets.getBytes());

// HttpRequest request =
//     HttpRequest.newBuilder()
//        .header("Authorization", "Basic " + auth)
//        .build();

// Create authorization header
$combined = $_ENV['SAMSARA_CLIENT_ID'] . ':' . $_ENV['SAMSARA_CLIENT_SECRET'];
$auth = base64_encode($combined);

// $ch = curl_init();
// curl_setopt($ch, CURLOPT_HTTPHEADER, [
//     'Authorization: Basic ' . $encoded_auth,
// ]);

{
  "access_token": "hXdwQUq3GBKZTvSLyURh",
  "expires_in": 3599,
  "scope": "admin:read",
  "token_type": "bearer",
  "refresh_token": "tGzv3JOkF0XG5Qx2TlKWIA"
}

POST /oauth2/token HTTP/1.1
Host: api.samsara.com
Content-Type: application/x-www-form-urlencoded
Authorization: Basic bXlfaWQ6bXlfc2VjcmV0

code=hgg2tziN39&grant_type=authorization_code

curl -X POST \
  https://api.samsara.com/oauth2/token \
  -H 'Authorization: Basic bXlfaWQ6bXlfc2VjcmV0' \
  -d 'code=hgg2tziN39&grant_type=authorization_code'

// Using node-fetch
const fetch = (...args) =>
  import("node-fetch").then(({ default: fetch }) => fetch(...args));

const clientId = process.env.SAMSARA_CLIENT_ID;
const clientSecret = process.env.SAMSARA_CLIENT_SECRET;

// Base64 encoded authorization string
const auth = Buffer.from(`${clientId}:${clientSecret}`).toString("base64");

const response = await fetch("https://api.samsara.com/oauth2/token", {
  method: "POST",
  headers: {
    "Content-Type": "application/x-www-form-urlencoded",
    Authorization: `Basic ${auth}`,
  },
  body: new URLSearchParams({
    grant_type: "authorization_code",
    code: code, // from query string
  }),
});

const {access_token, refresh_token, expires_in} = await response.json();

// Calculate expire timestamp
const expiresAt = Math.floor(Date.now() / 1000) + expires_in;

// Store in session
const credentials = {
  access_token: access_token,
  refresh_token: refresh_token,
  expires_at: expiresAt,
};

SAMSARA_CLIENT_ID = os.getenv('SAMSARA_CLIENT_ID')
SAMSARA_CLIENT_SECRET = os.getenv('SAMSARA_CLIENT_SECRET')

# Within your redirect handler:
response = requests.post(
    "https://api.samsara.com/oauth2/token",
    data={
        'code': code, # from query string
        'grant_type': 'authorization_code',
    },
    auth=(SAMSARA_CLIENT_ID, SAMSARA_CLIENT_SECRET)
)

token_data = response.json()
access_token = token_data.get('access_token')
refresh_token = token_data.get('refresh_token')
expires_at = time.time() + token_data.get('expires_in')

# Store the tokens in the session
credentials = {
    'access_token': access_token,
    'refresh_token': refresh_token,
    'expires_at': expires_at
}
print(credentials)

auth = Base64.strict_encode64("#{ENV['SAMSARA_CLIENT_ID']}:#{ENV['SAMSARA_CLIENT_SECRET']}")

uri = URI('https://api.samsara.com/oauth2/token')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/x-www-form-urlencoded'
request['Authorization'] = "Basic #{auth}"
request.body = URI.encode_www_form({
  code: params[:code], # from query string
  grant_type: 'authorization_code',
})

response = http.request(request)

if response.code == '200'
  token_data = JSON.parse(response.body)
  access_token = token_data['access_token']
  refresh_token = token_data['refresh_token']
  expires_in = token_data['expires_in']

  # Calculate expires_at timestamp
  expires_at = Time.now.to_i + expires_in

  credentials = {
    'access_token' => access_token,
    'refresh_token' => refresh_token,
    'expires_at' => expires_at
  }
end

using var client = new HttpClient();
var tokenRequest = new FormUrlEncodedContent(new Dictionary<string, string>
{
    ["grant_type"] = "authorization_code",
    ["code"] = code // from query string
});

// Add Basic Auth header
var clientId = Environment.GetEnvironmentVariable("SAMSARA_CLIENT_ID");
var clientSecret = Environment.GetEnvironmentVariable("SAMSARA_CLIENT_SECRET");
var auth = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes($"{clientId}:{clientSecret}"));
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", auth);

var response = await client.PostAsync("https://api.samsara.com/oauth2/token", tokenRequest);
var result = await response.Content.ReadAsStringAsync();

if (!response.IsSuccessStatusCode)
{
    context.Response.StatusCode = 400;
    await context.Response.WriteAsync($"Failed to exchange code for tokens: {result}");
    return;
}

// Parse token response using JsonElement to handle numeric values correctly
var tokenResponse = System.Text.Json.JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(result);
var accessToken = tokenResponse["access_token"].GetString();
var refreshToken = tokenResponse["refresh_token"].GetString();
var expiresIn = tokenResponse["expires_in"].GetInt32();

// Calculate when the token will expire
var expiresAt = DateTimeOffset.UtcNow.AddSeconds(expiresIn).ToUnixTimeSeconds();

var credentials = new Dictionary<string, string>
{
    ["access_token"] = accessToken,
    ["refresh_token"] = refreshToken,
    ["expires_at"] = expiresAt.ToString()
};

client := &http.Client{}

tokenURL := "https://api.samsara.com/oauth2/token"
data := url.Values{}
data.Set("code", code)
data.Set("grant_type", "authorization_code")

req, err := http.NewRequest("POST", tokenURL, strings.NewReader(data.Encode()))
if err != nil {
  http.Error(w, "Error creating token request", http.StatusInternalServerError)
  return
}

// Add headers
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

// Add basic auth header
auth := os.Getenv("SAMSARA_CLIENT_ID") + ":" + os.Getenv("SAMSARA_CLIENT_SECRET")
basicAuth := base64.StdEncoding.EncodeToString([]byte(auth))
req.Header.Add("Authorization", "Basic "+basicAuth)

// Make request
resp, err := client.Do(req)
if err != nil {
  http.Error(w, "Error exchanging code for token", http.StatusInternalServerError)
  return
}
defer resp.Body.Close()

// Parse response
var result struct {
  AccessToken  string `json:"access_token"`
  RefreshToken string `json:"refresh_token"`
  ExpiresIn    int    `json:"expires_in"`
  TokenType    string `json:"token_type"`
  Scope        string `json:"scope"`
}

if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
  http.Error(w, "Error parsing token response", http.StatusInternalServerError)
  return
}

// Store tokens in session
credentials := map[string]interface{}{
  "access_token":  result.AccessToken,
  "refresh_token": result.RefreshToken,
  "expires_at":    time.Now().Unix(), // + int64(result.ExpiresIn),
}

HttpClient client = HttpClient.newHttpClient();
String code = "<code from query string>";
String requestBody =
    String.format("grant_type=authorization_code&code=%s", code);

String clientId = System.getenv("SAMSARA_CLIENT_ID");
String clientSecret = System.getenv("SAMSARA_CLIENT_SECRET");
String auth = Base64.getEncoder().encodeToString(
    (clientId + ":" + clientSecret).getBytes());

HttpRequest request =
    HttpRequest.newBuilder()
        .uri(URI.create("https://api.samsara.com/oauth2/token"))
        .header("Content-Type", "application/x-www-form-urlencoded")
        .header("Authorization", "Basic " + auth)
        .POST(HttpRequest.BodyPublishers.ofString(requestBody))
        .build();

HttpResponse<String> response =
    client.send(request, HttpResponse.BodyHandlers.ofString());

if (response.statusCode() != 200) {
  res.status(400);
  return "Failed to exchange code for tokens";
}

JsonObject tokens =
    JsonParser.parseString(response.body()).getAsJsonObject();
String accessToken = tokens.get("access_token").getAsString();
String refreshToken = tokens.get("refresh_token").getAsString();
long expiresIn = tokens.get("expires_in").getAsLong();
long expiresAt = System.currentTimeMillis() / 1000 + expiresIn;

<?php

// Extract code and state from query string
$code = $_GET['code'] ?? null;

// Create authorization header
$auth = $_ENV['SAMSARA_CLIENT_ID'] . ':' . $_ENV['SAMSARA_CLIENT_SECRET'];
$encoded_auth = base64_encode($auth);

// Initialize cURL session
$ch = curl_init();

// Set cURL options for token exchange
curl_setopt($ch, CURLOPT_URL, 'https://api.samsara.com/oauth2/token');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Basic ' . $encoded_auth,
    'Content-Type: application/x-www-form-urlencoded'
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query([
    'grant_type' => 'authorization_code',
    'code' => $code,
]));

// Execute request
$response = curl_exec($ch);

// Check for cURL errors
if (curl_errno($ch)) {
    die('Error exchanging code for tokens: ' . curl_error($ch));
}

// Close cURL session
curl_close($ch);

// Parse response
$token_data = json_decode($response, true);

// Calculate expires_at timestamp
$expires_at = time() + $token_data['expires_in'];

// Store credentials in session
$credentials = [
    'access_token' => $token_data['access_token'],
    'refresh_token' => $token_data['refresh_token'],
    'expires_at' => $expires_at
];

Authorization: Bearer <access_token>

curl -X GET \
  https://api.samsara.com/fleet/vehicles \
  -H 'Authorization: Bearer hXdwQUq3GBKZTvSLyURh'

const accessToken = 'hXdwQUq3GBKZTvSLyURh';

// Using node-fetch
const fetch = (...args) =>
  import("node-fetch").then(({ default: fetch }) => fetch(...args));

fetch('https://api.samsara.com/fleet/vehicles', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${accessToken}`,
    'Content-Type': 'application/json',
  }
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

access_token = 'hXdwQUq3GBKZTvSLyURh'

headers = {
    'Authorization': f'Bearer {access_token}',
    'Content-Type': 'application/json'
}

response = requests.get('https://api.samsara.com/fleet/vehicles', headers=headers)
response.raise_for_status()
vehicles = response.json()
print(vehicles)

access_token = 'hXdwQUq3GBKZTvSLyURh'

uri = URI('https://api.samsara.com/fleet/vehicles')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = "Bearer #{access_token}"

response = http.request(request)
p response

var accessToken = "hXdwQUq3GBKZTvSLyURh";

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken);
var response = await client.GetAsync("https://api.samsara.com/fleet/vehicles");
var rawResponse = await response.Content.ReadAsStringAsync();

accessToken := "hXdwQUq3GBKZTvSLyURh"

client := &http.Client{}
req, err := http.NewRequest("GET", "https://api.samsara.com/fleet/vehicles", nil)
if err != nil {
  http.Error(w, "Error creating request", http.StatusInternalServerError)
  return
}

// Add headers
req.Header.Add("Authorization", "Bearer "+accessToken)
req.Header.Add("Content-Type", "application/json")

// Make request
resp, err := client.Do(req)
if err != nil {
  http.Error(w, "Error making request", http.StatusInternalServerError)
  return
}
defer resp.Body.Close()
fmt.Println(resp.Body)

String accessToken = "hXdwQUq3GBKZTvSLyURh";

HttpClient client = HttpClient.newHttpClient();
HttpRequest request =
    HttpRequest.newBuilder()
        .uri(URI.create("https://api.samsara.com/fleet/vehicles"))
        .header("Authorization", "Bearer " + accessToken)
        .GET()
        .build();

HttpResponse<String> response =
    client.send(request, HttpResponse.BodyHandlers.ofString());

if (response.statusCode() != 200) {
  return "API call failed with status code: " + response.statusCode();
}

System.out.println(response.body());

<?php
  
$access_token = 'hXdwQUq3GBKZTvSLyURh';

$ch = curl_init();

// Set cURL options
curl_setopt($ch, CURLOPT_URL, 'https://api.samsara.com/fleet/vehicles');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer ' . $access_token,
    'Accept: application/json'
]);

// Execute request
$response = curl_exec($ch);

// Check for errors
if (curl_errno($ch)) {
    die('Error making API request: ' . curl_error($ch));
}

// Get HTTP status code
$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);

// Close cURL session
curl_close($ch);

// Set JSON content type header
header('Content-Type: application/json');

// Check if request was successful
if ($http_code !== 200) {
    die(json_encode([
        'error' => 'API request failed',
        'status' => $http_code,
        'response' => $response
    ]));
}

// Output response
echo $response;

const clientId = process.env.SAMSARA_OAUTH_CLIENT_ID;
const clientSecret = process.env.SAMSARA_OAUTH_CLIENT_SECRET;

// Base64 encoded authorization string
const auth = Buffer.from(`${clientId}:${clientSecret}`).toString("base64");

// Make the request with header `Authorization: Basic ${auth}`

client_id = os.getenv("SAMSARA_OAUTH_CLIENT_ID")
client_secret = os.getenv("SAMSARA_OAUTH_CLIENT_SECRET")

# Base64 encoded authorization string
auth = base64.b64encode(f"{client_id}:{client_secret}".encode()).decode()

# Make the request with header: `Authorization: Basic ${auth}`

# Note: The `requests` library supports Basic Auth by passing a tuple of (client_id, client_secret) to the `auth` parameter
# E.g.  
#   requests.post(
#     'https://api.samsara.com/oauth2/token', 
#     auth=(SAMSARA_CLIENT_ID, SAMSARA_CLIENT_SECRET), 
#     data={'grant_type': 'refresh_token', 'refresh_token': token })

client_id = ENV['SAMSARA_CLIENT_ID']
client_secret = ENV['SAMSARA_CLIENT_SECRET']
auth = Base64.strict_encode64("#{client_id}:#{client_secret}")

var clientId = Environment.GetEnvironmentVariable("SAMSARA_CLIENT_ID");
var clientSecret = Environment.GetEnvironmentVariable("SAMSARA_CLIENT_SECRET");

var auth = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes($"{clientId}:{clientSecret}"));

// using var client = new HttpClient();
// client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", auth);

// Add basic auth header
clientId := os.Getenv("SAMSARA_CLIENT_ID")
clientSecret := os.Getenv("SAMSARA_CLIENT_SECRET")
combined := clientId + ":" + clientSecret
auth := base64.StdEncoding.EncodeToString([]byte(combined))

// req.Header.Add("Authorization", "Basic "+auth)

String clientId = System.getenv("SAMSARA_CLIENT_ID");
String clientSecret = System.getenv("SAMSARA_CLIENT_SECRET");

String combinedSecrets = clientId + ":" + clientSecret;
String auth = Base64.getEncoder().encodeToString(combinedSecrets.getBytes());

// HttpRequest request =
//     HttpRequest.newBuilder()
//        .header("Authorization", "Basic " + auth)
//        .build();

// Create authorization header
$combined = $_ENV['SAMSARA_CLIENT_ID'] . ':' . $_ENV['SAMSARA_CLIENT_SECRET'];
$auth = base64_encode($combined);

// $ch = curl_init();
// curl_setopt($ch, CURLOPT_HTTPHEADER, [
//     'Authorization: Basic ' . $encoded_auth,
// ]);

{
  "access_token": "2YotnFZFEjr1zCsicMWpAA",
  "refresh_token": "tGzv3JOkF0XG5Qx2TlKWIA",
  "expires_in": 3599,
  "scope": "admin:read",
  "token_type": "bearer"
}

curl -X POST \
  https://api.samsara.com/oauth2/revoke \
  -H 'Authorization: Basic bXlfaWQ6bXlfc2VjcmV0' \
  -d 'token=tGzv3JOkF0XG5Qx2TlKWIA'

const clientId = process.env.SAMSARA_CLIENT_ID;
const clientSecret = process.env.SAMSARA_CLIENT_SECRET;
const refreshToken = 'tGzv3JOkF0XG5Qx2TlKWIA';

const auth = Buffer.from(`${clientId}:${clientSecret}`).toString("base64");

fetch('https://api.samsara.com/oauth2/revoke', {
  method: 'POST',
  headers: {
    'Authorization': `Basic ${auth}`
  },
  body: `token=${refreshToken}`
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

client_id = os.getenv("SAMSARA_CLIENT_ID")
client_secret = os.getenv("SAMSARA_CLIENT_SECRET")
refresh_token = 'tGzv3JOkF0XG5Qx2TlKWIA'

# Within your revoke handler:
response = requests.post(
    "https://api.samsara.com/oauth2/revoke",
    data={
        'token': refresh_token,
    },
    auth=(client_id, client_secret)
)

print(response.json())

client_id = ENV['SAMSARA_CLIENT_ID']
client_secret = ENV['SAMSARA_CLIENT_SECRET']
auth = Base64.strict_encode64("#{client_id}:#{client_secret}")
refresh_token = 'tGzv3JOkF0XG5Qx2TlKWIA'

uri = URI('https://api.samsara.com/oauth2/revoke')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/x-www-form-urlencoded'
request['Authorization'] = "Basic #{auth}"
request.body = URI.encode_www_form({
  token: refresh_token
})

response = http.request(request)

var clientId = Environment.GetEnvironmentVariable("SAMSARA_CLIENT_ID");
var clientSecret = Environment.GetEnvironmentVariable("SAMSARA_CLIENT_SECRET");
var refreshToken = "tGzv3JOkF0XG5Qx2TlKWIA";

// Call Samsara revoke endpoint
using var client = new HttpClient();
var revokeEndpoint = "https://api.samsara.com/oauth2/revoke";

// Add basic auth header
var auth = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes($"{clientId}:{clientSecret}"));
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", auth);

var revokeRequest = new Dictionary<string, string>
{
    { "token", refreshToken }
};

var revokeResponse = await client.PostAsync(revokeEndpoint, new FormUrlEncodedContent(revokeRequest));
var revokeResponseContent = await revokeResponse.Content.ReadAsStringAsync();

Console.WriteLine(revokeResponseContent);

clientId := os.Getenv("SAMSARA_CLIENT_ID")
clientSecret := os.Getenv("SAMSARA_CLIENT_SECRET")
refreshToken := "tGzv3JOkF0XG5Qx2TlKWIA"

// Create auth header
auth := clientId + ":" + clientSecret
basicAuth := base64.StdEncoding.EncodeToString([]byte(auth))

// Create request with refresh token in body
client := &http.Client{}
data := url.Values{}
data.Set("token", refreshToken)
req, err := http.NewRequest("POST", "https://api.samsara.com/oauth2/revoke", strings.NewReader(data.Encode()))
if err != nil {
  http.Error(w, "Error creating request", http.StatusInternalServerError)
  return
}

// Add headers
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
req.Header.Add("Authorization", "Basic "+basicAuth)

// Make request
resp, err := client.Do(req)
if err != nil {
  http.Error(w, "Error making request", http.StatusInternalServerError)
  return
}

defer resp.Body.Close()

String clientId = System.getenv("SAMSARA_CLIENT_ID");
String clientSecret = System.getenv("SAMSARA_CLIENT_SECRET");
String refreshToken = "tGzv3JOkF0XG5Qx2TlKWIA";

HttpClient client = HttpClient.newHttpClient();

String auth = Base64.getEncoder().encodeToString(
    (clientId + ":" + clientSecret).getBytes());

// Build request body
String requestBody = "token=" + refreshToken;

// Create request
HttpRequest request =
    HttpRequest.newBuilder()
        .uri(URI.create("https://api.samsara.com/oauth2/revoke"))
        .header("Content-Type", "application/x-www-form-urlencoded")
        .header("Authorization", "Basic " + auth)
        .POST(HttpRequest.BodyPublishers.ofString(requestBody))
        .build();

HttpResponse<String> response =
    client.send(request, HttpResponse.BodyHandlers.ofString());

<?php

$refresh_token = 'tGzv3JOkF0XG5Qx2TlKWIA';

// Create authorization header
$auth = $_ENV['SAMSARA_CLIENT_ID'] . ':' . $_ENV['SAMSARA_CLIENT_SECRET'];
$encoded_auth = base64_encode($auth);

// Initialize cURL session
$ch = curl_init();

// Set cURL options
curl_setopt($ch, CURLOPT_URL, 'https://api.samsara.com/oauth2/revoke');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Basic ' . $encoded_auth,
    'Content-Type: application/x-www-form-urlencoded'
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query([
    'token' => $refresh_token
]));

// Execute request
$response = curl_exec($ch);

// Get HTTP status code
$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);

// Check for errors
if (curl_errno($ch)) {
    die('Error revoking token: ' . curl_error($ch));
}

// Close cURL session
curl_close($ch);

const clientId = process.env.SAMSARA_OAUTH_CLIENT_ID;
const clientSecret = process.env.SAMSARA_OAUTH_CLIENT_SECRET;

// Base64 encoded authorization string
const auth = Buffer.from(`${clientId}:${clientSecret}`).toString("base64");

// Make the request with header `Authorization: Basic ${auth}`

client_id = os.getenv("SAMSARA_OAUTH_CLIENT_ID")
client_secret = os.getenv("SAMSARA_OAUTH_CLIENT_SECRET")

# Base64 encoded authorization string
auth = base64.b64encode(f"{client_id}:{client_secret}".encode()).decode()

# Make the request with header: `Authorization: Basic ${auth}`

# Note: The `requests` library supports Basic Auth by passing a tuple of (client_id, client_secret) to the `auth` parameter
# E.g.  
#   requests.post(
#     'https://api.samsara.com/oauth2/token', 
#     auth=(SAMSARA_CLIENT_ID, SAMSARA_CLIENT_SECRET), 
#     data={'grant_type': 'refresh_token', 'refresh_token': token })

client_id = ENV['SAMSARA_CLIENT_ID']
client_secret = ENV['SAMSARA_CLIENT_SECRET']
auth = Base64.strict_encode64("#{client_id}:#{client_secret}")

var clientId = Environment.GetEnvironmentVariable("SAMSARA_CLIENT_ID");
var clientSecret = Environment.GetEnvironmentVariable("SAMSARA_CLIENT_SECRET");

var auth = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes($"{clientId}:{clientSecret}"));

// using var client = new HttpClient();
// client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", auth);

// Add basic auth header
clientId := os.Getenv("SAMSARA_CLIENT_ID")
clientSecret := os.Getenv("SAMSARA_CLIENT_SECRET")
combined := clientId + ":" + clientSecret
auth := base64.StdEncoding.EncodeToString([]byte(combined))

// req.Header.Add("Authorization", "Basic "+auth)

String clientId = System.getenv("SAMSARA_CLIENT_ID");
String clientSecret = System.getenv("SAMSARA_CLIENT_SECRET");

String combinedSecrets = clientId + ":" + clientSecret;
String auth = Base64.getEncoder().encodeToString(combinedSecrets.getBytes());

// HttpRequest request =
//     HttpRequest.newBuilder()
//        .header("Authorization", "Basic " + auth)
//        .build();

// Create authorization header
$combined = $_ENV['SAMSARA_CLIENT_ID'] . ':' . $_ENV['SAMSARA_CLIENT_SECRET'];
$auth = base64_encode($combined);

// $ch = curl_init();
// curl_setopt($ch, CURLOPT_HTTPHEADER, [
//     'Authorization: Basic ' . $encoded_auth,
// ]);