Flow Gate
Unified Message Gateway

High-Performance Messaging Gateway

A Go-powered gateway that seamlessly routes messages between HTTP, WebSocket, MQTT, and SQS-like Queues. Build real-time apps with unified protocol support and flexible billing.

Everything you need for unified messaging

Powerful features designed for developers building connected applications

Go High-Performance

The core gateway is built with Go, offering extreme concurrency and microsecond-level latency.

Intelligent Billing Guard

State-aware usage protection with 1-min memory cache to prevent overage without DB latency.

Multi-Protocol Bridge

Seamlessly bridge HTTP, WebSocket, MQTT, and Queues through a unified routing engine.

SQS-Like Queue Service

Persistent message queues with visibility timeouts, batch operations, and DLQ support.

Cross-Protocol Delivery

Publish once to any protocol and deliver everywhere with automatic hierarchical topic routing.

JWT-Based Security

Secure, granular access control using JWT claims for specific app and topic permissions.

Real-time Monitoring

Track message flows, point consumption, and protocol usage with premium analytics.

Developer First

Clean REST/WS/MQTT APIs that work with your existing tools like cURL, Websocket, and mosquitto.

NATS Powered

Uses NATS JetStream as the backbone for guaranteed delivery and zero message loss.

Supported Protocols

Connect any client through their preferred protocol

HTTP / HTTP SSE

RESTful API for publishing messages and Server-Sent Events for real-time subscriptions

  • POST /api/v1/publish - Send messages
  • GET /api/v1/subscribe/:topic - Receive messages via SSE
  • Perfect for web applications and REST clients

WebSocket

Full-duplex communication channel for interactive real-time applications

  • Single connection for publish and subscribe
  • JSON message format with action types
  • Ideal for chat apps, live dashboards, collaborative tools

MQTT

Lightweight protocol optimized for IoT devices and resource-constrained clients

  • Standard MQTT 3.1.1 support
  • JWT-based authentication via username/password
  • Perfect for IoT, sensors, and embedded systems

How Flow-Gate Works

A unified gateway that bridges different protocols seamlessly

HTTP/SSE

WebSocket

MQTT

Queue (SQS)

Go-Powered Gateway

High-performance routing engine with JWT auth, billing guard, and cross-protocol bridging

HTTP RESTWebSocket NodeMQTT BrokerQueue Service

NATS JetStream

Persistent internal message bus with exactly-once delivery and DLQ support

SSE Streams

WS Messages

MQTT Topics

Persistent Queue

Real-World Use Cases

See how Flow-Gate bridges different protocols in practice

Real-time Web Applications

Build interactive web apps with live updates using HTTP SSE or WebSocket connections

Example: Live dashboards, collaborative tools, notification systems
HTTP SSEWebSocket

IoT & Smart Home

Connect IoT devices through MQTT while web dashboards use WebSocket or HTTP

Example: Smart home automation, sensor monitoring, device control panels
MQTTWebSocketHTTP

Microservices Communication

Enable microservices to communicate regardless of their preferred protocol

Example: Event-driven architectures, service mesh, distributed systems
HTTPWebSocket

Cross-Platform Messaging

Mobile apps, web clients, and embedded devices all communicating seamlessly

Example: Chat applications, multiplayer games, collaborative platforms
WebSocketHTTP SSEMQTT

Notification Systems

Push notifications to any client type through their optimal protocol

Example: Alert systems, status updates, event broadcasting
HTTP SSEWebSocketMQTT

Industrial Monitoring

Industrial equipment using MQTT with web-based monitoring dashboards

Example: Manufacturing monitoring, predictive maintenance, SCADA systems
MQTTWebSocket

Get started in minutes

Unified API for any messaging protocol

HTTP API
# Publish a message via HTTP
curl -X POST "https://api.flow-gate.com/api/v1/publish" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "topic": "notifications",
    "message": "Hello World!"
  }'
WebSocket
// Connect via WebSocket
const ws = new WebSocket('wss://api.flow-gate.com/ws?token=YOUR_JWT_TOKEN');

// Subscribe to topic
ws.send(JSON.stringify({
  action: "subscribe",
  topic: "notifications"
}));

// Publish message
ws.send(JSON.stringify({
  action: "publish",
  topic: "notifications",
  message: "Hello from WebSocket!"
}));

// Receive messages
ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  // data: { action: "message", topic: "notifications", data: "..." }
  console.log('Received:', data);
};
MQTT
# Connect via MQTT using mosquitto
mosquitto_pub -h api.flow-gate.com -p 1883 \
  -u "Bearer" \
  -P "YOUR_JWT_TOKEN" \
  -t "123_myapp_notifications" \
  -m "Hello from MQTT!"

# Subscribe to topic
mosquitto_sub -h api.flow-gate.com -p 1883 \
  -u "Bearer" \
  -P "YOUR_JWT_TOKEN" \
  -t "123_myapp_notifications"
Queue New
# Send message to Queue
curl -X POST "https://api.flow-gate.com/api/v1/queues/myqueue/messages" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d '{"body": "Hello Queue!"}'

# Receive message from Queue
curl -X GET "https://api.flow-gate.com/api/v1/queues/myqueue/messages?waitTimeSeconds=10" \
  -H "Authorization: Bearer YOUR_TOKEN"
Try it live - No API key required
Ready to integrate? Get your JWT token from the dashboard.

Loading high-performance plans...