Outeract documentation#

Outeract is a unified messaging gateway and event ledger. It connects WhatsApp, Instagram, Telegram, Slack, Discord, SMS, Email and more through a single GraphQL API, and turns every message into a structured, queryable event.

These docs cover connecting a platform, sending and receiving messages, and working with the event ledger, from a five-minute quick start through to the full API reference.

Where to start#

Quick startCreate an app, connect a channel, and send your first message in five minutes. Core conceptsEvents, graph edges, conversations, users and identities. Platform guidesStep-by-step setup for each of the nine supported channels. GraphQL APIEvery query and mutation, with arguments and worked examples. Outbound webhooksReceive events at your own endpoint, signed and retried. Event streamingRead events as they happen over SSE, with lossless resume. How-to guidesFiles, schemas, account linking, health monitoring. ReferenceEvent types, error codes, rate limits and pricing. TroubleshootingSymptom-by-symptom fixes and the debugging tools.

Quick start#

Get up and running in under five minutes:

1. Create an application. Sign in at outeract.com/console and create your first app.

2. Create an API key. In Config → API Keys, create a key with the scopes you need.

3. Connect a platform. In Config → Platforms, connect WhatsApp, Slack, Telegram, or any other channel via OAuth or a bot token.

4. Send your first message:

mutation SendMessage {
  sendMessage(
    recipientUserId: "user-uuid"
    message: "Hello from Outeract!"
    platform: WHATSAPP
  ) {
    id
    eventTypeName
    createdAt
  }
}
curl -X POST https://api.outeract.com/ \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "mutation { sendMessage(recipientUserId: \"user-uuid\", message: \"Hello from Outeract!\", platform: WHATSAPP) { id eventTypeName createdAt } }"
  }'
import requests

response = requests.post(
    "https://api.outeract.com/",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "query": """
            mutation SendMessage($userId: UUID, $message: String) {
              sendMessage(recipientUserId: $userId, message: $message) {
                id
                eventTypeName
              }
            }
        """,
        "variables": {"userId": "user-uuid", "message": "Hello from Outeract!"},
    },
)

print(response.json())

The API is plain GraphQL over HTTP, so no SDK is required. Open api.outeract.com in a browser for the built-in GraphiQL explorer.

Connect a platform#

Nine channels, one API. Each connects with either OAuth or a bot token, and every one of them produces the same message.inbound and message.outbound events.

Discord Token Facebook OAuth Instagram OAuth Email Token Slack Token Telegram Token SMS Token WhatsApp OAuth iMessage Token

How it fits together#

flowchart TB
    Platforms["Messaging platforms<br/>WhatsApp · Slack · Telegram · …"] --> Outeract["Outeract<br/>gateway · event ledger"]
    Outeract -->|signed webhooks| App["Your application"]
    App -->|sendMessage / GraphQL| Outeract
    Outeract -.->|live view| Console["Outeract console"]

Messages flow in from every connected platform, become structured events in the ledger, and reach your application through signed webhook subscriptions or GraphQL queries. Your app sends replies back through the same gateway.

What the docs cover#

Event ledger with graph edges: every message, delivery receipt, and custom event carries typed edges to users, identities, conversations, and files. Query your entire messaging history with filters on type, participant, conversation, and payload.

Auto-created conversations: inbound messages are threaded into conversations automatically, matched on participant sets. No session bookkeeping in your app.

Account linking: connect user identities across platforms with secure link codes, so the WhatsApp user and the Slack user resolve to one person.

Outbound webhooks: subscribe to events with pattern matching (message.*), HMAC-signed payloads, automatic retries, and per-delivery logs.

Custom events & schemas: define your own event types with JSON Schema validation and mix product events into the same ledger.

Health monitoring: per-connection health checks and delivery metrics.

Support#