The story behind BabySea

5 months ago, I set out to build a consumer app that let users generate images and videos using AI. It featured 70+ models, all running on a single provider. The idea was simple: let people pick a model, write a prompt, and get results.

The reality was anything but simple.

Even within the same provider, every model had its own unique schema. One model expects the aspect ratio to be called aspect_ratio. Another calls it image_size. A third expects raw pixel dimensions like 2848x1600. It was the exact same capability, but with three completely different interfaces.

I was writing a custom converter for every single model. Eventually, I surrendered.

And then I thought: why hasn't anyone solved this yet?

There are auto-failover solutions for LLMs everywhere; routers, load balancers, gateway proxies. But none of them solve the actual integration bottleneck for media generation: normalizing the schemas.

Inference providers are where models run directly, and every provider has its own conventions and quirks. Gateway proxies might route your requests, but you still have to write a different request body for each destination.

What if there was a single API that sat in front of all these providers, normalized every schema, and handled failover automatically? What if developers could spend less time wrestling with provider-specific documentation and more time building their products?

So, I stopped building my consumer app and started building the infrastructure layer I wished had existed.

That's BabySea.

BabySea is a unified orchestration API for AI image and video generation. You send a single request using our normalized schema. BabySea translates it to the right provider, routes it based on health and your priority preferences, and returns a perfectly normalized response.

You write your integration once. We handle the rest.

Whether it ran on ReplicateReplicate, Fal, BytePlus, or Cloudflare, the request and response shape is identical. Your code doesn't change when we add a new provider. It doesn't change when a provider updates their API. It doesn't change when you switch models.

I've been on the receiving end of provider outages. Few things are more frustrating than a user hitting "generate" and getting a cryptic 500 error because your only provider went down.

BabySea solves this with automatic multi-provider failover. You define your preferred generation_provider_order and our circuit breaker monitors provider health in real-time. If the primary provider times out or fails, BabySea routes to the next one automatically. If all providers fail, your credits are refunded immediately. You never pay for a failed generation.

To make debugging painless, every failure returns a structured BSE error code with a retryable flag, allowing your app to handle errors programmatically without ever parsing provider-specific error messages.

The TypeScript SDK (npm install babysea) is zero-dependency and works everywhere: Node.js 18+, Edge runtimes, browsers. It has 17 typed methods covering generation, cancellation, cost estimation, health checks, and model library queries. Auto-retry with exponential backoff is built in.

API keys use a secure format with scoped permissions. Four presets let you control exactly what each key can do: Full Access, Generate Only, Read Only, or Monitor Only. Per-key IP allowlisting and configurable expiration give you granular control. Key rotation with grace periods (1 to 168 hours) means you never have downtime during rotation.

Webhooks are cryptographically signed (HMAC-SHA256) with auto-retry, delivery IDs for idempotency, replay protection with a 5-minute timestamp tolerance, and a dead letter queue for events that fail delivery.

Your dashboard shows everything: generation charts by model, provider, and status. API usage with request counts, error rates, and latency. Performance metrics with success rates and average generation time. Credit balance and transaction history.

All metrics support period filtering from 1 day to 60 days. Persistent analytics snapshots survive data retention cleanup, so you never lose historical trends even after raw logs are purged.

Six categories of logs (output files, generation records, API requests, webhook events, activity logs, and credit audit trails) each have plan-based retention ranging from hours to a full year, all viewable in your dashboard.

Team accounts have a three-tier role hierarchy: Primary Owner, Owner, and Member. Role enforcement is applied at both the UI and database level. Credits are shared across the team, and every action is logged in the activity trail.

We are adding new models regularly as providers release them, and our provider network is constantly growing. But right now, our primary focus is making the platform as reliable and performant as possible: faster failovers, lower latency, stronger monitoring, and ensuring every generation completes successfully.

This is day one, and I'm building this in public.