List Country Codes

GET /api/v1/phone-numbers/countries?provider=telnyx

{
  "detail": "Provider must be 'twilio' or 'telnyx'"
}

{
  "detail": "Internal error: Provider API unavailable"
}

curl -X GET "https://api.burki.dev/api/v1/phone-numbers/countries?provider=telnyx" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Get Telnyx coverage
curl -X GET "https://api.burki.dev/api/v1/phone-numbers/countries?provider=telnyx" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Get Twilio coverage  
curl -X GET "https://api.burki.dev/api/v1/phone-numbers/countries?provider=twilio" \
  -H "Authorization: Bearer YOUR_API_KEY"

const axios = require('axios');

async function getCountryCodes(provider = 'telnyx') {
  try {
    const response = await axios.get(`https://api.burki.dev/api/v1/phone-numbers/countries?provider=${provider}`, {
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
      }
    });
    
    return response.data.country_codes;
  } catch (error) {
    console.error('Failed to get country codes:', error.response.data);
    throw error;
  }
}

// Usage
const telnyxCountries = await getCountryCodes('telnyx');
const twilioCountries = await getCountryCodes('twilio');

// Find countries supported by both providers
const commonCountries = telnyxCountries.filter(code => 
  twilioCountries.includes(code)
);

import requests

def get_country_codes(provider='telnyx'):
    url = f"https://api.burki.dev/api/v1/phone-numbers/countries?provider={provider}"
    headers = {"Authorization": "Bearer YOUR_API_KEY"}
    
    response = requests.get(url, headers=headers)
    
    if response.status_code == 200:
        return response.json()['country_codes']
    else:
        raise Exception(f"Failed to get country codes: {response.json()['detail']}")

# Usage
telnyx_countries = get_country_codes('telnyx')
twilio_countries = get_country_codes('twilio')

# Compare coverage
print(f"Telnyx supports {len(telnyx_countries)} countries")
print(f"Twilio supports {len(twilio_countries)} countries")

<?php
function getCountryCodes($provider = 'telnyx') {
    $url = "https://api.burki.dev/api/v1/phone-numbers/countries?provider=" . urlencode($provider);
    $headers = ['Authorization: Bearer YOUR_API_KEY'];
    
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode === 200) {
        return json_decode($response, true)['country_codes'];
    } else {
        throw new Exception("Failed to get country codes: " . $response);
    }
}

// Usage
$countries = getCountryCodes('telnyx');
?>

async function buildCountryDropdown() {
  const countries = await getCountryCodes('telnyx');
  const countryNames = {
    'US': 'United States',
    'CA': 'Canada',
    'GB': 'United Kingdom',
    'AU': 'Australia',
    'DE': 'Germany',
    // ... more mappings
  };
  
  return countries.map(code => ({
    value: code,
    label: countryNames[code] || code
  }));
}

def compare_provider_coverage():
    telnyx_countries = get_country_codes('telnyx')
    twilio_countries = get_country_codes('twilio')
    
    only_telnyx = set(telnyx_countries) - set(twilio_countries)
    only_twilio = set(twilio_countries) - set(telnyx_countries)
    both_providers = set(telnyx_countries) & set(twilio_countries)
    
    return {
        'telnyx_only': list(only_telnyx),
        'twilio_only': list(only_twilio),
        'both_providers': list(both_providers)
    }

async function validateCountrySupport(countryCode, provider) {
  const supportedCountries = await getCountryCodes(provider);
  
  if (!supportedCountries.includes(countryCode)) {
    throw new Error(`${provider} does not support country code: ${countryCode}`);
  }
  
  return true;
}

// Usage
try {
  await validateCountrySupport('FR', 'telnyx');
  // Proceed with number search
} catch (error) {
  console.error('Country not supported:', error.message);
}

class CountryCodeCache {
  constructor() {
    this.cache = new Map();
    this.TTL = 24 * 60 * 60 * 1000; // 24 hours
  }
  
  async getCountryCodes(provider) {
    const cacheKey = `countries_${provider}`;
    const cached = this.cache.get(cacheKey);
    
    if (cached && Date.now() - cached.timestamp < this.TTL) {
      return cached.data;
    }
    
    const countries = await getCountryCodes(provider);
    this.cache.set(cacheKey, {
      data: countries,
      timestamp: Date.now()
    });
    
    return countries;
  }
}

def get_country_codes_with_fallback(provider='telnyx'):
    try:
        return get_country_codes(provider)
    except Exception as e:
        # Log error but return common countries as fallback
        logger.error(f"Failed to fetch country codes from {provider}: {e}")
        return ['US', 'CA', 'GB', 'AU', 'DE', 'FR']  # Common fallback

async function monitorCountryAvailability() {
  const providers = ['twilio', 'telnyx'];
  const results = {};
  
  for (const provider of providers) {
    try {
      const countries = await getCountryCodes(provider);
      results[provider] = {
        success: true,
        count: countries.length,
        countries: countries
      };
    } catch (error) {
      results[provider] = {
        success: false,
        error: error.message
      };
    }
  }
  
  return results;
}