DEV Community: yoola sms

Forget Twilio — Here's a Cheaper SMS API Built for African Developers

yoola sms — Sun, 21 Jun 2026 17:09:10 +0000

Forget Twilio — Here's a Cheaper SMS API Built for African Developers

Before anyone comes at me in the comments: Twilio is excellent. If you are building for the US or EU, use Twilio.

But if you are building for Uganda, Kenya, Tanzania, Rwanda, or anywhere in East Africa — there is a better option that your clients can actually pay for.

Here is the honest comparison, then the code.

The Real Problem With Twilio in Africa

Twilio is a global product built for global markets. For Uganda, Kenya, and East Africa specifically, the pricing model and payment options create real problems for your clients. Here is why:

1. Payment. Twilio requires a VISA or Mastercard for billing. In Uganda, less than 15% of adults have credit cards. When your client is a school, a SACCO, or a small business — they pay with Mobile Money. They cannot use Twilio directly.

2. USD pricing. Explaining "your campaign will cost USD 12.50" to a Ugandan business owner creates friction. "Your campaign will cost UGX 50,000" is immediately clear and budgetable.

3. Setup complexity. Twilio's console is powerful but overwhelming for non-developers. Your client cannot manage their own campaigns without you holding their hand.

4. Exchange rate risk. When the UGX/USD rate moves, your SMS costs change. Local UGX pricing removes this uncertainty entirely.

The Alternative: Yoola SMS

Yoola SMS was built specifically for East Africa — local currency pricing in UGX, Mobile Money top-up, and a full client dashboard your non-technical clients can use themselves.

	Twilio	Yoola SMS
Uganda SMS cost	~UGX 333 (~USD 0.09)	UGX 20–35
Payment method	VISA/Mastercard only	MTN MoMo · Airtel Money · Visa/Mastercard
Pricing currency	USD	UGX
Client dashboard	No (dev only)	Yes (non-tech clients)
Min. top-up	$20	UGX 1,000
East Africa coverage	Yes	Yes
International	Yes	Yes (40+ countries)
Free trial	Trial account	3 free SMS

Migration: From Twilio to Yoola SMS in 10 Minutes

If you have an existing Twilio integration, here is what changes:

Before (Twilio PHP)

require_once 'vendor/autoload.php';
use Twilio\Rest\Client;

$client = new Client($accountSid, $authToken);
$client->messages->create(
    '+256704487563',
    ['from' => '+1234567890', 'body' => 'Your OTP is 847291']
);

After (Yoola SMS PHP)

// No composer install. No vendor folder. Just cURL.
function yoolaSend($phone, $message, $sender = 'MyApp') {
    $ch = curl_init('https://yoolasms.com/api/v1/send.php');
    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => json_encode([
            'phone'   => $phone,
            'message' => $message,
            'api_key' => 'YOUR_API_KEY',
            'sender'  => $sender,
        ]),
        CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT        => 30,
    ]);
    $r = json_decode(curl_exec($ch), true);
    curl_close($ch);
    return $r;
}

yoolaSend('0704487563', 'Your OTP is 847291. Expires in 5 minutes.', 'MyApp');

Two differences: no SDK dependency, and you use local Uganda numbers (0704...) instead of international format — though international format (+256704...) also works.

From Twilio Python SDK to Yoola SMS Python

Before

from twilio.rest import Client

client = Client(account_sid, auth_token)
client.messages.create(
    to="+256704487563",
    from_="+1234567890",
    body="Your payment has been confirmed."
)

After

import requests

def send_sms(phone: str, message: str, sender: str = "MyApp") -> dict:
    return requests.post(
        "https://yoolasms.com/api/v1/send.php",
        json={"phone": phone, "message": message, "api_key": "YOUR_API_KEY", "sender": sender},
        timeout=30,
    ).json()

result = send_sms("0704487563", "Your payment has been confirmed.")
print(result["status"])   # "success"
print(result["balance"])  # remaining credits

No pip install. No client object. No from_ number. Your sender name (up to 11 chars) appears as the sender ID.

From Twilio Node.js to Yoola SMS Node.js

Before

const twilio = require('twilio');
const client = twilio(accountSid, authToken);

await client.messages.create({
  body: 'Appointment reminder: tomorrow 10AM.',
  from: '+1234567890',
  to: '+256704487563',
});

After

// No npm install required
async function sendSMS(phone, message, sender = 'MyApp') {
  const res = await fetch('https://yoolasms.com/api/v1/send.php', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ phone, message, sender, api_key: 'YOUR_API_KEY' }),
  });
  return res.json();
}

const r = await sendSMS('0704487563', 'Appointment reminder: tomorrow 10AM.', 'ClinicSMS');
console.log(r.status, r.credits_used, r.balance);

Bulk SMS — Where Yoola SMS Really Wins

Twilio's bulk SMS requires multiple API calls or their Messaging Services setup. Yoola SMS does it in one call:

// Send to 1,000 people in one API call
const phones = customers.map(c => c.phone).join(',');

const result = await sendSMS(
  phones,
  'SALE: 30% off everything this weekend. Visit our shop. Reply STOP to unsubscribe.',
  'ShopAlert'
);

console.log(`Sent: ${result.recipients} | Credits: ${result.credits_used} | Balance: ${result.balance}`);

At UGX 35/credit (Basic rate), 1,000 SMS = UGX 35,000 (~USD 9.50). Compare that to Twilio at ~USD 90 for the same 1,000 Uganda SMS.

When to Still Use Twilio

Be honest here: use Twilio if:

Your primary market is USA, EU, or other Western markets
You need advanced features like Verify API, Conversations, or Video
Your client already has a VISA card and USD billing set up
You need enterprise SLA guarantees in those markets

Use Yoola SMS if:

You are building for Uganda, Kenya, Tanzania, Rwanda, or East Africa
Your clients pay with Mobile Money
You want UGX pricing and local support
You need a client-facing dashboard your non-technical clients can use themselves

Five Minutes to Test It

# Test with curl right now
curl -X POST https://yoolasms.com/api/v1/send.php \
  -H "Content-Type: application/json" \
  -d '{
    "phone": "YOUR_UGANDA_NUMBER",
    "message": "Test from Yoola SMS API — it works!",
    "api_key": "YOUR_API_KEY"
  }'

Get your free API key at yoolasms.com/accounts/register — takes 60 seconds, 3 SMS free, no credit card.

Resources

📖 API Documentation

🌍 Coverage — all countries and rates

💬 Developer Community Q&A

📞 WhatsApp support: +256 704 484 563 (Kampala time, quick responses)

This is not a Twilio takedown — it is a recognition that different tools are built for different markets. Africa deserves tools built for Africa.

Made in Uganda 🇺🇬 · yoolasms.com

africa #uganda #sms #api #twilio #php #python #javascript #eastafrica #developer #webdev #showdev

I Built an SMS API for Africa That Accepts Mobile Money (PHP + Python + JS Examples)

yoola sms — Sun, 21 Jun 2026 17:07:19 +0000

I Built an SMS API for Africa That Accepts Mobile Money (PHP + Python + JS Examples)

Two years ago I was building apps for Ugandan businesses — a SACCO management system, a school portal, a small e-commerce platform. Every single one needed SMS. Every single one hit the same problem.

Twilio: requires a VISA card. My clients pay with MTN Mobile Money.

Generic SMS solutions: require building everything yourself — no dashboard, no client product, no local support.

Local providers: expensive, poorly documented, support goes quiet on weekends.

I built Yoola SMS to solve this. It is now live, serving real Ugandan businesses, and I want to share everything about how to integrate it — because the more developers use it, the better the platform gets.

What I Built and Why

Yoola SMS is a bulk SMS platform and REST API for Uganda and East Africa with:

Mobile Money top-up — MTN MoMo and Airtel Money, instant credits
Prices starting at UGX 20/SMS — enterprise-grade delivery, built for East Africa
One API for 40+ countries — Uganda, Kenya, Tanzania, Rwanda, UK, UAE, USA and more
Full dashboard — your clients can use it without any technical knowledge
Reseller support — build your own SMS product on top of ours
Community Q&A — get answers from our team and other developers

Let me show you how the API works.

The API is a Single HTTP POST

No SDK. No package to install. Works from any language, any framework, any server.

POST https://yoolasms.com/api/v1/send.php
Content-Type: application/json

{
    "phone":   "0704487563",
    "message": "Your OTP is 847291. Expires in 5 minutes.",
    "api_key": "YOUR_API_KEY",
    "sender":  "MyApp"
}

Response:

{
    "status":       "success",
    "code":         200,
    "recipients":   1,
    "credits_used": 1,
    "balance":      284,
    "message_parts": 1
}

That is it. The message_parts field tells you if your message was split across multiple SMS (anything over 160 characters). Each part costs 1 credit per recipient.

PHP — The Way Most Uganda Devs Are Building

<?php

// Simple helper function — drop this in your helpers file
function yoolaSMS(string $phone, string $message, string $sender = 'YoolaSMS'): array {
    static $apiKey = 'YOUR_API_KEY_HERE';

    $ch = curl_init('https://yoolasms.com/api/v1/send.php');
    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => json_encode([
            'phone'   => $phone,
            'message' => $message,
            'api_key' => $apiKey,
            'sender'  => $sender,
        ]),
        CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT        => 30,
    ]);
    $result = json_decode(curl_exec($ch), true);
    curl_close($ch);
    return $result ?? ['status' => 'error', 'message' => 'No response'];
}

// OTP verification
$otp = rand(100000, 999999);
$_SESSION['otp'] = $otp;

yoolaSMS(
    $_POST['phone'],
    "Your Yoola SMS verification code is {$otp}. Valid for 5 minutes. Do not share.",
    'MyApp'
);

// Payment confirmation
yoolaSMS(
    $customer_phone,
    "Payment of UGX " . number_format($amount) . " received. Ref: #{$transaction_id}. Thank you!",
    'PayAlert'
);

// Bulk announcement
$phones = implode(',', array_column($members, 'phone'));
$result = yoolaSMS(
    $phones,
    "AGM Notice: Annual General Meeting on Saturday 12th July at 10AM. Venue: Kampala Serena Hotel. RSVP by Thursday.",
    'SACCOAlert'
);
echo "Notified {$result['recipients']} members\n";

Python — For the Django/Flask Devs

import requests
from functools import lru_cache

YOOLA_API_KEY = "YOUR_API_KEY_HERE"
YOOLA_BASE    = "https://yoolasms.com/api/v1"


def send_sms(phone: str | list, message: str, sender: str = "YoolaSMS") -> dict:
    """
    Send SMS via Yoola SMS API.
    phone: single number string or list of numbers
    """
    if isinstance(phone, list):
        phone = ",".join(phone)

    response = requests.post(
        f"{YOOLA_BASE}/send.php",
        json={"phone": phone, "message": message, "api_key": YOOLA_API_KEY, "sender": sender},
        timeout=30,
    )
    return response.json()


@lru_cache(maxsize=1)
def get_balance() -> dict:
    return requests.get(f"{YOOLA_BASE}/balance.php?api_key={YOOLA_API_KEY}").json()


# Django view example
from django.http import JsonResponse

def verify_phone(request):
    if request.method == "POST":
        phone = request.POST.get("phone")
        otp   = generate_otp()

        result = send_sms(
            phone,
            f"Your verification code is {otp}. Expires in 5 minutes.",
            "MyApp"
        )

        if result["status"] == "success":
            request.session["otp"]   = otp
            request.session["phone"] = phone
            return JsonResponse({"success": True})
        else:
            return JsonResponse({"success": False, "error": result["message"]}, status=400)


# Celery task for bulk notifications
from celery import shared_task

@shared_task
def send_bulk_campaign(phones: list, message: str, sender: str):
    """Fire-and-forget bulk SMS task"""
    result = send_sms(phones, message, sender)
    return {
        "sent":    result.get("recipients", 0),
        "credits": result.get("credits_used", 0),
        "balance": result.get("balance", 0),
    }

JavaScript — For Node.js / Next.js Backends

// lib/sms.js
const YOOLA_API = 'https://yoolasms.com/api/v1/send.php';
const API_KEY   = process.env.YOOLA_API_KEY;

export async function sendSMS(phone, message, sender = 'YoolaSMS') {
  const phones = Array.isArray(phone) ? phone.join(',') : phone;

  const res = await fetch(YOOLA_API, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ phone: phones, message, sender, api_key: API_KEY }),
  });

  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json();
}

// Next.js API route — pages/api/send-otp.js
import { sendSMS } from '@/lib/sms';

export default async function handler(req, res) {
  if (req.method !== 'POST') return res.status(405).end();

  const { phone } = req.body;
  const otp = Math.floor(100000 + Math.random() * 900000).toString();

  const result = await sendSMS(
    phone,
    `Your verification code is ${otp}. Do not share it. Expires in 5 minutes.`,
    'MyNextApp'
  );

  if (result.status === 'success') {
    // Store OTP in Redis/session for verification
    await redis.setex(`otp:${phone}`, 300, otp);
    return res.json({ success: true });
  }

  return res.status(400).json({ error: result.message });
}

// Express.js example
app.post('/api/notify-all', async (req, res) => {
  const { message } = req.body;
  const users = await db.users.findMany({ select: { phone: true } });

  const result = await sendSMS(
    users.map(u => u.phone),
    message,
    'AppAlert'
  );

  res.json({
    sent:    result.recipients,
    credits: result.credits_used,
    balance: result.balance,
  });
});

What I Learned Building This

1. Pricing in local currency matters more than developers think. When a school bursar asks "how much will this cost?" and the answer is "USD 0.09 per SMS" — they have no idea. When the answer is "UGX 35 per SMS" — they can calculate it immediately.

2. Payment flexibility matters. We support MTN MoMo, Airtel Money, and Visa/Mastercard via Flutterwave — all in UGX. Whether your client is a school bursar paying with MoMo or an international NGO paying by card, it just works.

3. The dashboard matters as much as the API. Developers use the API. Their clients use the dashboard. If the dashboard is confusing, you lose the client even if the API is perfect.

4. East Africa is not one market. Kenya has different routing costs to Uganda. Rwanda differs from Tanzania. Getting the per-network, per-country credit calculation right — so every send is fairly priced and profitable — took serious work with real delivery data from thousands of messages.

What is Next for Yoola SMS

Airtime API — send airtime to any Uganda number via the API (sandbox ready, live activation pending)
WhatsApp Business API — coming alongside SMS for richer messaging
SMS Templates library — pre-built templates for schools, SACCOs, hospitals, e-commerce
Developer sandbox — test your integration without spending real credits

Get Started Free

🔗 Create your account — 3 SMS free, no card needed

📖 API documentation

🌍 Coverage guide — all countries and rates

💬 Community Q&A

📞 WhatsApp: +256 704 484 563

If you build something with it — drop a comment. I want to see what developers across Africa are building.

Made in Uganda 🇺🇬 · yoolasms.com

showdev #buildinpublic #africa #uganda #sms #api #php #python #javascript #eastafrica #developer #startup

The Cheapest SMS API for Uganda and East Africa — UGX 20/SMS, Pay with Mobile Money or Card

yoola sms — Sun, 21 Jun 2026 16:32:43 +0000

The Cheapest SMS API for Uganda and East Africa — UGX 20/SMS, Pay with Mobile Money or Card

Let me show you exactly how much SMS costs across the main providers, then show you the cheapest working option with code you can use today.

The Real Cost of SMS APIs in Uganda (2026)

Provider	Price per SMS	Uganda Networks	Pay with MoMo?	Min. top-up
Twilio	~USD 0.09 (~UGX 333)	✅	❌ VISA only	$20
Yoola SMS	UGX 20–35	✅	✅	UGX 1,000
Most local providers	UGX 40–80	Partial	❌	High

Yoola SMS gives you enterprise-grade SMS delivery with a full dashboard, API, PhoneBook management, scheduling, delivery reports, and Mobile Money top-up — at prices no other Uganda provider matches.

Why "Cheapest" Matters in Uganda

If your client is a SACCO with 2,000 members sending monthly statements:

Rate	Monthly cost (2,000 SMS)
UGX 80/SMS (some local)	UGX 160,000
UGX 35/SMS (Yoola Basic)	UGX 70,000
UGX 25/SMS (Yoola Advanced)	UGX 50,000
UGX 20/SMS (Yoola Unlimited)	UGX 40,000

That is a UGX 120,000 saving per month compared to expensive local providers — just from switching API.

Getting Started (Literally 3 Minutes)

# No npm install. No pip install. No SDK.
# Just HTTP POST. Works from any language.

1. Create account: yoolasms.com/accounts/register — free, 3 SMS included

2. Top up: MTN MoMo, Airtel Money, or Visa/Mastercard — credits land instantly

3. Integrate: copy the code below

JavaScript / Node.js (fetch API)

async function sendSMS(phone, message, apiKey, sender = 'YoolaSMS') {
  const res = await fetch('https://yoolasms.com/api/v1/send.php', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ phone, message, api_key: apiKey, sender }),
  });
  return res.json();
}

// Single
const r = await sendSMS('0704487563', 'Your loan is approved. Visit our office Monday.', 'YOUR_KEY', 'SACCO');
console.log(r.status, r.credits_used, r.balance);

// Bulk — just comma-separate
const phones = ['0701111111', '0772222222', '0756333333', '0703444444'].join(',');
const bulk = await sendSMS(phones, 'SACCO AGM: Saturday 12th July, 10AM. Ggaba Community Hall. Attendance mandatory.', 'YOUR_KEY', 'SACCOAlert');
console.log(`Sent to ${bulk.recipients} members`);

Python

import requests

def send_sms(phone, message, api_key, sender="YoolaSMS"):
    r = requests.post(
        "https://yoolasms.com/api/v1/send.php",
        json={"phone": phone, "message": message, "api_key": api_key, "sender": sender},
        timeout=30
    )
    return r.json()

# Check balance first
def get_balance(api_key):
    r = requests.get(f"https://yoolasms.com/api/v1/balance.php?api_key={api_key}")
    return r.json()

api_key = "YOUR_API_KEY"

# Check balance before bulk send
balance = get_balance(api_key)
print(f"Credits available: {balance['balance']}")

# Send
result = send_sms(
    "0704487563,0772727716,+254712345678",  # Uganda + Kenya in one call
    "Your order #4521 has been shipped. Delivery in 2 business days.",
    api_key,
    "ShopAlert"
)
print(f"Sent to {result['recipients']} | Credits: {result['credits_used']} | Balance: {result['balance']}")

Volume Pricing That Scales With You

UGX 35/SMS — 1 to 999 per month      (starter, small business)
UGX 30/SMS — 1,000 to 9,999          (growing business)
UGX 25/SMS — 10,000 to 59,999        (established business)
UGX 20/SMS — 60,000+                 (enterprise)

Credits never expire. Load once, use whenever.

What Makes It Cheaper Than Going Direct to

Yoola SMS gives you everything out of the box — your client logs in, uploads a CSV, types a message, and sends. No technical knowledge needed on their end. You integrate the API once, they use the dashboard forever.

East Africa Pricing

Uganda (MTN/Airtel)    — 1 credit/SMS  (~UGX 35)
Uganda (UTL/Hamilton)  — 2 credits/SMS (~UGX 70)
Kenya  (+254)          — 3 credits/SMS (~UGX 105)
Tanzania (+255)        — 3 credits/SMS (~UGX 105)
Rwanda (+250)          — 4 credits/SMS (~UGX 140)
South Sudan (+211)     — 4 credits/SMS (~UGX 140)
Nigeria (+234)         — 5 credits/SMS (~UGX 175)
UK (+44)               — 12 credits/SMS (~UGX 420)
UAE (+971)             — 8 credits/SMS  (~UGX 280)
USA (+1)               — 10 credits/SMS (~UGX 350)

Start Free Today

🔗 yoolasms.com — 3 free SMS on signup

📖 Full API documentation

💬 Community Q&A

📞 WhatsApp: +256 704 484 563

What are you building? Drop it in the comments — I'd love to see what people are integrating SMS into across Africa.

africa #uganda #sms #api #javascript #python #eastafrica #developer #pricing

How to Send Bulk SMS in Uganda with PHP (MTN MoMo Top-Up, No VISA Card Needed)

yoola sms — Sun, 21 Jun 2026 16:30:47 +0000

How to Send Bulk SMS in Uganda with PHP (MTN MoMo Top-Up, No VISA Card Needed)

If you've ever tried to integrate SMS into a Ugandan app, you've hit the same wall every developer here hits:

Twilio wants a VISA card your client doesn't have
International APIs charge in USD with no Mobile Money option
Local options are either expensive, poorly documented, or both

I spent months dealing with this before building Yoola SMS — a bulk SMS API designed specifically for Uganda and East Africa. You top up with MTN Mobile Money or Airtel Money. No VISA. No USD. Prices start at UGX 35/SMS dropping to UGX 20 at volume.

Here's how to integrate it today.

Step 1: Get Your Free Account and API Key

Go to yoolasms.com/accounts/register — 60 seconds, no credit card. You get 3 free SMS to test immediately.

Once in, go to My API Key and copy your key.

Step 2: Top Up With Mobile Money

Click Top Up Credits in your dashboard. Enter your MTN MoMo or Airtel Money number. You get a payment prompt on your phone. Approve it. Credits appear instantly.

UGX 10,000 = 285 credits at the Basic rate. Each credit = 1 SMS.

Step 3: Send Your First SMS in PHP

<?php

function yoolaSend($phone, $message, $apiKey, $sender = 'YoolaSMS') {
    $ch = curl_init('https://yoolasms.com/api/v1/send.php');
    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => json_encode([
            'phone'   => $phone,
            'message' => $message,
            'api_key' => $apiKey,
            'sender'  => $sender,
        ]),
        CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT        => 30,
    ]);
    $result = json_decode(curl_exec($ch), true);
    curl_close($ch);
    return $result;
}

$apiKey = 'YOUR_API_KEY_HERE';

// Single SMS
$r = yoolaSend('0704487563', 'Hello! Your order is confirmed. Thank you.', $apiKey, 'MyShop');
echo "Sent: {$r['status']} | Credits used: {$r['credits_used']} | Balance: {$r['balance']}\n";

// Bulk SMS — comma-separate numbers
$phones = '0704487563,0772727716,0756111222,0701333444';
$r = yoolaSend($phones, 'Dear customer, Term 2 fees are due Friday. Pay via MoMo to 0704484563.', $apiKey, 'SchoolSMS');
echo "Bulk sent to {$r['recipients']} people. Credits used: {$r['credits_used']}\n";

That is it. No SDK to install. No npm package. Just cURL.

Real Example: Automated Fee Reminders for a School

This is one of the most common use cases in Uganda. Here is a complete script:

<?php
// fee_reminders.php — add to cron: 0 8 * * 1 (runs every Monday at 8AM)

require 'db.php'; // your database connection
$API_KEY  = 'YOUR_API_KEY';
$due_date = date('j F Y', strtotime('+7 days'));

$students = $pdo->query("
    SELECT s.parent_phone, s.student_name, f.balance_due
    FROM students s
    JOIN fees f ON f.student_id = s.id
    WHERE f.balance_due > 0 AND f.term = 'Term2'
")->fetchAll();

foreach ($students as $s) {
    $msg = "Dear Parent, {$s['student_name']}'s fees balance of UGX "
         . number_format($s['balance_due'])
         . " is due {$due_date}. Pay via MTN MoMo to 0704484563. Thank you.";

    $result = yoolaSend($s['parent_phone'], $msg, $API_KEY, 'SchoolSMS');

    if ($result['status'] !== 'success') {
        error_log("SMS failed: {$s['parent_phone']} — {$result['message']}");
    }
    usleep(100000); // 0.1s pause between sends
}
echo "Fee reminders sent.\n";

Set this as a cron job. Your bursar never chases parents manually again.

Handling Errors Properly

$result = yoolaSend($phone, $message, $apiKey);

match($result['status']) {
    'success'          => handleSuccess($result),
    'insufficient_fund'=> notifyAccountOwner('Low SMS credits! Top up now.'),
    'invalidkey'       => throw new Exception('Check your Yoola SMS API key'),
    'missing'          => throw new Exception('Phone or message field is empty'),
    default            => retryAfterDelay(3),
};

Sending to East Africa and International

Same API, same code — just use international format:

// Uganda — 1 credit
yoolaSend('0704487563', $msg, $apiKey);

// Kenya — 3 credits
yoolaSend('+254712345678', $msg, $apiKey);

// Tanzania — 3 credits  
yoolaSend('+255756123456', $msg, $apiKey);

// UK Diaspora — 12 credits
yoolaSend('+447384014597', $msg, $apiKey);

// Mix Uganda + Kenya in one bulk call — credits calculated per number
$phones = '0704487563,+254712345678,0772727716';
yoolaSend($phones, $msg, $apiKey);

Check Balance Anytime

$balance = json_decode(file_get_contents(
    'https://yoolasms.com/api/v1/balance.php?api_key=' . $apiKey
), true);

echo "Credits: {$balance['balance']}\n";
echo "UGX value: {$balance['amount']}\n";

The API Response Object

{
    "status": "success",
    "code": 200,
    "message": "SMS sent successfully",
    "recipients": 4,
    "credits_used": 4,
    "balance": 281,
    "message_parts": 1
}

message_parts tells you if your message was split (over 160 characters = multiple parts = multiple credits per recipient). Keep messages under 160 characters for best value.

Get Started

🔗 Create free account — 3 SMS free, no card

📖 Full API docs

💬 Community Q&A — ask anything

📞 WhatsApp support: +256 704 484 563

Built in Uganda 🇺🇬 — works across East Africa and 40+ countries worldwide.

Drop your questions in the comments — I reply to every one.

php #uganda #africa #sms #api #webdev #tutorial

# Send SMS to Uganda, Kenya, Tanzania, Rwanda and 40+ Countries From One API — Here's the Code

yoola sms — Sun, 21 Jun 2026 16:21:11 +0000

Send SMS to Uganda, Kenya, Tanzania, Rwanda and 40+ Countries From One API — Here's the Code

Most SMS APIs treat Africa as one bucket with one high price. The reality is very different — Kenya's networks have completely different termination costs than Uganda, and Tanzania is different again. Getting this wrong means either overcharging your clients or losing money on every send.

Here is how to do it right with one API that handles all of it automatically.

The Problem With Generic SMS APIs in East Africa

If you use a global SMS provider for Uganda/East Africa:

They quote you in USD
They charge the same rate whether you send to MTN Uganda or Safaricom Kenya — usually high
You cannot pay with Mobile Money
Support is in a different timezone and has never heard of MTN MoMo

Yoola SMS was built specifically for this region. One account. One top-up via Mobile Money. Automatic per-network credit calculation. Send to Uganda, Kenya, Tanzania, Rwanda, South Sudan, Ethiopia, DR Congo, and 40+ countries internationally.

Supported Countries and Credit Rates

Uganda (All Networks)

MTN Uganda (074x, 075x, 076x, 077x, 078x)    → 1 credit/SMS
Airtel Uganda (070x, 072x, 073x, 079x)         → 1 credit/SMS
UTL / LycaMobile (0710–0719)                   → 2 credits/SMS
Hamilton Telecom (0798–0799)                   → 2 credits/SMS

East Africa

Kenya (+254)       — Safaricom, Airtel Kenya, Telkom   → 3 credits/SMS
Tanzania (+255)    — Vodacom, Airtel, Tigo, Halotel    → 3 credits/SMS
Rwanda (+250)      — MTN Rwanda, Airtel Rwanda          → 4 credits/SMS
South Sudan (+211) — MTN, Zain                          → 4 credits/SMS
Ethiopia (+251)    — Ethio Telecom, Safaricom           → 4 credits/SMS
DR Congo (+243)    — Vodacom DRC, Airtel, Orange        → 5 credits/SMS

International

UAE (+971)         → 8 credits/SMS
USA/Canada (+1)    → 10 credits/SMS
UK (+44)           → 12 credits/SMS
Germany (+49)      → 15 credits/SMS
Australia (+61)    → 16 credits/SMS

At the Basic rate of UGX 35/credit.

The Code — Works for All Countries

The API is identical regardless of destination country. Just pass the number in international format and credits are calculated automatically.

PHP

<?php

function sendSMS(string $phone, string $message, string $apiKey, string $sender = 'YoolaSMS'): array {
    $ch = curl_init('https://yoolasms.com/api/v1/send.php');
    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => json_encode(compact('phone', 'message', 'sender') + ['api_key' => $apiKey]),
        CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT        => 30,
    ]);
    $res = json_decode(curl_exec($ch), true);
    curl_close($ch);
    return $res;
}

$key = 'YOUR_API_KEY';

// Uganda
sendSMS('0704487563', 'Your package has been dispatched.', $key, 'ShopUG');

// Kenya
sendSMS('+254712345678', 'Your package has been dispatched.', $key, 'ShopKE');

// Tanzania
sendSMS('+255756123456', 'Your package has been dispatched.', $key, 'ShopTZ');

// Mix all in one bulk call — auto-calculates credits per country
$allNumbers = '0704487563,+254712345678,+255756123456,+250785432100';
$r = sendSMS($allNumbers, 'Regional campaign: 20% off all products this weekend!', $key, 'RegionalSMS');

echo "Sent to: {$r['recipients']} recipients across Uganda, Kenya, Tanzania, Rwanda\n";
echo "Credits used: {$r['credits_used']}\n";
echo "Balance remaining: {$r['balance']}\n";

Python

import requests

def send_regional_sms(numbers: list[str], message: str, api_key: str, sender: str = "YoolaSMS") -> dict:
    """Send SMS to Uganda, East Africa, or International numbers."""
    return requests.post(
        "https://yoolasms.com/api/v1/send.php",
        json={
            "phone":   ",".join(numbers),
            "message": message,
            "api_key": api_key,
            "sender":  sender,
        },
        timeout=30,
    ).json()


api_key = "YOUR_API_KEY"

# Regional NGO notification — Uganda + Kenya + Rwanda
recipients = [
    "0704487563",       # Uganda MTN
    "0772727716",       # Uganda MTN
    "+254712345678",    # Kenya Safaricom
    "+254733803035",    # Kenya Airtel
    "+250785123456",    # Rwanda MTN
]

result = send_regional_sms(
    recipients,
    "Community health clinic: Free malaria testing this Saturday 8AM-2PM at all district offices.",
    api_key,
    "HealthAlert"
)

print(f"Delivered to {result['recipients']} recipients")
print(f"Covered: Uganda + Kenya + Rwanda in one send")
print(f"Credits used: {result['credits_used']}")

Node.js

const sendRegional = async (numbers, message, apiKey, sender = 'YoolaSMS') => {
  const res = await fetch('https://yoolasms.com/api/v1/send.php', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      phone:   Array.isArray(numbers) ? numbers.join(',') : numbers,
      message, sender,
      api_key: apiKey,
    }),
  });
  return res.json();
};

const apiKey = 'YOUR_API_KEY';

// E-commerce: notify buyers across East Africa
const orders = [
  { phone: '0704487563',    name: 'James',   country: 'Uganda'   },
  { phone: '+254712345678', name: 'Mary',    country: 'Kenya'    },
  { phone: '+255756123456', name: 'Patrick', country: 'Tanzania' },
];

// Send personalised messages individually
for (const order of orders) {
  const result = await sendRegional(
    order.phone,
    `Hi ${order.name}, your order from ${order.country} has been confirmed. Delivery in 3-5 days.`,
    apiKey,
    'EastAfricaShop'
  );
  console.log(`${order.country}: ${result.status} | ${result.credits_used} credit(s) used`);
}

Real Use Case: NGO Regional Campaign Manager

<?php
// ngos often need to reach communities across multiple East African countries
// This class handles it cleanly

class YoolaSMSRegional {
    private string $apiKey;
    private string $baseUrl = 'https://yoolasms.com/api/v1/';

    public function __construct(string $apiKey) {
        $this->apiKey = $apiKey;
    }

    public function send(array|string $phones, string $message, string $sender = 'NGOAlert'): array {
        $phone = is_array($phones) ? implode(',', $phones) : $phones;
        $ch = curl_init($this->baseUrl . 'send.php');
        curl_setopt_array($ch, [
            CURLOPT_POST           => true,
            CURLOPT_POSTFIELDS     => json_encode(['phone'=>$phone,'message'=>$message,'api_key'=>$this->apiKey,'sender'=>$sender]),
            CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
            CURLOPT_RETURNTRANSFER => true,
        ]);
        $r = json_decode(curl_exec($ch), true);
        curl_close($ch);
        return $r;
    }

    public function balance(): int {
        $r = json_decode(file_get_contents($this->baseUrl . 'balance.php?api_key=' . $this->apiKey), true);
        return (int)($r['balance'] ?? 0);
    }

    public function schedule(array|string $phones, string $message, string $datetime, string $sender = 'NGOAlert'): array {
        $phone = is_array($phones) ? implode(',', $phones) : $phones;
        $ch = curl_init($this->baseUrl . 'schedule_sms.php');
        curl_setopt_array($ch, [
            CURLOPT_POST           => true,
            CURLOPT_POSTFIELDS     => json_encode(['phone'=>$phone,'message'=>$message,'api_key'=>$this->apiKey,'sender'=>$sender,'schedule_time'=>$datetime]),
            CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
            CURLOPT_RETURNTRANSFER => true,
        ]);
        $r = json_decode(curl_exec($ch), true);
        curl_close($ch);
        return $r;
    }
}

// Usage
$sms = new YoolaSMSRegional('YOUR_API_KEY');

echo "Credits available: " . $sms->balance() . "\n";

// Immediate send across East Africa
$result = $sms->send(
    ['0704487563', '+254712345678', '+255756123456', '+250785123456', '+211912345678'],
    'Community meeting: Monday 7th July, 2PM. Venue: District Hall. All members required.',
    'NGOAlert'
);
echo "Sent to {$result['recipients']} people across 5 countries\n";

// Schedule a reminder for the morning of the event
$sms->schedule(
    ['0704487563', '+254712345678', '+255756123456'],
    'REMINDER: Community meeting TODAY at 2PM. District Hall. Do not miss.',
    '2026-07-07 08:00:00'
);
echo "Morning reminder scheduled.\n";

Coverage Map

✅ Uganda — all networks

✅ Kenya · Tanzania · Rwanda · South Sudan · Ethiopia · DR Congo

✅ Nigeria · Ghana · South Africa · Malawi · Zambia + 20 more African countries

✅ UK · USA · UAE · Australia · Germany · France · India · China + 20 more

Full list at yoolasms.com/coverage

Get Started

🔗 Free account — 3 SMS included

💳 Top up with: MTN MoMo · Airtel Money · Visa/Mastercard (via Flutterwave) — all in UGX

📖 API docs

🌍 Coverage & credit rates

💬 Community Q&A

Built in Uganda 🇺🇬 for East Africa and the world.

Building something that spans multiple African countries? Share it in the comments — genuinely curious what people are working on.

eastafrica #uganda #kenya #tanzania #africa #sms #api #php #python #javascript #developer