API-first · DigitalOcean · Redis + SQLite

Team messaging.
Actually affordable.

Relay is a minimal, streaming-first team chat built on DigitalOcean Droplets, Redis, and SQLite. No integrations nobody uses. No enterprise pricing. Just a clean API and conversations that move fast.

api.relay.dev / quickstart
# Create a workspace
POST https://api.relay.dev/v1/workspaces
{
  "name": "acme-corp",
  "plan": "starter"
}

# Send a message
POST https://api.relay.dev/v1/messages
{
  "channel_id": "ch_01HXYZ",
  "text": "Hello, world."
}

# Stream events via SSE
GET https://api.relay.dev/v1/stream
  ?workspace=ws_01HXYZ

✓ 200 OK — 42ms

Slack charges per seat.
We charge per server.

A 10-person team on Slack Pro pays $72.50/month. That same team on Relay BYOI rides a $6/month DigitalOcean Droplet — pass-through infra, not per-seat rent. Want zero ops? Relay Cloud is the same transparent DO bill plus 20% — we run it 100% (uptime, backups, patches, upgrades).

Slack Pro $7.25/user/mo
Published list · per seat · their cloud only
Relay · one workspace, your choice

The default team chat playbook: every hire raises the tab, history and APIs follow paid tiers, and there is no self-hosted escape hatch — you rent the app, the roadmap, and the integration marketplace forever.

Relay BYOI $6/server/mo Your Droplet, your bill, your keys. We ship Relay; you own the box — DigitalOcean’s line-item pricing stays obvious.
Relay Cloud $7.20/server/mo Same published Droplet price × 1.2. We run it 100% — monitoring, backups, patches, upgrades. You chat; we operate.
10 users $72.50 / mo
10 users $6 / mo $7.20 / mo
25 users $181.25 / mo
25 users $6–$12 / mo $7.20–$14.40 / mo
50 users $362.50 / mo
50 users $12 / mo $14.40 / mo
100 users $725.00 / mo
100 users $18–$24 / mo $21.60–$28.80 / mo
Message history 90 days (free tier)
Message history Unlimited (SQLite)
API access Restricted on free
API access Full access, always
Integration cost Baked into pricing
Integration cost Build your own, free
Who runs the server Slack · their cloud only
Who runs the server You · your DO account Relay · fully managed

Monthly burn · same headcount

Slack bills per seat. Relay bills per server.

Relay · tap to compare
Slack Pro — $7.25/user/mo list · every teammate multiplies the bill. Bars below: Slack = full width; Relay = actual share of that Slack total (same row).
Relay BYOI $6/server/mo Pass-through Droplet pricing. You operate the box.
Relay Cloud $7.20/server/mo DO list × 1.2 — we run it 100%.
Slack total Relay total

Shared axis on every row: $0–$725/mo (100 people × $7.25 Slack Pro list). Bar length = that dollar amount ÷ $725.

10 users
Slack
$72.50
Relay
$6
Relay
$7.20
25 users
Slack
$181.25
Relay
$6–$12
Relay
$7.20–$14.40
50 users
Slack
$362.50
Relay
$12
Relay
$14.40
100 users
Slack
$725
Relay
$18–$24
Relay
$21.60–$28.80

25 & 100-seat Relay bars use the midpoint of the Droplet tier range vs Slack list. Ranges are labeled on the bar.

Also not even close

Message history 90 days ✓ Unlimited
API access Gated ✓ Always on
Integration cost In the rent ✓ Build your own
Who runs the server Slack only ✓ You (DO)✓ Relay ops

Add-on

Disaster recovery · Neon cold archive

Off-Droplet backup and replay-friendly archive storage piggybacks on Neon’s published pricing — serverless Postgres, branches, and storage exactly as they list it. Pick who holds the connection string: you, or us.

BYO Neon

Your connection string

Paste your Neon Postgres URL into Relay. You pay Neon directly at neon.com/pricing; we route cold archive and DR targets to your project — no markup on their line items.

Relay managed · +20%

We run Neon for you

We provision, monitor, and operate the Neon side — still billed at their public rates, plus 20% for our lifecycle work (scaling cues, failover drills, credential rotation, on-call). Same transparency model as Relay Cloud on the Droplet.

Optional on every workspace. Stacks with Relay BYOI or Relay Cloud — flip the toggle above; this add-on is orthogonal.

While we’re here: enterprise Slack is a procurement saga, a SSO tax, a 90-day history ransom on “free,” and a marketplace of integrations you could ship yourself before the kickoff call ends. Relay is chat infrastructure — not a platform rent-seeking on every seat.

Same headcount · different physics

Enterprise Slack isn’t priced like software — it’s priced like a second office lease.

Illustrative 500-person org. Slack bar uses common published Business+–style list pricing (~$12.50/user/mo). Relay bar: one Scale Droplet on your account — $48/mo list, whole workspace. Your Slack contract may differ; the shape of the chart won’t.

Illustrative 500-person org. Slack bar uses common published Business+–style list pricing (~$12.50/user/mo). Relay bar: same box fully managed — list $48/mo × 1.2 = $57.60/mo. Your Slack contract may differ; the shape of the chart won’t.

Slack · 500 × $12.50 list $6,250 / mo

Bar = 100% — this is the burn you’re normalizing.

Relay BYOI · Scale Droplet (500 seats) $48 / mo

~0.77% of the Slack bar — true proportion ($48 ÷ $6,250). Bar is barely visible on purpose.

Relay Cloud · same box, fully managed (+20%) $57.60 / mo

~0.92% of the Slack bar — coffee budget for one VP; chat for five hundred people.

Baseline Slack burn here: $6,250/mo (500 × $12.50 list). For Relay BYOI at $48/mo: monthly difference (Slack − Relay), yearly cash kept (×12), and percent vs that Slack line — plus the ratio.

Baseline Slack burn here: $6,250/mo (500 × $12.50 list). For Relay Cloud at $57.60/mo: monthly difference (Slack − Relay), yearly cash kept (×12), and percent vs that Slack line — plus the ratio.

Relay BYOIYour Droplet · $48/mo

$6,202/mo less than Slack (monthly difference)

$74,424/yr total not spent vs Slack, same headcount

99.23% lower than Slack · Relay is 0.77% of Slack’s tab · ~130.2× cheaper

Relay CloudFully managed · $57.60/mo

$6,192.40/mo less than Slack (monthly difference)

$74,308.80/yr total not spent vs Slack, same headcount

99.08% lower than Slack · Relay is 0.92% of Slack’s tab · ~108.5× cheaper

Checks: $6,250 − $48 = $6,202; ×12 = $74,424; savings ÷ $6,250 = 99.23%. Ratio: $6,250 ÷ $48 ≈ 130.2×. Not financial advice — illustrative list math.

Checks: $6,250 − $57.60 = $6,192.40; ×12 = $74,308.80; savings ÷ $6,250 = 99.08%. Ratio: $6,250 ÷ $57.60 ≈ 108.5×. Not financial advice — illustrative list math.

Built on primitives.
Nothing you don't need.

01 — Compute

DigitalOcean Droplet

Your workspace runs on a single Droplet. Start at $4/mo (512 MiB) and scale vertically as you grow. Each workspace gets its own isolated instance.

$4–$96 / mo
02 — Real-time

Redis Pub/Sub

All live message delivery runs through Redis. Channel subscriptions, presence, typing indicators, and SSE event fanout. Sub-20ms delivery.

Hot path
03 — Persistence

SQLite (hot)

Recent messages, channel metadata, and user state stored in SQLite on the Droplet's SSD. Blazing-fast local reads. WAL mode for concurrent writes.

Hot storage
04 — Archive

Neon Postgres

Messages older than your retention threshold are archived to Neon serverless Postgres. Cold reads on-demand via the same API — zero data loss. Spend follows Neon’s pricing page; optional DR add-on (your connection string vs our +20% managed Neon).

Cold archive
05 — Interface

REST + SSE API

Every feature is a first-class API endpoint. Build your own client, automate workflows, or integrate with anything. OpenAI-compatible tool schemas for AI agents.

API-first
06 — Intelligence

AI-ready Tooling

Relay's API follows OpenAI function-calling conventions. Drop an AI agent into any channel as a participant. Webhooks, tool schemas, and structured responses built in.

OpenAI-compatible

Pick your Droplet.
Scale when you need to.

Each tier hosts one Relay workspace. Upgrade by resizing your Droplet — your data stays put. The $6/mo tier handles most small teams comfortably.

TierMemoryvCPUsSSDTransferCost~Max UsersCost/User (50 users)Notes
Nano512 MiB110 GiB500 GiB$4/mo~15Dev / testing
Starter1 GiB125 GiB1,000 GiB$6/mo~30$0.20⭐ Most teams start here
Standard2 GiB150 GiB2,000 GiB$12/mo~75$0.16Small company
Growth2 GiB260 GiB3,000 GiB$18/mo~150$0.12Active mid-size
Pro4 GiB280 GiB4,000 GiB$24/mo~300$0.08High-traffic workspace
Scale8 GiB4160 GiB5,000 GiB$48/mo~750$0.064Community / large org
Cluster16 GiB8320 GiB6,000 GiB$96/mo~2000+$0.048Enterprise self-hosted

Redis-first streaming.
Events, not polling.

Clients subscribe to an SSE stream. Redis Pub/Sub fans out events across all connected clients in a workspace. No WebSocket complexity — just a persistent HTTP connection.

14:32:01.042 message.created channel=#engineering  author=tyler  text="just deployed v2.1"
14:32:01.089 presence.update user=sarah  status=online  workspace=ws_01HXYZ
14:32:02.310 typing.start channel=#engineering  user=sarah
14:32:04.881 message.created channel=#engineering  author=sarah  text="🎉 nice work"
14:32:04.883 reaction.added message=msg_01HABC  emoji=🚀  user=marcus
14:32:05.001 ai.response bot=relay-bot  channel=#engineering  streaming=true

Hot-cold storage.
Reads always fast. History never lost.

Client Web, mobile, or API consumer sends message
API Layer Validates auth, parses request, assigns IDs
Redis Publishes to channel subscribers instantly
SQLite Persists to local hot store (WAL mode)
Neon Archives old messages to serverless Postgres
Hot Path (Redis)
All active channel messages live in Redis for instant Pub/Sub fanout. TTL-based eviction keeps memory lean. Presence and typing use ephemeral keys.
Warm Store (SQLite)
Local SSD SQLite in WAL mode handles concurrent reads and writes. Recent history (configurable 30–90 days) lives here. Zero network overhead for reads.
Cold Archive (Neon)
Neon serverless Postgres archives the full message history. Queries against archived data are served transparently through the same /messages API.

The full API.
Documented before a line was written.

This documentation was written first. Every endpoint here is the spec. The implementation follows it — not the other way around.

Authentication Authorization: Bearer <RELAY_API_KEY>

All requests require a Bearer token. Tokens are workspace-scoped — generate from the dashboard or via /auth/token.

Create a new workspace. Provisions an isolated namespace, default channels, and an admin user. Returns the workspace object with provisioning status.

ParameterTypeRequiredDescription
namestringrequiredUnique workspace slug (lowercase, hyphens OK)
display_namestringrequiredHuman-readable workspace name
planenumoptionalstarter | standard | pro | scale
admin_emailstringrequiredEmail of initial workspace admin
regionstringoptionalDO datacenter region slug (e.g. nyc3, sfo3)
Request
{
  "name": "acme-corp",
  "display_name": "Acme Corp",
  "plan": "starter",
  "admin_email": "tyler@acme.com",
  "region": "nyc3"
}
200 OK
{
  "id": "ws_01HXYZ4RELAY",
  "name": "acme-corp",
  "plan": "starter",
  "region": "nyc3",
  "created_at": "2026-04-28T09:00:00Z",
  "status": "provisioning",
  "api_key": "rly_live_sk_...",
  "stream_url": "https://ws_01HXYZ4RELAY.relay.dev/v1/stream"
}
422 Validation Error
{
  "error": "validation_error",
  "message": "Workspace name already taken",
  "field": "name"
}

Retrieve workspace details by ID. Includes provisioning status, plan, region, and member count.

Path ParamTypeRequiredDescription
idstringrequiredWorkspace ID (ws_...)

List all channels in the workspace. Supports filtering by type (public/private/dm) and membership.

Query ParamTypeRequiredDescription
typeenumoptionalpublic | private | dm
member_ofbooleanoptionalOnly return channels the authenticated user belongs to
cursorstringoptionalPagination cursor from previous response
limitintegeroptionalResults per page (default: 50, max: 200)

Create a new channel. Public channels are discoverable by all workspace members. Private channels require explicit membership.

ParameterTypeRequiredDescription
namestringrequiredChannel name (lowercase, hyphens, no spaces)
typeenumoptionalpublic (default) | private
descriptionstringoptionalChannel purpose/description
member_idsstring[]optionalInitial member user IDs

Join a public channel. For private channels, membership must be granted by a channel admin.

Path ParamTypeRequiredDescription
idstringrequiredChannel ID (ch_...)

Post a message to a channel or DM thread. Supports plain text, Markdown, file attachments, and structured blocks. Message is instantly fanned out via Redis Pub/Sub to all connected subscribers.

ParameterTypeRequiredDescription
channel_idstringrequiredTarget channel ID (ch_...) or DM ID (dm_...)
textstringrequired*Message body. Markdown supported. *Required if blocks not provided
blocksBlock[]optionalStructured message blocks (see Block Schema)
thread_idstringoptionalReply in a thread by referencing a parent message ID
attachmentsAttachment[]optionalFile or link attachments
metadataobjectoptionalArbitrary JSON metadata (stored, queryable)
Request — with blocks
{
  "channel_id": "ch_01HXYZ",
  "text": "Deploy summary",
  "blocks": [
    { "type": "header", "text": "v2.1 deployed successfully" },
    { "type": "section", "text": "Environment: **production**\nDuration: 42s\nStatus: ✅" },
    { "type": "actions", "elements": [
      { "type": "button", "text": "View logs", "url": "https://logs.acme.com" }
    ]}
  ]
}

Retrieve messages for a channel. Hot messages are served from SQLite. Queries spanning the archive threshold are transparently merged with Neon Postgres results.

Query ParamTypeRequiredDescription
channel_idstringrequiredTarget channel or DM ID
beforeISO 8601optionalFetch messages before this timestamp
afterISO 8601optionalFetch messages after this timestamp
limitintegeroptionalMax messages returned (default: 50, max: 500)
include_threadsbooleanoptionalInclude threaded replies inline

Edit the content of an existing message. Only the message author or workspace admins may edit. Edits are recorded in the message's edit_history.

ParameterTypeRequiredDescription
textstringoptionalNew message text
blocksBlock[]optionalUpdated structured blocks

Soft-delete a message. The message is replaced with a tombstone in the channel. Permanently deleted after the workspace retention period.

Path ParamTypeRequiredDescription
idstringrequiredMessage ID (msg_...)

Send an invitation email to a new workspace member. Generates a one-time invite token valid for 7 days.

ParameterTypeRequiredDescription
emailstringrequiredEmail address to invite
roleenumoptionalmember (default) | admin
channel_idsstring[]optionalAuto-join these channels on first login

Returns presence status for all or specified workspace members. Backed by Redis TTL keys — refreshed every 30s by connected clients.

Query ParamTypeRequiredDescription
user_idsstringoptionalComma-separated user IDs (omit for all members)

Open a Server-Sent Events stream for the workspace. The client receives a real-time feed of all events the authenticated user is permitted to receive. Redis Pub/Sub fans out internally; clients see a clean SSE stream.

Query ParamTypeRequiredDescription
workspace_idstringrequiredTarget workspace ID
channelsstringoptionalComma-separated channel IDs to filter stream
eventsstringoptionalComma-separated event types (default: all)
last_event_idstringoptionalResume from last received event (SSE standard)
SSE Event Types
// message.created
data: {"type":"message.created","id":"evt_01H...","data":{"message":{...}}}

// typing.start / typing.stop
data: {"type":"typing.start","id":"evt_01H...","data":{"user_id":"usr_...","channel_id":"ch_..."}}

// presence.update
data: {"type":"presence.update","id":"evt_01H...","data":{"user_id":"usr_...","status":"online"}}

// ai.response (streaming token)
data: {"type":"ai.response","id":"evt_01H...","data":{"bot_id":"bot_...","token":"Hello","done":false}}

Register an AI bot or integration participant. Bots receive messages via webhook and can post back using the standard messages API. Tool schemas follow the OpenAI function-calling format.

ParameterTypeRequiredDescription
namestringrequiredBot display name
webhook_urlstringrequiredHTTPS endpoint to receive message events
toolsTool[]optionalOpenAI-compatible tool/function schemas the bot exposes
channelsstring[]optionalChannel IDs the bot is a member of
mention_onlybooleanoptionalOnly trigger webhook on @mention (default: false)
OpenAI-compatible Tool Schema
{
  "name": "deploy-bot",
  "webhook_url": "https://your-server.com/relay-hook",
  "mention_only": true,
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_deployment_status",
        "description": "Get the current deployment status for an environment",
        "parameters": {
          "type": "object",
          "properties": {
            "environment": { "type": "string", "enum": ["production","staging","dev"] }
          },
          "required": ["environment"]
        }
      }
    }
  ]
}

Returns the OpenAI-compatible tool schema array for a registered bot. Used by AI agents to discover callable functions in a channel.

Register an outbound webhook. Relay will POST event payloads to your endpoint when specified events occur. HMAC-SHA256 signed with your webhook secret.

ParameterTypeRequiredDescription
urlstringrequiredHTTPS endpoint to receive webhook payloads
eventsstring[]requiredEvent types to subscribe to (e.g. ["message.created","reaction.added"])
channel_idsstring[]optionalScope webhook to specific channels
secretstringoptionalHMAC signing secret for payload verification

No bloat.
Add exactly what you need.

AI makes integrations trivial to build.
We don't charge for them.

Slack's pricing model bundles integrations you'll never use into the cost of messaging. In 2026, connecting two services is a 10-minute GPT task. Relay provides the webhook surface and the bot API — you own the integrations.

Want us to build one? We can. Want to build it yourself? The API is everything you need. The architecture is intentionally open-ended: bots are just webhook listeners that speak the Relay message format.

There's no app directory to unlock, no per-seat fee for GitHub notifications, no enterprise tier required to connect your CI pipeline. Register a bot, point it at your server, and write 20 lines of code.

relay-bot (AI) Built-in

GPT-4o-powered assistant in every workspace. @mention to ask questions, summarize threads, draft replies, or run custom tools.

Webhooks Built-in

HMAC-signed outbound webhooks for any event. The foundation for every integration you'll ever build.

GitHub / GitLab Community

Post PR, issue, and deployment events to channels. Open-source template — deploy in minutes on your own infra.

PagerDuty / alerts Community

Route on-call alerts to Relay channels. Acknowledge directly from the API. Template available.

Your integration Custom

Register a bot, point a webhook at your server, use the /bots API. You build it in an afternoon. We're here if you need help.