DEV Community: David Harvey

How to Send iMessages Programmatically (REST API, Python & Node.js)

David Harvey — Sun, 28 Jun 2026 03:45:08 +0000

If you've ever tried to send an iMessage programmatically, you've probably hit the same wall everyone does: Apple has no public iMessage API. There's no POST /imessage in the developer docs, no SDK, no OAuth scope. Yet "blue bubble" delivery has 3–4× the open rates of SMS, so the demand to send iMessages from code — for CRMs, bots, notifications, and outbound — keeps growing.

This guide covers the realistic options, then walks through actually sending and receiving iMessages over a REST API with working Python, Node.js, and curl examples you can paste and run today.

Why there's no official iMessage API

iMessage is a closed, end-to-end-encrypted protocol tied to Apple IDs and Apple hardware. Apple has never shipped a public API to send iMessages, and "Messages for Business" is a support-inbox product gated behind an approval process — not a way to send outbound messages from a script.

So historically, developers reached for hacks:

Approach	Works from a server?	Reliability	Receiving messages	Notes
AppleScript / `osascript`	No — needs a logged-in Mac with Messages open	Brittle	Polling the local SQLite `chat.db`	Mac-only, breaks on macOS updates
Shortcuts automation	No	Brittle	No	Manual, not built for scale
"Just use SMS" (Twilio etc.)	Yes	High	Yes	Green bubbles, no typing indicators/tapbacks/HD media
Hosted iMessage REST API	Yes	High	Yes (webhooks)	What this guide uses

The AppleScript route is fine for a one-off script on your own Mac. The moment you want to send from a server, send at scale, or receive replies reliably, you need a hosted API that manages the Apple side for you and exposes a normal HTTP interface.

The setup

For the examples below I'm using Blooio, an iMessage REST API. Any provider with a similar HTTP surface will follow the same patterns — the concepts (Bearer auth, a send endpoint, webhooks for inbound) are what matter.

You'll need:

An API key (Blooio gives you one in the dashboard — no credit card, no A2P/10DLC registration, no DUNS number)
A phone number you can test against

Base URL for all calls:

https://api.blooio.com/v2/api

Send your first iMessage (curl)

The whole thing is one authenticated POST. The chat is identified by the recipient's phone number (URL-encoded, because of the +):

curl -X POST \
  "https://api.blooio.com/v2/api/chats/%2B15551234567/messages" \
  -H "Authorization: Bearer sk_live_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello from the command line 👋"}'

Response:

{ "message_id": "msg_a1b2c3", "status": "queued" }

That's it — no Mac, no AppleScript, no polling. If the recipient has iMessage, it lands as a blue bubble.

Send an iMessage from Python

The minimal version uses requests. Note the quote(..., safe='') on the phone number — forgetting to URL-encode the + is the #1 cause of silent 400s.

import os
import requests
from urllib.parse import quote

API_KEY = os.environ["BLOOIO_API_KEY"]
BASE_URL = "https://api.blooio.com/v2/api"

def send_imessage(to: str, text: str) -> dict:
    chat_id = quote(to, safe="")
    res = requests.post(
        f"{BASE_URL}/chats/{chat_id}/messages",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json",
        },
        json={"text": text},
        timeout=10,
    )
    res.raise_for_status()
    return res.json()

if __name__ == "__main__":
    result = send_imessage("+15551234567", "Hello from Python!")
    print(f"Message {result['message_id']} -> {result['status']}")

export BLOOIO_API_KEY=sk_live_your_key_here
python send.py

Send an iMessage from Node.js

Node 18+ has native fetch, so the basic case needs zero dependencies:

const API_KEY = process.env.BLOOIO_API_KEY;
const BASE_URL = "https://api.blooio.com/v2/api";

async function sendImessage(to, text) {
  const chatId = encodeURIComponent(to);
  const res = await fetch(`${BASE_URL}/chats/${chatId}/messages`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ text }),
  });

  if (!res.ok) {
    throw new Error(`Blooio ${res.status}: ${await res.text()}`);
  }
  return res.json();
}

const result = await sendImessage("+15551234567", "Hello from Node.js!");
console.log(`Message ${result.message_id} -> ${result.status}`);

Blue bubble or green? Check capability first

Not every number can receive iMessage. If you're building an iMessage-first flow with SMS fallback, check capability before sending:

def has_imessage(phone: str) -> bool:
    chat_id = quote(phone, safe="")
    res = requests.get(
        f"{BASE_URL}/contacts/{chat_id}/capabilities",
        headers={"Authorization": f"Bearer {API_KEY}"},
        timeout=10,
    )
    if not res.ok:
        return False
    return bool(res.json().get("capabilities", {}).get("imessage"))

if has_imessage("+15551234567"):
    send_imessage("+15551234567", "Blue bubbles only ✨")
else:
    # fall back to your SMS provider here
    ...

Receiving iMessages (webhooks)

Sending is half the story — to build a bot or a two-way CRM thread you need inbound messages. Instead of polling, you register a webhook URL and the API POSTs events to you. Verify the HMAC signature so you only trust real events:

import express from "express";
import crypto from "node:crypto";

const app = express();

app.post(
  "/webhooks/blooio",
  express.raw({ type: "application/json" }),
  (req, res) => {
    const signature = req.header("x-blooio-signature") ?? "";
    const event = req.header("x-blooio-event") ?? "";
    const secret = process.env.BLOOIO_WEBHOOK_SECRET;

    const expected = crypto
      .createHmac("sha256", secret)
      .update(req.body)
      .digest("hex");

    const ok = crypto.timingSafeEqual(
      Buffer.from(expected),
      Buffer.from(signature),
    );
    if (!ok) return res.sendStatus(401);

    const payload = JSON.parse(req.body.toString("utf8"));

    if (event === "message.received") {
      const { from, text } = payload.data;
      console.log(`${from}: ${text}`);
      // ...reply, route to your CRM, trigger an LLM, etc.
    }

    res.sendStatus(200);
  },
);

app.listen(3001, () => console.log("Listening on :3001"));

For local development, tunnel the endpoint with ngrok and point the webhook at the tunnel URL. Now you have a full send + receive loop — enough to build an iMessage bot.

Automating without writing code

If you'd rather wire iMessage into existing tools than write a service, the same API drops into no-code/low-code platforms. Blooio has native nodes/actions for n8n, GoHighLevel, HubSpot, and Zapier — so "new lead in CRM → send iMessage" is a couple of clicks rather than a deploy.

Gotchas worth knowing up front

URL-encode the phone number. +15551234567 must become %2B15551234567. This bites everyone once.
No A2P/10DLC registration, DUNS, or campaign approval with a hosted iMessage API — that paperwork is an SMS/carrier thing. iMessage rides Apple's network.
Use idempotency keys for retries. Pass an Idempotency-Key header derived from your domain entity (e.g. order-123-shipped) so a retry never double-sends.
Throttle bulk sends. Don't fire 1,000 parallel requests — cap concurrency (e.g. p-limit in Node, a semaphore in Python) and back off on 429.
iMessage ≠ guaranteed. If a number isn't on iMessage, check capability and fall back to SMS rather than assuming a blue bubble.

Wrapping up

You don't need a Mac mini farm or fragile AppleScript to send iMessages programmatically anymore. A hosted iMessage REST API turns it into a normal HTTP call — POST to send, webhooks to receive — that works the same from Python, Node.js, curl, or your automation tool of choice.

If you want to try the exact examples above, you can grab a free key (no credit card, no A2P registration) and read the full reference here:

What are you building — a bot, a CRM integration, outbound? Drop it in the comments. 👇

SMS Pumping Is Draining Your 2FA Budget — and Mobile-Originated iMessage 2FA Fixes It

David Harvey — Sun, 28 Jun 2026 03:36:47 +0000

If you send SMS one-time codes, there's a decent chance you're paying scammers to phone-spam themselves on your dime. It even has a name: SMS pumping. And it's not a rounding error — Elon Musk claimed Twitter was losing ~$60M/year to fake 2FA traffic before they killed SMS 2FA for free accounts.

Here's how the scam works, why SMS 2FA is structurally expensive, and why flipping the direction — mobile-originated (MO) 2FA, taken to its logical end over iMessage — fixes both the cost and the fraud at once.

What is SMS pumping?

SMS pumping (also called AIT — Artificially Inflated Traffic, or SMS toll fraud) is a scheme where bad actors abuse a form that sends SMS one-time codes. They pump thousands of phone numbers — usually premium ranges they secretly control with a telecom — into your "send me a code" endpoint.

You pay for every one of those messages. A cut of that termination fee flows back to the fraudsters via the carrier. The "users" never log in. They were never users. The entire point was to make your verification endpoint dial a meter that pays them.

The structure that makes this possible is simple: you, the company, send (and pay for) the message. Every code is revenue for someone in the delivery chain — so there's a direct financial incentive to trigger as many as possible.

Why SMS 2FA is expensive even without fraud

Even with zero abuse, application-to-person (A2P SMS) is a bad cost curve:

You pay per message. Volume spikes — a launch, a bot attack, an international audience — turn into surprise bills.
International is brutal. Cross-border A2P carries steep carrier surcharges that vary wildly by destination.
Carrier fees and registration overhead. In the US you're funneled through A2P 10DLC registration, brand vetting, and per-segment fees before you send a single legit code.

So your 2FA line item is pay-per-event, unpredictable, and exploitable. Three bad properties for something that's supposed to be boring infrastructure.

The Twitter/X case

This isn't theoretical. When X announced it was removing SMS 2FA for non-paying users, the stated reason was fraud at scale:

A company that size could "fix" it by paywalling a security feature. Most teams can't — and shouldn't have to make 2FA a paid tier just to dodge a billing exploit.

The fix: flip the direction (mobile-originated 2FA)

Here's the key insight. SMS pumping only works because the company sends the message. That outbound, pay-per-code flow is the thing being gamed.

So flip it. In mobile-originated (MO) 2FA, the user sends a message to you to prove possession of their device. There's no outbound code to pump, no per-message payout to harvest, and nothing for a bot farm to monetize. The incentive that powers the entire scam disappears.

MO verification has been around (think shortcodes), but shortcodes are clunky, region-locked, and still cost money to provision. The modern version is much nicer.

Taking it further: reverse 2FA over iMessage

We built a live demo of this. Instead of us texting you a code to type back, you text a one-time code to us from your own iMessage — and we verify you the instant the message lands.

👉 Try it: demo.blooio.com/2fa

The flow:

Your app generates a short one-time code and a deep link that opens Messages with that code pre-filled.
The user hits send from their iMessage.
Blooio delivers an inbound message.received webhook. You match the code and read who sent it — verified.

Because the user sends from their own Apple ID over end-to-end-encrypted iMessage, it's spoof-resistant (unlike trivially-faked SMS sender IDs) and phishing-resistant (the user proves real possession instead of reading digits back to an attacker). And there's no outbound message to pump.

The code is almost embarrassingly small

Start a challenge, then let a webhook flip it to verified:

// 1. Start a challenge: generate a code + an iMessage deep link
app.post("/2fa/start", async (c) => {
  const code = newCode(); // short, unambiguous one-time code
  await store.create(code); // status: "pending"
  return c.json({
    code,
    // opens Messages to your Blooio number with the code pre-filled
    link: `https://start.msg.new/<your-handle>?text=${code}`,
  });
});

// 2. Blooio calls your webhook when the user texts the code in
app.post("/webhook/blooio", async (c) => {
  const event = await c.req.json();
  if (event.event === "message.received") {
    const code = extractCode(event.text);
    if (code) {
      // event.sender is the verified identifier (phone/email)
      await store.verify(code, event.sender);
    }
  }
  return c.json({ ok: true });
});

That's the whole trick: no outbound SMS, no per-code billing, no A2P registration. Just an inbound webhook and a string match.

SMS 2FA vs. reverse iMessage 2FA

	Reverse iMessage 2FA	Traditional SMS 2FA
Pricing	Flat monthly rate, predictable	Pay per message — spikes = surprise bills
Abuse	Can't be pumped (users message you)	Wide open to SMS pumping / AIT fraud
Cost at scale	Cheap, especially cross-border	Steep international + carrier surcharges
Security	E2E encrypted, tied to Apple ID	Sender IDs spoofable; SIM-swap exposure
Anti-phishing	User proves real possession	Codes get phished or relayed
Speed	Instant over WiFi/data	Often delayed, sometimes never delivered

How this actually saves you money

Predictable cost, not pay-per-event. A flat rate means a bot storm can't author your invoice.
Fraud incentive removed. No outbound code = nothing to pump = the $60M-style leak can't happen.
No A2P 10DLC / DUNS / carrier registration tax to start sending.
Cheaper internationally, where SMS surcharges hurt the most.

Try it / build it

Play with the live reverse-2FA demo: demo.blooio.com/2fa

If you want to build it into your own auth flow, Blooio is an iMessage API for developers — REST API, webhooks, and SDKs. Start free — no credit card, no A2P registration, no DUNS.

How to Check if a Phone Number is Registered with iMessage Using Google Sheets and the Blooio API

David Harvey — Sun, 22 Feb 2026 04:38:57 +0000

For sales, marketing, and outreach teams, knowing whether a prospect uses iMessage or standard SMS is a game-changer. Delivering a "blue bubble" message gives you access to read receipts, typing indicators, high-quality media sharing, and generally higher engagement rates — features that simply don't exist with regular SMS.

But how do you check if a phone number is registered with iMessage across a list of hundreds of contacts without manually typing them into your iPhone?

In this tutorial, you'll learn how to build a custom Google Sheets function using Google Apps Script and the Blooio API to automatically detect iMessage availability for any phone number or Apple ID email — at scale.

By the end of this guide, you'll be able to type =CHECKIMESSAGE(A2) into any cell and instantly know if that contact is iMessage-ready.

Why iMessage Detection Matters for Sales and Marketing

Understanding whether your prospects are on iMessage vs. SMS isn't just a nice-to-have — it directly impacts your outreach strategy:

iMessage users get rich media, read receipts, and higher open rates — ideal for high-touch B2B sales.
SMS fallback is universal and works for everyone else.
Routing messages correctly reduces costs and increases deliverability.

This is especially powerful when combined with a tool like Blooio, a cloud-hosted messaging API that bridges automation platforms and native Apple iMessage — letting you send and receive iMessages programmatically without needing a physical Mac or iPhone constantly active.

Prerequisites

Before you start, make sure you have the following:

A Google account (for Google Sheets and Google Apps Script).
A list of phone numbers or Apple ID emails to check.
A Blooio account and API Key — you can grab your key from the Blooio dashboard. (Blooio is a cloud-hosted messaging API that bridges the gap between automation tools and native Apple iMessage.)

Step 1: Set Up Your Google Sheet

Head to sheets.new to instantly create a new Google Sheet. Add a column of phone numbers in Column A and label Column B as "iMessage Status".

Don't worry if your numbers are formatted messily (e.g., with dashes, spaces, or country codes) — our script will normalize them automatically into the E.164 format that APIs prefer.

Step 2: Open Google Apps Script

Google Apps Script is a JavaScript-based cloud scripting platform that lets you extend Google Workspace products like Sheets, Docs, and Gmail. It supports custom functions in Google Sheets — meaning you can write your own formulas just like =SUM() or =VLOOKUP().

From your Google Sheet, navigate to the top menu and click:

Extensions > Apps Script

This opens a new browser tab with the Apps Script editor. Clear any default code in the Code.gs file.

Step 3: Add the Blooio iMessage Detection Code

Copy and paste the following JavaScript into your Apps Script editor.

Important: Replace 'YOUR_BLOOIO_API_KEY_HERE' with your actual Blooio API key, which you can find in your Blooio dashboard.

/**
 * Normalize a US phone number string to E.164 (+1XXXXXXXXXX).
 */
function normalizeToE164US(input) {
  if (typeof input !== 'string') input = String(input || '');
  let s = input.trim();

  // Already E.164 format
  if (/^\+1\d{10}$/.test(s)) return s;

  // Remove extensions like ext.123, x123, #123
  s = s.replace(/\s*(ext\.?|x|#)\s*\d+\s*$/i, '');

  // Remove non-digits
  const digits = s.replace(/\D/g, '');

  // Handle 10 or 11-digit US numbers
  if (digits.length === 11 && digits.startsWith('1')) return '+1' + digits.slice(1);
  if (digits.length === 10) return '+1' + digits;

  // Handle something like "+1 707 653 2043"
  const plusDigits = s.replace(/\s+/g, '');
  if (/^\+1\d{10}$/.test(plusDigits)) return plusDigits;

  return null;
}

/**
 * Calls the Blooio API and returns if iMessage is available.
 */
function fetchImessageAvailability_(contact) {
  const API_KEY = 'YOUR_BLOOIO_API_KEY_HERE'; // Replace with your actual key from https://app.blooio.com
  const BASE_URL = 'https://backend.blooio.com/v1/api/contacts/';
  const endpoint = encodeURIComponent(contact);
  const url = BASE_URL + endpoint + '/capabilities';

  const options = {
    method: 'get',
    headers: {
      Authorization: 'Bearer ' + API_KEY,
      Accept: 'application/json',
    },
    muteHttpExceptions: true,
  };

  try {
    const resp = UrlFetchApp.fetch(url, options);
    const code = resp.getResponseCode();
    const text = resp.getContentText();

    if (code === 200) {
      const data = JSON.parse(text);
      return data?.capabilities?.imessage
        ? 'iMessage available'
        : 'iMessage not available';
    }

    if (code === 404) return 'Not Found';
    return 'API Error: ' + code + ' - ' + text.substring(0, 100) + '...';
  } catch (e) {
    return 'Request Failed: ' + (e && e.message ? e.message : String(e));
  }
}

/**
 * Custom Google Sheets function to check if a phone number or email is registered with iMessage.
 *
 * Example: =CHECKIMESSAGE(A2)
 *
 * @param {string} contact Phone number or Apple ID email.
 * @return {string} "iMessage available" / "iMessage not available" / error message.
 * @customfunction
 */
function CHECKIMESSAGE(contact) {
  if (!contact) return '';

  const str = String(contact).trim();

  // Handle Apple ID email addresses directly
  if (str.includes('@')) {
    return fetchImessageAvailability_(str);
  }

  // Normalize phone numbers to E.164
  const e164 = normalizeToE164US(str);
  if (!e164) {
    return "Error: Couldn't parse as a US phone number or email.";
  }

  return fetchImessageAvailability_(e164);
}

Once pasted, click the Save icon (the floppy disk) or press Cmd+S / Ctrl+S.

Step 4: Test Your New Custom Function

Head back to your Google Sheet. In cell B2, type:

=CHECKIMESSAGE(A2)

Hit Enter. The cell will briefly show Loading... while it calls the Blooio API, then return one of these results:

Result	Meaning
`iMessage available`	The number/email is registered with iMessage
`iMessage not available`	The contact uses standard SMS (Android or SMS-only)
`Not Found`	The number isn't recognized
`Error: ...`	A parsing or network issue occurred

Once it works for one cell, drag the formula down column B to enrich your entire list in seconds.

How It Works Under the Hood

1. Phone Number Normalization

The normalizeToE164US() function cleans up messy CRM data — stripping out extensions, dashes, spaces, and country code prefixes — converting everything into the standard E.164 format (+1XXXXXXXXXX) that REST APIs expect.

2. Blooio `/capabilities` API Call

The script calls Blooio's /capabilities endpoint, passing either a normalized phone number or an Apple ID email address. This is the same endpoint used by Blooio's messaging infrastructure to determine how to route a message before sending it.

You can explore Blooio's full pricing and feature set to understand what else is possible — including programmatic iMessage sending, read receipt tracking, and SMS fallback.

3. Response Parsing

The script checks the capabilities.imessage boolean in the JSON response and converts it to a human-readable label ("iMessage available" or "iMessage not available") directly inside your spreadsheet cell.

Scaling This Up: Tips for Large Lists

If you're running this against thousands of rows, keep these Google Apps Script best practices in mind:

Batch API calls — avoid calling the API on every cell individually; consider a trigger-based batch function instead.
Cache results — use CacheService to store results for numbers you've already checked.
Rate limiting — respect API rate limits; add a Utilities.sleep() call between requests for large batches.
Error handling — the script already handles 404s and network failures gracefully, but log unexpected errors to a separate sheet for review.

Wrapping Up

By connecting Google Sheets and Google Apps Script with the Blooio API, you've built a lightweight but powerful CRM enrichment tool for iMessage detection.

Sales teams can now confidently segment their outreach:

Send rich media, reactions, and read-receipt-enabled messages to iMessage users via Blooio.
Fall back to standard A2P SMS for Android and non-Apple contacts.

This kind of contact intelligence — knowing before you send whether someone is reachable over iMessage — is a small automation that compounds into significantly better deliverability and engagement over time.

Ready to get started? Create your free Blooio account and grab your API key.

Have you built any other automations around iMessage, RCS, or SMS routing? Drop a comment below — I'd love to see what you're building!

iMessage Group Chats in HighLevel: Native Integration Without Chrome Plugins

David Harvey — Sun, 11 Jan 2026 09:04:54 +0000

Connect iMessage to HighLevel Workflows - No A2P or 10DLC Required

HighLevel users can now create iMessage group chats directly from workflows using Blooio's native integration. Unlike traditional SMS that requires A2P registration and 10DLC compliance, iMessage group chats work instantly - and the best part? No Chrome plugin required, making it fully compatible with the HighLevel mobile app (Lead Connector).

Why iMessage for Business Communication?

While SMS requires jumping through regulatory hoops with A2P and 10DLC registration, iMessage bypasses these restrictions entirely. You can send messages programmatically through the iMessage API without carrier fees, registration delays, or compliance headaches.

Compared to alternatives like SendBlue or Linq, Blooio offers native HighLevel integration with group chat support, making it the superior choice for agencies and SaaS platforms.

How iMessage Group Chats Work in HighLevel

The integration is seamless and works across all HighLevel environments:

1. Trigger From Workflows

Add the "Send Group Message" action to any HighLevel workflow. Perfect for:

Buyer introductions (loop in multiple stakeholders)
Customer onboarding (connect clients with support teams)
Project kickoffs (bring together clients and account managers)
Multi-party negotiations

2. Or Start Manually

You can also initiate group chats directly from the Conversations tab in HighLevel. No need to switch between tools.

3. Native Mobile App Support

Because Blooio integrates natively into HighLevel (not via a Chrome extension), it works perfectly on the Lead Connector mobile app. Respond to group messages on the go, just like any other conversation in HighLevel.

Use Cases: iMessage API for Customer Support

Here's how businesses are using iMessage group chats with HighLevel:

Real Estate Agents: Create a group with buyer, seller, and lender to streamline communication

Agencies: Loop in clients with their account manager and specialist team members

SaaS Onboarding: Connect new customers with CSM, technical support, and billing in one thread

E-commerce: Create group chats between customers, fulfillment, and customer service

Setting Up iMessage in HighLevel Workflows

Getting started takes less than 5 minutes:

Step 1: Connect Blooio

Sign up at blooio.com
Connect your Blooio account to HighLevel from app.blooio.com under the integrations tab
Get your API credentials from the Blooio API dashboard

Step 2: Add to Workflow

Open any HighLevel workflow
Add the "Send Group Message" action
Enter participant phone numbers or emails
Customize your message
Save and activate

Step 3: Manage Conversations

All group chat messages sync as contacts in HighLevel. Read and reply directly in the Conversations tab - no external apps needed.

iMessage Automation: Beyond HighLevel

Blooio's iMessage API works with more than just HighLevel:

n8n Workflows

Build custom iMessage automation with n8n. Examples:

Make.com Integration

Connect iMessage to thousands of apps with Blooio's Make integration.

Zapier Support

Use Blooio with Zapier to automate iMessage without code.

Clay Integration

Send personalized iMessages at scale with Blooio + Clay.

Building an iMessage Chatbot with AI

Want to create an AI agent for iMessages? Blooio's API makes it simple:

Receive webhooks for incoming messages
Send typing indicators to show the bot is responding
Mark messages as read programmatically
Send multiple messages for natural conversation flow

The iMessage bot example workflow shows how to build a conversational AI that:

Remembers conversation history (Postgres memory)
Responds naturally (Claude AI)
Splits responses into multiple texts
Shows typing indicators

iMessage API vs SendBlue vs Linq

Here's why developers are choosing Blooio:

Feature	Blooio	SendBlue	Linq
HighLevel Native Integration	✅ Yes	❌ No	✅ Yes
Group Chat Support	✅ Yes	❌ beta	✅ Yes
Works on Mobile App	✅ Yes (no plugin)	❌ No	❌ No
Read Receipts API	✅ Yes	❌ No	✅ Yes
Typing Indicators API	✅ Yes	❌ No	✅ Yes
n8n Integration	✅ Yes	❌ No	❌ No
Make.com Support	✅ Yes	✅ Yes	❌ No
Migration Assistance	✅ Yes	N/A	✅ Yes
Send to Email Addresses	✅ Yes	✅ Yes	❌ No
Receive from Email Addresses	✅ Yes	✅ Yes	❌ No

See the full comparison: Blooio vs SendBlue or Blooio vs Linq

Switching from Linq? Check out the Linq migration guide.

Send Messages Without A2P or 10DLC

One of the biggest advantages of using iMessage for business:

No A2P registration required

No 10DLC compliance needed

No carrier fees

No message limits

No registration delays

While SMS requires weeks of registration, spending limits, and ongoing compliance, iMessage works immediately. This makes it perfect for:

Time-sensitive communications
International messaging
High-volume sending
Personal relationship building

Broadcast Messages with iMessage

Need to send bulk iMessages? Blooio's developer API supports:

Personalized mass messaging via Clay or n8n
Scheduled broadcasts through workflows
Drip campaigns with HighLevel automation
Event-triggered messages based on user actions

Unlike SMS where broadcast messages often get filtered or blocked, iMessages land in the primary inbox with full rich media support.

iMessage Developer API Documentation

Ready to build? Here's what you can do with Blooio's API:

Core Endpoints

POST /v1/api/messages - Send iMessage
POST /v1/api/read/{id} - Mark as read
POST /v1/api/typing/{id} - Show typing
DELETE /v1/api/typing/{id} - Hide typing
GET /v1/api/messages - List messages

Webhook Events

message.received - New message
message.sent - Message delivered
message.read - Read receipt

Full documentation: Blooio API Docs

Apple Messages API Alternative

While Apple doesn't officially offer a public iMessage API, Blooio provides a production-ready alternative that:

Works with existing Apple infrastructure
Requires no reverse engineering
Maintains message security and encryption
Scales to enterprise needs
Includes developer support

iMessage for SaaS Platforms

SaaS companies are using Blooio to:

Embed iMessage into products - White-label messaging without building infrastructure

Customer onboarding - Text users directly during signup flows

Support conversations - Handle iMessage customer support tickets

Transactional messages - Order confirmations, shipping updates, account alerts

Product notifications - Feature announcements, usage alerts, renewal reminders

Getting Started with iMessage in HighLevel

Sign up for Blooio: blooio.com
Connect to HighLevel: Integration guide
Create your first group chat: Add "Send Group Message" to a workflow
Test on mobile: Download Lead Connector and see it work without Chrome

Pricing & Partners

Blooio offers transparent pricing for all use cases. If you're a HighLevel agency or reseller, check out the Blooio Partners Program for exclusive benefits.

Frequently Asked Questions

Q: Do I need A2P registration for iMessage?

No. iMessage bypasses SMS regulations entirely. No A2P, no 10DLC, no compliance headaches.

Q: Will this work on the Lead Connector mobile app?

Yes! Because Blooio integrates natively (not via Chrome plugin), it works perfectly on mobile.

Q: Can I send attachments in group chats?

Yes. iMessage supports images, videos, documents, and more.

Q: How does this compare to SendBlue?

Blooio offers native HighLevel integration, group chat support, and works on mobile apps. See the full comparison.

Q: Can I build an AI chatbot with this?

Absolutely. Check out the iMessage bot examples for inspiration.

Q: Is there a limit to group chat participants?

Follows standard iMessage limits (typically 32 participants).

What's Next?

Blooio continues to expand iMessage capabilities for business users:

MCP (Model Context Protocol) integration - Check it out
Whop marketplace support - Learn more
Enhanced analytics - Message delivery tracking and insights
Additional automation platforms - More integrations on the way

Stay updated with the Blooio feature log.

Start Using iMessage Group Chats Today

Stop juggling multiple apps and Chrome plugins. Unify all your HighLevel communications with native iMessage support that works everywhere - desktop, mobile, and web.

Try Blooio today: blooio.com

Connect to HighLevel: Integration guide

Need help? Check the privacy policy and terms of service.

Built for developers, loved by agencies. Blooio makes iMessage programmable.

Build Your Own iMessage AI Bot in Minutes with blooio

David Harvey — Sat, 10 Jan 2026 12:30:05 +0000

Try msg.new - Then Build Your Own

Want to see what's possible? Text msg.new right now and chat with an AI via iMessage. It responds like a real person—complete with typing indicators, read receipts, and natural multi-message replies.

msg.new is a proof of concept we built to showcase what you can create with Blooio. The entire workflow is open source, running on n8n, so you can deploy your own iMessage bot in minutes.

Why Build iMessage Bots with Blooio?

Building iMessage bots has traditionally been complex and locked behind Apple's ecosystem. Blooio changes that with a REST API for iMessage. With Blooio and this n8n workflow, you can:

Deploy in minutes: Import the workflow, add your API keys, and you're live
Full iMessage features: Read receipts, typing indicators, attachments
AI-powered: Uses Claude for natural conversations with memory
Open source workflow: Customize every part of the bot's behavior

How the msg.new Workflow Works

The workflow powering msg.new is elegantly simple:

Webhook receives incoming iMessages from Blooio
Event filter checks for message.received events
Attachment check routes text vs image messages
Natural delay adds realistic response timing
Read receipt marks the message as read via Blooio API
Typing indicator shows the bot is "typing" via Blooio API
AI Agent generates responses using Claude + Postgres chat memory
Message splitting breaks responses into natural, short messages
Loop sends each message separately via Blooio API for authentic texting feel

Key Features

Conversational AI with Memory

The bot uses Postgres to store conversation history, so it remembers previous exchanges. This is powered by the n8n Postgres Chat Memory node connected to Claude.

Multi-Message Responses

Real people don't send wall-of-text messages. The workflow splits AI responses into multiple shorter messages:

// Split by newline and remove empty lines
const lines = aiOutput
  .split("\n")
  .map(l => l.trim())
  .filter(l => l.length > 0);

// Each line becomes a separate message
return lines.map(line => ({ json: { line } }));

Natural Texting Behavior

The system prompt instructs Claude to text like a casual human:

Short, 1-3 sentence messages
Lowercase, minimal punctuation
Authentic reactions and occasional humor
No corporate speak or over-explaining

Full iMessage Integration via Blooio

Using Blooio's API endpoints:

POST /v1/api/read/{external_id} - Send read receipts
POST /v1/api/typing/{external_id} - Show typing indicator
DELETE /v1/api/typing/{external_id} - Hide typing indicator
POST /v1/api/messages - Send messages

Build Your Own iMessage Bot

1. Try msg.new First

Visit https://msg.new and text the bot to see what's possible.

2. Get the Workflow

Full code and setup instructions: https://blooio.com/integrations/n8n/workflows/imessage-bot-example

3. What You'll Need

A Blooio account (for the iMessage API) - Sign up here
n8n instance (cloud or self-hosted)
Anthropic API key (for Claude)
Postgres database (for chat memory)

4. Quick Setup

Sign up for Blooio and get your API token
Import the workflow JSON into n8n
Add your Blooio API token to the HTTP Request nodes
Configure your Postgres credentials in the Chat Memory node
Add your Anthropic API key
Activate the workflow
Set the webhook URL in your Blooio dashboard

Customization Ideas

The open-source nature means you can modify anything:

Change the personality: Edit the system prompt to make your bot formal, funny, or professional
Add tools: Connect the AI Agent to other services (weather, calendar, databases)
Handle attachments: The workflow already detects attachments—add image analysis with vision models
Response timing: Adjust the Wait node duration for faster/slower replies
Message splitting logic: Modify the Code node to control how responses are broken up

Technical Highlights

The workflow uses several advanced n8n features:

AI Agent with memory: Maintains conversation context across sessions
Split in Batches: Loops through messages to send them sequentially
HTTP Request nodes: Direct API integration with Blooio
Conditional routing: Handles different event types and message formats
Code node: Custom JavaScript for message processing

Why Blooio?

Blooio provides a REST API for iMessage, letting you:

Send and receive iMessages programmatically
Access read receipts and typing indicators
Handle attachments (images, videos, files)
Scale to multiple phone numbers
Get webhooks for real-time message events

No need to reverse-engineer Apple protocols or maintain Mac infrastructure. Blooio handles the complexity so you can focus on building your bot's features.

What You Can Build

This workflow is just the beginning. With Blooio, you can create:

Customer service bots
Personal AI assistants
Automated notifications and alerts
Two-way communication systems
Integration with existing business tools

The combination of Blooio + n8n + AI makes iMessage automation accessible to developers without deep iOS knowledge.

Get Started Today

Try msg.new to see a live example: https://msg.new
Get the workflow: https://blooio.com/integrations/n8n/workflows/imessage-bot-example
Sign up for Blooio: https://blooio.com

The entire setup takes less than 10 minutes if you have your API keys ready. Start building your iMessage bot today!

Have you built any iMessage automations? What would you use this for? Drop a comment below!

iMessage Enrichment in Clay: Boost Your Outreach with Real-Time Contact Detection

David Harvey — Thu, 25 Dec 2025 22:37:41 +0000

If you're doing outreach in 2026, you already know that not all communication channels are created equal. But did you know that iMessage has a 98% open rate compared to SMS's 20-30%? That's a game-changer for sales, marketing, and customer success teams.

The catch? You need to know which contacts actually support iMessage before you reach out. Enter iMessage enrichment – and today, I'm excited to share that Blooio now integrates directly with Clay to make this incredibly simple.

What is iMessage Enrichment?

iMessage enrichment is the process of checking whether a phone number or email address is registered with Apple's iMessage service. This lets you:

Prioritize high-engagement channels (iMessage has 45% higher response rates)
Segment your outreach based on messaging capabilities
Improve lead scoring with real-time contact validation
Automate workflow routing based on iMessage availability

Why This Matters for Clay Users

Clay is the go-to platform for data enrichment and outreach automation. But until now, checking iMessage availability required custom API calls or manual verification.

With Blooio's new Clay integration, you can now:

✅ Check iMessage availability directly in your Clay tables
✅ Enrich phone numbers AND email addresses

✅ Get instant, real-time detection
✅ Use a ready-made template (no setup required)

How to Set Up iMessage Enrichment in Clay

It takes just 3 steps:

Step 1: Add the Blooio Template

Search for "Blooio" in Clay's enrichment templates and add it to your table. Connect it with your Blooio API key (get one free at app.blooio.com).

Step 2: Select Your Contact Data

Choose which column contains phone numbers or emails. Blooio will check each contact for iMessage availability.

Step 3: Get Enriched Results

Instantly see which contacts support iMessage. Use this data to segment and prioritize your outreach.

API Response Example

Here's what you get back from the Blooio API:

{
  "contact": "+1234567890",
  "type": "phone",
  "capabilities": {
    "imessage": true,
    "sms": true
  },
  "lastChecked": "2024-01-01T00:00:00.000Z"
}

You can also check email addresses:

{
  "contact": "user@example.com",
  "type": "email",  
  "capabilities": {
    "imessage": true
  },
  "lastChecked": "2024-01-01T00:00:00.000Z"
}

Real-World Use Cases

1. Sales Outreach Prioritization

Identify iMessage-enabled prospects and route them to high-touch sequences. These contacts convert 3x better due to personal device engagement.

2. Marketing Campaign Segmentation

Create separate campaigns for iMessage vs. SMS contacts. Leverage the "blue bubble advantage" for maximum engagement.

3. Customer Success Optimization

Reach customers on their preferred channel. iMessage-enabled contacts respond 72% faster to support messages.

4. Lead Scoring Enhancement

Add iMessage availability as a lead scoring factor. It's a strong indicator of contact quality and reachability.

5. Data Quality Validation

Validate phone numbers while enriching. Know which numbers are active and reachable through Apple's network.

Pricing

Blooio's iMessage enrichment API is available on all plans starting at $89/month. Enterprise plans include unlimited enrichment checks.

Learn more about Blooio's Clay integration →

Try It Yourself

Ready to supercharge your Clay workflows with iMessage enrichment?

Get your free Blooio API key at app.blooio.com
Search for "Blooio" in Clay's enrichment templates
Start enriching your contact data

Check out the full documentation or explore the integration page to learn more.

About Blooio: Blooio is a Communications Platform as a Service (CPaaS) that enables businesses to send iMessages, RCS, and make calls. Our mission is to help teams reach their contacts on the channels that drive the best engagement.

Build a Receipt Parser AI Bot with Blooio, n8n, Claude & Google Sheets

David Harvey — Mon, 08 Dec 2025 05:36:39 +0000

Imagine this: every time someone finishes a purchase, they snap a photo of the receipt and text it to your number. A few seconds later, all the key fields—merchant, date, total, tax, category, payment method—show up in a Google Sheet, ready for bookkeeping or expense dashboards.

In this tutorial, you'll build exactly that: a "text-a-receipt" AI bot that uses:

Blooio Messaging with a pre-warmed iMessage number
n8n's Blooio node to receive incoming messages and images
Claude AI (with "parse binary images" enabled) to extract receipt data
Google Sheets node to log structured JSON data automatically

Prerequisites

You'll need:

A Blooio account and API key from app.blooio.com
At least one pre-warmed number in Blooio (Blooio shows how many pre-warmed numbers are available on blooio.com)
An n8n instance (Cloud or self-hosted)
A Google account with access to Google Sheets
An Anthropic API key for Claude from the Anthropic console

Step 1: Set Up Blooio and Your Pre-Warmed Number

Go to app.blooio.com and create a new organization if you don't have one yet.
On the home/dashboard page, note the number of pre-warmed numbers available. As of writing, there are 3 pre-warmed numbers ready for testing and small production pilots.
In the Blooio app, generate an API key and store it somewhere safe—you'll paste this into n8n as credentials.

At this point, you're ready to send and receive iMessages/texts through Blooio programmatically.

Step 2: Create the Google Sheet for Receipts

Create a new Google Sheet called something like Receipt Log (AI Bot) with these columns:

Timestamp
From (phone/contact)
Merchant
Date
Total
Tax
Currency
Category
Payment Method
Raw JSON

You can adapt this schema to your needs, but this structure works well for bookkeeping and analytics.

Step 3: Connect n8n to Blooio (Incoming Messages)

Log into your n8n instance.
Install or enable the Blooio Messaging integration if it isn't already available in your nodes list. You can find it at n8n.io/integrations/blooio-messaging.
Create a new workflow and add the Blooio trigger/node that listens for incoming messages (typically exposed as a webhook-style trigger).

In the Blooio dashboard, point your chosen pre-warmed iMessage number to the n8n webhook URL so that every incoming text or image to that number triggers your workflow.

Test it: Send yourself a text and a photo of a receipt to confirm:

The workflow is triggered
The incoming message includes binary data for images

Step 4: Configure the AI Node (Claude with Parse Binary Images)

Now let's parse the receipt image with Claude via the n8n AI node.

Add an AI node after your Blooio trigger.
Choose Claude as the provider and plug in your Anthropic API key from console.anthropic.com.
Enable "parse binary images" in the AI node so the model can see the receipt image directly from the incoming Blooio message.

The Claude Prompt for Receipt Parsing

Use this as the system/instruction prompt in your AI node:

You are a precise receipt parser.

Input: a photo of a receipt sent by a user.

Task: Extract clean, structured data from the receipt and return **valid JSON only**, no prose.

JSON schema (all fields required, use null if missing):

{
  "merchant": "string",
  "purchase_date": "YYYY-MM-DD",
  "purchase_time": "HH:MM or null",
  "total_amount": "number",
  "subtotal_amount": "number or null",
  "tax_amount": "number or null",
  "currency": "3-letter ISO code or null",
  "payment_method": "string (e.g. VISA, Mastercard, Cash, Amex, Apple Pay)",
  "line_items": [
    {
      "description": "string",
      "quantity": "number or null",
      "unit_price": "number or null",
      "line_total": "number or null",
      "category": "string (e.g. groceries, restaurant, transport, software, utilities, other)"
    }
  ],
  "notes": "string with any extra comments, discounts, tips, or ambiguity notes"
}

Rules:
- Never include explanations, markdown, or commentary.
- If multiple totals exist (e.g. with tip), choose the **final amount charged** as total_amount.
- Normalize dates to YYYY-MM-DD even if the receipt uses another format.
- If you are unsure, make your best guess and add an explanation to the notes field.

In the AI node, map the incoming binary image data from the Blooio node as the image input so Claude can see the receipt image.

Step 5: Map AI Output to Google Sheets

After the AI node, add a Set node (or Code node if you prefer) to:

Parse the JSON returned by Claude
Flatten/map it to match your Google Sheets columns

For example, you might map:

Timestamp → {{$now}} or the message timestamp from Blooio
From → sender phone number from Blooio's payload
Merchant → {{$json["merchant"]}}
Date → {{$json["purchase_date"]}}
Total → {{$json["total_amount"]}}
Tax → {{$json["tax_amount"]}}
Currency → {{$json["currency"]}}
Payment Method → {{$json["payment_method"]}}
Raw JSON → full stringified JSON from the AI node (handy for debugging)

Then:

Add a Google Sheets node, choose Append or Add Row.
Authenticate with your Google account.
Select the spreadsheet and worksheet you created in Step 2.
Map each field from the Set node to the correct column in the sheet.

Run the workflow with test data (e.g. send a new receipt photo) and verify that a new row appears in your sheet with all fields populated.

Step 6: Optional Enhancements

Once the basic flow works, consider adding:

Validation & Fallback: If Claude returns invalid JSON, route the message to a human-review channel or a separate "Errors" sheet.

Auto-Categorization Rules: Post-process the category field with your own rules or another AI call, then update the row in Sheets.

Reply Back via Blooio: Add a Blooio send node at the end to confirm: "Got your receipt from {merchant} for {total}. Logged to your expense sheet."

This turns your workflow into a full loop: user sends a receipt, AI parses, data is stored, and the user gets instant confirmation via iMessage.

Useful Links

Blooio Messaging Dashboard (get your API key, pre-warmed numbers): app.blooio.com
Blooio + n8n Integration: n8n.io/integrations/blooio-messaging
Blooio Home: blooio.com
n8n Automation Platform: n8n.io
Anthropic Console (Claude API key): console.anthropic.com

Wrapping Up

You've just built an AI-powered receipt parser that turns text messages into structured expense data—no backend coding required. This same pattern works for invoices, business cards, handwritten notes, and more.

What will you automate next with Blooio and n8n? Drop a comment below with your ideas!

Automate iMessage at Scale with the Blooio API: Direct Integration Guide

David Harvey — Fri, 14 Nov 2025 05:14:07 +0000

Why iMessage Automation Is a Game Changer

If you want sky-high open rates, instant trust, and rich customer communication, iMessage is unbeatable:

2x higher open rates than SMS
Blue bubble creates trust with US customers
90% of iPhone users prefer iMessage
Images, videos, reactions—rich media support

Yet, Apple offers no official API. Most automation guides rely on hacks or third-party services. Blooio solves this the right way: using actual iPhones as hardware bridges and exposes a true HTTP REST API for direct automation.

How Blooio Works: Core Architecture

[Your App / Workflow]
      ↓  (HTTP API)
[Blooio API]
      ↓
[Physical Apple Devices]
      ↓
[iMessage Network]
      ↓
[Customer's iPhone]

No extra scripts, browser emulators, or unreliable hacks. Just send an API request; Blooio delivers your iMessage.

Getting Started: Blooio API

Prerequisites

Blooio account (free trial, no CC required)
API key from your dashboard

The API

Sending a Message

Endpoint:

POST https://backend.blooio.com/v1/api/messages

Headers:

Authorization: Bearer YOUR_API_KEY
Content-Type: application/json
Idempotency-Key: unique-id-123 (optional - prevents duplicates)

Request Body Example:

{
    "to": "+15551234567",                  // recipient in E.164 format
    "text": "Hello from Blooio API!",      // your message
    "attachments": ["https://example.com/img.png"], // array of public media URLs
    "metadata": { "ticketid": "TCK-123" }  // optional tracking info
}

What Happens:

Your message is queued for delivery.
Attachments (image, video) are sent if URLs provided.
All metadata tracked for your own analytics.

Response

For duplicates:

{
   "messageid": "Qm8FhbH3P7R",
   "status": "queued"
}

If new, status code is 202 Accepted and same response payload.

Key Endpoints

Endpoint	Purpose
`/v1/api/messages`	Send new iMessage/SMS
`/v1/api/messages?limit=100&sort=desc`	List messages (filterable by contact/status/date)
`/v1/api/messages/{messageId}`	Get message details/status
`/v1/api/messages/{messageId}/status`	Get delivery status only
`/v1/api/messages/{messageId}` (DELETE)	Cancel a queued message
`/v1/api/contacts/{contact}/capabilities`	Check contact's iMessage/SMS support
`/v1/api/webhooks`	Manage webhook URLs for delivery events (sent/failed/delivered)

Webhooks for Incoming & Status

Register a webhook (e.g., on your backend): /v1/api/webhooks
Get real-time POSTs for events like:
- message.received (inbound from customer)
- message.sent, delivered, failed, read

Payloads include all message content, contact, status, timestamps.

Example: Send a Message from Python

import requests

resp = requests.post(
    'https://backend.blooio.com/v1/api/messages',
    headers={
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    json={
        'to': '+15551234567',
        'text': 'Welcome to Blooio direct API!'
    }
)
print(resp.json())

Real-World Use Cases

Support Chatbot: Receive iMessages via webhook, send to AI, reply back instantly.
Appointment Reminders: Trigger via Google Calendar API, send iMessage with details using Blooio API.
Order Updates: Connect your backend (Shopify, Woo) and notify with delivery info.

All flows integrate natively via HTTP, but you can still use Make.com, Zapier, or n8n for visual orchestration if preferred—just use their HTTP module to talk to Blooio API.

Error Handling & Validation

Use the response codes and webhook status.
Validate recipient formats: use E.164 (+1XXXXXXXXXX).
Implement idempotency with Idempotency-Key.
Rate limits: ~100+ messages/min via Apple hardware.
You can always fallback to SMS using Blooio, or another SMS provider if recipient is not an iPhone user.

Security:

Store API keys securely, never hardcode!

Advanced Features

Check device/account status: /v1/api/me for plan/devices/usage
Contact capability lookup: /v1/api/contacts/{contact}/capabilities Find if target supports iMessage, SMS, RCS, etc.
Batch sending: Bulk endpoints are available (stubbed for now).

Integration with No-Code Tools

While this guide focuses on direct API usage, you can always plug Blooio into:

Make.com: Use HTTP module to POST directly to Blooio.
n8n: Free and open source. Use HTTP Node.
Zapier: Connect via webhook.

Official Make app.

Official Zapier app.

This lets you use drag-and-drop automation but leverages Blooio's direct messaging API for reliability and scale.

Useful References

Have questions or want to see more examples? Drop them in the comments!

This guide spotlights direct Blooio API capabilities, minimizing reliance on third-party automation suites. Plug in your workflow, code, or favorite automation builder—Blooio handles iMessage delivery with real devices and simple REST endpoints.

DEV Community: David Harvey

How to Send iMessages Programmatically (REST API, Python & Node.js)

Why there's no official iMessage API

The setup

Send your first iMessage (curl)

Send an iMessage from Python

Send an iMessage from Node.js

Blue bubble or green? Check capability first

Receiving iMessages (webhooks)

Automating without writing code

Gotchas worth knowing up front

Wrapping up

SMS Pumping Is Draining Your 2FA Budget — and Mobile-Originated iMessage 2FA Fixes It

What is SMS pumping?

Why SMS 2FA is expensive even without fraud

The Twitter/X case

The fix: flip the direction (mobile-originated 2FA)

Taking it further: reverse 2FA over iMessage

The code is almost embarrassingly small

SMS 2FA vs. reverse iMessage 2FA

How this actually saves you money

Try it / build it

How to Check if a Phone Number is Registered with iMessage Using Google Sheets and the Blooio API

Why iMessage Detection Matters for Sales and Marketing

Prerequisites

Step 1: Set Up Your Google Sheet

Step 2: Open Google Apps Script

Step 3: Add the Blooio iMessage Detection Code

Step 4: Test Your New Custom Function

How It Works Under the Hood

1. Phone Number Normalization

2. Blooio /capabilities API Call

3. Response Parsing

Scaling This Up: Tips for Large Lists

Wrapping Up

iMessage Group Chats in HighLevel: Native Integration Without Chrome Plugins

Connect iMessage to HighLevel Workflows - No A2P or 10DLC Required

Why iMessage for Business Communication?

How iMessage Group Chats Work in HighLevel

1. Trigger From Workflows

2. Or Start Manually

3. Native Mobile App Support

Use Cases: iMessage API for Customer Support

Setting Up iMessage in HighLevel Workflows

Step 1: Connect Blooio

Step 2: Add to Workflow

Step 3: Manage Conversations

iMessage Automation: Beyond HighLevel

n8n Workflows

Make.com Integration

Zapier Support

Clay Integration

Building an iMessage Chatbot with AI

iMessage API vs SendBlue vs Linq

Send Messages Without A2P or 10DLC

Broadcast Messages with iMessage

iMessage Developer API Documentation

Core Endpoints

Webhook Events

Apple Messages API Alternative

iMessage for SaaS Platforms

Getting Started with iMessage in HighLevel

Pricing & Partners

Frequently Asked Questions

What's Next?

Start Using iMessage Group Chats Today

Build Your Own iMessage AI Bot in Minutes with blooio

Try msg.new - Then Build Your Own

Why Build iMessage Bots with Blooio?

How the msg.new Workflow Works

Key Features

Conversational AI with Memory

Multi-Message Responses

Natural Texting Behavior

Full iMessage Integration via Blooio

Build Your Own iMessage Bot

1. Try msg.new First

2. Get the Workflow

3. What You'll Need

4. Quick Setup

2. Blooio `/capabilities` API Call