Error Handling

const response = await fetch('/v3/messages', { ... });
const data: ApiResponse<Message> = await response.json();

if (!data.success) {
  // Handle error
  console.error(`Error ${data.error?.code}: ${data.error?.message}`);
  return;
}

// Process successful response
console.log(data.data);

import requests

response = requests.post('/v3/messages', ...)
data = response.json()

if not data['success']:
    # Handle error
    print(f"Error {data['error']['code']}: {data['error']['message']}")
    return

# Process successful response
print(data['data'])

resp, err := http.Post("/v3/messages", "application/json", body)
if err != nil {
    log.Fatal(err)
}
defer resp.Body.Close()

var data ApiResponse[Message]
if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
    log.Fatal(err)
}

if !data.Success {
    // Handle error
    log.Printf("Error %s: %s\n", data.Error.Code, data.Error.Message)
    return
}

// Process successful response
log.Println(data.Data)

switch (data.error?.code) {
  case 'AUTH_001':
  case 'AUTH_002':
    // Redirect to login or refresh API key
    break;
  case 'RESOURCE_001':
    // Prompt user to create the resource
    break;
  case 'BUSINESS_002':
    // Implement retry with backoff
    const retryAfter = response.headers.get('Retry-After');
    await sleep(parseInt(retryAfter || '60') * 1000);
    break;
  default:
    // Log unexpected error
    console.error('Unexpected error:', data.error);
}

error_code = data['error']['code']

if error_code in ('AUTH_001', 'AUTH_002'):
    # Redirect to login or refresh API key
    pass
elif error_code == 'RESOURCE_001':
    # Prompt user to create the resource
    pass
elif error_code == 'BUSINESS_002':
    # Implement retry with backoff
    retry_after = int(response.headers.get('Retry-After', 60))
    time.sleep(retry_after)
else:
    # Log unexpected error
    print('Unexpected error:', data['error'])

switch data.Error.Code {
case "AUTH_001", "AUTH_002":
    // Redirect to login or refresh API key
case "RESOURCE_001":
    // Prompt user to create the resource
case "BUSINESS_002":
    // Implement retry with backoff
    retryAfter := resp.Header.Get("Retry-After")
    seconds, _ := strconv.Atoi(retryAfter)
    if seconds == 0 {
        seconds = 60
    }
    time.Sleep(time.Duration(seconds) * time.Second)
default:
    // Log unexpected error
    log.Printf("Unexpected error: %+v\n", data.Error)
}

console.error(`Request ID: ${data.meta.request_id}`);
// Provide this to support@sent.dm when reporting issues

print(f"Request ID: {data['meta']['request_id']}")
# Provide this to support@sent.dm when reporting issues

log.Printf("Request ID: %s\n", data.Meta.RequestID)
// Provide this to support@sent.dm when reporting issues

const idempotencyKey = `send-msg-${messageId}`;

const response = await fetch('/v3/messages', {
  method: 'POST',
  headers: {
    'x-api-key': apiKey,
    'Idempotency-Key': idempotencyKey,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(payload)
});

idempotency_key = f"send-msg-{message_id}"

response = requests.post(
    '/v3/messages',
    headers={
        'x-api-key': api_key,
        'Idempotency-Key': idempotency_key,
        'Content-Type': 'application/json'
    },
    json=payload
)

idempotencyKey := fmt.Sprintf("send-msg-%s", messageID)

req, err := http.NewRequest("POST", "/v3/messages", body)
if err != nil {
    log.Fatal(err)
}

req.Header.Set("x-api-key", apiKey)
req.Header.Set("Idempotency-Key", idempotencyKey)
req.Header.Set("Content-Type", "application/json")

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

// Validate phone number format
function isValidE164(phone: string): boolean {
  return /^\+[1-9]\d{1,14}$/.test(phone);
}

if (!isValidE164(phoneNumber)) {
  throw new Error('Phone number must be in E.164 format');
}

import re

# Validate phone number format
def is_valid_e164(phone: str) -> bool:
    return bool(re.match(r'^\+[1-9]\d{1,14}$', phone))

if not is_valid_e164(phone_number):
    raise ValueError('Phone number must be in E.164 format')

import "regexp"

// Validate phone number format
func isValidE164(phone string) bool {
    matched, _ := regexp.MatchString(`^\+[1-9]\d{1,14}$`, phone)
    return matched
}

if !isValidE164(phoneNumber) {
    log.Fatal("Phone number must be in E.164 format")
}