Early access · Limited spots

One stream.
Every event.

Stop stitching together webhooks, queues, and message brokers. Mycelo is a unified event streaming platform — inbound, internal pub/sub, and outbound delivery through a single API.

✓ At-least-once delivery✓ Per-event pricing

// join the waitlist

No spam. No credit card. Just early access.

↓

Inbound webhooks

Receive events from Stripe, GitHub, Razorpay with automatic verification, retries, and fan-out to your internal streams.

⇄

Internal pub/sub

Topic-based streaming between your services. Persistent, replayable, with per-tenant isolation.

↑

Outbound delivery

Push events to customer endpoints with exponential backoff, dead letter queues, and full delivery observability.

// the problem

Three products. One primitive.

The market split a single concept — the event stream — into three separate product categories. You're paying for all three and gluing them together yourself.

TodayThe fragmented stack

✕Webhook receiver + message broker + outbound delivery — three vendors, three APIs, three billing relationships

✕Events get lost at the seams between systems

✕No unified observability across the full event lifecycle

✕Idle cluster costs even when traffic is zero

MyceloOne unified stream

✓Single API, single mental model for inbound, internal, and outbound events

✓Event traced end-to-end from source to consumer with full lineage

✓Built-in retries, DLQs, and delivery guarantees at every hop

✓Per-event pricing — pay for what you use, nothing when idle

// how it works

The stream is the spine.

Every event — regardless of where it comes from or where it's going — flows through the same durable, ordered log.

inbound

Event arrives

From a third-party webhook, your own service, or a connected source. Verified, deduplicated, and committed to the stream.

stream

Persisted to the log

Append-only, durable, ordered. Each topic is isolated per tenant. Replay from any offset, any time.

outbound

Delivered to consumers

Internal services via pub/sub, or external endpoints via outbound webhooks. Retries, backoff, and dead letter queues included.

// quickstart

Up in minutes.

One SDK. Publish, subscribe, deliver. No cluster config, no ZooKeeper, no ops team required.

quickstart.py

from mycelo import Client

# one client. inbound, pub/sub, and outbound.
client = Client("mc_live_...")

# publish an event to a topic
client.topics["orders.created"].publish({
  "order_id": "ord_8f2k",
  "amount": 2499,
  "currency": "INR"
})

# subscribe internally
@client.subscribe("orders.created")
def handle_order(event):
  fulfill(event.data)

# deliver outbound to your customer's endpoint
client.webhooks.send(
  endpoint="https://customer.com/hooks",
  topic="orders.created"
)

Stop gluing. Start streaming.

Join the waitlist and be first when Mycelo opens for early access.