Error Reference

import axios, { AxiosError } from 'axios';

try {
  const { data } = await client.post('/v1/messages', payload);
  console.log('Sent:', data.message_id);
} catch (err) {
  const e = err as AxiosError<{ error: { code: string; message: string; request_id: string } }>;

  if (e.response) {
    const { code, message, request_id } = e.response.data.error;
    console.error(`[${code}] ${message} (req: ${request_id})`);

    switch (e.response.status) {
      case 401:
        // Re-check your API key in Settings → Developers
        break;
      case 403:
        // Add the missing scope when creating the key
        break;
      case 409:
        // Contact already exists — search by phone instead
        break;
      case 429: {
        const retryAfter = e.response.headers['retry-after'];
        await new Promise(r => setTimeout(r, Number(retryAfter) * 1000));
        // retry...
        break;
      }
      case 500:
        // Log and alert your team — include request_id when contacting support
        break;
    }
  }
}

import time
import httpx

try:
    resp = client.post("/v1/messages", json=payload)
    resp.raise_for_status()
    print("Sent:", resp.json()["message_id"])

except httpx.HTTPStatusError as exc:
    error = exc.response.json().get("error", {})
    code = error.get("code")
    request_id = error.get("request_id")
    print(f"[{code}] {error.get('message')} (req: {request_id})")

    if exc.response.status_code == 429:
        retry_after = int(exc.response.headers.get("retry-after", 5))
        time.sleep(retry_after)
        # retry...

    elif exc.response.status_code >= 500:
        raise

use Illuminate\Http\Client\RequestException;

try {
    $response = Http::withHeaders(['X-API-Key' => env('SAFRAVO_API_KEY')])
        ->post('https://api.safravo.com/v1/messages', $payload)
        ->throw();

    $messageId = $response->json('message_id');

} catch (RequestException $e) {
    $error     = $e->response->json('error');
    $code      = $error['code'];
    $requestId = $error['request_id'];

    Log::error("[safravo:{$code}] {$error['message']}", ['request_id' => $requestId]);

    match ($e->response->status()) {
        429 => sleep((int) $e->response->header('Retry-After')),
        409 => null,  // duplicate — safe to ignore or fetch existing
        default => throw $e,
    };
}

type APIError struct {
    Code      string `json:"code"`
    Message   string `json:"message"`
    RequestID string `json:"request_id"`
}
type ErrorResponse struct {
    Error APIError `json:"error"`
}

resp, err := http.DefaultClient.Do(req)
if err != nil {
    panic(err)
}
defer resp.Body.Close()

if resp.StatusCode >= 400 {
    var errResp ErrorResponse
    json.NewDecoder(resp.Body).Decode(&errResp)

    fmt.Printf("[%s] %s (req: %s)\n",
        errResp.Error.Code,
        errResp.Error.Message,
        errResp.Error.RequestID)

    if resp.StatusCode == 429 {
        retryAfter := resp.Header.Get("Retry-After")
        // parse and sleep
    }
}

response = http.request(request)

unless response.is_a?(Net::HTTPSuccess)
  error = JSON.parse(response.body)['error']
  puts "[#{error['code']}] #{error['message']} (req: #{error['request_id']})"

  case response.code.to_i
  when 429
    sleep(response['retry-after'].to_i)
    # retry...
  when 409
    # duplicate — look up by phone
  when 500..599
    raise "Safravo internal error: #{error['request_id']}"
  end
end