Messages

Send and list 1:1 or group iMessages. iMessage requests are scoped to the agent identity and keyed by conversation_id; callers never choose a sending number in the message request. Shared lines remain hidden, while an attached dedicated line lets the identity start a conversation or group.

Get message

GET /messages/{message_id}

Read a message by UUID, including its current delivery status. The response is a single message object with the same fields as a message-list entry. You can pass agent_identity_id to restrict the lookup to that identity. Identity-scoped credentials remain restricted to their own visible messages. An inaccessible or unknown message returns 404. error_code: "send_outcome_ambiguous" means delivery could not be confirmed. After a 15-minute confirmation window, the message can have status: "error" and error_reason: "delivery_unconfirmed". This is not proof that it was never delivered. Keep the original message rather than sending another copy; a later delivery update can still resolve it.

Send message

Send Idempotency-Key with Prefer: idempotency-replay to protect retries. The same key and input replay the original queued response and message ID. Read the message for current delivery status; do not create another message just because delivery is pending. See message send retries and lookup.

POST /messages

Send an outbound iMessage. Pass conversation_id to reply into an existing conversation, or to as either one E.164 phone number or a list of 1-8 E.164 phone numbers — exactly one of the two. A dedicated line can receive messages from non-phone sender addresses. Those conversations are receive-only: sending by conversation_id returns 422 with detail.error: "recipient_not_e164". The to field still requires E.164 phone numbers. Standard shared-service identities can reply only after the recipient has started a conversation. A dedicated line can start a new 1:1 conversation or a group chat; lists with 2-8 recipients select group behavior, while a scalar or one-item list keeps the 1:1 behavior. Organizations with their own organization-owned shared pool can submit the first message through POST /connect, available only by request. Subsequent sends use this message endpoint. Until the recipient replies, they return 409 with error: "imessage_awaiting_inbound", unless prior direct engagement on the assigned number already satisfies the reply requirement. Reply into a conversation:

JSON

{
  "conversation_id": "82cf24f6-78fe-48da-a673-6a75b4f4a819",
  "text": "On it — give me two minutes."
}

Or address the connected recipient directly:

JSON

{
  "to": "+15555550123",
  "text": "Done!",
  "send_style": "confetti"
}

Or start or select a group from a dedicated line:

JSON

{
  "to": ["+14155550100", "+14155550101"],
  "text": "Planning starts at 10.",
  "send_style": "confetti"
}

For groups, an unresolved local conversation with the same requested members is reused before a remote thread has been established. An established best-known match is reused only when its current membership can be verified and still matches the request. If no reusable match remains, a new group is created; multiple best-known matches return 409. A different to set never edits an existing group’s membership. Keep the returned conversation_id and use it to continue the exact same thread. See Group chats for membership and delivery semantics.

Query parameters

Parameter	Type	Description
`agent_identity_id`	UUID	The identity to send as. Required for admin API keys when sending by `to`; ignored for identity-scoped API keys, which always send as their own identity

Request body

Field	Type	Required	Description
`to`	string \| string[]	Conditional	One E.164 phone number, or 1-8 distinct E.164 phone numbers. A list with 2 or more recipients starts or selects a group. Mutually exclusive with `conversation_id`
`conversation_id`	UUID	Conditional	Existing conversation to reply into. Mutually exclusive with `to`
`reply_to_message_id`	UUID \| null	No	Reply to a specific message in the same conversation. Requires `conversation_id`; cannot be used with `to`. Omit or pass null for an ordinary message
`plain_reply_fallback`	boolean	No	Defaults to `true`. If the target is known to use SMS/RCS or was downgraded, send an ordinary message in the same conversation. Set `false` to require a native reply. Ignored without a reply target
`text`	string \| null	No	Message body, up to 18,995 characters. Required unless `media_urls` has an item
`media_urls`	string[] \| null	No	Publicly fetchable media URL to attach — at most 1 entry. Use Upload media to turn raw bytes into a URL. Required unless `text` is present
`send_style`	string \| null	No	Expressive send style applied to a 1:1 or group message, including group creation and conversation replies. Can accompany text, media, or both

Preconditions

Identity opt-in. The sending identity must have imessage_enabled: true; otherwise sends return 400.
Line capability. Standard shared service requires recipient-first contact. A dedicated line can start 1:1 conversations and is required for groups.
Group participants. Group to lists contain 2-8 distinct remote E.164 phone numbers and cannot include the attached sending line. Every participant must pass opt-out and contact-rule checks before the message is queued.
Connection still active. If the recipient disconnected from the agent, sends into the old conversation return 409. Reconnect through the router for standard shared service, or through connect for a organization-owned shared pool, subject to its eligibility checks.
Contact rules. Sends to a recipient blocked by the identity’s contact rules return 403 before anything is sent.

Before the first reply

Before a qualifying recipient reply, every 1:1 message must contain fewer than 160 characters (159 maximum), without phone numbers, links, or media. These content requirements apply to all line types, including dedicated lines. They do not apply to group sends or grant permission to send before a connection is ready. At most three 1:1 messages total are allowed before the recipient’s first qualifying reply. When this limit rejects a send, the API returns 422 imessage_unanswered_followup_limit; wait for a reply before sending again. This ceiling does not grant additional sends when a connection requires an earlier reply. The three-message cap ends after the first qualifying reply, but other unanswered-message limits still apply. Violations return 422 before the message is queued, with the error code in detail.error. A numeric identifier that resembles a phone number can also produce imessage_reply_required_for_phone_numbers. Wait for the recipient’s reply before including that identifier. After a qualifying reply, these pre-reply content restrictions no longer apply; other send requirements and limits still do.

Rate limits

Each agent identity can send up to 100 iMessages per rolling 24-hour window. When the cap is reached, 429 responses include:

Header	Description
`X-RateLimit-Limit`	Maximum sends allowed per identity per 24 hours
`X-RateLimit-Remaining`	Remaining sends in the current window
`X-RateLimit-Reset`	ISO 8601 timestamp at which the oldest send in the window will fall off
`Retry-After`	Seconds until at least one slot frees up

Dedicated lines carry additional guardrails on agent-initiated conversations. A dedicated line can start conversations with at most 10 new recipients per rolling 1-hour window and 40 new recipients per rolling 24-hour window, which keeps the line in good standing. Both limits apply only to recipients the line hasn’t reached before:

It does not apply to a recipient the agent has already connected with on that line.
It does not apply when the recipient messages the line first.

Repeat sends to an already-connected recipient never count against either limit. In a group chat, each previously unknown participant counts as one new recipient, and the whole request is rejected if the line lacks enough remaining slots in either window. At a cap, sends return 429 with error: "outbound_line_new_contact_rate_limited" and the same Retry-After and X-RateLimit-* headers. Those headers describe the limit that rejected the request, and Retry-After counts down until enough new-recipient slots in that window age out.

Response (201)

The queued message, wrapped in a message envelope. Delivery state updates asynchronously. Re-read the message to observe every outcome. Delivery-lifecycle webhooks (imessage.sent, imessage.delivered, imessage.delivery_failed) report delivery updates, but do not cover every failure before sending.

JSON

{
  "message": {
    "id": "f1a2b3c4-d5e6-7890-abcd-ef1234567890",
    "conversation_id": "82cf24f6-78fe-48da-a673-6a75b4f4a819",
    "reply_to_message_id": null,
    "thread_id": null,
    "thread_root_message_id": null,
    "assignment_id": "9b2e4a68-8cb1-4f18-b97d-a2324c8b4d1f",
    "direction": "outbound",
    "remote_number": "+15555550123",
    "sender_number": null,
    "participants": null,
    "is_group": false,
    "content": "On it — give me two minutes.",
    "message_type": "message",
    "service": "imessage",
    "send_style": null,
    "media": null,
    "was_downgraded": null,
    "status": "pending",
    "error_code": null,
    "error_message": null,
    "error_reason": null,
    "error_detail": null,
    "is_read": true,
    "is_blocked": false,
    "recipients": [
      {
        "remote_number": "+15555550123",
        "delivery_status": "pending",
        "service": "imessage",
        "error_code": null,
        "error_message": null,
        "error_reason": null,
        "error_detail": null,
        "sent_at": null,
        "delivered_at": null,
        "failed_at": null
      }
    ],
    "reactions": null,
    "created_at": "2026-06-09T14:30:00Z",
    "updated_at": "2026-06-09T14:30:00Z"
  }
}

Error responses

Status	Description
400	Sending identity is not enabled for iMessage, or `agent_identity_id` is missing on an admin send by `to`
402	The organization’s current billing-cycle iMessage capacity is exhausted
403	A recipient is blocked by a contact rule or has opted out
404	No connection exists for this recipient — the response tells you the connect command and router number to relay
404	`conversation_id` not found or inaccessible; `imessage_reply_target_not_found` for a missing or inaccessible reply target in that conversation
409	The recipient hasn’t messaged this agent yet, the connection is disconnected or expired, a group send lacks a dedicated line, a targeted reply’s group is not yet established, multiple groups match, current group membership is inconsistent or changes while resolving, or the line attachment changed
422	Invalid body: both/neither `to` and `conversation_id`, a reply target without `conversation_id`, `imessage_reply_target_unavailable` for an unavailable target (including unsupported transport in strict mode), invalid or duplicate recipients, no text or media, more than one `media_urls` entry, or `text` over 18,995 characters
422	`recipient_not_e164` when the conversation has a non-phone sender address and is receive-only
422	`imessage_unanswered_followup_limit` when the pre-reply three-message limit is reached; wait for the recipient’s first reply
422	`imessage_reply_required_for_phone_numbers` when a pre-reply 1:1 message contains a phone number; applies to shared and dedicated lines
422	`imessage_reply_required_for_links_or_media` when a pre-reply 1:1 message contains links or media; applies to shared and dedicated lines
422	`imessage_opening_message_too_long` when a pre-reply 1:1 message exceeds 159 characters
429	24-hour per-identity send limit or dedicated-line new-contact limit reached; respect the `Retry-After` header
503	`group_membership_unavailable` because current membership for an existing group could not be verified; retry with backoff

The 404 and 409 connection errors carry a structured detail — read detail.error to branch and detail.message for the sentence to relay:

`detail.error`	Meaning	Recovery
`imessage_no_assignment`	No active connection is available for this recipient	For an organization-owned shared pool, use an authorized connect request. Otherwise relay the router command from `detail.message`, or send through an attached dedicated line
`imessage_awaiting_inbound`	The recipient named in `detail.address` is connected, but has not sent the first message to the agent’s iMessage number	Ask them to send a direct message to the connected number, not the router. For an organization-owned shared pool, an authorized connect request can accept an opening, but ordinary sends still require a reply; a tapback is insufficient. `GET /identities/self/channel-status` lists these under `imessage.awaiting_inbound`
`imessage_assignment_inactive`	The connection is no longer active, so the old conversation is history	Have the recipient reconnect, or start a new conversation on a dedicated line
`imessage_connection_expired`	A standard shared-service connection expired due to inactivity	Relay `detail.message` and ask the recipient to text `connect @your-agent-handle` to the current router number. Do not retry until they reconnect and message your agent

The expiry error returns 409 whether you address the expired connection by conversation_id or the recipient’s to number. It does not expose the previous shared sending number. Conversation history stays readable. See inactive shared connections for the default expiry policy. Compatibility note: a send addressed by to whose latest connection expired now returns 409 imessage_connection_expired instead of 404 imessage_no_assignment. Update any handling that assumes every recipient without an active connection returns 404. Ordinary missing connections and manual disconnects retain their existing error behavior. Reactions, read receipts, and typing indicators also reject inactive connections. They return imessage_connection_expired when the connection expired due to inactivity. Delivery happens asynchronously after the 201, so later failures do not change the send response. Re-read the message to observe every outcome. Delivery updates can emit webhooks, but do not cover every failure before sending. If a reply target becomes unavailable before sending, the message reports status: "error" and error_code: "imessage_reply_target_unavailable". The first message in a new group also creates the group asynchronously. Check the conversation’s group_creation_status: "creating" while that attempt resolves, "ready" after success, or "not_created" when no confirmed group is available. During creating, later messages wait for the first send. If creation remains unconfirmed after 15 minutes, the first message gets an unknown-delivery outcome. Waiting messages that were never sent get error_code: "group_creation_unconfirmed" and error_reason: "request_not_sent". A fresh explicit send can attempt group creation again; the uncertain original is never automatically resent. All attempts remain in the conversation’s history. Existing-group membership is rechecked before delivery, so a change after the 201 can move the queued message to status: "error". A later conversation_id send resolves its current membership again.

List messages

GET /messages

List iMessages visible to the caller, newest first, across all of the caller’s conversations or narrowed to one.

Query parameters

Parameter	Type	Default	Description
`agent_identity_id`	UUID	-	Narrow to one identity. Ignored for identity-scoped API keys, which always see their own identity
`conversation_id`	UUID	-	Narrow to one conversation
`thread_id`	UUID	-	Filter to one reply thread. Requires `conversation_id`; use the opaque `thread_id` from a message or thread response, not a root message ID
`include_groups`	boolean	false	Include group messages in list results. A known group `conversation_id` is read directly even when this remains false
`limit`	integer	50	Number of results (1-200)
`offset`	integer	0	Pagination offset
`is_read`	boolean	-	Filter by read state. Omit for all messages
`is_blocked`	boolean	-	Filter by blocked state. `true` returns only blocked rows, `false` only non-blocked rows, and omitting it applies the caller’s default visibility
`start_datetime`	string	-	Only messages created on or after this date/time
`end_datetime`	string	-	Only messages created on or before this date/time; a bare date includes the whole day
`tz`	string	UTC	IANA zone for interpreting zone-less `start_datetime`/`end_datetime` values. Defaults to UTC

Identity-scoped API keys never see contact-rule-blocked messages, regardless of is_blocked. Admin API keys and the Inkbox Console see blocked and non-blocked messages by default; use is_blocked=true for a blocked-only audit listing. start_datetime, end_datetime, and tz filter on created_at. Both bounds are optional and non-breaking — omit them for unchanged behavior. See Filtering by date.

Response (200)

Returns a list[IMessage]. Live tapbacks ride along on each message — see the Message object. Within an accessible conversation, an unknown or inaccessible thread_id returns 200 with []. In contrast, Get conversation thread returns 404 when that thread is not visible.

JSON

[
  {
    "id": "1a90e8b0-0e1e-485f-b316-28f7dfa96afd",
    "conversation_id": "82cf24f6-78fe-48da-a673-6a75b4f4a819",
    "reply_to_message_id": null,
    "thread_id": "91b1a20b-3ee3-5f4d-b976-e578972b9f38",
    "thread_root_message_id": "1a90e8b0-0e1e-485f-b316-28f7dfa96afd",
    "assignment_id": "9b2e4a68-8cb1-4f18-b97d-a2324c8b4d1f",
    "direction": "inbound",
    "remote_number": "+15555550123",
    "sender_number": null,
    "participants": null,
    "is_group": false,
    "content": "Can you move my 3pm?",
    "message_type": "message",
    "service": "imessage",
    "send_style": null,
    "media": null,
    "was_downgraded": null,
    "status": "received",
    "error_code": null,
    "error_message": null,
    "error_reason": null,
    "error_detail": null,
    "is_read": false,
    "is_blocked": false,
    "recipients": null,
    "reactions": [
      {
        "id": "0f6b8a5e-1ca0-4a4f-8e94-44b3e4374f9a",
        "direction": "outbound",
        "reaction": "like",
        "custom_emoji": null,
        "remote_number": "+15555550123",
        "part_index": 0,
        "created_at": "2026-06-09T14:31:00Z"
      }
    ],
    "created_at": "2026-06-09T14:30:00Z",
    "updated_at": "2026-06-09T14:31:00Z"
  }
]

Error responses

Status	Description
400	`agent_identity_id` names an identity that is not enabled for iMessage
403	Identity-scoped key passed an `agent_identity_id` other than its own
404	`agent_identity_id` or `conversation_id` not found, or not visible to the caller
422	`thread_requires_conversation` when `thread_id` is supplied without `conversation_id`, or invalid query parameters

Reply to a specific message

Native replies work within both 1:1 and group iMessage conversations. A conversation is the whole chat; a reply thread groups a message and its replies. Ordinary conversation message lists remain flat and include all messages. Pass the existing conversation_id and the message’s Inkbox UUID as reply_to_message_id:

JSON

{
  "conversation_id": "82cf24f6-78fe-48da-a673-6a75b4f4a819",
  "reply_to_message_id": "1a90e8b0-0e1e-485f-b316-28f7dfa96afd",
  "plain_reply_fallback": true,
  "text": "Friday works for me."
}

You can target a received message or a confirmed sent message, including another reply. The target must belong to the same conversation and be accessible to you. Missing, inaccessible, pending, failed, or unresolved targets remain errors; fallback does not bypass these checks. plain_reply_fallback defaults to true. Inkbox uses a native reply when supported. If the target is known to use SMS/RCS or was downgraded, Inkbox sends an ordinary message in the same conversation, using normal transport selection. This does not force SMS/RCS, create a new conversation, or change a group’s audience. Set plain_reply_fallback: false to require native threading instead; an unsupported target then returns 422. Fallback is decided before sending, from what is known about the target. If the target was recorded as iMessage but native delivery is later rejected, Inkbox does not retry it as an ordinary message, even with plain_reply_fallback: true. A delivery failure, timeout, or uncertain result also does not trigger an automatic resend. A queued response is not confirmation of delivery. Poll GET /messages/{message_id} for the current status and error fields. If the target becomes unavailable before sending, the message reports status: "error" and error_code: "imessage_reply_target_unavailable". Delivery webhooks do not cover every failure before sending, so they supplement message reads rather than replace them. An ordinary fallback has no reply_to_message_id and does not join the target’s native thread. It may have its own standalone thread_id. A queued response can initially contain the requested native parent; an allowed ordinary fallback decided before sending can clear that relationship. Re-read the message for current metadata rather than treating the requested target or initial queued response as the final reply relationship. Omit reply_to_message_id or pass null for the existing ordinary-message behavior; plain_reply_fallback has no effect then. A reply remains one message in the same conversation, with the same usage accounting and send limits. Changing the target or its fallback policy changes the send input: use a new idempotency key for a different intended send. Each message can expose three nullable fields:

reply_to_message_id: its immediate parent message, when visible and resolved. A non-null value identifies a reply, not an ordinary message.
thread_root_message_id: the message that started the thread. For a standalone message, this can be its own id.
thread_id: the opaque identifier used to retrieve the whole thread. This is not the root message’s ID, and its presence does not mean replies exist.

A newly received or confirmed sent ordinary message can have its own thread_id before anyone replies. Reading that thread returns the message itself. A null parent alone does not prove a message is standalone: a reply’s parent can be unresolved or hidden. If B replies to A and C replies to B, their immediate parents differ, but A, B, and C belong to the same thread. Incoming native replies preserve these relationships in 1:1 and group chats. Fields can be null while a message is pending or a reference is unresolved or not visible to you. Older message history might not have thread metadata; clients must tolerate missing or null fields.

Get a reply thread

GET /messages/{message_id}/thread

Read the stored, visible root and replies using any message in the thread. An ordinary standalone message returns itself. A missing root does not prevent accessible replies from being read.

Query parameter	Type	Default	Description
`agent_identity_id`	UUID	-	Restrict the lookup to one identity
`limit`	integer	50	Maximum messages per page, from 1 to 200
`cursor`	string	-	The `next_cursor` returned by the previous page

Response (200)

Field	Type	Description
`thread_id`	UUID \| null	Opaque thread identifier, when known
`conversation_id`	UUID	The containing conversation
`thread_root_message_id`	UUID \| null	Root message ID, when visible and resolved
`messages`	array	Message objects, oldest first, with message ID breaking timestamp ties
`next_cursor`	string \| null	Pass as `cursor` for the next page; null when this page reaches the end

Continue with the returned cursor on the same thread and conversation. Do not parse or construct cursors yourself. Reads only return history you can access; they do not fetch missing messages from participants’ devices. An inaccessible or unknown anchor returns 404; an invalid cursor or pagination parameter returns 422. If you already have conversation_id and thread_id, use Get conversation thread. For the existing newest-first list shape and offset pagination, use GET /messages?conversation_id=...&thread_id=... instead.

Upload media

POST /media

Upload a file and get back a URL you can pass in media_urls on a send. The request is multipart/form-data with a single file field.

Request

Field	Type	Required	Description
`file`	file	Yes	The file to upload, up to 10 MiB. The part’s content type and filename are preserved

Response (201)

JSON

{
  "media_url": "https://media.example.com/abc123_chart.png",
  "content_type": "image/png",
  "size": 48211
}

Error responses

Status	Description
400	Caller’s identity is not enabled for iMessage
413	File exceeds 10 MiB
502	Upstream upload failure — safe to retry

Send styles

Pass send_style on a 1:1 or group send to apply one of Apple’s expressive effects. Dedicated-line groups support styles on both creation and conversation_id replies, including messages that also carry the single allowed media item:

Bubble effects	Full-screen effects
`slam`	`celebration`
`loud`	`shooting_star`
`gentle`	`fireworks`
`invisible` (invisible ink)	`lasers`
	`love`
	`confetti`
	`balloons`
	`spotlight`
	`echo`

Send styles render on the recipient’s device when the message is delivered over iMessage; they do not apply to SMS fallback.

Message object

Field	Type	Description
`id`	string (UUID)	Message ID
`conversation_id`	string (UUID)	The conversation this message belongs to
`reply_to_message_id`	string (UUID) \| null	Immediate parent, when visible and resolved. Non-null identifies a reply; null can also mean an unavailable parent
`thread_id`	string (UUID) \| null	Opaque thread identifier, including standalone messages with no replies. Not a message ID; use it with `conversation_id` for thread reads
`thread_root_message_id`	string (UUID) \| null	Visible, resolved root message. Can equal this message’s `id` for a standalone message
`assignment_id`	string (UUID) \| null	The 1:1 connection carrying the conversation; null for group messages
`direction`	string	`"inbound"` or `"outbound"`
`remote_number`	string \| null	The other party’s address for 1:1 messages. This can be a non-phone address on a dedicated line. On inbound group messages it mirrors `sender_number`; null on outbound group messages
`sender_number`	string \| null	Sender’s E.164 phone number on an inbound group message; null for 1:1 and outbound group messages
`participants`	string[] \| null	Best-known E.164 participant snapshot for a group message; null for 1:1 messages
`is_group`	boolean	Whether the message belongs to an iMessage group chat
`content`	string \| null	Message body. Null for media-only messages
`message_type`	string	`"message"`, or `"carousel"` for rich multi-part messages
`service`	string	Transport actually used: `"imessage"`, `"sms"`, or `"rcs"`
`send_style`	string \| null	Send style applied to the message, if any
`media`	array \| null	Media attachments. Each item has `url`, `content_type`, and `size`. URLs for stored inbound media are presigned and expire after 1 hour
`was_downgraded`	boolean \| null	Whether delivery fell back from iMessage to SMS
`status`	string \| null	Delivery lifecycle: `"registered"`, `"pending"`, `"queued"`, `"accepted"`, `"sent"`, `"delivered"`, `"declined"`, `"error"`, or `"received"` for inbound
`error_code`	string \| null	Delivery error code, when delivery failed
`error_message`	string \| null	Short delivery error description
`error_reason`	string \| null	Delivery error reason, when reported
`error_detail`	string \| null	Human-readable detail accompanying the error
`is_read`	boolean	Read state. For inbound messages, set by mark-read
`is_blocked`	boolean	Whether the message was blocked by a contact rule or by default-block in whitelist mode. Identity-scoped API keys never receive rows where this is `true`
`recipients`	array \| null	Per-recipient delivery state for outbound messages, including one entry per group participant; null for inbound. Each entry has `remote_number`, `delivery_status`, `service`, error fields, and `sent_at` / `delivered_at` / `failed_at` timestamps
`reactions`	array \| null	Live tapbacks targeting this message, oldest first. Each entry has `id`, `direction`, `reaction`, `custom_emoji`, `remote_number`, `part_index`, and `created_at`
`created_at`	string (ISO 8601)	Creation timestamp
`updated_at`	string (ISO 8601)	Last update timestamp

Agent signup API

Agent identity API

Agent2Agent API

Message retries

Mail API

Phone API

iMessage API

Slack API

Webhooks API

Tunnels API

Contacts API

Notes API

Vault API

Billing API

Get message

Send message

Query parameters

Request body

Preconditions

Before the first reply

Rate limits

Response (201)

Error responses

List messages

Query parameters

Response (200)

Error responses

Reply to a specific message

Get a reply thread

Response (200)

Upload media

Request

Response (201)

Error responses

Send styles

Message object

​Get message

​Send message

​Query parameters

​Request body

​Preconditions

​Before the first reply

​Rate limits

​Response (201)

​Error responses

​List messages

​Query parameters

​Response (200)

​Error responses

​Reply to a specific message

​Get a reply thread

​Response (200)

​Upload media

​Request

​Response (201)

​Error responses

​Send styles

​Message object

Get message

Send message

Query parameters

Request body

Preconditions

Before the first reply

Rate limits

Response (201)

Error responses

List messages

Query parameters

Response (200)

Error responses

Reply to a specific message

Get a reply thread

Response (200)

Upload media

Request

Response (201)

Error responses

Send styles

Message object