Autenticação

class PontuaClient {
  constructor({ token, baseUrl = 'https://api.pontua.com.br' }) {
    if (!token) throw new Error('PONTUA_API_TOKEN obrigatório')
    this.token = token
    this.baseUrl = baseUrl
  }

  async fetch(path, init = {}) {
    const response = await fetch(`${this.baseUrl}${path}`, {
      ...init,
      headers: {
        Authorization: `Bearer ${this.token}`,
        Accept: 'application/json',
        ...init.headers,
      },
    })

    if (response.status === 401) {
      const erro = await response.json()
      throw new TokenInvalidoError(erro.message)
    }

    if (!response.ok) {
      const erro = await response.json()
      throw new PontuaApiError(response.status, erro)
    }

    return response.json()
  }
}

const pontua = new PontuaClient({ token: process.env.PONTUA_API_TOKEN })
const { resultados } = await pontua.fetch('/colaborador?pagina=0&limite=10')

import os
import requests

class PontuaClient:
    def __init__(self, token: str = None, base_url: str = "https://api.pontua.com.br"):
        self.token = token or os.environ.get("PONTUA_API_TOKEN")
        if not self.token:
            raise ValueError("PONTUA_API_TOKEN obrigatório")
        self.base_url = base_url

    def request(self, method: str, path: str, **kwargs):
        headers = kwargs.pop("headers", {})
        headers["Authorization"] = f"Bearer {self.token}"
        headers.setdefault("Accept", "application/json")

        resp = requests.request(method, f"{self.base_url}{path}",
                                headers=headers, timeout=30, **kwargs)

        if resp.status_code == 401:
            raise TokenInvalidoError(resp.json().get("message"))

        if not resp.ok:
            raise PontuaApiError(resp.status_code, resp.json())

        return resp.json()

pontua = PontuaClient()
data = pontua.request("GET", "/colaborador", params={"pagina": 0, "limite": 10})

package pontua

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

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

func NewClient() *Client {
    token := os.Getenv("PONTUA_API_TOKEN")
    if token == "" {
        panic("PONTUA_API_TOKEN obrigatório")
    }
    return &Client{
        Token:   token,
        BaseURL: "https://api.pontua.com.br",
        HTTP:    &http.Client{Timeout: 30 * time.Second},
    }
}

func (c *Client) Do(req *http.Request, out interface{}) error {
    req.Header.Set("Authorization", "Bearer "+c.Token)
    req.Header.Set("Accept", "application/json")
    req.URL, _ = url.Parse(c.BaseURL + req.URL.Path + "?" + req.URL.RawQuery)

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

    if resp.StatusCode == 401 {
        body, _ := io.ReadAll(resp.Body)
        return fmt.Errorf("token inválido: %s", body)
    }
    if resp.StatusCode >= 400 {
        body, _ := io.ReadAll(resp.Body)
        return fmt.Errorf("HTTP %d: %s", resp.StatusCode, body)
    }
    return json.NewDecoder(resp.Body).Decode(out)
}

require 'net/http'
require 'json'

class PontuaClient
  BASE_URL = 'https://api.pontua.com.br'

  def initialize(token: ENV['PONTUA_API_TOKEN'])
    raise 'PONTUA_API_TOKEN obrigatório' if token.nil? || token.empty?
    @token = token
  end

  def request(method, path, body: nil, params: {})
    uri = URI("#{BASE_URL}#{path}")
    uri.query = URI.encode_www_form(params) unless params.empty?

    klass = { get: Net::HTTP::Get, post: Net::HTTP::Post,
              patch: Net::HTTP::Patch, delete: Net::HTTP::Delete }[method]
    req = klass.new(uri)
    req['Authorization'] = "Bearer #{@token}"
    req['Accept'] = 'application/json'
    req['Content-Type'] = 'application/json' if body
    req.body = body.to_json if body

    resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }

    raise "Token inválido: #{resp.body}" if resp.code == '401'
    raise "HTTP #{resp.code}: #{resp.body}" if resp.code.to_i >= 400

    JSON.parse(resp.body)
  end
end

pontua = PontuaClient.new
data = pontua.request(:get, '/colaborador', params: { pagina: 0, limite: 10 })