Build with fal

The generative media platform powering the world's top AI apps.

Call 1,000+ optimized models through a unified API, or deploy your own on the same infrastructure. Image, video, audio, music, speech, 3D, and real-time streaming. Built to scale to billions of requests.

99.99%+

Uptime

Billions+

Requests/day

1,000+

Endpoints

**Call 1,000+ models with one API.** Image, video, audio, and multimodal generation. Optimized and production-ready. **Deploy your own models.** Same infrastructure, same autoscaling, same reliability. From zero to thousands of GPUs. **Dedicated GPU instances.** Full SSH access for training, fine-tuning, and persistent workloads. REST APIs for model metadata, pricing, usage tracking, logs, files, and metrics ## Start with a Model API Call Most users start here. Pick a model from the [Marketplace](https://fal.ai/models), get an [API key](https://fal.ai/dashboard/keys), and make a request. Three lines of code, no infrastructure to manage. ```python Python theme={null} import fal_client result = fal_client.subscribe("fal-ai/nano-banana-2", arguments={"prompt": "a sunset over mountains"} ) print(result["images"][0]["url"]) ``` ```javascript JavaScript theme={null} import { fal } from "@fal-ai/client"; const result = await fal.subscribe("fal-ai/nano-banana-2", { input: { prompt: "a sunset over mountains" } }); console.log(result.data.images[0].url); ``` ```bash cURL theme={null} curl -X POST https://queue.fal.run/fal-ai/nano-banana-2 \ -H "Authorization: Key $FAL_KEY" \ -H "Content-Type: application/json" \ -d '{"prompt": "a sunset over mountains"}' ``` Every model supports [synchronous and async queue](/documentation/model-apis/inference) calls out of the box. Many also support [streaming](/documentation/model-apis/inference/streaming) and [real-time WebSocket](/documentation/model-apis/inference/real-time) connections. You can compare models side-by-side in the [Sandbox](https://fal.ai/sandbox) before committing to one. Browse models, see pricing, and start generating *** ## Deploy Your Own Models For teams that need to run custom models, proprietary pipelines, or fine-tuned variants, [fal Serverless](/documentation/serverless) lets you deploy on the same engine that powers the Marketplace. fal has been running this infrastructure for over 3 years, and every model on the platform goes through the same lifecycle below. A [fal.App](/documentation/development/app-setup) is a Python class where your `setup()` method runs once per [runner](/documentation/deployment/runners) to load model weights and initialize resources. Your [`@fal.endpoint`](/documentation/development/handle-inputs-and-outputs) methods then serve incoming [requests](/documentation/deployment/requests) using the initialized state. You declare hardware needs and [environment](/documentation/development/container-setup) alongside your code, so infrastructure is versioned with your app. ```python theme={null} import fal class MyModel(fal.App): machine_type = "GPU-H100" def setup(self): self.model = load_my_model() @fal.endpoint("/") def generate(self, prompt: str): return self.model(prompt) ``` [`fal run`](/documentation/development/getting-started/quick-start) spins up a cloud GPU [runner](/documentation/deployment/runners) and gives you a temporary URL so you can test on the same hardware you'll use in production. It also generates a [playground UI](/documentation/model-apis/playground) automatically. For CI, [`AppClient`](/documentation/development/test-models-and-endpoints) lets you run tests against ephemeral deployments. ```bash theme={null} fal run my_app.py ``` [`fal deploy`](/documentation/deployment/deploy-to-production) creates a persistent, authenticated endpoint with autoscaling and built-in [retries](/documentation/serverless/reliability/retries). Every deploy creates a new revision for instant [rollbacks](/documentation/deployment/rollbacks). For staging and production separation, fal supports [multiple environments](/documentation/deployment/manage-environments) per app. ```bash theme={null} fal deploy my_app.py ``` The [dashboard](https://fal.ai/dashboard) gives you real-time logs, request-level [analytics](/documentation/serverless/observability/app-analytics), and [error tracking](/documentation/serverless/observability/error-analytics) out of the box. Trace individual requests, spot latency regressions, and monitor runner utilization. For external stacks, fal supports [Prometheus metrics](/documentation/serverless/observability/exporting-metrics) and [log drains](/documentation/serverless/observability/log-drains) to Datadog, Splunk, and Elasticsearch. fal scales [runners](/documentation/deployment/runners) from zero to thousands of GPUs based on demand, with a multi-layer [caching](/documentation/deployment/caching) system that reduces cold starts over time. [Scaling parameters](/documentation/deployment/scale-your-application) let you control the tradeoff: `min_concurrency` keeps runners warm, `max_concurrency` caps spend, and `concurrency_buffer` pre-warms ahead of spikes. See [optimizing cold starts](/documentation/serverless/optimizations/optimize-cold-starts) and [machine types](/documentation/deployment/machine-types) for latency-sensitive workloads. ```python theme={null} class MyModel(fal.App): min_concurrency = 2 max_concurrency = 100 concurrency_buffer = 3 ``` Endpoints start as private. You can deploy in `public` mode for open access, or [`shared` mode](/documentation/deployment/deploy-to-production) where callers pay for their own usage. To list on the [Marketplace](https://fal.ai/models) for broader distribution and revenue, see [publishing to the marketplace](/documentation/serverless/publishing-to-marketplace). ```python theme={null} class MyModel(fal.App): app_auth = "shared" ``` Deploy your first model in minutes *** ## Train Your Own Models For training runs, fine-tuning, and workloads that need sustained GPU access, [fal Compute](/documentation/compute) gives you dedicated instances with full SSH control. No cold starts, no autoscaling, just raw GPU power billed at a fixed hourly rate. Single-GPU instances for development, fine-tuning, and single-GPU training Multi-GPU instances connected over InfiniBand for distributed training | | Compute | Serverless | | :----------- | :-------------------------------- | :--------------------------------- | | **Best for** | Training, fine-tuning, batch jobs | API endpoints, on-demand inference | | **Billing** | Per-hour, fixed rate | Per-second of execution | | **Scaling** | Manual | Automatic | | **Access** | Full SSH | Managed runners | Provision your first GPU instance in minutes