How It Works

DeadDrop is a bidirectional messaging bridge between cloud services and your local AI. No server required.

• Messages flow both ways — Receive Telegram messages in Claude Code. Send alerts from your local LLM to Slack. Both directions, one simple pattern.
• One hub for everything — Email, Telegram, Slack, Discord, GitHub - all flow through the same topic. Configure once, connect everywhere.
• Format conversion on the fly — Post JSON, read Markdown. Write YAML, consume plain text.

The Problem

Your local AI tools (Claude Code, Ollama, Claude Desktop) can’t easily communicate with cloud services. They can’t receive Telegram messages. They can’t send alerts to Slack. They’re behind your firewall with no simple way to bridge the gap.

Current workarounds are painful:

• Tunneling services — New URL every restart, constant reconfiguration
• Custom webhooks — Requires running a server 24/7
• Native integrations — OAuth dance, all-or-nothing access, per-service setup

The Solution

DeadDrop is the rendezvous point between cloud services and local AI.

Telegram ◄──┐                  ┌──► Your Local LLM
Slack ◄─────┼──► DeadDrop ◄────┤    (reads & writes)
Discord ◄───┤                  └──► Your Scripts
Email ──────┘
GitHub ─────┘

Messages flow both ways. Your AI reads when convenient, writes when needed. No always-on infrastructure.

Core Concepts

Topics

Topics are message channels that organize conversations. Each topic:

• Has a unique name within your account
• Stores messages with guaranteed ordering (sequence numbers)
• Supports multiple connections (your AI agents and cloud services)
• Auto-cleans old messages based on your plan’s retention period

Think of topics as message hubs where cloud services and your local AI exchange messages bidirectionally.

Messages

Messages are the atomic units of communication. Each message:

• Receives a unique sequence number for ordering
• Tracks sender identity (which connection sent it)
• Supports multiple formats: JSON, YAML, Markdown, plain text
• Persists until acknowledged by all connections or retention expires

Connections

Connections are instances of integrations attached to a topic. Each connection:

• Links one integration (Telegram, MCP, REST, etc.) to one topic
• Has its own API key or authentication credentials
• Declares permissions: read-only, write-only, or both
• Tracks its position in the message stream (watermark)
• Operates independently of other connections

Think of it this way: Integrations are what DeadDrop supports. Connections are what you create.

Integrations

DeadDrop supports multiple integration types organized into Core (all plans) and Premium (Pro tier).

Core Integrations

Available on all plans including Trial and Basic.

REST API

Direct HTTP access for programmatic control.

• Direction: Pull (read on demand) and push (write anytime)
• Auth: API key in X-API-Key header or URL query parameter
• Use case: Custom scripts, local LLMs, backend services

MCP (Model Context Protocol)

Tool-based access for AI agents using the MCP standard. MCP is now supported by all major AI providers including Anthropic, OpenAI, Google, Microsoft, and Amazon.

• Direction: Pull and push via tool calls
• Tools: write_message, read_messages, acknowledge
• Supported clients: Claude Code, Cursor, GitHub Copilot, Gemini CLI, ChatGPT Desktop, Amazon Q, LM Studio, Open WebUI, Cline, Continue, and 50+ more

Email

Forward emails to your topic.

• Direction: Inbound (emails become messages)
• Setup: Forward to your-topic@in.deaddrop.sh
• Use case: Daily summaries, receipts, alerts — processed by your local AI

Webhooks

HTTP callbacks when new messages arrive.

• Direction: Push-only (DeadDrop calls your endpoint)
• Security: Signed requests for verification
• Use case: Event-driven architectures, serverless functions, n8n

Premium Integrations

Available during Trial (14 days) and on Pro tier ($15/month).

Telegram

Telegram bot integration for mobile control.

• Direction: Bidirectional (receive and send messages)
• Auth: Bot token with webhook validation
• Use case: Mobile control of your local AI, personal alerts, daily braindump

Slack

Native Slack workspace integration.

• Direction: Bidirectional (read from channel, post to channel)
• Auth: OAuth (one-click install)
• Features: Channel selection, mention filtering, link unfurling
• Use case: Team notifications, human-in-the-loop workflows

Discord

Discord bot integration.

• Direction: Bidirectional (receive and send messages)
• Auth: Bot token with OAuth
• Use case: Community AI assistants, gaming bots, dev team alerts

GitHub

GitHub webhook integration.

• Direction: Inbound (issues, PRs, comments, CI events become messages)
• Auth: Webhook with secret verification
• Use case: PR summaries, issue triage, CI failure notifications

Message Flow

Writing Messages

1. Service authenticates with API key or OAuth token
2. Message content validated (size limits, format)
3. Message normalized and stored in database
4. Topic assigns next sequence number
5. WebSocket subscribers notified instantly
6. Push connections (webhooks, Slack, Telegram) receive delivery

Reading Messages

1. Agent authenticates and requests messages
2. DeadDrop returns unread messages since last acknowledgment
3. Content rendered in requested format (JSON, Markdown, etc.)
4. Agent processes messages
5. Agent acknowledges to mark messages as read (or auto-acknowledge)

Acknowledgment

Acknowledgment tells DeadDrop that a connection has processed messages up to a certain point.

• Updates the connection’s read position
• Enables automatic message cleanup
• Supports auto-acknowledge mode for stateless consumers

Example: Telegram to Claude Code

Here’s how the “Telegram to Claude Code” use case works:

1. Setup (once):

   • Create a topic called “mobile-commands”
   • Add a Telegram connection (create bot, connect to topic)
   • Add an MCP connection for your Claude Code session

2. Message flow:

   • You message your Telegram bot: “Check the status of PR #123”
   • Telegram posts to DeadDrop topic
   • Your Claude Code session reads the message via MCP
   • Claude investigates the PR and responds
   • Response posts back to Telegram

3. No infrastructure:

   • Your laptop doesn’t expose any ports
   • Claude Code polls DeadDrop when convenient
   • Works even if you close and reopen Claude Code

Security

Encryption

• In Transit: TLS for all connections
• At Rest: AES-256 encryption for credentials
• Webhooks: Signed requests for verification

Access Control

• Each connection has isolated credentials
• Permissions (read/write) enforced per connection
• API keys rotatable without disrupting other connections

Protection

• Server-Side Request Forgery (SSRF) protection blocks webhooks to private addresses
• Rate limiting prevents abuse (100 requests/min)
• Automatic connection disabling on repeated failures

Plan Limits

Resource limits vary by subscription tier.

Getting Started

1. Sign up — Create your free account at deaddrop.sh
2. Create a topic — Name it based on your use case (e.g., “mobile-commands”, “github-alerts”)
3. Add connections — Start with REST/MCP for your local AI, then add Telegram, email, or GitHub
4. Configure your local AI — Add DeadDrop MCP to Claude Code or use REST from your scripts
5. Start messaging — Cloud services post, your AI reads. Your AI writes, cloud services deliver.

Questions? Email support@deaddrop.sh