canonical: https://jentic.com/apis/blooio.com/blooio

# Blooio v4 API

The Blooio v4 API sends and receives messages across iMessage, SMS, RCS, WhatsApp, and Apple Messages for Business from one interface. An agent finds or creates a chat, sends messages on a chosen channel, and reads message status, reactions, and polls. It manages channels, contacts and their identities, groups, and webhooks, and exposes a unified event feed so a single feed carries activity from every channel.

## For AI agents

Send and receive messages across iMessage, SMS, RCS, WhatsApp, and Apple Messages for Business: manage chats, contacts, groups, polls, reactions, webhooks, and a unified event feed.

## Scope

Does not run voice calls, email campaigns, or video conferencing. Use for multi-channel text messaging across iMessage, SMS, RCS, and WhatsApp only.

## Capabilities

- Send messages across iMessage, SMS, RCS, WhatsApp, and Apple Messages for Business channels
- Find or create a chat and list its messages
- Create contacts and attach identities to them
- Send polls and record reactions in a chat
- Create groups and manage their members
- Register webhooks and replay their deliveries
- Look up a phone number's reachability and capabilities

## Use cases

### Agent-run multi-channel messaging

An AI assistant reaches a customer on whatever channel works. Through Jentic the agent finds or creates a chat and sends a message over iMessage, SMS, RCS, or WhatsApp, letting the chat pick the channel or targeting a specific one. It then reads message status and reactions to confirm delivery, all through one interface instead of one SDK per channel.

Example prompt: Find or create a chat with a contact and send a message, then read its status to confirm it was delivered

### Unified inbound handling

A support bot works one feed instead of many webhooks. Blooio exposes a unified event feed and webhooks that carry message events, reactions, and deliveries from every channel, so an agent subscribes once and handles inbound messages regardless of where they came from. Webhook deliveries can be replayed if a handler misses one.

Example prompt: Register a webhook for message events, then replay a missed delivery when a handler reports a gap

### Contact and number intelligence

An agent checks who it can reach and how. The phone-number lookup reports a number's reachability and capabilities, and contacts carry identities across channels, so before sending the agent knows whether a number supports RCS or iMessage. This avoids a failed send on a channel the recipient cannot receive.

Example prompt: Look up a phone number's capabilities and send over the channel it supports, falling back to SMS when it does not

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/messages` | Send a message |
| GET | `/chats` | List chats |
| POST | `/chats` | Find or create a chat |
| POST | `/chats/{chatId}/messages` | Send a message to a chat |
| POST | `/channels/{channel}/messages` | Send a message on a specific channel |
| GET | `/contacts` | List contacts |
| POST | `/contacts` | Create a contact |
| POST | `/webhooks` | Create a webhook |

## Key resources

- **Channels** — List channels, read capabilities and health, and update settings
- **Chats** — Find or create chats, read and send messages, and send polls
- **Contacts** — Create contacts and attach cross-channel identities
- **Groups** — Create groups and manage their members and icons
- **Webhooks** — Register webhooks and replay their deliveries

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 61 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 50 / 100
  - Developer Experience & Jentic Compatibility: 61 / 100
  - AI-Readiness & Agent Experience: 54 / 100
  - Agent Usability: 83 / 100
  - Security: 60 / 100
  - AI Discoverability: 71 / 100
- **View full report:** https://jentic.com/apis/blooio.com/blooio/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring the Blooio v4 API by hand means handling its bearer API key, choosing the right channel for each message across iMessage, SMS, RCS, and WhatsApp, and tracking webhook deliveries and the unified event feed yourself. Through Jentic you install once, import it from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** The Blooio v4 API puts the channel and chat ids in the URL path (`/channels/{channel}`, `/chats/{chatId}`), so a rule can pin your agent to one channel or chat: it can send and read messages there without reaching contact deletion or API-key management. You choose the operations it may call, so destructive ones like removing a channel or deprecating an API key are not included unless you add them.
- **Credential handling:** Your Blooio API key is held once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'send a message' or 'look up a phone number', and Jentic returns the matching Blooio operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Twilio** — Programmable SMS, voice, and messaging across channels
- **Sinch** — SMS, RCS, and conversation APIs across channels
- **Telnyx** — Messaging and voice over a private carrier network
- **Plivo** — SMS and voice APIs for high-volume messaging

## FAQ

### What authentication does the Blooio v4 API use?

The Blooio v4 API authenticates with an API key sent as a bearer token in the Authorization header per its OpenAPI spec. Through Jentic the key is injected at call time by your own Jentic One instance, so it never enters the agent's prompt or logs.

### Can I send a WhatsApp message with the Blooio v4 API?

Yes. Blooio is multi-channel: the send-message operations deliver over iMessage, SMS, RCS, WhatsApp, and Apple Messages for Business, and you can send on a specific channel or let a chat pick one. Each channel's capabilities endpoint reports what that line supports.

### What are the rate limits for the Blooio v4 API?

The OpenAPI spec does not specify rate limits. Check the Blooio documentation at https://blooio.com for current limits and per-channel throughput before sending at volume.

### Is there a Blooio MCP server?

You don't need an MCP server to give your agent the Blooio v4 API. Jentic connects it directly from the API Directory: import it, store your key once, and your agent calls it, so you skip installing and syncing a separate server.

### Can I limit what my agent is allowed to do with the Blooio v4 API?

Yes. Write a rule that allows only the send-message and chat-read operations for one channel, so your agent can send and follow conversations there but cannot delete contacts or rotate webhook secrets. Every call it makes is logged.

### How do I send a message with the Blooio v4 API through Jentic?

Search Jentic for 'send a message' and it returns the send operation with its input schema; the agent passes the recipient and body and Blooio routes it over the chosen channel. To run it on your own infrastructure, install Jentic One from its GitHub repo.
