SMS pumping, also called artificially inflated traffic, is a scam where someone triggers thousands of texts from your app to numbers they profit from. You pay for every message. They collect a share of the termination fees, and your product gets nothing out of it.

If your signup form, password reset or login flow sends a code to any number a visitor types, you're a target. Here's how the attack works, what it costs, and the controls a developer can add this week.

What is SMS pumping fraud?

SMS pumping is traffic generated for money, not for users. An attacker finds a public form that sends a text, such as a verification code, and feeds it a stream of phone numbers. Some of those numbers sit on routes where whoever receives the traffic earns a cut of each message. The attacker, or a partner, gets paid when your app sends.

No customer is ever reading those codes. The signups don't convert, the accounts are junk, and the bill arrives anyway.

It hits one-time passcode (OTP) and signup flows hardest because they share three traits:

  • They're open to anyone, with no login required.
  • They send a text on demand to a number the visitor chose.
  • They look harmless in logs, since each request is a normal form submit.

This is a cost attack, not a data breach. Nobody needs to get into your accounts. They only need your send button.

What does an attack look like in your logs?

You rarely see one loud spike. Attackers spread requests out to stay under naive limits. The signs are a pattern across many requests:

SignalWhat it looks like
Sudden jump in verification sendsVolume far above your signup count for the same hours
Low completion rateCodes sent, almost none entered
Number clusteringMany requests to numbers with the same prefix or range
Odd destinationsCountries you don't sell to
Rotating sourcesMany IPs, one device fingerprint, or the reverse
Sequential numbersPhone numbers that count up one by one

The strongest single signal is the gap between sends and completions. A real flow converts most codes into a login. A pumped flow converts almost none.

Watch that ratio per hour and alert on it. Our post on SMS API observability, logging and alerting covers the dashboards worth building.

How much can it cost? A worked example

Here's an illustration with assumed numbers. These aren't Ready's prices, and real destinations vary widely.

  • Assume your verification text costs $0.05 on an expensive route.
  • Assume a bot submits your form 20,000 times over a weekend.
  • Cost: 20,000 x $0.05 = $1,000.

Now change one assumption. If your form had no limit on requests per phone number and the bot ran for a week at the same pace, the bill is 7 x $1,000 = $7,000, all for codes nobody entered.

The point of the math is the shape, not the figure. Cost scales with how long the form stays open and how many destinations it accepts. Every control below cuts one of those two.

Which controls stop it?

Layer these. Each one alone has a gap, and attackers probe for the gap.

Rate limit by number and by IP

Cap how many codes one phone number can request, for example three in an hour. Cap requests from one IP and one device too. Per-number limits stop a bot hammering a single target. Per-IP limits slow a single source. Neither stops a distributed attack alone, which is why you need the rest.

Rate limits on your own endpoints are a different thing from the limits on a messaging API. For the sending side, see SMS API rate limits.

Put a captcha or proof of work before the send

Require a challenge before any text goes out, so a script can't trigger a send by posting to your form. Run it server-side and tie the token to the request. A captcha that only renders in the browser but isn't verified on the server does nothing.

Allow-list the countries you serve

If you only sell in the United States, a text to a number elsewhere is either a mistake or an attack. Reject it before it reaches your messaging API. Ready's texting runs on local 10DLC numbers, so US-bound traffic is the normal case, and a country allow-list on your side makes that explicit.

Validate the number before you send

Check that a number is real and can receive texts before you spend on it. Ready exposes GET /v1/validate/:phone, and the docs cover it at number validation. Validation catches malformed numbers, landlines and many fake entries. It doesn't catch a real mobile number an attacker controls, so it's one layer, not the answer. Our guide to phone number validation APIs goes deeper.

One cost note: with Number validation switched on for an account, Ready charges $0.003 extra per segment for screening, and it's off by default. Quoted all-in rates don't include screening.

Cap spend

Set a daily and hourly ceiling on verification sends per sub-account or per product, and stop when you hit it. A cap turns an open-ended loss into a known one. Ready bills from prepaid credits, so you can also keep the balance on a pumping-exposed account small.

Make retries safe

Send an Idempotency-Key header with each request so a retried call never sends twice. It won't stop an attacker, but it keeps your own retry logic from doubling a bill during an incident. More in SMS API idempotency and duplicate texts.

How do you build a safe OTP flow?

Order matters. Put the cheap checks first, so a bad request never reaches anything that costs money.

  1. Verify the captcha token on the server.
  2. Normalize the number to E.164 and reject malformed input.
  3. Check the country against your allow-list.
  4. Apply per-number, per-IP and per-device limits.
  5. Check the spend cap for the day.
  6. Validate the number if you use that layer.
  7. Send with an idempotency key so retries stay safe.

After the send, watch completions. If a number or range requests codes and never completes, stop sending to it for a while. A short cooldown after two unanswered codes cuts losses without blocking real users, who almost always enter the first code.

Also think about what you reveal. An error such as "that number is not supported" tells an attacker which destinations to try next. Return the same neutral response for blocked and accepted requests where you can.

For the sending rules specific to codes, read our guide to bulk SMS, OTP and verification sending rules.

What should you do during an attack?

Move fast, because cost accrues by the minute.

  • Turn on the strictest limit you have, even if it hurts real signups for an hour.
  • Pause verification for destinations you don't serve.
  • Lower the spend cap.
  • Save logs: timestamps, IPs, numbers, user agents.
  • Tell your messaging provider what happened and ask about the charges.

Afterward, work out which control would have stopped it. Usually it's the missing one in the list above.

Frequently asked questions

Is SMS pumping the same as toll fraud?

They're close cousins. SMS pumping, also called artificially inflated traffic, is the text version: fake requests that send messages to numbers the attacker profits from. Toll fraud usually refers to the same scheme with voice calls.

Can number validation alone stop it?

No. Validation filters bad, fake and landline numbers, which cuts a lot of waste. A real mobile number the attacker controls still passes, so pair validation with rate limits, a captcha and a spend cap.

Does Ready detect pumping for me?

The facts we can state are narrower. Ready offers number validation, an idempotency key on sends and prepaid billing, and those help. Pumping controls such as captcha, per-number limits and country allow-lists belong in your own app, in front of the send call.

The practical takeaway

Pumping works because a public form sends a paid text to any number. Close that gap in layers: verify a captcha, allow-list countries, limit per number and IP, validate numbers, and cap spend. Then watch the send-to-completion ratio so you notice the next attempt within an hour instead of at the end of the month.

If you're building a texting product on a messaging API, start with the API quickstart and add the controls above before you open any send to anonymous traffic.