To send an SMS from Pipedream, add a Node.js code step that calls POST https://api.tryready.com/v1/messages with your API key in an X-API-Key header and a JSON body of to, body and consent_attested. Keep the key in an environment variable, build an Idempotency-Key from an ID in the trigger event, and stop the workflow cleanly on a refusal so nothing loops.

Pipedream is a good fit when the trigger is a webhook or an app event and you want a few lines of real code instead of a drag-and-drop mapping. We make Ready, so the example sticks to the one request shape we document. Nothing here needs a Ready-specific component.

Before you start

  • An API key from Ready, stored as an environment variable in Pipedream (for example READY_API_KEY) rather than typed into code.
  • A card on file and a number. Both are needed to send, and a number is $2 a month.
  • Consent you can show. consent_attested: true is your promise that the person agreed to texts. Send it only when you hold that record.
  • A trigger. An HTTP webhook, a form tool, a Stripe event or a schedule all work.

A text costs $0.0075 per segment plus a $0.0045 carrier fee per segment, from the first text. Accounts opened before November 12, 2026 keep their signup prices, shown under Billing.

Code step or the HTTP action?

Pipedream gives you two ways to make the call. Here's how they compare.

FeatureBuilt-in HTTP request actionNode.js code step
Setup timeA few minutes, all form fieldsA few minutes, about 30 lines
Custom headersYesYes
Branching on the answerNeeds extra stepsPlain if statements
Stable idempotency keyPossible with an expressionEasy, one variable
Ending the run on a refusalAwkwardOne return or exit call

If you only ever send one fixed message, the HTTP action is fine. Once you want to look at the status code and decide what happens next, a code step is shorter and easier to read.

The code step

Add a Node.js step after your trigger:

export default defineComponent({
  async run({ steps, $ }) {
    const event = steps.trigger.event.body;

    const res = await fetch("https://api.tryready.com/v1/messages", {
      method: "POST",
      headers: {
        "X-API-Key": process.env.READY_API_KEY,
        "Idempotency-Key": `order-${event.order_id}-shipped`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        to: event.phone,
        body: `Hi ${event.first_name}, your order #${event.order_id} has shipped.`,
        consent_attested: true,
      }),
    });

    const answer = await res.json().catch(() => ({}));
    if (!res.ok) {
      $.export("failed", { status: res.status, answer });
      throw new Error(`Send failed with ${res.status}`);
    }
    return answer;
  },
});

Using JSON.stringify means a name with a quote in it can't break the body, which is the usual bug in no-code tools that build JSON by pasting text together.

to is E.164, like +12125550199. A 10-digit US number is treated as +1, but normalize in your own data anyway. Our guide to E.164 formatting for SMS APIs covers the edge cases. Leave from out and Ready picks the number for you. Field details are in the messages API docs.

Make the idempotency key stable

Pipedream can run a step again. You can replay an event from the inspector, a source can deliver the same webhook twice, and a step set to auto-retry will call the API again after an error. Each of those can send a second text.

Build the Idempotency-Key from your data: order-1042-shipped is good. Don't use a random UUID created inside the step or the workflow run ID, because a replay changes both. A stable key means the repeated request is recognized and Ready doesn't send twice. If one order can legitimately get the same message twice, add what differs, such as a shipment number. The post on idempotency and duplicate texts explains why.

Decide what each answer means

Different failures want different handling.

  • Timeout or 5xx. Retrying is safe because the key is the same. Turn on the step's retry setting and let it go round again.
  • A 4xx like a bad number. Retrying won't help. Export the status and answer, stop the run, and let someone fix the data. The error codes page lists what each code means.
  • 409 QUIET_HOURS_BLOCK. An API text is held only if the recipient's window opens within 6 hours. Otherwise nothing is sent. Either schedule a later run, or add hold_until_allowed: true to the body, which holds the text up to 24 hours like a campaign text. See handling the quiet hours 409.
  • Opt-out refusal. Opted-out numbers and numbers on your Ban list are refused up front and not charged. Treat that as final.

Our post on SMS API retries and failure handling goes through the full decision table.

Check opt-outs before the send

If your contacts come from outside Ready, add a small step before the send that calls GET /v1/opt-outs/:phone with the same header. Skip the number if it comes back opted out. That matters most for lists you copied from another provider, since a STOP held somewhere else won't be in your sheet.

Sending to a list from one workflow

For one message to many numbers, use POST /v1/messages/bulk with to as an array. At most 100 recipients go in each call, so split bigger lists into batches inside the code step. This keeps one workflow run from making hundreds of separate requests. The bulk messages docs have the details.

Pipedream or Make?

Both tools work. Pipedream suits people who are happy writing a few lines of JavaScript and want full control over branching. If your team prefers a visual canvas, the guide to sending SMS from Make scenarios covers the same request in that style. If you're running the call from your own code instead, start with how to send SMS with Node.js.

Frequently asked questions

Do I need a Ready component in Pipedream? No. A Node.js step or the HTTP action covers it.

Where should the key live? In an environment variable, never in the code or in a step's exported data, since exports show up in the event history.

What does a text cost? $0.0075 per segment plus the $0.0045 carrier fee. See the pricing page.

Next step

Send one message to your own phone, then replay the same event on purpose and confirm no second text arrives. When that works, point the trigger at real traffic. The API quickstart shows how to create your key and make a first send.