SMS API
Integration Guide

# POST request
curl -X POST "https://sms.gonlinesites.com/app/sms/api" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "action=send-sms" \
  -d "api_key=YOUR_API_KEY" \
  -d "to=+233244000000" \
  -d "from=MySenderID" \
  -d "sms=Hello from the API"

import urllib.request, urllib.parse, json

API_URL = "https://sms.gonlinesites.com/app/sms/api"
API_KEY = "YOUR_API_KEY"

def send_sms(to, sender_id, message):
    params = urllib.parse.urlencode({
        "action":"send-sms", "api_key":API_KEY,
        "to":to, "from":sender_id, "sms":message,
    })
    with urllib.request.urlopen(f"{API_URL}?{params}", timeout=30) as r:
        return json.loads(r.read().decode())

print(send_sms("+233244000000", "MySenderID", "Hello!"))

import requests
from typing import Union, List

class SMSClient:
    BASE_URL = "https://sms.gonlinesites.com/app/sms/api"

    def __init__(self, api_key: str, sender_id: str):
        self.api_key   = api_key
        self.sender_id = sender_id
        self.session   = requests.Session()

    def send(self, to: Union[str, List[str]], message: str) -> dict:
        recipients = ",".join(to) if isinstance(to, list) else to
        r = self.session.get(self.BASE_URL, params={
            "action":"send-sms", "api_key":self.api_key,
            "to":recipients, "from":self.sender_id, "sms":message
        }, timeout=30)
        r.raise_for_status()
        return r.json()

sms = SMSClient("YOUR_API_KEY", "MySenderID")
sms.send("+233244000000", "Hello!")
sms.send(["+233244000000", "+233200111222"], "Bulk alert!")

<?php
$query = http_build_query([
    'action'  => 'send-sms',
    'api_key' => 'YOUR_API_KEY',
    'to'      => '+233244000000',
    'from'    => 'MySenderID',
    'sms'     => 'Hello World!',
]);
$ctx  = stream_context_create(['http' => ['timeout' => 30]]);
$data = json_decode(file_get_contents("https://sms.gonlinesites.com/app/sms/api?{$query}", context: $ctx), true);
var_dump($data);

<?php
// composer require guzzlehttp/guzzle
use GuzzleHttp\Client;

$client   = new Client(['base_uri' => 'https://sms.gonlinesites.com']);
$response = $client->get('/app/sms/api', [
    'query' => [
        'action'  => 'send-sms',
        'api_key' => 'YOUR_API_KEY',
        'to'      => '+233244000000',
        'from'    => 'MySenderID',
        'sms'     => 'Hello via Guzzle!',
    ],
]);
print_r(json_decode($response->getBody(), true));

<?php
use Illuminate\Support\Facades\Http;

$response = Http::get('https://sms.gonlinesites.com/app/sms/api', [
    'action'  => 'send-sms',
    'api_key' => env('SMS_API_KEY'),
    'to'      => '+233244000000',
    'from'    => env('SMS_SENDER_ID'),
    'sms'     => 'Hello from Laravel!',
]);

$data = $response->json();

match ($data['code']) {
    'OK'  => logger("Sent: {$data['message_id']}"),
    102   => abort(401, 'SMS authentication failed'),
    105   => abort(402, 'Insufficient SMS balance'),
    default => logger("SMS error {$data['code']}: {$data['message']}"),
};

SMS_API_KEY=YOUR_API_KEY
SMS_SENDER_ID=MySenderID
SMS_BASE_URL=https://sms.gonlinesites.com/app/sms/api

<?php
return [
    'api_key'   => env('SMS_API_KEY'),
    'sender_id' => env('SMS_SENDER_ID', 'MySenderID'),
    'base_url'  => env('SMS_BASE_URL', 'https://sms.gonlinesites.com/app/sms/api'),
];

<?php
namespace App\Notifications;
use Illuminate\Notifications\Notification;

class SmsNotification extends Notification
{
    public function __construct(protected string $message) {}

    public function via($notifiable): array
    { return ['sms']; }

    public function toSms($notifiable): array
    { return ['to' => $notifiable->phone_number, 'message' => $this->message]; }
}
// $user->notify(new SmsNotification('Your OTP is 4921'));

const https = require('https');
const qs    = require('querystring');

function sendSms(to, message) {
  return new Promise((resolve, reject) => {
    const q = qs.stringify({ action:'send-sms', api_key:'YOUR_API_KEY',
                              to, from:'MySenderID', sms: message });
    https.get(`https://sms.gonlinesites.com/app/sms/api?${q}`, res => {
      let b = '';
      res.on('data', c => b += c);
      res.on('end',  () => resolve(JSON.parse(b)));
    }).on('error', reject);
  });
}
sendSms('+233244000000', 'Hello!').then(console.log);

import axios from 'axios';

interface SmsResponse {
  code       : string | number;
  message_id?: string;
  message?   : string;
  units?     : number;
  balance?   : number;
}

export async function sendSms(
  to      : string | string[],
  message : string,
  from    : string = process.env.SMS_SENDER_ID ?? '',
): Promise<SmsResponse> {
  const recipients = Array.isArray(to) ? to.join(',') : to;
  const { data } = await axios.get<SmsResponse>(
    'https://sms.gonlinesites.com/app/sms/api', {
      params: { action:'send-sms', api_key: process.env.SMS_API_KEY,
                to: recipients, from, sms: message },
    }
  );
  if (data.code !== 'OK') throw new Error(`SMS ${data.code}: ${data.message}`);
  return data;
}

async function sendSms({ to, from, message }) {
  const url = new URL('https://sms.gonlinesites.com/app/sms/api');
  Object.entries({ action:'send-sms', api_key:'YOUR_API_KEY', to, from, sms: message })
    .forEach(([k,v]) => url.searchParams.set(k,v));

  const data = await (await fetch(url)).json();
  if (data.code !== 'OK') throw new Error(`[${data.code}] ${data.message}`);
  return data;
}

// implementation 'com.squareup.okhttp3:okhttp:4.12.0'
import okhttp3.*;

public class SmsOkHttp {
    private static final OkHttpClient CLIENT = new OkHttpClient();

    public static String send(String to, String msg) throws Exception {
        HttpUrl url = HttpUrl.parse("https://sms.gonlinesites.com/app/sms/api")
            .newBuilder()
            .addQueryParameter("action",  "send-sms")
            .addQueryParameter("api_key", "YOUR_API_KEY")
            .addQueryParameter("to",      to)
            .addQueryParameter("from",    "MySenderID")
            .addQueryParameter("sms",     msg).build();
        try (Response r = CLIENT.newCall(new Request.Builder().url(url).build()).execute()) {
            return r.body().string();
        }
    }
}

// Program.cs
builder.Services.AddHttpClient<ISmsService, SmsService>();
builder.Services.Configure<SmsOptions>(builder.Configuration.GetSection("Sms"));

public interface ISmsService { Task<bool> SendAsync(string to, string msg); }

public class SmsService(HttpClient http, IOptions<SmsOptions> opts) : ISmsService
{
    public async Task<bool> SendAsync(string to, string msg) {
        var o = opts.Value;
        var r = await http.GetAsync(
            $"{o.BaseUrl}?action=send-sms&api_key={o.ApiKey}&to={to}&from={o.SenderId}&sms={Uri.EscapeDataString(msg)}");
        return r.IsSuccessStatusCode;
    }
}
// appsettings.json: { "Sms": { "ApiKey": "...", "SenderId": "...", "BaseUrl": "..." } }

# gem install httparty
require 'httparty'

class SmsClient
  include HTTParty
  base_uri 'https://sms.gonlinesites.com'

  def initialize(api_key, sender)
    @key = api_key; @sender = sender
  end

  def send(to, message)
    self.class.get('/app/sms/api',
      query: { action: 'send-sms', api_key: @key, to:, from: @sender, sms: message })
  end
end

sms  = SmsClient.new('YOUR_API_KEY', 'MySenderID')
data = sms.send('+233244000000', 'Hello!')
puts data

/**
 * Reusable SMS helper for Google Apps Script.
 * Drop this function into any .gs file and call:
 *   sendSMS("+233244000000", "Your message here");
 */
function sendSMS(to, message) {
  var url =
    "https://sms.gonlinesites.com/app/sms/api" +
    "?action=send-sms" +
    "&api_key=YOUR_API_KEY" +
    "&to="   + encodeURIComponent(to) +
    "&from=YOUR_SENDER_ID" +
    "&sms="  + encodeURIComponent(message);

  var response = UrlFetchApp.fetch(url, {
    muteHttpExceptions: true
  });

  var result = JSON.parse(response.getContentText());
  if (result.code === "OK") {
    Logger.log("Sent successfully. ID: " + result.message_id);
  } else {
    Logger.log("SMS error [" + result.code + "]: " + result.message);
  }
  return result;
}

/**
 * Maps responses by question TITLE instead of index position.
 * More resilient — survives reordering of form fields.
 */
function onFormSubmit(e) {
  try {
    var responses = {};
    e.response.getItemResponses().forEach(function(item) {
      responses[item.getItem().getTitle()] = item.getResponse();
    });

    // ← change these strings to match your exact question titles
    var name     = (responses["Full Name"]     || "").trim();
    var email    = (responses["Email Address"] || "").trim();
    var phone    = formatGhanaPhone(responses["Phone Number"] || "");
    var comments = (responses["Comments"]      || "N/A").trim();

    var adminPhone = "233242625794";

    if (!phone) {
      Logger.log("No phone number found in response.");
      return;
    }

    sendSMS(phone,
      "Hello " + name + ", thanks for submitting the form successfully."
    );
    sendSMS(adminPhone,
      "New submission:\nName: "     + name  +
      "\nEmail: "   + email    +
      "\nPhone: "   + phone    +
      "\nComments: "+ comments
    );

  } catch (err) {
    Logger.log("Error: " + err.toString());
  }
}

// Paste formatGhanaPhone() and sendSMS() from the Full Script tab above

https://sms.gonlinesites.com/app/sms/api
  ?action=send-sms
  &api_key=YOUR_API_KEY
  &to=PhoneNumber
  &from=SenderID
  &sms=YourMessage
  &unicode=1

https://sms.gonlinesites.com/app/sms/api
  ?action=send-sms
  &api_key=YOUR_API_KEY
  &to=PhoneNumber
  &from=SenderID
  &sms=YourMessage
  &schedule=03/19/2026 10:36 AM

<?php

// Format: mm/dd/yyyy hh:mm AM
$scheduleTime = '03/19/2026 10:36 AM';

// Or build it dynamically
$scheduleTime = date('m/d/Y h:i A', strtotime('+2 hours'));

$params = http_build_query([
    'action'   => 'send-sms',
    'api_key'  => 'YOUR_API_KEY',
    'to'       => '+233244000000',
    'from'     => 'MySenderID',
    'sms'      => 'This is a scheduled reminder!',
    'schedule' => $scheduleTime,
]);

$ch = curl_init('https://sms.gonlinesites.com/app/sms/api?' . $params);
curl_setopt_array($ch, [CURLOPT_RETURNTRANSFER => true, CURLOPT_TIMEOUT => 30]);
$data = json_decode(curl_exec($ch), true);
curl_close($ch);
print_r($data);

use Carbon\Carbon;
use Illuminate\Support\Facades\Http;

// Format: mm/dd/yyyy hh:mm AM
$scheduleTime = Carbon::now()->addHours(2)->format('m/d/Y h:i A');

$response = Http::get('https://sms.gonlinesites.com/app/sms/api', [
    'action'   => 'send-sms',
    'api_key'  => config('sms.api_key'),
    'to'       => '+233244000000',
    'from'     => config('sms.sender_id'),
    'sms'      => 'Scheduled reminder from Laravel!',
    'schedule' => $scheduleTime,
]);

return $response->json();

const axios = require('axios');

// Format: mm/dd/yyyy hh:mm AM
function formatSchedule(date) {
  const mm  = String(date.getMonth() + 1).padStart(2, '0');
  const dd  = String(date.getDate()).padStart(2, '0');
  const yy  = date.getFullYear();
  let   hh  = date.getHours();
  const min = String(date.getMinutes()).padStart(2, '0');
  const ampm = hh >= 12 ? 'PM' : 'AM';
  hh = hh % 12 || 12;
  return `${mm}/${dd}/${yy} ${hh}:${min} ${ampm}`;
}

const sendAt = new Date(Date.now() + 2 * 60 * 60 * 1000); // 2 hrs from now

axios.get('https://sms.gonlinesites.com/app/sms/api', {
  params: {
    action   : 'send-sms',
    api_key  : 'YOUR_API_KEY',
    to       : '+233244000000',
    from     : 'MySenderID',
    sms      : 'Scheduled reminder!',
    schedule : formatSchedule(sendAt),
  },
}).then(r => console.log(r.data));

curl "https://sms.gonlinesites.com/app/sms/api\
?action=send-sms\
&api_key=YOUR_API_KEY\
&to=+233244000000\
&from=MySenderID\
&sms=Scheduled+reminder\
&schedule=03/19/2026+10:36+AM"

<?php

$query = http_build_query([
    'action'   => 'check-balance',
    'api_key'  => 'YOUR_API_KEY',
    'response' => 'json',
]);

$ctx  = stream_context_create(['http' => ['timeout' => 30]]);
$data = json_decode(
    file_get_contents("https://sms.gonlinesites.com/app/sms/api?{$query}", context: $ctx),
    true
);
echo "Balance: {$data['balance']} credits";

public function checkBalance(): array
{
    return Http::timeout(30)->get($this->baseUrl, [
        'action'   => 'check-balance',
        'api_key'  => $this->apiKey,
        'response' => 'json',
    ])->json();
}

// Usage: $smsService->checkBalance()['balance']

const axios = require('axios');

async function checkBalance(apiKey) {
  const { data } = await axios.get(
    'https://sms.gonlinesites.com/app/sms/api', {
      params: { action: 'check-balance', api_key: apiKey, response: 'json' },
    }
  );
  console.log(`Balance: ${data.balance} credits`);
  return data;
}

checkBalance('YOUR_API_KEY');

curl "https://sms.gonlinesites.com/app/sms/api\
?action=check-balance\
&api_key=YOUR_API_KEY\
&response=json"

<?php

function addContact(string $phoneBook, string $phoneNumber, array $extra = []): array
{
    $params = http_build_query(array_filter(array_merge([
        'action'       => 'subscribe-us',
        'api_key'      => 'YOUR_API_KEY',
        'phone_book'   => $phoneBook,
        'phone_number' => $phoneNumber,
    ], $extra)));

    $ctx = stream_context_create(['http' => ['timeout' => 30]]);
    return json_decode(
        file_get_contents("https://sms.gonlinesites.com/app/contacts/api?{$params}", context: $ctx),
        true
    );
}

// Minimal
addContact('Customers', '+233244000000');

// With optional fields
addContact('Customers', '+233244000000', [
    'first_name' => 'Kwame',
    'last_name'  => 'Mensah',
    'email'      => 'kwame@example.com',
    'company'    => 'Acme Ltd',
]);

protected string $contactsUrl = 'https://sms.gonlinesites.com/app/contacts/api';

public function addContact(
    string $phoneBook,
    string $phoneNumber,
    array  $extra = []
): array {
    return Http::timeout(30)->get($this->contactsUrl, array_filter(array_merge([
        'action'       => 'subscribe-us',
        'api_key'      => $this->apiKey,
        'phone_book'   => $phoneBook,
        'phone_number' => $phoneNumber,
    ], $extra)))->json();
}

// Usage
// $sms->addContact('Customers', '+233244000000', ['first_name' => 'Kwame']);

const axios = require('axios');

async function addContact(phoneBook, phoneNumber, extra = {}) {
  const { data } = await axios.get(
    'https://sms.gonlinesites.com/app/contacts/api', {
      params: {
        action       : 'subscribe-us',
        api_key      : 'YOUR_API_KEY',
        phone_book   : phoneBook,
        phone_number : phoneNumber,
        ...extra,
      },
    }
  );
  return data;
}

// Minimal
addContact('Customers', '+233244000000');

// With optional fields
addContact('Customers', '+233244000000', {
  first_name : 'Kwame',
  last_name  : 'Mensah',
  email      : 'kwame@example.com',
  company    : 'Acme Ltd',
});

# Minimal
curl "https://sms.gonlinesites.com/app/contacts/api\
?action=subscribe-us\
&api_key=YOUR_API_KEY\
&phone_book=Customers\
&phone_number=+233244000000"

# With optional fields
curl "https://sms.gonlinesites.com/app/contacts/api\
?action=subscribe-us\
&api_key=YOUR_API_KEY\
&phone_book=Customers\
&phone_number=+233244000000\
&first_name=Kwame\
&last_name=Mensah\
&email=kwame%40example.com\
&company=Acme+Ltd"

<?php
$numbers = ['+233244000001', '+233244000002', '+233200111222'];
$query   = http_build_query([
    'action'  => 'send-sms',
    'api_key' => 'YOUR_API_KEY',
    'to'      => implode(',', $numbers),
    'from'    => 'MySenderID',
    'sms'     => 'Announcement for all customers!',
]);
print_r(json_decode(file_get_contents("https://sms.gonlinesites.com/app/sms/api?{$query}"), true));

const axios   = require('axios');
const numbers = ['+233244000001', '+233244000002', '+233200111222'];
axios.get('https://sms.gonlinesites.com/app/sms/api', {
  params: { action:'send-sms', api_key:'YOUR_API_KEY',
            to: numbers.join(','), from:'MySenderID', sms:'Announcement!' }
}).then(r => console.log(r.data));