Become a White-Label ISP Reseller in the UK

// Example: Node.js/Express portal pulling data from Splynx API
const express = require('express');
const axios = require('axios');
const app = express();

const SPLYNX_API = 'https://billing.yourisp.co.uk/api/2.0';
const API_KEY = process.env.SPLYNX_API_KEY;

// Customer dashboard
app.get('/dashboard', async (req, res) => {
    try {
        const customerId = req.session.customerId;
        
        // Get customer details
        const customer = await axios.get(
            `${SPLYNX_API}/admin/customers/customer/${customerId}`,
            { headers: { 'Authorization': `Splynx-EA (api_key=${API_KEY})` } }
        );
        
        // Get invoices
        const invoices = await axios.get(
            `${SPLYNX_API}/admin/finance/invoices?customer_id=${customerId}`,
            { headers: { 'Authorization': `Splynx-EA (api_key=${API_KEY})` } }
        );
        
        // Get services
        const services = await axios.get(
            `${SPLYNX_API}/admin/customers/customer/${customerId}/internet-services`,
            { headers: { 'Authorization': `Splynx-EA (api_key=${API_KEY})` } }
        );
        
        res.render('dashboard', {
            customer: customer.data,
            invoices: invoices.data,
            services: services.data
        });
    } catch (error) {
        console.error('Portal error:', error);
        res.status(500).render('error');
    }
});

// Coverage checker (using wholesaler API)
app.post('/check-coverage', async (req, res) => {
    const { postcode } = req.body;
    
    // Example: ICUK availability check
    const availability = await axios.get(
        `https://api.icuk.net/broadband/availability/${postcode}`,
        { headers: { 'Authorization': 'Bearer YOUR_ICUK_API_KEY' } }
    );
    
    res.json(availability.data);
});

app.listen(3000);

import requests
import json

class ICUKClient:
    """Example wholesale broadband API client"""
    
    def __init__(self, api_key, api_secret):
        self.base_url = "https://api.icuk.net/api/v1"
        self.session = requests.Session()
        self.session.headers.update({
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json',
            'Accept': 'application/json'
        })
    
    def check_availability(self, postcode, address_id=None):
        """Check broadband availability at a postcode/address"""
        params = {'postcode': postcode}
        if address_id:
            params['address_id'] = address_id
        response = self.session.get(
            f"{self.base_url}/broadband/availability", params=params
        )
        return response.json()
    
    def search_address(self, postcode):
        """Search for addresses at a postcode"""
        response = self.session.get(
            f"{self.base_url}/broadband/address-search",
            params={'postcode': postcode}
        )
        return response.json()
    
    def place_order(self, order_data):
        """Place a broadband order"""
        response = self.session.post(
            f"{self.base_url}/broadband/orders", json=order_data
        )
        return response.json()
    
    def get_line_details(self, service_id):
        """Get line details including sync speed, SNR, etc."""
        response = self.session.get(
            f"{self.base_url}/broadband/services/{service_id}"
        )
        return response.json()
    
    def get_usage(self, service_id, start_date, end_date):
        """Get bandwidth usage for a service"""
        response = self.session.get(
            f"{self.base_url}/broadband/services/{service_id}/usage",
            params={'start': start_date, 'end': end_date}
        )
        return response.json()
    
    def raise_fault(self, service_id, fault_data):
        """Raise a fault/ticket with the wholesaler"""
        response = self.session.post(
            f"{self.base_url}/broadband/services/{service_id}/faults",
            json=fault_data
        )
        return response.json()

# Usage example
client = ICUKClient(api_key='your_api_key', api_secret='your_api_secret')

# 1. Search for addresses
addresses = client.search_address('SW1A 1AA')

# 2. Check availability
if addresses:
    availability = client.check_availability('SW1A 1AA', addresses[0]['id'])
    for product in availability.get('products', []):
        print(f"  {product['name']}: {product['downstream_speed']}/"
              f"{product['upstream_speed']} Mbps - £{product['monthly_cost']}/mo")

# 3. Place an order
order = client.place_order({
    'address_id': addresses[0]['id'],
    'product_id': 'FTTP_80_20',
    'customer': {
        'title': 'Mr', 'first_name': 'John', 'last_name': 'Smith',
        'email': 'john@example.com', 'phone': '07700900000'
    },
    'go_live_date': '2026-04-01'
})

from flask import Flask, request, jsonify
import hmac, hashlib

app = Flask(__name__)
WEBHOOK_SECRET = 'your_webhook_secret'

@app.route('/webhooks/broadband', methods=['POST'])
def handle_broadband_webhook():
    """Handle order status updates from wholesaler"""
    
    # Verify webhook signature
    signature = request.headers.get('X-Webhook-Signature')
    payload = request.get_data()
    expected = hmac.new(
        WEBHOOK_SECRET.encode(), payload, hashlib.sha256
    ).hexdigest()
    
    if not hmac.compare_digest(signature, expected):
        return jsonify({'error': 'Invalid signature'}), 403
    
    data = request.json
    event_type = data.get('event_type')
    order_id = data.get('order_id')
    
    if event_type == 'order.accepted':
        notify_customer(order_id,
            f"Your broadband order has been accepted. "
            f"Expected go-live: {data.get('estimated_activation')}")
        
    elif event_type == 'order.activated':
        notify_customer(order_id,
            "Your broadband is now live! 🎉 "
            "Connect your router and you should be online in minutes.")
        start_billing(order_id)
        
    elif event_type == 'order.delayed':
        notify_customer(order_id,
            f"Delay with your order. New date: {data.get('new_estimated_date')}. "
            f"Reason: {data.get('delay_reason')}")
    
    return jsonify({'status': 'ok'}), 200

if __name__ == '__main__':
    app.run(port=5000)

import requests
from datetime import datetime

class SplynxBilling:
    """Integration between wholesaler events and Splynx billing"""
    
    def __init__(self, splynx_url, api_key):
        self.base_url = f"{splynx_url}/api/2.0"
        self.session = requests.Session()
        self.session.headers.update({
            'Authorization': f'Splynx-EA (api_key={api_key})'
        })
    
    def create_customer(self, customer_data):
        """Create customer in Splynx"""
        return self.session.post(
            f"{self.base_url}/admin/customers/customer",
            json={
                'name': customer_data['first_name'],
                'surname': customer_data['last_name'],
                'email': customer_data['email'],
                'phone': customer_data['phone'],
                'street_1': customer_data['address_line_1'],
                'city': customer_data['city'],
                'zip_code': customer_data['postcode'],
                'status': 'active',
                'billing_type': 'recurring',
                'partner_id': 1
            }
        ).json()
    
    def create_internet_service(self, customer_id, plan_data):
        """Create internet service for customer"""
        return self.session.post(
            f"{self.base_url}/admin/customers/customer/"
            f"{customer_id}/internet-services",
            json={
                'plan_id': plan_data['splynx_plan_id'],
                'login': plan_data['pppoe_username'],
                'password': plan_data['pppoe_password'],
                'status': 'active',
                'start_date': datetime.now().strftime('%Y-%m-%d'),
                'description': plan_data['product_name']
            }
        ).json()
    
    def create_invoice(self, customer_id, amount, description):
        """Generate invoice"""
        return self.session.post(
            f"{self.base_url}/admin/finance/invoices",
            json={
                'customer_id': customer_id,
                'date_created': datetime.now().strftime('%Y-%m-%d'),
                'items': [{
                    'description': description,
                    'quantity': 1,
                    'unit_price': amount,
                    'tax_percent': 20  # VAT
                }]
            }
        ).json()