$endpoint = "https://routeafrica.net/modules/addons/DomainsReseller/api/index.php";
 $action = "/order/domains/renew";
 $params = [
     "domain" => "example.com",
     "regperiod" => "3",
     "addons" => [
         "dnsmanagement" => 0,
         "emailforwarding" => 1,
         "idprotection" => 1,
     ]
 ];

 $headers = [
     "username: email@example.com",
     "action: " . $action,
     "token: " . base64_encode(hash_hmac("sha256", "1234567890QWERTYUIOPASDFGHJKLZXCVBNM", "email@example.com:" . gmdate("y-m-d H")))
 ];

 $curl = curl_init();
 curl_setopt($curl, CURLOPT_URL, "{$endpoint}{$action}");
 curl_setopt($curl, CURLOPT_POST, true);
 curl_setopt($curl, CURLOPT_POSTFIELDS, http_build_query($params));
 curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, true);
 curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);

 $response = curl_exec($curl);
 curl_close($curl);

// Node.js example
 const crypto = require('crypto');

 function generateToken(apiKey, email) {
   const timestamp = new Date().toISOString().slice(2, 13).replace('T', ' ');
   const message = `${email}:${timestamp}`;
   const hash = crypto.createHmac('sha256', apiKey).update(message).digest('base64');
   return hash;
 }

 const headers = {
   'username': 'email@example.com',
   'action': '/order/domains/register',
   'token': generateToken('YOUR_API_KEY', 'email@example.com'),
   'Content-Type': 'application/json'
 };

 fetch('https://routeafrica.net/modules/addons/DomainsReseller/api/index.php/order/domains/register', {
   method: 'POST',
   headers: headers,
   body: JSON.stringify({
     domain: 'example.com',
     regperiod: '1'
   })
 })
 .then(response => response.json())
 .then(data => console.log(data));

{
  "domain": "example.com",
  "regperiod": "1",
  "addons": {
    "dnsmanagement": 1,
    "emailforwarding": 0,
    "idprotection": 1
  },
  "nameservers": {
    "ns1": "ns1.example.com",
    "ns2": "ns2.example.com"
  },
  "contacts": {
    "registrant": {
      "firstname": "John",
      "lastname": "Doe",
      "email": "john@example.com",
      "address1": "123 Main St",
      "city": "New York",
      "state": "NY",
      "postcode": "10001",
      "country": "US",
      "phonenumber": "+1-555-123-4567"
    }
  }
}

{
  "result": "success",
  "message": "Domain registration initiated successfully",
  "data": {
    "domain": "example.com",
    "orderid": "12345",
    "status": "pending",
    "estimated_completion": "2024-01-15T10:30:00Z",
    "price": "12.99",
    "currency": "USD"
  }
}

{
  "result": "error",
  "message": "Domain is not available for registration",
  "error_code": "DOMAIN_UNAVAILABLE",
  "data": {
    "domain": "example.com",
    "suggestions": [
      "example.net",
      "example.org",
      "myexample.com"
    ]
  }
}

{
  "domain": "example.com",
  "eppcode": "ABC123XYZ",
  "regperiod": "1",
  "addons": {
    "dnsmanagement": 1,
    "emailforwarding": 0,
    "idprotection": 1
  },
  "nameservers": {
    "ns1": "ns1.example.com",
    "ns2": "ns2.example.com"
  },
  "contacts": {
    "registrant": {
      "firstname": "John",
      "lastname": "Doe",
      "email": "john@example.com",
      "address1": "123 Main St",
      "city": "New York",
      "state": "NY",
      "postcode": "10001",
      "country": "US",
      "phonenumber": "+1-555-123-4567"
    }
  }
}

{
  "domain": "example.com",
  "regperiod": "1",
  "addons": {
    "dnsmanagement": 1,
    "emailforwarding": 1,
    "idprotection": 0
  }
}

{
  "domain": "example.com",
  "transfertag": "RELEASE123"
}

GET /domains/example.com/eppcode

GET /domains/example.com/contact

{
  "domain": "example.com",
  "contactdetails": {
    "Registrant": {
      "firstname": "Jane",
      "lastname": "Smith",
      "email": "jane@example.com",
      "address1": "456 Oak Ave",
      "city": "Los Angeles",
      "state": "CA",
      "postcode": "90210",
      "country": "US",
      "phonenumber": "+1-555-987-6543"
    }
  }
}

GET /domains/example.com/lock

{
  "domain": "example.com",
  "lockstatus": "locked"
}

GET /domains/example.com/dns

{
  "domain": "example.com",
  "dnsrecords": [
    {
      "hostname": "@",
      "type": "A",
      "address": "192.168.1.1",
      "priority": 0,
      "recid": "12345"
    },
    {
      "hostname": "www",
      "type": "CNAME",
      "address": "example.com",
      "priority": 0,
      "recid": "12346"
    }
  ]
}

{
  "domain": "example.com"
}

{
  "domain": "example.com"
}

{
  "domain": "example.com"
}

GET /domains/example.com/email

{
  "domain": "example.com",
  "prefix": ["info", "contact", "support"],
  "forwardto": ["admin@example.com", "support@example.com"]
}

{
  "domain": "example.com",
  "status": 1
}

{
  "searchTerm": "example",
  "tldsToInclude": ["com", "net", "org"],
  "isIdnDomain": false,
  "premiumEnabled": true
}

{
  "searchTerm": "mybusiness",
  "tldsToInclude": ["com", "net", "co", "io"],
  "isIdnDomain": false,
  "premiumEnabled": false,
  "suggestionSettings": {
    "maxSuggestions": 10,
    "includeHyphenated": true
  }
}

GET /domains/example.com/nameservers

{
  "domain": "example.com",
  "ns1": "ns1.example.com",
  "ns2": "ns2.example.com",
  "ns3": "ns3.example.com"
}

{
  "domain": "example.com",
  "nameserver": "ns1.example.com",
  "ipaddress": "192.168.1.100"
}

{
  "nameserver": "ns1.example.com",
  "currentipaddress": "192.168.1.100",
  "newipaddress": "192.168.1.200"
}

{
  "nameserver": "ns1.example.com"
}

GET /order/pricing/domains/register?domain=example.com

GET /billing/credits

GET /version

GET /tlds

GET /tlds/pricing

GET /domains/example.com/information

{
  "ns1": "string (required)",
  "ns2": "string (required)",
  "ns3": "string (optional)",
  "ns4": "string (optional)",
  "ns5": "string (optional)"
}

{
  "hostname": "string (required)",
  "type": "string (required)",
  "address": "string (required)",
  "priority": "numeric (required)",
  "recid": "string (required)"
}

{
  "registrant": "contact object (required)",
  "tech": "contact object (required)",
  "billing": "contact object (required)",
  "admin": "contact object (required)"
}

{
  "dnsmanagement": "numeric (optional)",
  "emailforwarding": "numeric (optional)",
  "idprotection": "numeric (optional)"
}

{
  "result": "success|error",
  "message": "Response message",
  "data": {
    // Response data specific to the endpoint
  }
}

{
   "result": "error",
   "message": "Human-readable error message",
   "error_code": "MACHINE_READABLE_CODE",
   "timestamp": "2024-01-15T10:30:00Z",
   "request_id": "req_123456789",
   "data": {
     // Additional error context (optional)
   }
 }

X-RateLimit-Limit: 100
 X-RateLimit-Remaining: 95
 X-RateLimit-Reset: 1642233600
 X-RateLimit-Reset-Time: 2024-01-15T11:00:00Z

// PHP Example
 function makeApiRequest($url, $data, $headers, $retries = 3) {
     $attempt = 0;
     $baseDelay = 1; // Start with 1 second delay
     
     while ($attempt < $retries) {
         $response = curl_request($url, $data, $headers);
         
         if ($response['status'] === 429) {
             $attempt++;
             if ($attempt < $retries) {
                 $delay = $baseDelay * pow(2, $attempt - 1); // Exponential backoff
                 sleep($delay);
                 continue;
             }
         }
         
         return $response;
     }
     
     throw new Exception('Max retries exceeded');
 }

 // JavaScript Example
 async function makeApiRequest(url, data, headers, retries = 3) {
     let attempt = 0;
     const baseDelay = 1000; // Start with 1 second delay
     
     while (attempt < retries) {
         try {
             const response = await fetch(url, {
                 method: 'POST',
                 headers: headers,
                 body: JSON.stringify(data)
             });
             
             if (response.status === 429) {
                 attempt++;
                 if (attempt < retries) {
                     const delay = baseDelay * Math.pow(2, attempt - 1);
                     await new Promise(resolve => setTimeout(resolve, delay));
                     continue;
                 }
             }
             
             return await response.json();
         } catch (error) {
             attempt++;
             if (attempt >= retries) throw error;
         }
     }
 }

// Complete domain registration example
 class DomainManager {
     private $apiKey;
     private $email;
     private $endpoint;
     
     public function __construct($apiKey, $email) {
         $this->apiKey = $apiKey;
         $this->email = $email;
         $this->endpoint = 'https://routeafrica.net/modules/addons/DomainsReseller/api/index.php';
     }
     
     private function generateToken($action) {
         $timestamp = gmdate('y-m-d H');
         $message = $this->email . ':' . $timestamp;
         return base64_encode(hash_hmac('sha256', $this->apiKey, $message, true));
     }
     
     private function makeRequest($action, $data = []) {
         $headers = [
             'username: ' . $this->email,
             'action: ' . $action,
             'token: ' . $this->generateToken($action),
             'Content-Type: application/json'
         ];
         
         $ch = curl_init();
         curl_setopt($ch, CURLOPT_URL, $this->endpoint . $action);
         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);
         curl_setopt($ch, CURLOPT_TIMEOUT, 30);
         curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
         
         $response = curl_exec($ch);
         $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
         curl_close($ch);
         
         return [
             'status' => $httpCode,
             'data' => json_decode($response, true)
         ];
     }
     
     public function checkDomainAvailability($domain) {
         return $this->makeRequest('/domains/lookup', [
             'searchTerm' => $domain
         ]);
     }
     
     public function registerDomain($domain, $contacts, $nameservers, $addons = []) {
         // First check availability
         $availability = $this->checkDomainAvailability($domain);
         if ($availability['data']['result'] !== 'success' || !$availability['data']['data']['available']) {
             throw new Exception('Domain is not available for registration');
         }
         
         // Proceed with registration
         return $this->makeRequest('/order/domains/register', [
             'domain' => $domain,
             'regperiod' => '1',
             'contacts' => $contacts,
             'nameservers' => $nameservers,
             'addons' => $addons
         ]);
     }
     
     public function getDomainInfo($domain) {
         return $this->makeRequest('/domains/' . $domain . '/information');
     }
 }

 // Usage example
 $domainManager = new DomainManager('YOUR_API_KEY', 'email@example.com');

 try {
     // Check availability
     $availability = $domainManager->checkDomainAvailability('example.com');
     if ($availability['data']['data']['available']) {
         // Register domain
         $result = $domainManager->registerDomain('example.com', [
             'registrant' => [
                 'firstname' => 'John',
                 'lastname' => 'Doe',
                 'email' => 'john@example.com',
                 'address1' => '123 Main St',
                 'city' => 'New York',
                 'state' => 'NY',
                 'postcode' => '10001',
                 'country' => 'US',
                 'phonenumber' => '+1-555-123-4567'
             ]
         ], [
             'ns1' => 'ns1.example.com',
             'ns2' => 'ns2.example.com'
         ], [
             'dnsmanagement' => 1,
             'idprotection' => 1
         ]);
         
         echo "Domain registered successfully: " . $result['data']['data']['orderid'];
     }
 } catch (Exception $e) {
     echo "Error: " . $e->getMessage();
 }

// Webhook handler for domain status updates
 class WebhookHandler {
     public function handleDomainStatusUpdate($payload) {
         $event = $payload['event'];
         $domain = $payload['data']['domain'];
         $status = $payload['data']['status'];
         
         switch ($event) {
             case 'domain.registered':
                 $this->handleDomainRegistered($domain, $payload['data']);
                 break;
             case 'domain.transferred':
                 $this->handleDomainTransferred($domain, $payload['data']);
                 break;
             case 'domain.renewed':
                 $this->handleDomainRenewed($domain, $payload['data']);
                 break;
             case 'domain.expired':
                 $this->handleDomainExpired($domain, $payload['data']);
                 break;
             default:
                 error_log("Unknown event: " . $event);
         }
     }
     
     private function handleDomainRegistered($domain, $data) {
         // Send confirmation email to customer
         $this->sendRegistrationConfirmation($domain, $data);
         
         // Update your database
         $this->updateDomainStatus($domain, 'active');
         
         // Set up DNS records if needed
         if (!empty($data['nameservers'])) {
             $this->configureDNS($domain, $data['nameservers']);
         }
     }
     
     private function handleDomainTransferred($domain, $data) {
         // Notify customer of successful transfer
         $this->sendTransferConfirmation($domain, $data);
         
         // Update domain status
         $this->updateDomainStatus($domain, 'transferred');
     }
     
     private function handleDomainRenewed($domain, $data) {
         // Send renewal confirmation
         $this->sendRenewalConfirmation($domain, $data);
         
         // Update expiration date
         $this->updateDomainExpiration($domain, $data['expiration_date']);
     }
     
     private function handleDomainExpired($domain, $data) {
         // Send expiration notification
         $this->sendExpirationNotification($domain, $data);
         
         // Update domain status
         $this->updateDomainStatus($domain, 'expired');
     }
 }

 // Webhook endpoint
 if ($_SERVER['REQUEST_METHOD'] === 'POST') {
     $payload = json_decode(file_get_contents('php://input'), true);
     
     // Verify webhook signature (if implemented)
     if ($this->verifyWebhookSignature($payload, $_SERVER['HTTP_X_WEBHOOK_SIGNATURE'])) {
         $handler = new WebhookHandler();
         $handler->handleDomainStatusUpdate($payload);
         
         http_response_code(200);
         echo json_encode(['status' => 'success']);
     } else {
         http_response_code(401);
         echo json_encode(['error' => 'Invalid signature']);
     }
 }