WebSMS Connexus API

const express = require('express');
const app = express();
app.use(express.json());

app.post('/webhook', (req, res) => {
  const data = req.body;

  if (data.type === 'mo') {
    // Incoming SMS
    console.log(`SMS from ${data.from}: ${data.body}`);
  } else if (data.type === 'dlr') {
    // Delivery report
    console.log(`Message ${data.messageId}: ${data.status}`);
  }

  res.json({ success: true });
});

app.listen(3000);

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/webhook', methods=['POST'])
def webhook():
    data = request.json

    if data['type'] == 'mo':
        # Incoming SMS
        print(f"SMS from {data['from']}: {data['body']}")
    elif data['type'] == 'dlr':
        # Delivery report
        print(f"Message {data['messageId']}: {data['status']}")

    return jsonify({'success': True})

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

const axios = require('axios');

// In-memory store (use Redis/DB in production)
const otpStore = new Map();

async function sendOTP(phone, company) {
  const response = await axios.post('https://websms.co.nz/api/connexus/sms/otp', {
    userId: 'user@domain.co.nz',
    password: 'yourpassword',
    to: phone,
    msgCompany: company,
    msgComment: 'Valid for 5 minutes.'
  });

  // Store code for verification
  otpStore.set(phone, {
    code: response.data.code,
    expires: Date.now() + 300000 // 5 minutes
  });

  return response.data;
}

function verifyOTP(phone, userInput) {
  const stored = otpStore.get(phone);
  if (!stored || Date.now() > stored.expires) return false;
  if (userInput === stored.code) {
    otpStore.delete(phone);
    return true;
  }
  return false;
}

// Usage
const result = await sendOTP('6421234567', 'MyApp');
console.log('OTP sent! Code:', result.code);

import requests
import time

# In-memory store (use Redis/DB in production)
otp_store = {}

def send_otp(phone, company):
    response = requests.post('https://websms.co.nz/api/connexus/sms/otp', data={
        'userId': 'user@domain.co.nz',
        'password': 'yourpassword',
        'to': phone,
        'msgCompany': company,
        'msgComment': 'Valid for 5 minutes.'
    })
    data = response.json()

    # Store code for verification
    otp_store[phone] = {
        'code': data['code'],
        'expires': time.time() + 300  # 5 minutes
    }

    return data

def verify_otp(phone, user_input):
    stored = otp_store.get(phone)
    if not stored or time.time() > stored['expires']:
        return False
    if user_input == stored['code']:
        del otp_store[phone]
        return True
    return False

# Usage
result = send_otp('6421234567', 'MyApp')
print(f"OTP sent! Code: {result['code']}")

using System.Net.Http;
using System.Text.Json;

public class OtpService
{
    private static Dictionary<string, (string code, DateTime expires)> _store = new();
    private readonly HttpClient _http = new();

    public async Task<string> SendOtpAsync(string phone, string company)
    {
        var content = new FormUrlEncodedContent(new[]
        {
            new KeyValuePair<string, string>("userId", "user@domain.co.nz"),
            new KeyValuePair<string, string>("password", "yourpassword"),
            new KeyValuePair<string, string>("to", phone),
            new KeyValuePair<string, string>("msgCompany", company),
            new KeyValuePair<string, string>("msgComment", "Valid for 5 minutes.")
        });

        var response = await _http.PostAsync(
            "https://websms.co.nz/api/connexus/sms/otp", content);
        var json = await response.Content.ReadAsStringAsync();
        var data = JsonSerializer.Deserialize<JsonElement>(json);
        var code = data.GetProperty("code").GetString();

        // Store code for verification
        _store[phone] = (code, DateTime.UtcNow.AddMinutes(5));

        return code;
    }

    public bool VerifyOtp(string phone, string userInput)
    {
        if (!_store.TryGetValue(phone, out var stored)) return false;
        if (DateTime.UtcNow > stored.expires) return false;
        if (userInput == stored.code)
        {
            _store.Remove(phone);
            return true;
        }
        return false;
    }
}

// Usage
var otp = new OtpService();
var code = await otp.SendOtpAsync("6421234567", "MyApp");
Console.WriteLine($"OTP sent! Code: {code}");

import requests

url = 'https://websms.co.nz/api/connexus/sms/out'
data = {
    'userId': 'user@domain.co.nz',
    'password': 'yourpassword',
    'to': '6421234567',
    'body': 'Hello from WebSMS!'
}

response = requests.post(url, data=data)

if response.status_code == 204:
    print("Message sent successfully!")
else:
    print(f"Error: HTTP {response.status_code}")

const axios = require('axios');

const data = new URLSearchParams({
    userId: 'user@domain.co.nz',
    password: 'yourpassword',
    to: '6421234567',
    body: 'Hello from WebSMS!'
});

axios.post('https://websms.co.nz/api/connexus/sms/out', data)
    .then(response => {
        if (response.status === 204) {
            console.log('Message sent successfully!');
        }
    })
    .catch(error => {
        console.error('Error:', error.response?.status);
    });

using System;
using System.Net.Http;
using System.Collections.Generic;

var client = new HttpClient();
var values = new Dictionary<string, string>
{
    { "userId", "user@domain.co.nz" },
    { "password", "yourpassword" },
    { "to", "6421234567" },
    { "body", "Hello from WebSMS!" }
};

var content = new FormUrlEncodedContent(values);
var response = await client.PostAsync(
    "https://websms.co.nz/api/connexus/sms/out",
    content
);

if ((int)response.StatusCode == 204)
{
    Console.WriteLine("Message sent successfully!");
}
else
{
    Console.WriteLine($"Error: {response.StatusCode}");
}