API v2 Documentation

fetch('https://ugsms.com/api/v2/sms/send', {
    method: 'POST',
    headers: {
        'X-API-Key': 'YOUR_API_KEY',
        'Content-Type': 'application/json',
    },
    body: JSON.stringify({
        numbers: '0702913454,0776913451',
        message_body: 'Hello from UGSMS API v2',
        sender_id: 'UGSMS'
    })
})
.then(response => response.json())
.then(data => console.log(data));

$apiKey = 'YOUR_API_KEY';
$data = [
    'numbers' => '0702913454,0776913451',
    'message_body' => 'Hello from UGSMS API v2',
    'sender_id' => 'UGSMS'
];

$ch = curl_init('https://ugsms.com/api/v2/sms/send');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-API-Key: ' . $apiKey
]);

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

$result = json_decode($response, true);
print_r($result);

import requests
import json

url = "https://ugsms.com/api/v2/sms/send"
api_key = "YOUR_API_KEY"
data = {
    "numbers": "0702913454,0776913451",
    "message_body": "Hello from UGSMS API v2",
    "sender_id": "UGSMS"
}

headers = {
    "X-API-Key": api_key,
    "Content-Type": "application/json"
}

response = requests.post(url, json=data, headers=headers)
result = response.json()
print(result)

#include <stdio.h>
#include <curl/curl.h>
#include <string.h>

struct MemoryStruct {
    char *memory;
    size_t size;
};

static size_t WriteMemoryCallback(void *contents, size_t size, size_t nmemb, void *userp) {
    size_t realsize = size * nmemb;
    struct MemoryStruct *mem = (struct MemoryStruct *)userp;

    char *ptr = realloc(mem->memory, mem->size + realsize + 1);
    if(!ptr) {
        return 0;
    }

    mem->memory = ptr;
    memcpy(&(mem->memory[mem->size]), contents, realsize);
    mem->size += realsize;
    mem->memory[mem->size] = 0;

    return realsize;
}

int main(void) {
    CURL *curl;
    CURLcode res;

    char *api_key = "YOUR_API_KEY";
    char *url = "https://ugsms.com/api/v2/sms/send";

    struct MemoryStruct chunk;
    chunk.memory = malloc(1);
    chunk.size = 0;

    curl = curl_easy_init();
    if(curl) {
        struct curl_slist *headers = NULL;
        char auth_header[100];
        sprintf(auth_header, "X-API-Key: %s", api_key);

        headers = curl_slist_append(headers, auth_header);
        headers = curl_slist_append(headers, "Content-Type: application/json");

        char *json_data = "{\"numbers\":\"0702913454,0776913451\",\"message_body\":\"Hello from UGSMS API v2\",\"sender_id\":\"UGSMS\"}";

        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_POST, 1L);
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json_data);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);

        res = curl_easy_perform(curl);

        if(res == CURLE_OK) {
            printf("%s\n", chunk.memory);
        } else {
            fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
        }

        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
        free(chunk.memory);
    }

    return 0;
}

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

class Program
{
    static async Task Main(string[] args)
    {
        var apiKey = "YOUR_API_KEY";
        var url = "https://ugsms.com/api/v2/sms/send";

        var data = new
        {
            numbers = "0702913454,0776913451",
            message_body = "Hello from UGSMS API v2",
            sender_id = "UGSMS"
        };

        var json = JsonSerializer.Serialize(data);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("X-API-Key", apiKey);

            var response = await client.PostAsync(url, content);
            var responseString = await response.Content.ReadAsStringAsync();

            Console.WriteLine(responseString);
        }
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    apiKey := "YOUR_API_KEY"
    url := "https://ugsms.com/api/v2/sms/send"

    data := map[string]string{
        "numbers":      "0702913454,0776913451",
        "message_body": "Hello from UGSMS API v2",
        "sender_id":    "UGSMS",
    }

    jsonData, err := json.Marshal(data)
    if err != nil {
        fmt.Println("Error marshaling JSON:", err)
        return
    }

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-API-Key", apiKey)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error sending request:", err)
        return
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)

    fmt.Println(result)
}

import 'dart:convert';
import 'package:http/http.dart' as http;

void main() async {
  final apiKey = 'YOUR_API_KEY';
  final url = 'https://ugsms.com/api/v2/sms/send';

  final data = {
    'numbers': '0702913454,0776913451',
    'message_body': 'Hello from UGSMS API v2',
    'sender_id': 'UGSMS',
  };

  final response = await http.post(
    Uri.parse(url),
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': apiKey,
    },
    body: jsonEncode(data),
  );

  final result = jsonDecode(response.body);
  print(result);
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import com.google.gson.Gson;

public class SendSMS {
    public static void main(String[] args) {
        String apiKey = "YOUR_API_KEY";
        String url = "https://ugsms.com/api/v2/sms/send";

        SMSData data = new SMSData();
        data.numbers = "0702913454,0776913451";
        data.message_body = "Hello from UGSMS API v2";
        data.sender_id = "UGSMS";

        Gson gson = new Gson();
        String jsonData = gson.toJson(data);

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Content-Type", "application/json")
                .header("X-API-Key", apiKey)
                .POST(HttpRequest.BodyPublishers.ofString(jsonData))
                .build();

        try {
            HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class SMSData {
    public String numbers;
    public String message_body;
    public String sender_id;
}

require 'net/http'
require 'json'

api_key = 'YOUR_API_KEY'
url = URI('https://ugsms.com/api/v2/sms/send')

data = {
  numbers: '0702913454,0776913451',
  message_body: 'Hello from UGSMS API v2',
  sender_id: 'UGSMS'
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = (url.scheme == 'https')

request = Net::HTTP::Post.new(url)
request['Content-Type'] = 'application/json'
request['X-API-Key'] = api_key
request.body = data.to_json

response = http.request(request)
puts response.body

fetch('https://ugsms.com/api/v2/sms/send/bulk', {
    method: 'POST',
    headers: {
        'X-API-Key': 'YOUR_API_KEY',
        'Content-Type': 'application/json',
    },
    body: JSON.stringify({
        messages: [
            {
                number: '0702913454',
                message_body: 'Dear John, your appointment is at 2 PM today.'
            },
            {
                number: '0776913451',
                message_body: 'Dear Jane, your payment of UGX 50,000 was received.'
            },
            {
                number: '0755913452',
                message_body: 'Dear Robert, your order #12345 is ready for pickup.'
            }
        ],
        sender_id: 'UGSMS',
        reference: 'NOTIFICATIONS-2024'
    })
})
.then(response => response.json())
.then(data => console.log(data));

$apiKey = 'YOUR_API_KEY';
$url = 'https://ugsms.com/api/v2/sms/send/bulk';

$messages = [
    [
        'number' => '0702913454',
        'message_body' => 'Dear John, your appointment is at 2 PM today.'
    ],
    [
        'number' => '0776913451',
        'message_body' => 'Dear Jane, your payment of UGX 50,000 was received.'
    ],
    [
        'number' => '0755913452',
        'message_body' => 'Dear Robert, your order #12345 is ready for pickup.'
    ]
];

$data = [
    'messages' => $messages,
    'sender_id' => 'UGSMS',
    'reference' => 'NOTIFICATIONS-2024'
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-API-Key: ' . $apiKey
]);

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

$result = json_decode($response, true);
echo json_encode($result, JSON_PRETTY_PRINT);

import requests
import json

api_key = "YOUR_API_KEY"
url = "https://ugsms.com/api/v2/sms/send/bulk"

messages = [
    {"number": "0702913454", "message_body": "Dear John, your appointment is at 2 PM today."},
    {"number": "0776913451", "message_body": "Dear Jane, your payment of UGX 50,000 was received."},
    {"number": "0755913452", "message_body": "Dear Robert, your order #12345 is ready for pickup."}
]

data = {
    "messages": messages,
    "sender_id": "UGSMS",
    "reference": "NOTIFICATIONS-2024"
}

headers = {
    "X-API-Key": api_key,
    "Content-Type": "application/json"
}

response = requests.post(url, json=data, headers=headers)
result = response.json()
print(json.dumps(result, indent=2))

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

class Program
{
    static async Task Main(string[] args)
    {
        var apiKey = "YOUR_API_KEY";
        var url = "https://ugsms.com/api/v2/sms/send/bulk";

        var data = new
        {
            messages = new[]
            {
                new { number = "0702913454", message_body = "Dear John, your appointment is at 2 PM today." },
                new { number = "0776913451", message_body = "Dear Jane, your payment of UGX 50,000 was received." },
                new { number = "0755913452", message_body = "Dear Robert, your order #12345 is ready for pickup." }
            },
            sender_id = "UGSMS",
            reference = "NOTIFICATIONS-2024"
        };

        var json = JsonSerializer.Serialize(data);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("X-API-Key", apiKey);

            var response = await client.PostAsync(url, content);
            var responseString = await response.Content.ReadAsStringAsync();

            Console.WriteLine(responseString);
        }
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    apiKey := "YOUR_API_KEY"
    url := "https://ugsms.com/api/v2/sms/send/bulk"

    messages := []map[string]string{
        {"number": "0702913454", "message_body": "Dear John, your appointment is at 2 PM today."},
        {"number": "0776913451", "message_body": "Dear Jane, your payment of UGX 50,000 was received."},
        {"number": "0755913452", "message_body": "Dear Robert, your order #12345 is ready for pickup."},
    }

    data := map[string]interface{}{
        "messages":  messages,
        "sender_id": "UGSMS",
        "reference": "NOTIFICATIONS-2024",
    }

    jsonData, err := json.Marshal(data)
    if err != nil {
        fmt.Println("Error marshaling JSON:", err)
        return
    }

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-API-Key", apiKey)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error sending request:", err)
        return
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)

    fmt.Println(result)
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import com.google.gson.Gson;
import java.util.List;
import java.util.ArrayList;

public class SendBulkSMS {
    public static void main(String[] args) {
        String apiKey = "YOUR_API_KEY";
        String url = "https://ugsms.com/api/v2/sms/send/bulk";

        List<SMSMessage> messages = new ArrayList<>();
        messages.add(new SMSMessage("0702913454", "Dear John, your appointment is at 2 PM today."));
        messages.add(new SMSMessage("0776913451", "Dear Jane, your payment of UGX 50,000 was received."));
        messages.add(new SMSMessage("0755913452", "Dear Robert, your order #12345 is ready for pickup."));

        BulkSMSData data = new BulkSMSData();
        data.messages = messages;
        data.sender_id = "UGSMS";
        data.reference = "NOTIFICATIONS-2024";

        Gson gson = new Gson();
        String jsonData = gson.toJson(data);

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header("Content-Type", "application/json")
                .header("X-API-Key", apiKey)
                .POST(HttpRequest.BodyPublishers.ofString(jsonData))
                .build();

        try {
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            System.out.println(response.body());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class BulkSMSData {
    public List<SMSMessage> messages;
    public String sender_id;
    public String reference;
}

class SMSMessage {
    public String number;
    public String message_body;

    public SMSMessage(String number, String message_body) {
        this.number = number;
        this.message_body = message_body;
    }
}

require 'net/http'
require 'json'

api_key = 'YOUR_API_KEY'
url = URI('https://ugsms.com/api/v2/sms/send/bulk')

messages = [
  { number: '0702913454', message_body: 'Dear John, your appointment is at 2 PM today.' },
  { number: '0776913451', message_body: 'Dear Jane, your payment of UGX 50,000 was received.' },
  { number: '0755913452', message_body: 'Dear Robert, your order #12345 is ready for pickup.' }
]

data = {
  messages: messages,
  sender_id: 'UGSMS',
  reference: 'NOTIFICATIONS-2024'
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = (url.scheme == 'https')

request = Net::HTTP::Post.new(url)
request['Content-Type'] = 'application/json'
request['X-API-Key'] = api_key
request.body = data.to_json

response = http.request(request)
puts response.body