Authentication

curl -X GET "https://api-{region}.sesametime.com/core/v3/employees" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json"

const SESAME_API_TOKEN = process.env.SESAME_API_TOKEN;
const BASE_URL = 'https://api-{region}.sesametime.com';

async function fetchEmployees() {
  const response = await fetch(`${BASE_URL}/core/v3/employees`, {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${SESAME_API_TOKEN}`,
      'Content-Type': 'application/json'
    }
  });

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

  return response.json();
}

const axios = require('axios');

const sesameClient = axios.create({
  baseURL: 'https://api-{region}.sesametime.com',
  headers: {
    'Authorization': `Bearer ${process.env.SESAME_API_TOKEN}`,
    'Content-Type': 'application/json'
  }
});

// Usage
const { data } = await sesameClient.get('/core/v3/employees');

import os
import requests

class SesameAPI:
    def __init__(self):
        self.base_url = 'https://api-{region}.sesametime.com'
        self.token = os.environ.get('SESAME_API_TOKEN')
        self.headers = {
            'Authorization': f'Bearer {self.token}',
            'Content-Type': 'application/json'
        }

    def get_employees(self, **params):
        response = requests.get(
            f'{self.base_url}/core/v3/employees',
            headers=self.headers,
            params=params
        )
        response.raise_for_status()
        return response.json()

# Usage
api = SesameAPI()
employees = api.get_employees(limit=10)

import httpx
import os

async def get_employees():
    async with httpx.AsyncClient() as client:
        response = await client.get(
            'https://api-{region}.sesametime.com/core/v3/employees',
            headers={
                'Authorization': f'Bearer {os.environ["SESAME_API_TOKEN"]}',
                'Content-Type': 'application/json'
            }
        )
        response.raise_for_status()
        return response.json()

<?php
class SesameAPI {
    private string $baseUrl = 'https://api-{region}.sesametime.com';
    private string $token;

    public function __construct() {
        $this->token = getenv('SESAME_API_TOKEN');
    }

    public function getEmployees(array $params = []): array {
        $url = $this->baseUrl . '/core/v3/employees?' . http_build_query($params);

        $ch = curl_init($url);
        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => [
                'Authorization: Bearer ' . $this->token,
                'Content-Type: application/json'
            ]
        ]);

        $response = curl_exec($ch);
        $statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($statusCode >= 400) {
            throw new Exception("API Error: $statusCode");
        }

        return json_decode($response, true);
    }
}

// Usage
$api = new SesameAPI();
$employees = $api->getEmployees(['limit' => 10]);

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "os"
)

type SesameClient struct {
    BaseURL string
    Token   string
    Client  *http.Client
}

func NewSesameClient() *SesameClient {
    return &SesameClient{
        BaseURL: "https://api-{region}.sesametime.com",
        Token:   os.Getenv("SESAME_API_TOKEN"),
        Client:  &http.Client{},
    }
}

func (c *SesameClient) GetEmployees() (map[string]interface{}, error) {
    req, _ := http.NewRequest("GET", c.BaseURL+"/core/v3/employees", nil)
    req.Header.Set("Authorization", "Bearer "+c.Token)
    req.Header.Set("Content-Type", "application/json")

    resp, err := c.Client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    return result, nil
}

require 'net/http'
require 'json'

class SesameAPI
  BASE_URL = 'https://api-{region}.sesametime.com'

  def initialize
    @token = ENV['SESAME_API_TOKEN']
  end

  def get_employees(params = {})
    uri = URI("#{BASE_URL}/core/v3/employees")
    uri.query = URI.encode_www_form(params) if params.any?

    request = Net::HTTP::Get.new(uri)
    request['Authorization'] = "Bearer #{@token}"
    request['Content-Type'] = 'application/json'

    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end

    JSON.parse(response.body)
  end
end

# Usage
api = SesameAPI.new
employees = api.get_employees(limit: 10)