Layer 8 networking for your API calls
Not an API gateway. An API Aqueduct™ — bidirectional flow control for requests and responses. Built on 40-year-old telecom-grade BEAM with a new Gleam.
Two Protocols:
STREAM (TCP)
Reliable delivery. Queue 429s. Retry 500s. Guaranteed completion.
TORRENT (UDP)
Speed over reliability. Race 3 regions. First wins. Sub-80ms.
Closed beta. Free tier (1M requests) coming after first enterprise customer.
Beta Status: Running 9 machines across 3 regions on Fly.io's edge network. Working with design partners to perfect the protocols before public launch.
Every API can fail. Your workflows shouldn't.
Your agents call dozens of APIs per workflow. One 429 error crashes the entire sequence. Restart from scratch. Lose all context.
❌ Without EZThrottle:
✅ With EZThrottle:
Your ETL jobs process millions of records across multiple APIs. Manual rate limiting is slow, brittle, and loses data on failures.
❌ Without EZThrottle:
✅ With EZThrottle:
Your checkout flow calls 5+ APIs. Payment succeeds, but if fulfillment fails, orders are orphaned. Manual cleanup required.
❌ Without EZThrottle:
✅ With EZThrottle:
Your APIs can fail. Your workflows won't.
STREAM for reliability. TORRENT for speed. Layer 8 networking.
Request Beta AccessFlow control in both directions
AWS API Gateway, Kong, Nginx — great for routing, terrible for reliability.
EZThrottle — built for reliability from the ground up.
Requests flow from you → EZThrottle → APIs. Smooth, controlled, rate-limited.
Responses flow from APIs → EZThrottle → You. Deduplicated, validated, delivered.
Buffer bursts, smooth peaks, prevent overload. Like Roman castellum tanks.
Choose reliability or speed. We handle the rest.
Like TCP for APIs
Reliable delivery. Guaranteed completion. Your request will succeed, even if it takes hours.
// STREAM: Guaranteed delivery
const result = await ezthrottle.stream({
url: "https://api.openai.com/chat",
body: { prompt: "..." },
timeout: "1h" // How long to keep trying
});
// Returns: When completed (might be queued)
// Guarantee: Will succeed or timeout
Perfect For:
Like UDP for APIs
Speed over reliability. Race multiple regions. First response wins. Sub-80ms latency.
// TORRENT: Fastest response
const result = await ezthrottle.torrent({
url: "https://api.anthropic.com/complete",
body: { prompt: "..." },
regions: ["us-east", "us-west", "eu-west"]
});
// Returns: Immediately (first to respond)
// Guarantee: Speed, not reliability
Perfect For:
Use Both in the Same App
STREAM for your background jobs. TORRENT for your interactive UI. One network. One bill. Your choice.
Layer 8 networking with BEAM reliability
// Your code makes 100 requests/sec
for (let i = 0; i < items.length; i++) {
await api.post('/process', items[i])
// ❌ 429 Rate Limit Exceeded
// Your app crashes
}Result: Process fails. Data lost. Manual restart required.
// Same code, proxied through EZThrottle
for (let i = 0; i < items.length; i++) {
await ezthrottle.stream.post('/process', items[i])
// ✓ Automatically queued if rate limited
// ✓ Retried on failures
}Result: Process completes. No crashes. Zero manual intervention.
Proxied to EZThrottle's edge network (9 machines, 3 regions)
Distributed Syn process finds the least-busy queue across our cluster
STREAM (reliable) or TORRENT (fast) based on your call
STREAM: Queue if needed. TORRENT: Race 3 regions parallel.
Get response, trigger webhook if configured, return to client
💡 Why BEAM? Erlang/OTP has powered telecom systems for 40 years with 99.9999999% uptime. WhatsApp handles 2 billion users on BEAM. Discord serves 150 million concurrent connections. If it's reliable enough for them, it's reliable enough for your API calls.
Python, Node.js, and Go SDKs for both protocols
from ezthrottle import EZThrottle
client = EZThrottle("your_key")
# STREAM: Reliable delivery
resp = client.stream.post(
url="https://api.openai.com/chat",
json={"prompt": "..."}
)
# TORRENT: Fast delivery
resp = client.torrent.post(
url="https://api.anthropic.com/complete",
json={"prompt": "..."},
regions=["us-east", "us-west", "eu"]
)const { EZThrottle } =
require('ezthrottle');
const ez = new EZThrottle('key');
// STREAM: Reliable
const r1 = await ez.stream.post({
url: 'https://api.openai.com/chat',
json: { prompt: '...' }
});
// TORRENT: Fast
const r2 = await ez.torrent.post({
url: 'https://api.anthropic.com',
json: { prompt: '...' },
regions: ['us-east', 'us-west']
});import ez "github.com/rjpruitt16/
ezthrottle-sdk/go"
client := ez.NewClient("key")
// STREAM: Reliable
resp1, _ := client.Stream.Post(
"https://api.openai.com/chat",
map[string]any{"prompt": "..."},
)
// TORRENT: Fast
resp2, _ := client.Torrent.Post(
"https://api.anthropic.com",
map[string]any{"prompt": "..."},
[]string{"us-east", "us-west"},
)All SDKs support:
With a new Gleam ✨
40 Years of Telecom Reliability
Erlang/OTP has powered telecom systems since 1986. 99.9999999% uptime. Nine nines. Proven at scale.
WhatsApp: 2 Billion Users on BEAM
50 engineers serving 2 billion users. All on BEAM. If it scales for them, it scales for your API calls.
Discord: 150M Concurrent Connections
Real-time messaging at insane scale. BEAM handles it. Your API requests? Child's play.
Type Safety on BEAM
Rust-like type system. No runtime errors. Catch bugs at compile time. Ship with confidence.
Modern DX, Proven Runtime
Gleam compiles to BEAM bytecode. Best of both worlds: modern language, 40-year-old battle-tested runtime.
Built for Concurrency
Actors, supervision trees, distributed coordination. BEAM's primitives + Gleam's safety = reliable infrastructure.
"BEAM with a new Gleam" isn't just marketing.
It's 40 years of telecom reliability + modern type safety. Infrastructure built to last 2,000 years, like Roman aqueducts.
Layer 8 is just the beginning
TCP for APIs. Reliable delivery.
UDP for APIs. Speed over reliability.
Bidirectional streaming for AI agents.
APIs are the nervous system of modern software. They need their own protocol layer. We're building it.
Reliability. Like TCP.
Speed. Like UDP.
State. Like... nothing that exists.
Early design partners shape the roadmap
✓ Requests processed in-memory only
✓ No database storage of request/response data
✓ Webhooks deliver results directly to you
✓ Automatic deletion if temporary storage ever needed
Built on open-source Gleam + BEAM. Code transparency for security-conscious teams. Your data flows through, never stays.
Our landing page, FAQ, and beta process are all open source on GitHub.
We use email templates for beta requests. No hidden questions, no surprises. You can see the exact template before you apply.
"We're building with design partners. We want to know who we're building with."
Read the README • See beta email template • Fork if you want
We need production workloads to stress-test Layer 8 networking.
Translation: We're looking for serious companies with serious API problems. If 429s and 500s are costing you real money, let's talk.
This is infrastructure. Not a side project. We need partners who get that.
$1,500 value
Enough volume to properly evaluate both STREAM and TORRENT protocols under load.
With founder
Not support tickets. Real-time debugging with the person building this.
Your feedback = features
Need something specific? We'll build it. Your use case drives the roadmap.
Lock in early pricing forever. When we raise rates (we will), you don't pay more. Early bet = permanent discount.
If it works well, we'll write a case study together. Your success story = our credibility. Win-win marketing.
This is what we'll charge once beta ends. Beta partners get better terms.
$0.0015
per request
(Cheaper than sending an SMS)
Small
$15
10K requests/mo
Startup
$150
100K requests/mo
Growth
$1.5K
1M requests/mo
Scale
$15K
10M requests/mo
Volume discounts at 50M+. Enterprise custom pricing available.
We need 5-10 enterprise design partners with real production workloads.
Before you apply, ask yourself:
If you answered yes to all 5, we want to talk to you.
Limited to 5-10 partners. First-come, first-served for qualified companies.
Honest truth: EZThrottle works great in testing. But we're solo-founder-built infrastructure. We need real production workloads to find the edge cases we haven't thought of.
Your 429s and 500s will help us build better failover logic. Your burst traffic will help us tune our queueing. Your multi-region needs will help us optimize routing.
In exchange? You get infrastructure that actually works, direct access to the founder, and locked-in pricing when we raise rates. We both win.
TCP for reliability. UDP for speed. Built on 40-year-old BEAM with a new Gleam.
Not an API gateway. An API Aqueduct™
Request Beta Access →Closed beta. Limited spots. Building with design partners.