Release Phone Number

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

{
  "detail": "Phone number +14155551234 not found in database"
}

{
  "detail": "Failed to release phone number from telnyx"
}

# 1. List your current numbers (optional)
curl -X GET "https://api.burki.dev/api/v1/assistants/organization/phone-numbers" \
  -H "Authorization: Bearer YOUR_API_KEY"

# 2. Release a specific number
curl -X POST "https://api.burki.dev/api/v1/phone-numbers/release" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "phone_number": "+14155551234"
  }'

# 3. Number is immediately unavailable

# Release multiple numbers
for number in "+14155551234" "+14155551235" "+14155551236"; do
  curl -X POST "https://api.burki.dev/api/v1/phone-numbers/release" \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d "{\"phone_number\": \"$number\"}"
done

{
  "phone_number": "+14155551234"
}

{
  "phone_number": "+18005551234",
  "provider": "twilio"
}

{
  "phone_number": "+12125551234"
}

{
  "phone_number": "+14155551234",
  "provider": "twilio"
}

const axios = require('axios');

async function releasePhoneNumber(phoneNumber, provider = null) {
  try {
    const requestData = { phone_number: phoneNumber };
    if (provider) {
      requestData.provider = provider;
    }

    const response = await axios.post('https://api.burki.dev/api/v1/phone-numbers/release', requestData, {
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
      }
    });
    
    console.log(`Successfully released ${phoneNumber} from ${response.data.provider}`);
    return response.data;
  } catch (error) {
    console.error('Release failed:', error.response.data);
    throw error;
  }
}

// Usage with auto-detection
await releasePhoneNumber('+14155551234');

// Usage with explicit provider
await releasePhoneNumber('+14155551234', 'telnyx');

import requests

def release_phone_number(phone_number, provider=None):
    url = "https://api.burki.dev/api/v1/phone-numbers/release"
    headers = {
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json"
    }
    
    payload = {"phone_number": phone_number}
    if provider:
        payload["provider"] = provider
    
    response = requests.post(url, json=payload, headers=headers)
    
    if response.status_code == 200:
        return response.json()
    else:
        raise Exception(f"Release failed: {response.json()['detail']}")

# Usage examples
result = release_phone_number("+14155551234")  # Auto-detect provider
result = release_phone_number("+14155551234", "telnyx")  # Explicit provider

<?php
function releasePhoneNumber($phoneNumber, $provider = null) {
    $url = 'https://api.burki.dev/api/v1/phone-numbers/release';
    $headers = [
        'Authorization: Bearer YOUR_API_KEY',
        'Content-Type: application/json'
    ];
    
    $data = ['phone_number' => $phoneNumber];
    if ($provider) {
        $data['provider'] = $provider;
    }
    
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
    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);
    } else {
        throw new Exception("Release failed: " . $response);
    }
}

// Usage
$result = releasePhoneNumber('+14155551234');
?>

async function releaseMultipleNumbers(phoneNumbers) {
  const results = [];
  
  for (const phoneNumber of phoneNumbers) {
    try {
      const result = await releasePhoneNumber(phoneNumber);
      results.push({ phoneNumber, success: true, result });
    } catch (error) {
      results.push({ phoneNumber, success: false, error: error.message });
    }
  }
  
  return results;
}

// Usage
const numbersToRelease = ['+14155551234', '+14155551235', '+14155551236'];
const results = await releaseMultipleNumbers(numbersToRelease);

def release_unused_numbers(unused_threshold_days=30):
    """Release numbers that haven't been used for calls in X days"""
    
    # Get list of numbers and their last usage
    numbers = get_phone_number_usage()
    
    for number_info in numbers:
        if number_info['days_since_last_call'] > unused_threshold_days:
            try:
                result = release_phone_number(number_info['phone_number'])
                print(f"Released unused number: {number_info['phone_number']}")
            except Exception as e:
                print(f"Failed to release {number_info['phone_number']}: {e}")

async function safeRelease(phoneNumber) {
  try {
    // Check if number has recent activity
    const usage = await checkNumberUsage(phoneNumber);
    if (usage.recentCalls > 0) {
      throw new Error('Number has recent activity, release cancelled');
    }
    
    return await releasePhoneNumber(phoneNumber);
  } catch (error) {
    console.error(`Failed to release ${phoneNumber}:`, error.message);
    // Log to monitoring system
    // Send alert to admin
    throw error;
  }
}