To send an SMS from a Make scenario, add the HTTP module's "Make a request" action, point it at POST https://api.tryready.com/v1/messages, add your API key as an X-API-Key header, and send to, body and consent_attested as a JSON body. Add an Idempotency-Key header built from a stable ID in your data, and attach an error handler, so a retried run doesn't text the same person twice.
Make was formerly called Integromat, and plenty of people still search for it that way. There's no special Ready app in Make to install: the generic HTTP module is the whole integration. We make Ready, so the example uses the Ready REST API and only the request shape we document. The same steps apply to any no-code tool with an HTTP action.
What you need before you build
- An API key. Create it in Ready and store it somewhere you can paste it once. Make keeps header values in the module settings, so limit who can edit the scenario.
- A card and a number. A card on file and a number of your own are required to send. The number is $2 a month, with the first month charged when it's activated.
- Consent you can show. Each request carries
consent_attested: true, your promise that the recipient agreed to receive texts. Only send it for contacts where that's true. - Registration. An account can send up to 500 texts a month before it registers for 10DLC; after that it has to register, and most approvals take 2 to 7 days.
Every text is charged from the first one: $0.0075 per segment plus a $0.0045 carrier fee per segment. Accounts opened before November 12, 2026 keep their signup prices, shown under Billing.
Set up the HTTP module
Add the module HTTP, then "Make a request", and fill it in like this:
| Field | Value |
|---|---|
| URL | https://api.tryready.com/v1/messages |
| Method | POST |
| Headers | X-API-Key with your key; Idempotency-Key (see below) |
| Body type | Raw |
| Content type | JSON (application/json) |
| Request content | The JSON below |
| Parse response | Yes |
| Evaluate all states as errors | Yes |
The request content:
{
"to": "{{1.phone}}",
"body": "Hi {{1.first_name}}, your order #{{1.order_number}} has shipped.",
"consent_attested": true
} Here 1.phone and the other mapped values come from the module before it, such as a webhook, a spreadsheet row or a CRM trigger. to takes E.164 format like +12125550199; a 10-digit US number is treated as +1. Clean the number in an earlier step if your source holds spaces or dashes, or use the phone number formatting guide.
The one risk of raw JSON in Make is a name or a message with a quote in it, which breaks the body. Wrap mapped text values in Make's JSON-escaping function before they go inside the string, or build the body with Make's "Create JSON" module and pass its output on. Test with a name like O"Brien before you turn the scenario on.
Turning on "Evaluate all states as errors" matters. By default the HTTP module treats a 4xx or 5xx answer as a normal result and the scenario carries on as if the text was sent. With the setting on, a failed send goes down your error route.
An idempotency key per bundle
Make processes data in bundles, and it can run a bundle more than once: a scenario can retry after a failure, you can re-run an execution from the history, and a trigger can fire twice. Each of those can send the same text again unless you protect it.
Send an Idempotency-Key header built from something stable about the thing you're texting, not from the execution. Good choices are the order ID plus a word for the message type, such as order-1042-shipped, or a record ID from your CRM plus the event name. Don't use Make's execution ID or a random value, because a re-run changes both. With a stable key, a retried request is recognized and doesn't send twice. Our post on idempotency keys and duplicate texts explains the rules in depth.
If the same order can legitimately get the same message twice, add what makes it different, such as the shipment number. Keep the key meaningful and constant for one real message.
Error handling that doesn't text anyone twice
A scenario without an error handler stops at the first failed module and leaves the rest of the bundle unprocessed. Add an error handler route on the HTTP module and decide per case:
- Timeouts and rate limits (429): use Make's Break directive with automatic retries, so the same bundle goes round again with the same key. The key is what makes this safe.
- Other 4xx answers: a bad number or a malformed body won't fix itself. Use Ignore or Commit, and write the row to a "failed texts" sheet or data store with the response text so someone can fix the data.
- Rollback: avoid it for sends. A text can't be rolled back, and the directive only affects Make's own bookkeeping.
For a 5xx or an unclear outcome, check the error codes page and GET /v1/messages before you resend under a new key. Retrying with the same key is the safe default for a timeout. Our post on retries and failure handling covers the cases one by one.
Keep an eye on operations too. Each HTTP call uses a Make operation, so a scenario that loops over 5,000 rows and calls the API once per row uses at least 5,000 operations. For the same message to many numbers, POST /v1/messages/bulk takes to as an array, with at most 100 recipients per call. Make's Array aggregator can group rows into batches. See the bulk messages docs.
Opt-outs and quiet hours
No-code scenarios drift away from the source of truth. A contact opts out by replying STOP, but your spreadsheet or CRM still lists them as active. Ready refuses opted-out numbers and numbers on your Ban list up front, and doesn't charge for them, so a refused send is a safety net, not a plan. Treat that answer as final: don't retry it, and mark the row so the scenario skips it next time.
If the list comes from somewhere other than Ready, or from a provider you're migrating off, add a step before the send that calls GET /v1/opt-outs/:phone and filters on the answer. Our opt-out API post shows how to read the opt-out list and keep your own records in sync.
Quiet hours apply too. An API text is held only if the recipient's window opens within 6 hours. Otherwise it isn't sent and the API answers 409 QUIET_HOURS_BLOCK. Route that to a "resend later" path, or send with hold_until_allowed: true, which holds it up to 24 hours like a campaign text.
Make or the built-in automations?
A fair question. If your trigger lives in a CRM Ready already connects to, Ready's own App Library automations can text a contact when a deal changes stage with no code, and no per-operation cost on the Make side. Make is the better fit when the trigger is an app Ready doesn't connect to, when you need to combine several systems in one flow, or when your team already runs its operations there. Use the HTTP module for that, and keep the Ready side simple.
A worked cost example
Say a scenario texts 1,200 customers with a one-segment shipping update, no emoji. That's 1,200 segments, so 1,200 × ($0.0075 + $0.0045). Screening is extra when you switch it on. Make's own operations are billed separately by Make.
Ready's all-in prices per segment include the carrier fee but not screening: Scrub lists and Number validation, the two switches in Settings under Compliance, each add $0.003 per segment when switched on, shown as screening on your bill, and both are off by default. Unless you turn the opt-out footer off, the first text to each contact, and one again from time to time, also gets "Reply STOP to opt out" and your business name if the message does not already have them, so a text close to the segment limit can bill one more segment.
Frequently asked questions
Is there a Ready app for Make?
We don't publish one. The HTTP "Make a request" module covers it.
Why did my scenario text someone twice?
The usual causes are a trigger that fired twice, a re-run from history, or a retry with a new key. Build the idempotency key from a stable record ID and the problem goes away.
Can I receive replies in Make?
Yes, with a Make webhook that Ready calls. Our guide to receiving inbound webhooks covers the receiving side.
Where to go next
The takeaway: one HTTP module, a key in the header, a stable idempotency key, errors treated as errors, and an opt-out check for any list that didn't start in Ready. The API quickstart gets you a key and a first send.