Using the Python Runtime with Vercel Functions

Use the Python runtime to run ASGI (Asynchronous Server Gateway Interface) and WSGI (Web Server Gateway Interface) applications on Vercel. Vercel detects supported Python frameworks and runs your application as Vercel Functions.

Vercel detects your framework automatically when it finds a matching dependency in requirements.txt, pyproject.toml, or Pipfile. The Python framework presets work with FastAPI, Flask, Django, and other Python web frameworks. Define a supported Python entrypoint so Vercel can load your application.

Vercel then runs your app as Vercel Functions and routes every request to it, so the app you run locally deploys as-is.

For framework-specific setup guides, see:

• Deploy a FastAPI app on Vercel
• Deploy a Flask app on Vercel
• Deploy a Django app on Vercel

To run a Python backend and a frontend together in one project, you can use Services. Each part builds independently and routes to a shared domain.

A Python entrypoint is the file and top-level variable that Vercel loads as the Vercel Function handler. Vercel looks for a Python entrypoint in these locations:

• app.py, index.py, server.py, main.py, wsgi.py, or asgi.py
• the same filenames inside src/ or app/
• the module path configured with tool.vercel.entrypoint in pyproject.toml

For Django projects, Vercel also detects a manage.py file that sets DJANGO_SETTINGS_MODULE, including in an immediate subdirectory, and resolves the application from the WSGI_APPLICATION or ASGI_APPLICATION setting.

The entrypoint file must define one of these top-level names:

• app for most ASGI or WSGI frameworks, including FastAPI and Flask
• application for Django and other WSGI applications

To point Vercel to an app in a custom module, set tool.vercel.entrypoint to a Python module:variable value:

[tool.vercel]
entrypoint = "my_package.api:app"

Vercel still supports [project.scripts] app = "module:variable" for existing projects. Use tool.vercel.entrypoint for new projects.

Here's a FastAPI example:

from fastapi import FastAPI
 
app = FastAPI()
 
@app.get("/")
def home():
    return {"message": "Hello from Python on Vercel"}
 
@app.get("/api/items/{item_id}")
def read_item(item_id: int):
    return {"item_id": item_id}

[project]
name = "my-python-api"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = [
    "fastapi>=0.117.1",
]

Set the Python version for your project with pyproject.toml, .python-version, or Pipfile.lock. For step-by-step instructions, see Set the Python version for your Vercel project.

If the required Python version is not defined or not supported, Vercel uses the default version. The available versions are:

• 3.12 (default)
• 3.13
• 3.14

Define dependencies in pyproject.toml (with or without a uv.lock), requirements.txt, or a Pipfile with a corresponding Pipfile.lock.

fastapi==0.117.1

Vercel Functions support streaming responses when using the Python runtime. This lets you send parts of a response as they become ready.

By default, Python Vercel Functions include all files from your project that are reachable at build time. There is no automatic tree-shaking for Python.

During deployment builds, Vercel automatically compiles Python source files into bytecode and includes the resulting .pyc files in the function bundle when space allows. This reduces initialization time and requires no configuration.

Make sure your pyproject.toml or requirements.txt only lists packages necessary at runtime. Explicitly exclude files you don't need to keep bundles small and avoid hitting size limits.

To exclude unnecessary files (tests, static assets, test data), configure excludeFiles in vercel.json under the functions key. The pattern is a glob relative to your project root.

{
  "$schema": "https://openapi.vercel.sh/vercel.json",
  "functions": {
    "app.py": {
      "excludeFiles": "{tests/**,__tests__/**,**/*.test.py,**/test_*.py,fixtures/**,__fixtures__/**,testdata/**,sample-data/**,static/**,assets/**}"
    }
  }
}

Python uses the current working directory when you pass a relative path to open(). The working directory is the base of your project, not the directory containing the file.

Vercel supports existing projects that define file-based Python functions in an /api directory. See Python functions in the /api directory for routing, handlers, and configuration.