iMessage customer support, routed to Slack or your help desk

Who uses iMessage for customer support?

iMessage customer support through ZeroSettle fits support teams at apps, SaaS products and DTC brands whose customers mostly use iPhone and whose agents already work in Slack, Intercom, Zendesk or Front. ZeroSettle is an iMessage API: a real phone number on real iMessage, running on Apple hardware we operate for you in a server facility, that your code texts customers from and hears back on through a bearer token and signed webhooks.

Customers need no app and no login: they text, you answer, and the thread stays in Messages under your name and photo, while your team stays in the tool it already watches. If most customers use Android, see when ZeroSettle is not a fit; for order lookups from store data, see order-status support for Shopify brands.

How iMessage for customer support works, step by step

A customer texts your ZeroSettle number, a signed webhook hands the text to a relay you run, and the team answers from Slack or a help desk.

1. The customer starts the thread from a “Message us” button: an sms:+18055550100&body=… link prefilled with an order number or support code such as “K7Q2”, never an email address or a secret (see how to get customers to text first).
2. ZeroSettle posts a signed message.received to your webhook about 1–2 seconds after the line receives it. A screenshot arrives in the same event as an image object.
3. The relay verifies and forwards it. It checks X-ZeroSettle-Signature, dedupes on message.id plus event, and posts into the Slack thread keyed by the customer’s handle.
4. A 👍 tapback from POST /api/imessage/reactions ("reaction": "like") tells the customer the message landed.
5. The typing bubble from POST /api/imessage/typing (ttl_s up to 60) shows while an agent looks it up, and clears when the reply goes.
6. The agent replies from Slack with a slash command that calls POST /api/imessage/send (normally 2–5 seconds). Every send, console replies included, echoes back as message.sent into the same thread.

Help desks work the same way; ZeroSettle’s docs note that “Intercom, Zendesk, Front, and Linear all have equivalent inbound APIs.” In Front, an application channel you build syncs each inbound text in, and Front sends agents’ replies to its webhook, where your code calls POST /api/imessage/send. For CRM logging, see iMessages in HubSpot or Salesforce; for a low-code relay, see Zapier, n8n or Make.

With no code at all, the ZeroSettle console is the inbox: it shows every conversation live, and you can invite teammates to answer from it.

Example conversation: customer support

A billing question answered from Slack, with the relay’s 👍 and the agent’s typing bubble.

Setup: the docs’ Slack relay, with a thread per customer

This relay adapts the one in the customer support section of ZeroSettle’s docs: it keeps one Slack thread per customer (chat.postMessage with thread_ts), checks Slack’s request signature, retries line_busy, and answers Slack at once, reporting the result to response_url. Slack shows an operation_timeout error unless a slash command is answered within 3,000 milliseconds, and a ZeroSettle send normally takes 2–5 seconds.

# support_relay.py, adapted from ZeroSettle's docs. Run: uvicorn support_relay:app --port 8100
import asyncio, hmac, hashlib, json, os, time
from urllib.parse import parse_qs
import httpx
from fastapi import BackgroundTasks, FastAPI, Request, Response

app = FastAPI()
ZS = "https://portal.zerosettle.io"
TOKEN, SECRET = os.environ["ZEROSETTLE_TOKEN"], os.environ["ZEROSETTLE_WEBHOOK_SECRET"]
SLACK_TOKEN, SLACK_SECRET = os.environ["SLACK_BOT_TOKEN"], os.environ["SLACK_SIGNING_SECRET"]
CHANNEL = os.environ["SLACK_CHANNEL_ID"]
ZS_AUTH = {"Authorization": f"Bearer {TOKEN}"}
seen: set[tuple[int, str]] = set()     # use your database in production
threads: dict[str, str] = {}           # handle -> Slack thread ts (database too)

def verify(header: str, raw: bytes, tolerance: int = 300) -> bool:   # as in the docs
    try:
        parts = dict(p.split("=", 1) for p in header.split(","))
        t, v1 = int(parts["t"]), parts["v1"]
    except Exception:
        return False
    if abs(time.time() - t) > tolerance:
        return False
    expected = hmac.new(SECRET.encode(), f"{t}.".encode() + raw, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, v1)

async def post_thread(handle: str, text: str) -> None:
    text = text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")   # no @channel from a text
    body = {"channel": CHANNEL, "text": text}
    if handle in threads:
        body["thread_ts"] = threads[handle]
    async with httpx.AsyncClient() as c:
        r = await c.post("https://slack.com/api/chat.postMessage", json=body,
                         headers={"Authorization": f"Bearer {SLACK_TOKEN}"})
    if r.json().get("ts"):
        threads.setdefault(handle, r.json()["ts"])

async def relay(event: str, m: dict) -> None:
    h = m["handle"]
    if event == "message.received":
        photo = " [photo]" if m.get("image") else ""
        await post_thread(h, f"*{h}*: {m.get('text') or ''}{photo}\n_reply with_ `/imsg {h} your answer`")
        async with httpx.AsyncClient(timeout=90) as c:    # 👍 = "seen, on it"; queues like a send
            await c.post(f"{ZS}/api/imessage/reactions", headers=ZS_AUTH,
                         json={"message_id": m["id"], "reaction": "like"})
    elif event in ("message.sent", "message.failed", "reaction.received"):    # console sends too
        await post_thread(h, f"_{event}:_ {m.get('text') or ''}")

@app.post("/webhook")
async def webhook(req: Request, tasks: BackgroundTasks):
    raw = await req.body()
    if not verify(req.headers.get("X-ZeroSettle-Signature", ""), raw):
        return Response(status_code=401)
    ev = json.loads(raw); m = ev.get("message")
    if m is None or (m["id"], ev["event"]) in seen:    # typing.* has no message; dedupe retries
        return {"ok": True}
    seen.add((m["id"], ev["event"]))
    tasks.add_task(relay, ev["event"], m)              # 2xx now, within the 10 s timeout
    return {"ok": True}

def slack_ok(req: Request, raw: bytes) -> bool:      # Slack's v0 signature
    try:
        ts = int(req.headers["X-Slack-Request-Timestamp"])
    except (KeyError, ValueError):
        return False
    if abs(time.time() - ts) > 300:
        return False
    exp = "v0=" + hmac.new(SLACK_SECRET.encode(), f"v0:{ts}:".encode() + raw, hashlib.sha256).hexdigest()
    return hmac.compare_digest(exp, req.headers.get("X-Slack-Signature", ""))

# /imsg +18055559876 We just refunded that charge.   (handle alone: typing bubble for 60 s)
@app.post("/slack/imsg")
async def slack_imsg(req: Request, tasks: BackgroundTasks):
    raw = await req.body()
    if not slack_ok(req, raw):
        return Response(status_code=401)
    form = parse_qs(raw.decode())
    handle, _, reply = form.get("text", [""])[0].strip().partition(" ")
    tasks.add_task(answer, handle, reply.strip(), form["response_url"][0])
    return {"text": f"Working on {handle}..."}        # inside Slack's 3 s window

async def answer(handle: str, reply: str, response_url: str) -> None:
    path, body = (("send", {"to": handle, "text": reply}) if reply
                  else ("typing", {"to": handle, "state": "start", "ttl_s": 60}))
    async with httpx.AsyncClient(timeout=90) as c:
        for _ in range(3):
            r = await c.post(f"{ZS}/api/imessage/{path}", headers=ZS_AUTH, json=body)
            if r.status_code != 429 or r.json()["error"]["code"] != "line_busy":
                break
            await asyncio.sleep(2)                       # line_busy: retry after 2 s
        note = "Done." if r.status_code == 200 else "Failed: {code}: {message}".format(**r.json()["error"])
        await c.post(response_url, json={"text": note})

Give the Slack app the chat:write bot scope, invite it to the channel, and point an /imsg command at /slack/imsg. Register /webhook with PUT /api/imessage/webhook and store the signing secret, which is shown once; the iMessage webhook guide covers retries and a signed test event. Two things are left to you:

• Photos. A received photo’s image.url needs your ZeroSettle token, so fetch GET /api/imessage/messages/{id}/image and upload the file to the thread. Only the first of several photos is delivered.
• Identity. Store the handle on the customer’s account the first time they text. A customer on an iPad or Mac may appear as an iMessage email address, so treat the handle as an opaque string.

Limits and consent for customer support

A support line is customer-initiated, so ZeroSettle’s new-contact limits rarely apply: anyone who texted the line first is never limited. A support team meets the one-send-at-a-time queue instead, and a cap on unanswered messages.

Source: ZeroSettle iMessage API docs, “Errors, limits, and compliance”. The day runs 3 AM to 3 AM Eastern.

The limit math for a busy shift

• Five agents reply at once. At 2–5 seconds per send, the fifth reply waits 8 to 20 seconds behind the other four; past about 12 seconds it gets 429 line_busy, which the relay retries after 2 seconds.
• Following up 30 email tickets by text on one Pro number. Those customers never texted the line, so each is a new contact: 5 a day, so the follow-ups take six days, each new batch waiting for the 3 AM Eastern reset. For that volume, book a demo to upgrade to Growth. Text only customers who agreed to texts about their ticket, and leave links out of that first text, where they can’t be tapped.
• “Did that fix it?” on either plan. Your answer is the first unanswered message, so a follow-up sent more than 5 minutes later is the second, and a third returns 403 awaiting_reply. Anything the customer sends back, a tapback included, resets the count.

When ZeroSettle is not a fit for customer support

ZeroSettle is the wrong tool for a support line in these cases:

• You want a native Zendesk, Intercom or Front app with no code. There isn’t one.
• Most customers use Android. There is no SMS fallback, and the sms: link opens the SMS app on Android, so keep email or chat for them.
• You need group conversations, such as a customer and their accountant in one thread.
• Customers send screen recordings or log files. Inbound video and files arrive without the file.
• You need Apple Pay, list pickers or time pickers in the chat. Those are Apple Messages for Business features; see Apple Messages for Business vs an iMessage number.
• You report on read receipts. The API reports message.sent (left the line) and message.failed, not delivered or read.

How much does iMessage for customer support cost?

A support line costs the plan price: ZeroSettle has no per-message fees, and messages in both directions are unlimited (and counted).

Get a number, compare ZeroSettle’s plans, or browse the use cases hub.