Vercel Brings Python to General Availability: Six SDKs and FastAPI Support

Vercel has moved Python support to general availability. Ten months ago, the company set out to make its platform the best place to run Python applications, and the result is now available to everyone: auto-detection for four frameworks, execution on Fluid compute, and six Python SDKs for storage, queues, workflows, sandboxes, models and external APIs. For a company that grew up on JavaScript and Next.js, this is a notable step toward backend and AI workloads, where Python remains the default language.

What Vercel detects and runs on its own

The platform reads a project's dependency files, including those managed through uv, and recognizes FastAPI, Flask, Django and FastHTML on its own. Build and request routing are configured automatically, and static files are served through the CDN with the specifics of each framework taken into account. You don't need to assemble the configuration by hand.

The runtime is built on CPython on Linux. Vercel explains the choice by compatibility: the packages and tools Python developers are used to should work without workarounds. Applications run on Fluid compute, which handles concurrent requests and scales with traffic.

Key parameters of the release:

• runtime: CPython on Linux;
• compute: Fluid compute with concurrent request management;
• auto-detection: FastAPI, Flask, Django, FastHTML;
• dependencies: support for uv-based projects;
• full stack: Vercel Services combines backend and frontend in a single project;
• long-running processes: Vercel Daemons for workers that pull tasks from queues or databases.

Vercel Services addresses a common problem in projects with a Python backend and a JavaScript frontend. The `vercel dev` command runs both parts locally, a preview deployment builds them together, and release and rollback happen as a single action. Vercel Daemons covers a different scenario: containers with your code, packages and system dependencies stay running and work through a job queue.

Six SDKs for AI and background tasks

The second half of the announcement concerns libraries. Vercel has released Python versions of its tools with type annotations, async/await and context managers:

• AI SDK for Python: generating and streaming model responses, calling tools, building agents;
• Sandbox SDK: creating isolated environments for running code;
• Workflow SDK: durable workflows with retries and persisted execution state;
• Queues SDK: sending and receiving messages for background work and notifications;
• Blob SDK: uploading and retrieving files from object storage;
• Connect SDK: obtaining credentials for calling external APIs.

The set is telling. Sandbox, Workflow and AI SDK form the standard stack for agentic applications: the model makes a decision, the code runs in isolation, and a long chain of steps survives failures. Previously, you had to assemble such a stack from disparate services or write it in TypeScript.

What it looks like in a real project

As a demonstration, the author of the announcement built a collaborative web app for Jupyter notebooks. Users create notebooks, publish them, fork other people's notebooks and write code together with an AI assistant. The frontend is built with Vite, the backend with FastAPI, and the source code and chat history are stored in PostgreSQL.

When a user opens a notebook, FastAPI creates or reuses a Vercel Sandbox running Jupyter. User code is isolated from the app's backend, the browser connects to Jupyter directly, and mounted Drives supply the dependencies and working files. On save, the backend writes the source to PostgreSQL, renders the changes to HTML and uploads the result to Blob. Published notebooks are served through the CDN without starting a Python kernel. After publishing, FastAPI sends a message through Vercel Queues so that the updates reach the other backend instances.

Where to start

For a new project, the easiest path is to follow the guide for your framework. For existing code, it makes sense to check whether it matches what auto-detection expects: if dependencies are declared through uv or standard files, you may not need any configuration. For the FastAPI and Next.js combination, Vercel has a separate course covering deployment with Services.

The announcement gives no data on limits, pricing or cold starts for Python functions. Before moving a production workload, check these in the documentation and on a pilot service. This applies especially to heavy ML dependencies and long-running workers, where Daemons and Fluid compute will produce different cost profiles.