SMS API load testing is mostly a test of your own code: your queue, your retry logic and your webhook receiver. The carrier side has fixed limits you can't raise by hammering it, and blasting real handsets with test traffic is the quickest way to get a number filtered. So you simulate the provider for volume, send a small amount of real traffic for fidelity, and size everything else with arithmetic.

This guide is for developers launching a texting feature. It covers what to load test, what not to, how to use the throughput figures carriers imply, and how to prove your receiver survives a burst of replies and status callbacks.

What you're really testing

A texting integration has four parts that can fail under load, and only one of them is the carrier.

  • Your producer. The code that creates send requests, often from a cron job, a CRM trigger or a customer clicking send on a 5,000-contact list.
  • Your queue. What holds work when you're producing faster than the provider accepts.
  • The provider API. Request limits, bulk caps and idempotency behavior.
  • Your webhook receiver. It takes replies, opt-outs and delivery updates, and it has to stay up when a campaign finishes and thousands of callbacks land together.

Load testing the carrier path isn't useful. You can't change it, and you'd pay for it.

Rules that keep you out of trouble

Treat these as the ground rules before anything runs.

  1. Never send test traffic to numbers you don't control. Every real text is a real message to a real person, with TCPA and opt-out obligations attached.
  2. Never test through a production brand's numbers. Unregistered or odd traffic can get a number filtered, and filtering is hard to undo.
  3. Don't loop sends to the same handful of numbers. Repetitive identical traffic looks like spam to carriers.
  4. Use a stub for volume. A fake provider in your own network can accept 10,000 requests a second, which tells you whether your code survives.
  5. Send small real batches for fidelity. A few dozen messages to your own team's phones proves the full path.

On Ready, an API test key simulates send_sms over MCP and refuses every other tool that changes or bills something. For the REST routes, check the API quickstart for how test keys behave before you depend on one, and read SMS API sandbox and test numbers for the general pattern.

Size the throughput with the math first

Carriers publish no official rate card, so treat these as round approximations. The per-second rate is counted in segments, per campaign: about 1 to 4 segments per second for a fresh standard campaign with no vetting, and roughly 10 to 75 for higher use-case tiers. On top of that, T-Mobile caps daily volume by brand trust score at about 2,000, 10,000, 40,000, 100,000 or 200,000 messages a day, lowest score first. AT&T throttles per second and per minute instead of a hard daily cap. Brand vetting raises the daily cap only when it crosses a tier, and it doesn't change the per-second rate.

Here's a worked example, with every assumption labeled. Assume a platform sends a 50,000-segment campaign.

Assumed rateMathTime to drain
4 segments/second (fresh campaign)50,000 / 4 = 12,500 secondsabout 3.5 hours
10 segments/second50,000 / 10 = 5,000 secondsabout 83 minutes
40 segments/second50,000 / 40 = 1,250 secondsabout 21 minutes

Now check the daily cap. If the brand sits at the lowest assumed tier of about 2,000 messages a day, a 50,000-message list can't finish in a day at any speed, because a cap isn't a rate. That's a product decision for your launch plan, not a load test finding.

Your test's job is to confirm your system holds up for those hours, which means the queue keeps ordering, retries don't pile up, and memory stays flat. SMS throughput and TPS explained walks through the same math in more detail.

Test queue backpressure

Backpressure is what your system does when work arrives faster than it can leave. Test it deliberately.

  1. Point your producer at a stub that accepts 4 segments a second.
  2. Enqueue 20,000 sends at once.
  3. Watch queue depth, age of the oldest item, and worker memory for the full drain.

What you want to see: depth rises, then falls linearly. The oldest item's age matches the math above. A user-facing send button either shows "queued" or refuses politely, rather than timing out.

What fails in practice is the retry path. If a worker retries on a timeout and the first request actually succeeded, you send twice. Ready's API takes an Idempotency-Key header so a retried request, within the 7 days Ready keeps it, returns the first answer instead of sending again, so generate one key per logical message and reuse it on every retry. SMS API idempotency and duplicate texts covers the pattern.

For bulk, Ready's POST /v1/messages/bulk takes at most 100 recipients per call, so split bigger lists into batches and test the batching code itself. Request-rate limits and error codes live in the error docs and the rate limits post, so read them and handle a refusal as a normal outcome, not an exception.

Load test the webhook receiver

Outbound is paced by the carrier. Inbound isn't. When a campaign lands, replies and status updates arrive in a cluster, and a receiver that does slow work inline will drop them.

A good receiver does three things:

  • Acknowledges fast, then does the work from a queue.
  • Treats every event as possibly duplicated or out of order.
  • Records an opt-out before anything else.

To test it, replay a recorded or synthetic batch of 5,000 events at 200 a second against your own endpoint, with 10 percent of them duplicated and a slice shuffled out of order. Confirm the final state is correct and no opt-out was lost. Replies are billed like a sent text on Ready, so use synthetic events for volume rather than real inbound traffic.

Two posts help here: receiving SMS with inbound webhooks and out-of-order SMS webhooks. For a local setup, see SMS API webhook testing locally.

A small real-send test that's safe

After the stubbed volume test passes, run a short real one.

  • Use a few phones your team owns, on different carriers.
  • Send with consent_attested set to true only because those people did agree.
  • Confirm one message end to end, then a burst of 20 to the same group.
  • Check that STOP from one test phone blocks the next send, and that the refusal isn't charged.

On Ready, every text is charged at the normal rate from the first one, and a card on file and a number of the account's own are required. Keep the real-send step small, and don't use it for volume.

Frequently asked questions

Can I load test an SMS API against production?

You can test your own side against production-shaped traffic, but you shouldn't push volume through live carrier routes. Use a stub provider for volume and a few owned phones for the real path, because every real text is a real message with compliance obligations.

What throughput should I assume for a new number?

Assume about 1 to 4 segments per second for a fresh standard campaign with no vetting, and tens (roughly 10 to 75) for higher use-case tiers. These are approximations, so state the rate your test assumes and revisit it once the campaign is approved.

How do I test webhooks without real texts?

Replay synthetic events at your own endpoint, with duplicates and shuffled order mixed in. Check that opt-outs are recorded first and that the final state matches what you expect.

Next step

Build the stub, run the drain test with the math above, and replay a burst against your receiver. Then send a short batch to phones you own. When you're ready to try the real thing, the API quickstart covers the key, a first send and a webhook.