Working with AI image generation is supposed to be easy. Pick a model, call an API, get an image back. Done.
That's what we thought when we started building an object-based image editor late last year. The editor would let you manipulate individual elements on a canvas—move them, transform them, generate new ones with AI. We figured the AI integration would be the straightforward part.
It wasn't.
For some operations, we had to chain up to five models—one to understand the scene, another to segment objects, a third to generate replacements, and so on. Each model had different strengths, and figuring out which one handled which task well meant constant experimentation. And since not every model was available on every provider, we found ourselves integrating with multiple providers just to access the models we needed.
That's where things got messy. Every model and provider had its own way of doing things. One model expected size as a string like "1024x1024", another wanted an aspect_ratio combined with a resolution. Some returned images as base64, others gave you a URL. Some were synchronous, others required polling. Error formats were all different. If you wanted WebP but the model only generated PNG? Your problem.
We kept writing adapter code, normalizing responses, handling edge cases. Every new model or provider added another layer of complexity.
Here's the thing: with LLMs writing code for you these days, the code itself isn't really the hard problem anymore. You can scaffold an integration in minutes. But the devil is in the details. The subtle differences between providers. The format conversions. The error handling. The polling logic. Building and maintaining that infrastructure—just to be able to test different models, try new providers, and switch things around—was still annoying, error-prone, and time-consuming.
The image editor wasn't the hard problem. The infrastructure between your code and the models was. And every developer working with AI image generation was building it from scratch.
So we built Lumenfall.
One API, every model
Lumenfall is a unified API for AI image generation. One API call, and we handle the differences between providers—Google Vertex AI, Gemini, OpenAI, Replicate, fal.ai, Fireworks AI, Runware, and xAI.
It's OpenAI-compatible. If you already use the OpenAI SDK, change the base URL, swap in your Lumenfall API key, and everything works.
from openai import OpenAI
client = OpenAI(
api_key="lmnfl_...",
base_url="https://api.lumenfall.ai/openai/v1"
)
response = client.images.generate(
model="flux-2-max",
prompt="A mountain cabin at sunset",
size="1792x1024",
output_format="webp",
output_compression=85
)
Switch the model parameter, and you're using a completely different provider. No code changes. Python, TypeScript, Ruby, Go—any OpenAI SDK works out of the box.
We handle the messy parts
The real value is in what you don't have to think about.
Format emulation. Want WebP but the model only outputs PNG? Request WebP anyway. We convert it and return what you asked for. Same for JPEG, AVIF, and GIF.
Async-to-sync bridging. Some providers require you to poll for results. With Lumenfall, every request behaves synchronously. We handle the polling so you don't have to manage callbacks or timers.
Size normalization. Pass a size a model doesn't natively support, and we map it to the closest match. You describe what you want; we handle the translation.
Fast and resilient
We add roughly 5 milliseconds of overhead. Your requests go through 330+ edge locations with direct provider peering, so latency stays low.
Built-in resilience with automatic failover. If a provider goes down, we route around it—sub-second detection, no interruption. Your users never see an error that could have been avoided.
No markup, no surprises
You pay what providers charge. We add nothing on top. No platform fee, no subscription, no hidden costs. Sign up, get $1 in free credit, and start generating. Every request shows up in your dashboard with full cost visibility—what you spent, which provider handled it, how long it took.
Where we're going
Our goal is to become the infrastructure layer for AI media generation. We want developers and vibe coders to focus on what they're building—their product, their workflow, their creative vision—not on wrangling provider APIs.
That means staying flexible. When a better model drops, you should be able to switch to it without touching your codebase. When a provider has an outage, your users shouldn't notice. When you need a new output format or a different resolution, it should just work.
The unified image generation API is the foundation. We have some exciting features in the pipeline that will take this further—and soon. If you're building with AI image generation, we'd love for you to try Lumenfall and see where we're headed.
https://lumenfall.ai | https://docs.lumenfall.ai | https://lumenfall.ai/playground