curl -X GET https://app.reservei.co/api/v1/wallet/balance \
  -H "Authorization: Bearer mbx_live_sua_chave_aqui" \
  -H "Content-Type: application/json"

// Usando fetch nativo
const apiKey = process.env.RESERVEI_API_KEY;

const response = await fetch('https://app.reservei.co/api/v1/wallet/balance', {
  headers: {
    'Authorization': `Bearer ${apiKey}`,
    'Content-Type': 'application/json'
  }
});

const data = await response.json();

// Criando um cliente reutilizável
class ReserveiClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://app.reservei.co/api/v1';
  }

  async request(endpoint, options = {}) {
    const response = await fetch(`${this.baseUrl}${endpoint}`, {
      ...options,
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json',
        ...options.headers
      }
    });
    
    if (!response.ok) {
      const error = await response.json();
      throw new Error(error.message || 'API Error');
    }
    
    return response.json();
  }
}

const reservei = new ReserveiClient(process.env.RESERVEI_API_KEY);

import os
import requests

api_key = os.environ.get('RESERVEI_API_KEY')

# Requisição simples
headers = {
    'Authorization': f'Bearer {api_key}',
    'Content-Type': 'application/json'
}

response = requests.get(
    'https://app.reservei.co/api/v1/wallet/balance',
    headers=headers
)

data = response.json()

# Classe cliente reutilizável
class ReserveiClient:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = 'https://app.reservei.co/api/v1'
        self.session = requests.Session()
        self.session.headers.update({
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        })
    
    def get(self, endpoint):
        response = self.session.get(f'{self.base_url}{endpoint}')
        response.raise_for_status()
        return response.json()
    
    def post(self, endpoint, data):
        response = self.session.post(f'{self.base_url}{endpoint}', json=data)
        response.raise_for_status()
        return response.json()

reservei = ReserveiClient(os.environ['RESERVEI_API_KEY'])

<?php

$apiKey = getenv('RESERVEI_API_KEY');
$baseUrl = 'https://app.reservei.co/api/v1';

// Usando cURL
$ch = curl_init();
curl_setopt_array($ch, [
    CURLOPT_URL => $baseUrl . '/wallet/balance',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Content-Type: application/json'
    ]
]);

$response = curl_exec($ch);
$data = json_decode($response, true);
curl_close($ch);

// Classe cliente
class ReserveiClient {
    private $apiKey;
    private $baseUrl = 'https://app.reservei.co/api/v1';
    
    public function __construct($apiKey) {
        $this->apiKey = $apiKey;
    }
    
    public function request($method, $endpoint, $data = null) {
        $ch = curl_init();
        curl_setopt_array($ch, [
            CURLOPT_URL => $this->baseUrl . $endpoint,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_CUSTOMREQUEST => $method,
            CURLOPT_HTTPHEADER => [
                'Authorization: Bearer ' . $this->apiKey,
                'Content-Type: application/json'
            ]
        ]);
        
        if ($data) {
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        }
        
        $response = curl_exec($ch);
        curl_close($ch);
        
        return json_decode($response, true);
    }
}

$reservei = new ReserveiClient(getenv('RESERVEI_API_KEY'));

package main

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

type ReserveiClient struct {
    APIKey  string
    BaseURL string
    Client  *http.Client
}

func NewReserveiClient(apiKey string) *ReserveiClient {
    return &ReserveiClient{
        APIKey:  apiKey,
        BaseURL: "https://app.reservei.co/api/v1",
        Client:  &http.Client{},
    }
}

func (c *ReserveiClient) Request(method, endpoint string, body interface{}) (*http.Response, error) {
    var buf bytes.Buffer
    if body != nil {
        json.NewEncoder(&buf).Encode(body)
    }
    
    req, err := http.NewRequest(method, c.BaseURL+endpoint, &buf)
    if err != nil {
        return nil, err
    }
    
    req.Header.Set("Authorization", "Bearer "+c.APIKey)
    req.Header.Set("Content-Type", "application/json")
    
    return c.Client.Do(req)
}

func main() {
    client := NewReserveiClient(os.Getenv("RESERVEI_API_KEY"))
    resp, _ := client.Request("GET", "/wallet/balance", nil)
    defer resp.Body.Close()
}