Classe Cliente da API

import requests
import json
from typing import Dict, Optional, Any

class APIClient:
    def __init__(self, base_url: str, token: str):
        self.base_url = base_url.rstrip('/')
        self.session = requests.Session()
        self.session.headers.update({
            'Authorization': f'Bearer {token}',
            'Content-Type': 'application/json'
        })
    
    def _request(self, method: str, endpoint: str, 
                data: Optional[Dict] = None, 
                params: Optional[Dict] = None) -> Dict[str, Any]:
        url = f"{self.base_url}{endpoint}"
        
        try:
            response = self.session.request(
                method=method,
                url=url,
                json=data,
                params=params,
                timeout=30
            )
            response.raise_for_status()
            return response.json()
            
        except requests.exceptions.RequestException as e:
            raise Exception(f"Erro de requisição: {str(e)}")
    
    def get_users(self, page: int = 1, limit: int = 10) -> Dict[str, Any]:
        params = {'page': page, 'limit': limit}
        return self._request('GET', '/users', params=params)
    
    def create_user(self, user_data: Dict[str, Any]) -> Dict[str, Any]:
        return self._request('POST', '/users', data=user_data)

Classe Cliente da API

<?php

class APIClient {
    private $baseUrl;
    private $token;
    
    public function __construct($baseUrl, $token) {
        $this->baseUrl = rtrim($baseUrl, '/');
        $this->token = $token;
    }
    
    private function request($method, $endpoint, $data = null) {
        $url = $this->baseUrl . $endpoint;
        
        $ch = curl_init();
        
        curl_setopt_array($ch, [
            CURLOPT_URL => $url,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_CUSTOMREQUEST => $method,
            CURLOPT_HTTPHEADER => [
                'Authorization: Bearer ' . $this->token,
                'Content-Type: application/json'
            ]
        ]);
        
        if ($data) {
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        }
        
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        
        if (curl_errno($ch)) {
            throw new Exception('cURL Error: ' . curl_error($ch));
        }
        
        curl_close($ch);
        
        if ($httpCode >= 400) {
            throw new Exception('HTTP Error: ' . $httpCode);
        }
        
        return json_decode($response, true);
    }
    
    public function getUsers($page = 1, $limit = 10) {
        $endpoint = "/users?page={$page}&limit={$limit}";
        return $this->request('GET', $endpoint);
    }
    
    public function createUser($userData) {
        return $this->request('POST', '/users', $userData);
    }
}

?>

Configuração de Variáveis

#!/bin/bash

# Configurações da API
API_BASE_URL="https://api.exemplo.com/v1"
API_TOKEN="seu_token_aqui"

# Listar usuários
curl -X GET "${API_BASE_URL}/users?page=1&limit=10" \
  -H "Authorization: Bearer ${API_TOKEN}" \
  -H "Content-Type: application/json"

# Criar usuário
curl -X POST "${API_BASE_URL}/users" \
  -H "Authorization: Bearer ${API_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "João Silva",
    "email": "joao@exemplo.com",
    "password": "senha123",
    "role": "user"
  }'

Instalação e Configuração

# Instalar dependências
npm install axios

// api-client.js
const axios = require('axios');

class APIClient {
  constructor(baseURL, token) {
    this.client = axios.create({
      baseURL: baseURL,
      timeout: 30000,
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json'
      }
    });
  }
  
  async getUsers(page = 1, limit = 10) {
    const response = await this.client.get('/users', {
      params: { page, limit }
    });
    return response.data;
  }
  
  async createUser(userData) {
    const response = await this.client.post('/users', userData);
    return response.data;
  }
}

module.exports = APIClient;

Estruturas e Cliente Base

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
)

type APIClient struct {
    BaseURL    string
    Token      string
    HTTPClient *http.Client
}

type User struct {
    ID    string `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
    Role  string `json:"role"`
}

func NewAPIClient(baseURL, token string) *APIClient {
    return &APIClient{
        BaseURL: baseURL,
        Token:   token,
        HTTPClient: &http.Client{
            Timeout: 30 * time.Second,
        },
    }
}

func (c *APIClient) GetUsers() ([]User, error) {
    req, err := http.NewRequest("GET", c.BaseURL+"/users", nil)
    if err != nil {
        return nil, err
    }
    
    req.Header.Set("Authorization", "Bearer "+c.Token)
    req.Header.Set("Content-Type", "application/json")
    
    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    var users []User
    if err := json.NewDecoder(resp.Body).Decode(&users); err != nil {
        return nil, err
    }
    
    return users, nil
}