Try FLUX 3 Max, post-trained by fal
fal logo

The inference platform for generative media and world models

fal is an AI inference platform built for image, video, audio, 3D and world models. Call 1,400+ model endpoints through one inference API, or run your own models and pipelines on serverless GPUs that autoscale from zero, with reserved capacity when you need a guaranteed floor.

Contact sales
Requests served a year
Billions
Developers and teams building on fal
2M+
Image, video, audio and 3D endpoints behind one API and one key
1,400+
GPUs for your own model deployments, from RTX PRO 6000 to B300 and GB200
Up to B300
Trusted by teams at
Two paths

Call a hosted model, or deploy your own

Start with any of 1,400+ hosted models. When you have a model of your own, deploy it on fal Serverless. Both run on the same runtime and queue, so your client code stays the same when you switch.

Inference API

Call hosted image, video, audio and 3D models with one key.

See the inference API →

Serverless inference

Deploy your own model, pipeline or container on the runtime behind every fal Model API.

Explore the Serverless demo →
Inference API

1,400+ models, optimized for speed and reliability

The models fal hosts run on fal's serverless inference engine, with CUDA kernels written for each model architecture. Every endpoint sits behind a managed queue that absorbs spikes and retries failures. No GPUs to provision and no deploy step.

import { fal } from "@fal-ai/client";

const result = await fal.subscribe("fal-ai/nano-banana-pro", {
  input: {
    prompt: "a black lab swimming in a pool, half underwater",
    aspect_ratio: "1:1",
  },
});

console.log(result.data.images[0].url);

One client for every model

Image, video, audio and 3D endpoints take the same client and the same request shape. Switch models by changing one string.

Explore all models →

New models, optimized on fal

New models from leading labs go live on fal as they are released. The ones fal hosts run on its serverless inference engine, tuned for each architecture.

Pay for what you use

Most models are priced per output, and the rest per second of GPU time. When nothing runs, nothing is billed.

Reliable by default

Queued requests go through a managed queue. It absorbs traffic spikes, and requests that hit a transient failure go back into the queue and run again.

Ready for enterprise

Organizations, access controls and data controls for teams shipping to production.

Explore all models
Serverless

Serverless inference for your own models

The same runtime every fal Model API runs on. Deploy a model, pipeline or container, and fal handles the queue, the GPUs and the scaling.

An app.py defining a fal App, beside a terminal running fal deploy

Deploy your own model without managing infrastructure

Bring a custom container or write a fal.App class in Python. fal deploy builds, pushes, warms and serves it behind a stable endpoint on H100s through B300s.

The Serverless dashboard, showing an app's traffic, logs and runners as requests arrive

Monitor and debug every request in production

Requests, latency, errors, runners and cold starts in one dashboard, with logs for every request. Add your own OpenTelemetry traces, or send metrics to Grafana or Datadog.

Runner count rising and falling with demand across an app's GPUs

Scale to thousands of GPUs

Zero to thousands of GPUs, without waiting for allocation. Keep a reserved baseline of warm runners for steady traffic and burst onto the shared fleet when demand spikes. Billed per second while runners are up.

The configuration tray, adjusting machine type, concurrency and warm capacity

Optimize for speed and cost

Tune machine type, concurrency and warm capacity to balance latency against cost. Files on /data are cached across three layers, FlashPack streams weights from disk to GPU, and compiled kernels can be shared across runners, so cold starts stay short.

H3 Max: from training to inference on fal

fal Research post-trained H3 Max on fal Compute and serves it on fal Serverless across multiple nodes behind one endpoint. It launched at #1 for image-to-video on Artificial Analysis, and H3 Max Director generates it in real time as a live video stream at up to 1080p over fal WMA.

Read the case study →
“Elasticity is what's changed how we work. Standing up a new model fleet on fal Serverless, sizing it against real traffic, and scaling without hardware procurement helped make our Suno v6 rollout possible.”
Georg KucskoCTO and Cofounder, SunoSuno
Explore the Serverless demoLearn more about fal Serverless
Distribution

Distribute your model to enterprises and millions of developers

Serve a model on fal, then sell it on fal. Publish to the marketplace and reach the developers and enterprises already calling the inference API, with fal's team co-selling enterprise deals.

Listed next to 1,400+ model endpoints

Your model sits in the fal gallery and API alongside the models teams already use, in front of the developers and enterprise teams building on fal.

Co-marketed at launch

fal launches your model with you, across its channels and community, with GTM support on joint calls and custom demos.

A new revenue channel

Callers pay with their own fal key. You report billable units per request, fal sets the unit price with you, and there is no billing or infrastructure to run.
“fal doesn't act like an infrastructure vendor; it acts like a go-to-market partner. Our engineers deploy, iterate and release on their own schedule, and the time from a model being ready in research to being live for developers is measured in days, not weeks. Every launch fal amplifies brings a wave of new developers and teams. It's the reason we chose to build both on fal and with fal.”
Misha FeinsteinCTO, BriaBria
Talk to us about publishing
Modalities

Infrastructure tuned for every generative media modality

Each modality puts a different load on inference. fal tunes for each one: throughput for image, GPU memory for video, streaming for audio, and a live connection for world models.

Image output on fal

Image

Tuned for throughput, with kernels written per architecture. Generation, editing, upscaling and LoRA.

Browse image models →

Video

Long generations on high-memory GPUs, with the largest models served across multiple nodes behind one endpoint.

Browse video models →

Audio

Music, speech and sound effects, with streaming output on supported speech models so playback starts before generation ends.

Browse audio models →
3D output on fal

3D

Image and text to mesh, textures and multi-view, on the same queue and client as every other modality.

Browse 3D models →

The inference platform for world models

fal WMA, the World Model Accelerator, streams world models over a live WebRTC connection for interactive worlds, with the same inference, serverless compute and distribution as every other model on fal.

Explore fal WorldsHow fal WMA works
FAQ

Inference platform questions

What is an inference platform?
An inference platform runs trained AI models in production and serves their outputs over an API. It manages the GPUs, autoscaling, request queues and monitoring, so the team building the product does not have to.
What is AI inference?
AI inference is running a trained model on new inputs to produce outputs, such as generating an image from a prompt. Training builds the model once; inference runs every time a user makes a request, so its speed and cost decide the product's experience and margins.
What is the best inference platform for world models?
fal runs world models through fal WMA, the World Model Accelerator. It streams causal and bidirectional diffusion models over WebRTC, scales from 1 to 1,000 GPUs across clouds and regions, and handles signaling and TURN relay. H3 Max Director and Abot World run on it today, and fal Worlds lets you browse them and start a live session.
What is the best inference platform for generative media?
fal is built specifically for generative media inference: an inference API for 1,400+ image, video, audio and 3D model endpoints, serverless inference for your own models with reserved capacity and burst, real-time WebSocket and WebRTC transport, and a marketplace to distribute the models you serve.
What is serverless inference?
Serverless inference runs a model on GPUs that start when requests arrive and stop when they do not. On fal Serverless you set floors, caps and warm buffers per app, and you are billed per second while a runner is alive.
What is the difference between the inference API and serverless inference?
The inference API calls models fal already hosts, priced per output or per GPU second. Serverless inference runs your own model, pipeline or container on fal's GPUs, billed per second of runner time. Both use the same client, queue and calling patterns.
Does fal support new models on launch day?
Yes. New models from leading labs go live on fal as they are released, with an API endpoint and a playground on day one.
What are concurrency limits on the inference API?
Every account has a concurrency limit on how many requests run at once. New accounts start at 2 and the limit rises automatically with purchased credits, up to 40. Requests above the limit wait in the queue. Contact sales for higher limits.
How long does fal keep generated outputs?
Generated files are stored on the fal CDN for at least 7 days by default. You can set the retention period per request with the X-Fal-Object-Lifecycle-Preference header, and delete a request's stored payloads and output files through the Platform API.
Can I reserve GPU capacity for inference?
Yes. A reservation guarantees a baseline of GPUs for your Serverless endpoints, and traffic above it bursts onto fal's shared fleet automatically. Contact sales to size one.
How do I deploy a custom model for inference on fal?
Write a fal.App class in Python with @fal.endpoint routes, bring a container image, or expose an existing HTTP server with exposed_port. Test with fal run and deploy with fal deploy.
How does fal reduce inference cold starts?
Weights on /data are cached between startups automatically. FlashPack, fal's open-source loader, streams tensors from disk to GPU, and compiled kernels can be shared across runners. For latency-critical apps, min_concurrency and concurrency_buffer keep runners warm.
How is inference priced on fal?
Inference API models are priced per output unit or, for some models, per GPU second, as listed on each model page, and time waiting in the queue is not billed. Serverless inference is billed per second while a runner is alive, by GPU type; time spent pending or pulling the image is not billed. Serverless GPU list prices per hour: B300 $12.99, GB200 $9.99, B200 $7.99, H200 $6.00, H100 $4.50, RTX PRO 6000 $4.00, with lower rates for volume and commitments. Reserved capacity is priced through sales. See all pricing
Does fal support real-time inference?
Yes, for supported models. Real-time endpoints keep a persistent WebSocket open to a runner, models with a streaming endpoint send outputs over server-sent events, and fal WMA streams over WebRTC for interactive applications.
Can I sell a model I serve on fal?
Yes. Publish a Serverless app to the fal marketplace. Callers pay with their own fal key for their own usage, and the fal team configures unit pricing and the model card with you.
Should I use fal for training too?
For large training runs, fal Compute provides dedicated GPU clusters on reserved terms. Contact sales to size one. You can deploy the trained weights to fal Serverless for inference.

Start your partnership with fal

Tell us what you are serving, the traffic you expect and the latency you need. The team comes back with a plan for the inference API, serverless inference or a reserved floor, and stays with you from the first deploy to launch day.

Contact form