When MTN Nigeria SMS is delayed: an OTP incident playbook for product teams
Robase · 2026-10-08
On 6 October 2026, SMS providers posted delivery delays to MTN subscribers in Nigeria on their public status pages. If your login depends on an SMS OTP, a day like that shows up as a spike in "I never got the code" tickets, a wall of resend taps, and a prepaid balance that drops faster than usual.
This post is a playbook for the app side of that day: what a product team can do while a network is slow. It does not depend on which SMS provider you use. No SMS provider, Robase included, controls how a mobile network delivers, so plan for delays rather than assume they will not happen.
What happened on 6 October
SMS providers posted notices on their public status pages about delayed delivery to MTN subscribers in Nigeria. The notices described delays, and none of the ones we read gave a root cause, so this post does not guess at one.
One detail is worth keeping. In one case, an announced recovery was reversed about two hours later: the provider said delivery had recovered, then reported the delays again, and only later marked the incident resolved. If you had closed your own incident at that first "recovered" post, you would have reopened it soon after. That is the lesson for product teams: do not close your incident at the first recovery post. Close it when your own numbers say so (parts 1 and 5).
The playbook in five parts
- Detect that it is a network problem, not your code.
- Communicate with users before they flood support.
- Protect credits so resends do not drain your prepaid wallet.
- Fall back to a channel you chose in advance.
- Recover and review.
1. Detect: watch verify rate by network
Often the earliest signal is not a status page. It is your own data, split by network.
Verify rate by prefix. For each OTP send, record the time, the destination prefix, and whether that OTP was verified. On Robase, the otp.verified webhook tells you a code was accepted, and otp.sent, otp.delivered, otp.failed and otp.expired fill in the rest (Webhooks). Compare the share of OTPs verified within a few minutes against your normal level for the same hour. When MTN prefixes fall and Airtel and Glo hold steady, you have your answer.
Two cautions:
- Do not rely on delivery receipts alone. For an OTP, delivery is not a status. It shows up as a
deliveredhop on the timeline, adelivered_attime onGET /v1/otp/{id}, and theotp.deliveredwebhook, and all three appear only when the carrier sends a delivery receipt (Delivery timeline, Webhooks). Some routes never send one, so an OTP with nodeliveredhop can still have reached the phone. Verify rate measures what you actually care about. - You map prefixes to networks. The documented Robase send responses and webhook payloads carry
country_code, not a network name. Keep your own prefix table. Nigerian numbers can be ported between networks, so treat a prefix map as a good approximation, not a certainty.
Expired and failed counts. A rise in otp.expired for one network suggests codes are landing late or not at all. otp.failed carries a reason, such as delivery_failed when the network reported the message failed, rejected or expired, and a refunded flag (Delivery timeline).
Status pages. Subscribe your on-call channel to your SMS provider's status page. Robase posts active send outages at robase.dev/status. Treat any status page as a second signal. Your verify rate will often move first, and a "recovered" post is not the end of the incident until your own numbers agree.
2. Communicate: say it before they ask
Users who know a delay is expected wait. Users who do not know tap resend.
When your detection fires for one network, show a short notice on the code entry screen for numbers on that network:
Codes to MTN numbers may be slow right now. Your code can take a few minutes to arrive. Please wait before requesting a new one.
Keep it factual and temporary. Do not blame anyone, and do not promise a time. Give support the same wording as a reply template, plus a link to your fallback (part 4). Take the notice down when your verify rate recovers, not when the first status update says so.
3. Protect credits: slow down resends
On a prepaid wallet, every resend is a new charge. On Robase, an OTP is charged when the send is accepted, not when it is delivered (SMS overview). Only a terminal failed hop can bring the credit back, and its refunded flag reads from the credit ledger (Delivery timeline). Failures where every route failed or the network reported the message undelivered are refunded. The one documented exception is reason max_attempts_exceeded: the code was delivered and then burned by wrong verify attempts, so it is not refunded. An OTP that is late, expires, or is verified was never failed, so it stays charged. During a delay, the codes are often still on their way, so each extra tap usually buys another code that will also be late.
A Nigerian SMS OTP to MTN costs 1 credit (₦6) at today's rates (Pricing). That is small per message and adds up quickly when a whole user base taps resend at once.
What to change:
- Never auto-resend on a timeout. If your app resends automatically when no code arrives in N seconds, turn that off during an incident, or permanently.
- Lengthen the cooldown. Show a countdown and grow the wait after each resend, for example 60 seconds after the first send, then 3 minutes after the second.
- Cap resends per number. Robase allows 3 OTP sends per 10 minutes per phone number and returns
429 rate_limitedwith aRetry-Afterheader past that (Rate limits). Set your own cap below it so users see your message, not an error. - Honour Retry-After. Never retry a 429 in a loop.
- Send an Idempotency-Key. A network retry with the same key within 24 hours returns the original response instead of a second charge (Idempotency).
- Think about the TTL. The default
ttl_secondsis 600, and the maximum is 3600 (OTP verification). A longer TTL during a known delay lets a late code still verify, at the cost of a longer window for a stolen code. Make that a deliberate decision, not a panic edit.
A simple guard in Node:
// Decide when this phone number may get another OTP send.
// sendTimes: timestamps (ms) of earlier sends to this number, oldest first.
const COOLDOWN_SECONDS = [60, 180]; // wait after the 1st send, then after the 2nd
const MAX_SENDS_PER_10_MIN = 2; // stay below Robase's limit of 3
const WINDOW_MS = 10 * 60 * 1000;
function nextSendAllowedAt(sendTimes, now = Date.now()) {
if (sendTimes.length === 0) return now;
const recent = sendTimes.filter((t) => now - t < WINDOW_MS);
if (recent.length >= MAX_SENDS_PER_10_MIN) {
return recent[0] + WINDOW_MS; // show the fallback options meanwhile
}
const last = sendTimes[sendTimes.length - 1];
const step = Math.min(sendTimes.length, COOLDOWN_SECONDS.length) - 1;
return last + COOLDOWN_SECONDS[step] * 1000;
}
Also watch the wallet itself. The credit_balance.low and credit_balance.exhausted webhooks tell you before sends start failing with 402 insufficient_credits (Webhooks, Errors). See monitor your SMS credit balance.
4. Fall back: a channel you chose in advance
A fallback works best when the user chooses it and your team set it up before the incident. Options that do not depend on the delayed SMS route:
WhatsApp OTP. Robase can deliver the code over WhatsApp, using a Meta Authentication template with a copy-code button. It is OTP delivery only, not general WhatsApp messaging (WhatsApp OTP). The workspace delivery mode, set on the General settings page in the dashboard, decides what is allowed (OTP verification):
| Mode | Behaviour | | ---------- | ------------------------------------------------------ | | sms | SMS only (the default) | | whatsapp | WhatsApp only | | both | One code on SMS and WhatsApp. Both legs are charged. | | either | Your app picks channel per request. Omit it for SMS. |
For incidents, either is the flexible setup: your app can offer "Send the code on WhatsApp instead" to users on the affected network and keep SMS for everyone else. both sends every code on both channels, so you pay for both legs on every send. A Nigerian WhatsApp OTP is 4 credits (₦24), so both to an MTN number costs the 1 credit SMS leg plus the 4 credit WhatsApp leg.
Be clear on one rule: there is no silent fallback. A failed WhatsApp leg is refunded and reported failed. It is never re-sent as SMS. In both mode the SMS leg was already sent alongside it; in every other mode, an SMS only goes out if your app makes a new send (OTP verification). The switch is your decision, in your code. Verify works on the same otp_id whichever channel the user read the code from. The user also needs WhatsApp on that number. Our WhatsApp OTP API Nigeria guide covers setup.
An authenticator app. If users have enrolled a TOTP app or a passkey, offer it on the code screen. It does not depend on any network.
Email. A one-time link or code to a verified email address, sent through your own email provider. Robase does not send email.
Whatever you offer, put it on the code entry screen next to the resend button. A user who waited two minutes should see a better option than "tap again."
5. Recover: close it properly
- Wait for your own numbers. Close the incident when verify rate on the affected prefixes is back to normal for a sustained period, not at the first recovery post. On 6 October, one announced recovery was reversed about two hours later.
- Remove the notice and restore normal cooldowns.
- Count the cost. How many extra sends went to the affected prefixes, and how many credits did they use? How many
otp.failedevents came back withrefunded: true? - Check late arrivals. How many codes expired before the user could enter them? Was your TTL too short for a slow route?
- Check the fallback. How many users switched to WhatsApp, an authenticator or email, and did they complete login?
- Top up if needed and wait for
credit_balance.topped_upbefore you call the wallet healthy. - Write it down. Timeline, signals, what you changed, what you would change. Next time, the detection threshold and the notice text should already exist.
Checklist
Before the next incident
- [ ] Record verify rate per number prefix and alert on a drop for one network.
- [ ] Subscribe on-call to your SMS provider's status page.
- [ ] Write the in-app notice and the support reply now.
- [ ] Remove any auto-resend on timeout. Add growing cooldowns and a per-number cap below 3 sends per 10 minutes.
- [ ] Send an
Idempotency-Keyon every OTP POST. - [ ] Subscribe to
credit_balance.lowandcredit_balance.exhausted. - [ ] Choose your fallback: WhatsApp OTP (set the mode to
eitherif your app should decide per request), an authenticator app, or email.
During
- [ ] Confirm the drop is one network, not your code or your wallet.
- [ ] Turn on the notice for affected numbers.
- [ ] Offer the fallback on the code screen.
- [ ] Do not close on the first recovery post.
After
- [ ] Verify rate back to normal for a sustained period.
- [ ] Notice off, normal cooldowns back.
- [ ] Credits used, refunds, expiries and fallback use counted.
- [ ] Review written and thresholds updated.
When it is one user, not a network
If the problem is a single user, the cause is usually not the network at all. Work through that one attempt instead: number format, wallet, Sender ID, receipts, expiry and resends. See OTP SMS not arriving? How to debug one attempt.
Set up the fallback before you need it
Robase sends SMS OTP, WhatsApp OTP and transactional SMS on one prepaid wallet (1 credit = ₦6). A Nigerian SMS OTP starts at 1 credit (₦6), and a Nigerian WhatsApp OTP is 4 credits (₦24). Live rates are on Pricing. Creating an account is free, and your first successful top-up adds bonus credits, once per account.
Start with the SMS OTP API Nigeria guide.