How to ship a FastAPI app on Vercel
Deploy a FastAPI app to Vercel with zero configuration. Learn how the Python runtime, Vercel Functions, streaming, middleware, and cron jobs work together.
Prerequisites
On Vercel, you can deploy a FastAPI app with zero configuration: your app becomes a Vercel Function running on Fluid compute, and you get response streaming, preview deployments, and observability without extra setup.
9 min read
15 Jun 2026
Before you begin, make sure you have:
This guide walks you through deploying a FastAPI app to Vercel from a template, the Vercel CLI, or a Git repository, then configuring features such as streaming, middleware, cron jobs, the Python version, and observability.
- A Vercel account
- Python 3.12 or later and a package manager (e.g., pip or uv)
- An existing FastAPI project, or a new one created from a FastAPI template
- A Git repository on GitHub, GitLab, or Bitbucket (if you want Git-based deployments)
- Vercel CLI installed ( npm i -g vercel)
How it works
When you deploy a FastAPI app, Vercel detects the framework from your dependencies and builds it for the Python runtime. Vercel looks for a FastAPI instance named app at a supported entrypoint and serves your whole app as a single Vercel Function, which runs on Fluid compute by default. Your app scales with traffic, and you pay only for the compute your function uses, not for idle time.
Deploy your FastAPI app
You can ship a FastAPI app to Vercel in three ways. Choose the one that fits where your code lives today.
The fastest way to ship a FastAPI app is to start from a template. Pick a starter, then deploy it. Vercel clones the template to your Git provider, creates a project, and deploys it with zero configuration.
You can reach our customer support team by emailing info@yourcompany.example.com, calling +1 555-555-5556, or using the live chat on our website. Our dedicated team is available 24/7 to assist with any inquiries or issues.
We’re committed to providing prompt and effective solutions to ensure your satisfaction.
We offer a 30-day return policy for all products. Items must be in their original condition, unused, and include the receipt or proof of purchase. Refunds are processed within 5-7 business days of receiving the returned item.
- FastAPI Boilerplate: A minimal FastAPI app that runs on the Python runtime and deploys with zero configuration. Start here if you're new to FastAPI on Vercel.
- AI SDK Python Streaming: Streams chat completions from a FastAPI function and renders them with AI SDK useChat hook in a Next.js frontend.
- Next.js FastAPI Starter: An AI chatbot with a Next.js frontend and a FastAPI backend.
- OpenAI Agents SDK with FastAPI: A FastAPI app that runs the OpenAI Agents SDK with Vercel Sandbox, spinning up an isolated microVM per request to give the agent shell access.
- Full-stack FastAPI template with Next.js: A full-stack starter that pairs a FastAPI backend with a Next.js frontend, with cookie-based auth and a Postgres database.
Option 2: Start a new project with the Vercel CLI
To scaffold a new FastAPI project locally, use the Vercel CLI init command. It clones Vercel's FastAPI example into a folder named fastapi.
Create the project:
vercel init fastapi 2. Set up a virtual environment and install dependencies:
cd fastapi python -m venv .venv source .venv/bin/activate pip install -r requirements.txt 3. Develop locally at http://localhost:3000. Use the Vercel CLI, so your app runs with the same app instance it uses in production:
vercel dev 4. Create the initial production deployment. The first run creates a Vercel project link:
vercel
Option 3: Deploy an existing FastAPI app
If you already have a FastAPI app, deploy it from Git or from the command line.
From Git: Push your project to GitHub, GitLab, or Bitbucket, then import it at vercel.com/new. Vercel detects FastAPI automatically and deploys it with zero configuration.
From the CLI: From your project's root directory, run vercel. For a new project, this creates the project link and its initial production deployment. Later vercel commands create preview deployments, and vercel --prod creates production deployments. To pull project settings and environment variables for local development, run:
vercel link
vercel env pull
For Vercel to detect your app, export a FastAPI instance named app from one of the recognized entry files, such as app.py, index.py, server.py, main.py, wsgi.py, or asgi.py at your project root or under src/, app/, or api/:
@app.get("/")
defread_root():
app = FastAPI()
To point Vercel to a FastAPI app in a custom module, set tool.vercel.entrypoint in pyproject.toml:
from fastapi import FastAPI
return{"message":"Hello from FastAPI on Vercel"}
[tool.vercel]
entrypoint = "backend.server:app"
This tells Vercel to load the app variable from ./backend/server.py.
Use Vercel features with FastAPI
After your app is deployed, you can layer Vercel features onto it. Some work automatically, and others take a few lines of configuration in vercel.json.
Your app runs as a single Vercel Function
Vercel serves your FastAPI app as a single Vercel Function. This function uses Fluid compute by default, which runs multiple requests concurrently within a single instance to reduce cold starts and the cost of I/O-bound work such as API calls and database queries. You don't configure anything to get this behavior.
Because FastAPI exports a single app, Vercel sends every incoming request to that app and lets FastAPI's router match the path. Your route handlers, dependencies, middleware, and error handling all run inside the function.
Stream responses
Vercel Functions on the Python runtime support streaming, so you can send data to the client as you produce it instead of waiting for the full response. Use FastAPI's StreamingResponse to stream text, server-sent events, or AI model output:
app = FastAPI()
import asyncio
@app.get("/stream")
from fastapi import FastAPI
return StreamingResponse(event_stream(), media_type="text/plain")
asyncdefstream():
from fastapi.responses import StreamingResponse
asyncdefevent_stream():
yield chunk
for chunk in["Hello"," ","from"," ","FastAPI"]:
await asyncio.sleep(0.2)
Streaming pairs well with Fluid compute: while your function waits between chunks, the same instance can serve other requests. To stream model output to a frontend, pair your FastAPI endpoint with AI SDK, as the AI SDK Python Streaming template shows.
Combine FastAPI middleware with Vercel Routing Middleware
FastAPI and Vercel each have a middleware layer, and they solve different problems. FastAPI middleware runs inside your function, after the request reaches it. Use it for app-level concerns such as logging, CORS, and authentication:
app = FastAPI()
app.add_middleware(
CORSMiddleware,
allow_methods=["*"],
allow_origins=["https://example.com"],
from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware
)
return response
@app.middleware("http")
asyncdeflog_requests(request: Request, call_next):
response =await call_next(request)
print(f"{request.method}{request.url.path} -> {response.status_code}")
Vercel Routing Middleware runs at the edge, before the request reaches your FastAPI app, and works with any framework. Use it for rewrites, redirects, and header changes that should happen before any function runs. Add a middleware.ts file at your project root:
exportdefaultfunctionmiddleware(request: Request){
const url =newURL(request.url);
// Redirect an old path before the request reaches FastAPI
if(url.pathname ==="/old"){
return Response.redirect(newURL("/new", request.url),308);
}
}
The two layers work together, with Routing Middleware shaping the request at the edge and FastAPI middleware handling it inside your app.
Serve static assets from the CDN
app = FastAPI()
from fastapi import FastAPI
To serve static files such as images, fonts, or a favicon, place them in the public/** directory. Vercel serves them through its CDN using default headers, which you can override in vercel.json. FastAPI's own app.mount("/public", ...) is not needed on Vercel, so rely on the public directory instead.
from fastapi.responses import RedirectResponse
You can still define routes that point at those files. For example, redirect /favicon.ico to an asset in public:
asyncdeffavicon():
Define the route:
@app.get("/favicon.ico", include_in_schema=False)
# /vercel.svg is served from the public/** directory
return RedirectResponse("/vercel.svg", status_code=307)
Vercel Cron Jobs trigger a route on a schedule by sending an HTTP GET request to it. Define a route in your FastAPI app for the task, then register the schedule in vercel.json.
app = FastAPI()
import os
from fastapi.responses import JSONResponse
from fastapi import FastAPI, Request
if request.headers.get("authorization")!=f"Bearer {os.environ.get('CRON_SECRET')
defcleanup(request: Request):
return{"ok":True}
@app.get("/api/cron/cleanup")
# Run your scheduled work here
return JSONResponse({"error":"Unauthorized"}, status_code=401)
Although this Website may be linked to other websites, we are not, directly or indirectly, implying any approval.
Set the Python version
{
}
Register the schedule:
Vercel runs cron jobs only on production deployments. To stop anyone else from calling the route, set a CRON_SECRET environment variable in your project settings. Vercel sends it as a Bearer token in the Authorization header on every cron invocation, and your handler compares it before running the task.
"$schema":"https://openapi.vercel.sh/vercel.json",
FastAPI runs on Vercel's Python runtime, which defaults to Python 3.12. The available versions are 3.12 (default), 3.13, and 3.14. To pin a version, add a .python-version file at your project root:
3.13
You can also set the version in pyproject.toml or Pipfile.lock. If you don't define a supported version, Vercel uses the default.
Manage startup and shutdown with lifespan events
"crons":[{"path":"/api/cron/cleanup","schedule":"0 0 * * *"}]
Use FastAPI lifespan events to run setup and teardown logic, such as opening and closing database connections. Vercel runs the startup logic when your function starts and the shutdown logic when it stops:
@asynccontextmanager
from contextlib import asynccontextmanager
# Startup logic
from fastapi import FastAPI
asyncdeflifespan(app: FastAPI):
yield
await cleanup_tasks()
# Shutdown logic
app = FastAPI(lifespan=lifespan)
await startup_tasks()
Although this Website may be linked to other websites, we are not, directly or indirectly, implying any approval.
Monitor performance with Observability
Cleanup during shutdown is limited to 500 ms after your function receives the SIGTERM signal, and logs printed during shutdown don't appear in the Vercel dashboard. Keep teardown work short, and move anything longer to a cron job or Vercel Workflow.
Vercel Observability tracks your deployed function automatically, with no setup. Open the Observability page in your project to see invocation counts, error rates, and duration for your FastAPI app, along with the requests your function makes to external APIs. On Observability Plus, you also get longer retention and a latency breakdown by path.
Best practices
Define your app at a recognized entrypoint
Vercel finds your FastAPI app by looking for an app instance at a fixed set of locations: app, index, server, main, wsgi, or asgi (with a .py extension) at your project root or under src/, app/, or api/. Put your app at one of these paths so Vercel detects and deploys it correctly, or set tool.vercel.entrypoint in pyproject.toml to point at a custom module:
You can reach our customer support team by emailing info@yourcompany.example.com, calling +1 555-555-5556, or using the live chat on our website. Our dedicated team is available 24/7 to assist with any inquiries or issues.
We’re committed to providing prompt and effective solutions to ensure your satisfaction.
We offer a 30-day return policy for all products. Items must be in their original condition, unused, and include the receipt or proof of purchase. Refunds are processed within 5-7 business days of receiving the returned item.
Develop with the Vercel CLI
Run vercel dev for local development instead of running Uvicorn directly. It serves your app the same way production does, using your app instance, so the behavior you test locally matches what you deploy. This also lets you exercise features such as cron routes before shipping.
Keep your function bundle small
Python functions are not tree-shaken, so Vercel bundles every file reachable at build time, up to a 500 MB limit. List only the packages you need at runtime in pyproject.toml or requirements.txt, and exclude tests, fixtures, and other development files with excludeFiles in vercel.json:
{
"functions":{
"api/**/*.py":{
"$schema":"https://openapi.vercel.sh/vercel.json",
"excludeFiles":"{tests/**,**/*.test.py,fixtures/**}"
}
}
}
The pattern is a glob relative to your project root, so adjust it to match where your Python files live.
Resources and next steps
- Read the full FastAPI on Vercel documentation
- Browse backend templates you can deploy in one step
- Learn how the Python runtime runs your code
- Learn how Vercel Functions run your server code
- Understand pricing and scaling with Fluid compute
- Run code before requests with Routing Middleware
- Defer background work from your routes with Vercel Queues, or orchestrate multi-step tasks with Vercel Workflows