Send iMessages from Code with REST APIs in Python & Node.js

Apple’s iMessage platform remains one of the most secure and feature-rich messaging systems, but its closed ecosystem presents a unique challenge for developers. Unlike SMS, which offers a straightforward API integration through providers such as Twilio, iMessage lacks a public REST API from Apple. This absence forces teams to seek alternative methods to send and receive iMessages programmatically. However, the demand persists, especially for applications requiring high open rates or rich media support. By leveraging hosted iMessage REST APIs, developers can integrate blue-bubble messaging into their workflows without needing to manage Apple hardware or software directly.

Why Apple’s iMessage Remains Inaccessible via Official APIs

The iMessage protocol is deeply integrated with Apple’s ecosystem, relying on end-to-end encryption and Apple ID authentication. Apple has never released a public API for sending iMessages, and the only official business-facing solution, Messages for Business, is designed for customer support inboxes rather than outbound messaging. Historically, developers have relied on workarounds:

• AppleScript or `osascript` – Requires a logged-in Mac with the Messages app open, making it unsuitable for server environments.
• Polling local SQLite databases – Mac-only and prone to breaking with macOS updates.
• Shortcuts automation – Limited to manual triggers and lacks scalability.
• SMS via providers like Twilio – Reliable but delivers green bubbles, missing key features like typing indicators and tapbacks.

For developers needing server-side integration, outbound scale, or inbound message handling, a hosted iMessage REST API becomes the most viable solution.

Setting Up a Hosted iMessage API for Programmatic Use

To demonstrate integration, this guide uses Blooio, a third-party iMessage REST API provider. While providers vary, the core concepts—authentication, endpoints, and webhook support—remain consistent. Before proceeding, ensure you have:

• An active API key (Blooio issues keys via its dashboard without requiring credit card details or telecom compliance).
• A test phone number capable of receiving iMessages.
• The base URL for API requests: `

With these prerequisites in place, the next step is sending your first iMessage through a simple HTTP request.

Sending an iMessage via cURL: A Minimal Example

The process is straightforward—authenticate with a Bearer token and send a POST request to the designated endpoint. The recipient’s phone number must be URL-encoded to handle the + symbol correctly:

curl -X POST \
  " \
  -H "Authorization: Bearer sk_live_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello from the command line 👋"}'

The response confirms the message’s status as queued, meaning it has been accepted by the provider’s infrastructure and is awaiting delivery to the recipient’s device. This approach eliminates the need for local Apple hardware or manual scripting.

Automating iMessages in Python: A Scalable Approach

For server-side integration, Python offers flexibility and reliability. Below is a minimal script using the requests library. The phone number is safely encoded using urllib.parse.quote to prevent silent 400 errors from unencoded + symbols:

import os
import requests
from urllib.parse import quote

API_KEY = os.environ["BLOOIO_API_KEY"]
BASE_URL = "

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

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

To execute the script, set the environment variable BLOOIO_API_KEY and run:

export BLOOIO_API_KEY=sk_live_your_key_here
python send.py

This function can be extended to include media attachments, scheduled delivery, or batch processing for enterprise use cases.

Integrating iMessages into Node.js Applications

Node.js developers can leverage the native fetch API (available in Node 18+) to send iMessages without external dependencies. The implementation follows a similar pattern—authenticate, encode the phone number, and send a POST request:

const API_KEY = process.env.BLOOIO_API_KEY;
const BASE_URL = "

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

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

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

This approach integrates seamlessly into backend services, APIs, or serverless functions, enabling real-time messaging workflows.

Ensuring Deliverability: Checking iMessage Capability

Not all phone numbers support iMessage. To avoid failed deliveries, verify a recipient’s capability before sending. The API provides an endpoint to check whether a number can receive iMessages:

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

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

This dual-path strategy ensures messages reach recipients reliably, whether via iMessage or SMS, without manual intervention.

Building Two-Way Communication with Webhooks

Receiving iMessages programmatically requires real-time event handling. Instead of polling, configure a webhook URL on your iMessage API provider to receive incoming messages as HTTP POST requests. Below is a Node.js example using Express to process these events securely:

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

const app = express();
app.use(express.raw({ type: "application/json" }));

app.post("/webhooks/blooio", (req, res) => {
  const signature = req.header("x-blooio-signature") ?? "";
  const event = req.header("x-blooio-event") ?? "";
  const secret = process.env.BLOOIO_WEBHOOK_SECRET;

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

  const isValid = crypto.timingSafeEqual(
    Buffer.from(expectedSignature),
    Buffer.from(signature)
  );

  if (!isValid) 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}`);
    // Process message, reply, or integrate with CRM
  }
  res.sendStatus(200);
});

Security is critical—validate the HMAC signature to confirm events originate from your provider, preventing spoofed requests. Once validated, parse the payload to extract sender details and message content, enabling dynamic responses or CRM updates.

The Future of iMessage Automation

While Apple continues to prioritize security and privacy in its messaging ecosystem, the demand for programmatic iMessage access persists. Hosted REST APIs bridge this gap, offering a practical solution for businesses and developers seeking blue-bubble delivery without compromising on reliability. As APIs evolve to support richer features—such as media attachments, read receipts, and group messaging—their integration into automated workflows will become even more seamless. For now, leveraging third-party providers remains the most efficient path to unlocking iMessage’s full potential in modern applications.