DEV Community: yoola sms

Send Bulk SMS in Uganda by Importing Excel (YoolaSMS)

yoola sms — Tue, 25 Aug 2026 16:56:32 +0000

If you’re tired of manually handling phone numbers for notifications, fee reminders, or alerts, there’s a simpler way.
With YoolaSMS, you can:

Import contacts via Excel/CSV
Send bulk SMS in minutes
Track delivery status in real time
Use branded Sender IDs

Useful for schools, SACCOs, and developers building notification systems.
Get started: yoolasms.com

Contact: 0704 487 563

How to Send Bulk SMS in Uganda with a Branded Sender ID (Using YoolaSMS)

yoola sms — Mon, 24 Aug 2026 09:02:43 +0000

Sending bulk SMS in Uganda is still one of the most effective ways for schools, SACCOs, businesses, and developers to reach customers instantly. But many people still struggle with high costs, poor delivery reports, and messages that arrive from random numbers.
In this post, I’ll share a practical way to send bulk SMS professionally using YoolaSMS.

Why Branded Sender ID Matters
Instead of your messages showing a random phone number, a Custom Sender ID allows your SMS to appear as:

MUKONO_SCH
ST_MARYS
YOUR_BUSINESS

This increases trust and improves open rates, especially for schools and financial institutions.
Key Features Developers & Businesses Care About
With YoolaSMS you get:

Simple web dashboard
Excel/CSV contact import
Real-time delivery reports (Sent, Delivered, Failed)
Branded Sender ID (MTN & Airtel)
Mobile Money top-up
API access for developers

Current Introductory Offer
New fully registered accounts currently get:
UGX 30 per SMS for the first 1,000 messages.
This is useful if you’re testing the platform or onboarding a school/SACCO.
Getting Started

Create an account at yoolasms.com
Complete registration
Top up via Mobile Money
Import contacts or use the API
Start sending

For developers who want to integrate SMS into their systems, the platform also provides API access so you can trigger messages directly from your application (fee reminders, OTPs, notifications, etc.).
Who is this useful for?

Schools sending fee reminders
SACCOs sending loan notices
Developers building notification systems
Churches and NGOs
Small & medium businesses

Final Thoughts
If you need reliable, affordable bulk SMS in Uganda with proper delivery tracking and branded sender IDs, YoolaSMS is worth testing.
You can try it here:
👉 https://yoolasms.com
📞 0704 487 563

How Schools and SACCOs in Uganda Automate Fee Reminders & Notices | Save Time & Improve Collections

yoola sms — Sun, 16 Aug 2026 11:26:24 +0000

How Schools and SACCOs in Uganda Automate Fee Reminders & Notices | Save Time & Improve Collections
In this video, we show how schools and SACCOs in Uganda are using simple technology to automatically send fee reminders, payment notices, and important updates to parents and members without stress or manual work.
You’ll learn how institutions are:
• Sending bulk SMS reminders in minutes
• Reducing late payments
• Improving communication with parents and members
• Saving time and administrative costs
• Using branded sender IDs for trust and professionalism
Whether you run a school, SACCO, church, or community organisation, this video will help you understand how automation can transform your fee collection and communication process.
⏱ Video Length: 1 minute 43 seconds
🔗 Try it yourself: https://yoolasms.com
If this video helped you, please like, comment, and subscribe for more practical solutions for Ugandan schools, SACCOs, and businesses.

YoolaSMS #BulkSMSUganda #SchoolFees #SACCO #UgandaSchools #FeeReminders #SMSAutomation #EdTechUganda #MobileMoney

Best Bulk SMS API for Uganda in 2026 — Honest Comparison

yoola sms — Wed, 29 Jul 2026 08:39:42 +0000

Best Bulk SMS API for Uganda in 2026 — Honest Comparison (Pricing, Speed, Features)
published: true
description: An honest developer's comparison of bulk SMS APIs available in Uganda. YoolaSMS vs Africa's Talking vs Twilio vs Infobip vs Vonage. Pricing, delivery speed, API simplicity, and real-world experience.
tags: api, sms, africa, comparison
canonical_url: https://yoolasms.com/blog/best-bulk-sms-api-uganda-2026-comparison

cover_image: https://yoolasms.com/uploads/og-image.jpg

Best Bulk SMS API for Uganda in 2026 — Honest Comparison

If you're a developer building an application that needs to send SMS in Uganda, you have several API options. But which one is actually the best for your use case?

I'm David, founder of YoolaSMS. Yes, I have a bias — but I'll be honest about where each platform wins and loses. You can make your own decision.

The Contenders

Provider	HQ	Uganda support	Starting price
YoolaSMS	Kampala, Uganda 🇺🇬	Native	UGX 20/SMS
Africa's Talking	Nairobi, Kenya	Yes	~UGX 35/SMS
Twilio	San Francisco, USA	Yes	~UGX 150/SMS
Infobip	London/Croatia	Yes	~UGX 80/SMS
Vonage (Nexmo)	London, UK	Limited	~UGX 120/SMS

Comparison: What Actually Matters to Developers

1. Pricing (Cost per SMS to Uganda MTN)

This is usually the deciding factor for African applications.

Provider	Cost per SMS (UGX)	Cost for 10,000 SMS (UGX)	Cost for 100,000 SMS (UGX)
YoolaSMS	20	200,000	2,000,000
Africa's Talking	35	350,000	3,500,000
Infobip	~80	~800,000	~8,000,000
Vonage	~120	~1,200,000	~12,000,000
Twilio	~150	~1,500,000	~15,000,000

At 100,000 SMS, YoolaSMS saves you UGX 1.5M vs Africa's Talking and UGX 13M vs Twilio. For a school sending monthly fee reminders, that's the difference between affordable and impossible.

2. API Simplicity

How many lines of code to send your first SMS?

YoolaSMS — 4 lines (PHP):

$r = file_get_contents('https://yoolasms.com/api/v1/send?' . http_build_query([
    'api_key' => 'KEY', 'phone' => '0704487563',
    'message' => 'Hello!', 'sender' => 'ATInfo',
]));

Africa's Talking — 12+ lines (requires SDK installation):

// Must install: composer require africastalking/africastalking
$AT = new AfricasTalking($username, $apiKey);
$sms = $AT->sms();
$result = $sms->send([
    'to' => '+256704487563',
    'message' => 'Hello!',
    'from' => 'ATInfo',
]);

Twilio — 15+ lines (requires SDK + account SID + auth token):

// Must install: composer require twilio/sdk
$client = new Client($accountSid, $authToken);
$client->messages->create('+256704487563', [
    'from' => '+1234567890', // Must buy a Twilio number!
    'body' => 'Hello!',
]);

Winner: YoolaSMS — no SDK required, simple HTTP POST, works with any language that can make HTTP requests.

3. Uganda-Specific Features

Feature	YoolaSMS	Africa's Talking	Twilio	Infobip
Uganda Sender IDs	✅ Easy setup	✅	⚠️ Complex	⚠️ Complex
MTN Uganda delivery	✅ Direct	✅ Direct	✅ Via aggregator	✅ Via aggregator
Airtel Uganda delivery	✅ Direct	✅ Direct	✅ Via aggregator	✅ Via aggregator
UGX pricing display	✅ Native	✅	❌ USD only	❌ EUR/USD
Mobile Money top-up	✅ MTN MoMo + Airtel	❌ Card/bank only	❌ Card only	❌ Card only
Kampala-based support	✅ WhatsApp + call	❌ Nairobi HQ	❌ US timezone	❌ EU timezone
Uganda phone format (07XX)	✅ Auto-normalizes	⚠️ Requires +256	⚠️ Requires +256	⚠️ Requires +256

Winner: YoolaSMS — built BY Ugandans FOR Uganda. Phone number normalization, MTN MoMo top-ups, and Kampala-based support make the difference.

4. Delivery Speed

Real-world delivery times to Uganda MTN (tested July 2026):

Provider	Average delivery time
YoolaSMS	2-5 seconds
Africa's Talking	2-5 seconds
Twilio	3-8 seconds
Infobip	3-10 seconds
Vonage	5-15 seconds

All are acceptable. YoolaSMS and Africa's Talking are fastest because they have direct Uganda carrier connections.

5. Reliability & Transparency

Feature	YoolaSMS	Africa's Talking	Twilio	Infobip
Public status page	✅ status.yoolasms.com	✅	✅	✅
Real-time monitoring	✅ 6 services, every 5 min	✅	✅	✅
Public security page	✅ yoolasms.com/security	❌	✅	✅
Bug bounty program	✅ UGX 10K-150K rewards	❌	✅	✅
Uptime SLA	⚠️ Informal	⚠️ Informal	✅ 99.95%	✅ 99.95%

Winner: Tie. YoolaSMS punches above its weight with public status + security pages — unusual for a platform its size.

6. Scalability

How many SMS can you send in one API call?

Provider	Max per request	Rate limit
YoolaSMS	500 (auto-batched internally for larger)	30 req/min
Africa's Talking	~1,000	Varies
Twilio	1 (yes, one)	1 req/sec
Infobip	Unlimited (they batch)	Varies

YoolaSMS note: While we accept up to 500 per API call, we internally handle campaigns of 200,000+ SMS via micro-batching. Enterprise customers (universities, banks) send 200K+ through our platform regularly.

7. Free Tier / Testing

Provider	Free credits
YoolaSMS	3 free SMS on signup
Africa's Talking	Sandbox (not real SMS)
Twilio	$15 credit (~100 SMS to Uganda)
Infobip	Limited trial
Vonage	€2 credit

Winner: Twilio for credit amount, but YoolaSMS for simplicity — your 3 free SMS are real production SMS, no sandbox mode.

When to Choose Each Provider

Choose YoolaSMS when:

✅ Your primary market is Uganda / East Africa
✅ Price sensitivity matters (schools, SACCOs, SMEs)
✅ You want the simplest API (no SDK installation)
✅ You need MoMo top-up (no credit card required)
✅ You want Uganda-based support (same timezone, WhatsApp)
✅ You're bootstrapped and every UGX matters

Choose Africa's Talking when:

✅ You need USSD, voice, AND SMS from one provider
✅ Your app serves multiple African countries equally
✅ You want a larger ecosystem (airtime, payments, etc.)
✅ You're based in Kenya or building for the Kenyan market first

Choose Twilio when:

✅ You're building for global markets (not just Africa)
✅ You need advanced features (programmable voice, video, etc.)
✅ Budget is not a constraint
✅ You need a US phone number for two-way SMS

Choose Infobip when:

✅ You need omnichannel (SMS + WhatsApp + email + push in one API)
✅ You're an enterprise with global compliance needs
✅ Budget is not a constraint
✅ You need advanced analytics and reporting

My Honest Assessment

I built YoolaSMS because I needed something cheaper and simpler for the Ugandan market. Africa's Talking is excellent — in fact, our SMS delivery runs on their infrastructure. Twilio is world-class but priced for Silicon Valley, not Kampala.

For a Ugandan developer building a Ugandan product: YoolaSMS is the obvious choice. Not because I built it — because the economics make sense.

UGX 20/SMS. No SDK required. Mobile Money top-ups. Kampala support. 919 businesses already trust us.

Get Started

# Test with cURL right now (3 free SMS on signup)
curl -X POST https://yoolasms.com/api/v1/send \
  -d "api_key=YOUR_KEY&phone=07XXXXXXXX&message=Test&sender=ATInfo"

Sign up: yoolasms.com/register
API docs: yoolasms.com/developer
Pricing: yoolasms.com/pricing
Status: status.yoolasms.com

Disclaimer: I'm the founder of YoolaSMS. I've tried to be fair and factual, but I have an obvious bias. Try multiple providers and choose what works for your specific needs. The best API is the one that delivers your SMS reliably at a price you can afford.

Built in Kampala, Uganda 🇺🇬 by OSP IT Digital Solutions

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