Unified access to leading AI providers
True API Unification
One API. Every Model.
We Handle the Differences.
Every model has quirks: different parameter names, varying output formats. Providers add complexity with async vs. sync APIs and more. Lumenfall normalizes everything so you write once and it works everywhere.
Request 1024x1024 – We translate
Different models use different size parameters. Some want pixels, others want aspect ratios or megapixel tiers. You always use your preferred format. We convert it for each model.
You send
size:"1024x1024"
Model receives
// fal.ai FLUX Pro:
aspect_ratio:"1:1",megapixels:"1"
// OpenAI GPT Image 1:
size:"1024x1024"
Stay with the SDK you're already using.
You don't change, we change for you.
Why Lumenfall
Everything you need to ship AI features, nothing you don't
Stop wrestling with multiple provider APIs, billing accounts, and reliability concerns. Get back to building.
One API, every model
All important generative AI models - Nanobanana, Imagen, Flux, Kling and more - through a single, OpenAI-compatible interface. No SDK juggling.
One bill, zero markup
Pay what you use at official provider rates. One wallet, one invoice. Full cost visibility per request.
Built-in resilience
330+ edge locations with automatic failover. When one provider hiccups, traffic reroutes instantly. 5ms overhead.
Production Ready
Built for Scale, Reliability & Speed
Automatic Failover, Zero Downtime
When providers fail, your app doesn't.
Your requests automatically reroute to the next available provider—no code changes, no manual intervention, no failed generations. Sub-second detection means users never know a failover happened.
Sub-Second Detection
The moment a request fails, we're already retrying with the next provider.
Invisible to Users
Your end users never know a failover happened. They just get their image.
Scale Without Limits
From prototype to millions of requests.
Start with a single API call. Scale to millions. Our distributed infrastructure handles traffic spikes automatically—no capacity planning, no provisioning delays. Pay only for what you generate.
Auto-Scaling Infrastructure
Traffic spikes? We handle them automatically. No config needed.
Pay Per Generation
No monthly minimums. No reserved capacity. Just pay for what you use.
requests / month
No Compromise on Latency
Every millisecond counts.
We've obsessively optimized every layer of our stack. 330+ edge locations. Direct provider peering. The total overhead Lumenfall adds to your API calls? That's it.
330+ Edge Locations
Frankfurt, Tokyo, Sydney, São Paulo—we're already there.
Added latency. That's it.
Your users won't notice the difference—but they'll notice the reliability.
The dashboard built for pixels, not tokens
One dashboard across every provider you call. Click any request to see the prompt, the inputs, and the actual image or video, rendered inline instead of as base64 in a JSON blob. Catch the bad render and trace the slow provider without leaving the tab.
See every request. See the pixels.
Click any request to see the prompt, inputs, and generated output side by side. Media renders inline. No base64, no JSON hunting.
Why is it slow?
Gateway, provider, or the model itself. See where every millisecond went, critical when video gens take 30+ seconds.
One key, every provider
Replace Replicate, Fal, OpenAI, and Runway credentials with a single Lumenfall key. Rotate or revoke in one click.
Request API
Need it in code?
The same request data the dashboard runs on, pulled straight into your own tooling. Ship error summaries to Slack, power an internal cost dashboard, or reconcile billing in a nightly job.
-
error_codeand messages for every failed request - Cost in USD per request, plus aggregate totals over any time range
- Model, modality, duration, status, and key ID
- Cursor pagination with filters for time range and API key
Starter surface. We're exposing more fields over time.
curl https://api.lumenfall.ai/v1/requests?limit=3&summary=true \
-H"Authorization: Bearer $LUMENFALL_API_KEY"
{
"object":"list",
"data": [
{
"id":"req_2m4jLFHhkN1i4VrVHpjJqCOKlPw",
"model":"flux-pro",
"status":"upstream_failure",
"cost":0,
"duration_ms":12340,
"error_code":"ALL_PROVIDERS_EXHAUSTED",
"error_message":"All providers failed after retry"
},
{
"id":"req_2m4jKEGfmR8h3UqTGnhHpBNkMOx",
"model":"gpt-image-1.5",
"status":"completed",
"cost":0.045,
"duration_ms":2340
}
],
"summary": {"total_cost":12.34,"count":347}
}
Transparent, Usage-Based Pricing
Pay only for what you use at official provider rates. No platform fees, no markup - just the actual cost of generation.
One Wallet, All Providers
No need to set up payment methods with every provider. Load credits once and use them across Nano Banana Pro, Flux, GPT Image 1, and everything else.
Zero Markup
Get all the advantages of Lumenfall—unified API, automatic polling, format conversion—while only paying for the tokens you use. No service fees, no hidden costs.
Pure Usage-Based
No subscriptions, no tiers, no minimum commitments. Generate one image or one million—you're billed exactly for what you use, down to the token.
Lumenfall in a nutshell
Lumenfall is a unified API for AI image and video generation. It provides a single OpenAI-compatible endpoint to access 113+ models from providers including OpenAI, Google, Black Forest Labs, Stability AI, and others. Lumenfall adds zero markup to provider pricing, normalizes parameters and output formats across providers and models, bridges async APIs to synchronous responses, and automatically fails over between providers.
One API.
All important models.
Use the OpenAI SDK you already know. We handle provider quirks, format translations, and automatic fallbacks—so you can focus on building.
No credit card required · Free credits included
import OpenAI from 'openai';
const client = new OpenAI({
apiKey: 'YOUR_API_KEY',
baseURL: 'https://api.lumenfall.ai/openai/v1'
});
const image = await client.images.generate({
model: 'gemini-3-pro-image-preview',
prompt: 'A mountain lake at dawn',
size: '1024x1024'
});