Deploy to Vercel Edge Functions & Middleware

This page covers everything you need to know to deploy an app that uses Prisma Client for talking to a database in Vercel Edge Middleware or a Vercel Function deployed to the Vercel Edge Runtime.

Vercel supports both Node.js and edge runtimes for Vercel Functions. The Node.js runtime is the default and recommended for most use cases.

You can use Prisma Postgres in Vercel's edge runtime. Follow this guide for an end-to-end tutorial on deploying an application to Vercel using Prisma Postgres.

Vercel's Edge Runtime currently only supports a limited set of database drivers:

• Neon Serverless uses HTTP to access the database (also compatible with Vercel Postgres)
• PlanetScale Serverless uses HTTP to access the database
• @libsql/client is used to access Turso databases

Note that node-postgres (pg) is currently not supported on Vercel Edge Functions.

When deploying a Vercel Edge Function that uses Prisma ORM, you need to use one of these edge-compatible drivers and its respective driver adapter for Prisma ORM.

First, ensure that your datasource block in your Prisma schema is configured correctly. Database connection URLs are configured in prisma.config.ts:

datasource db {

  provider = "postgresql" // this might also be `mysql` or another value depending on your database

}

import "dotenv/config";

import { defineConfig, env } from "prisma/config";

export default defineConfig({

  schema: "prisma/schema.prisma",

  datasource: {

    url: env("DATABASE_URL"),

  },

});

When in development, you can configure your database connection via the DATABASE_URL environment variable (e.g. using .env files).

When deploying your Edge Function to production, you'll need to set the database connection using the vercel CLI:

bunx vercel env add DATABASE_URL

pnpm dlx vercel env add DATABASE_URL

yarn dlx vercel env add DATABASE_URL

npx vercel env add DATABASE_URL

This command is interactive and will ask you to select environments and provide the value for the DATABASE_URL in subsequent steps.

Alternatively, you can configure the environment variable via the UI of your project in the Vercel Dashboard.

In your package.json, you should add a "postinstall" section as follows:

{

  // ...,

  "postinstall": "prisma generate"

}

Vercel has a size limit of 1 MB on free accounts. If your application bundle with Prisma ORM exceeds that size, use an engine-less Prisma Client with a compatible driver adapter or upgrade to a plan with a larger limit.

This section provides database-specific instructions for deploying a Vercel Edge Functions with Prisma ORM.

As a prerequisite for the following section, you need to have a Vercel Edge Function (which typically comes in the form of a Next.js API route) running locally and the Prisma and Vercel CLIs installed.

If you don't have that yet, you can run these commands to set up a Next.js app from scratch (following the instructions of the Vercel Functions Quickstart):

bun add --global vercel

pnpm add -g vercel

yarn global add vercel

npm install -g vercel

bunx create-next-app@latest

pnpm dlx create-next-app@latest

yarn dlx create-next-app@latest

npx create-next-app@latest

bun add prisma@prev --dev&& bun add @prisma/client@7

pnpm add prisma@prev --save-dev&& pnpm add @prisma/client@7

yarn add prisma@prev --dev&& yarn add @prisma/client@7

npm install prisma@prev --save-dev && npm install @prisma/client@7

bunx --bun prisma init --output ../app/generated/prisma

pnpm prisma init --output ../app/generated/prisma

yarn prisma init --output ../app/generated/prisma

npx prisma init --output ../app/generated/prisma

We'll use the default User model for the example below:

model User {

  id    Int     @id @default(autoincrement())

  email String  @unique

  name  String?

}

If you are using Vercel Postgres, you need to:

• use the @prisma/adapter-neon database adapter because Vercel Postgres uses Neon under the hood

• be aware that Vercel by default calls the pooled connection string POSTGRES_PRISMA_URL while the direct, non-pooled connection string is exposed as POSTGRES_URL_NON_POOLING. Configure prisma.config.ts so that the Prisma CLI uses the direct connection string:

  import { defineConfig, env } from "prisma/config";
  
  export default defineConfig({
  
    schema: "prisma/schema.prisma",
  
    datasource: {
  
      url: env("POSTGRES_URL_NON_POOLING"), // direct connection for Prisma CLI
  
    },
  
  });

First, ensure that the database connection is configured properly. Database connection URLs are configured in prisma.config.ts:

generator client {

  provider = "prisma-client"

  output   = "./generated"

}

datasource db {

  provider = "postgresql"

}

import "dotenv/config";

import { defineConfig, env } from "prisma/config";

export default defineConfig({

  schema: "prisma/schema.prisma",

  datasource: {

    url: env("POSTGRES_URL_NON_POOLING"), // direct connection for Prisma CLI

  },

});

Next, you need to set the POSTGRES_PRISMA_URL and POSTGRES_URL_NON_POOLING environment variable to the values of your database connection.

If you ran npx prisma init, you can use the .env file that was created by this command to set these:

POSTGRES_PRISMA_URL="postgres://user:password@host-pooler.region.postgres.vercel-storage.com:5432/name?pgbouncer=true&connect_timeout=15"

POSTGRES_URL_NON_POOLING="postgres://user:password@host.region.postgres.vercel-storage.com:5432/name"

Next, install the required packages:

bun add @prisma/adapter-neon

pnpm add @prisma/adapter-neon

yarn add @prisma/adapter-neon

npm install @prisma/adapter-neon

Next, add a new key to the scripts section in your package.json:

{

  // ...

  "scripts": {

    // ...

    "postinstall": "prisma generate"

  }

}

If you ran npx prisma init above, you need to migrate your database schema to create the User table that's defined in your Prisma schema (if you already have all the tables you need in your database, you can skip this step):

bunx prisma migrate dev --name init

pnpm prisma migrate dev --name init

yarn prisma migrate dev --name init

npx prisma migrate dev --name init

If you created the project from scratch, you can create a new edge function as follows.

First, create a new API route, e.g. by using these commands:

mkdir src/app/api

mkdir src/app/api/edge

touch src/app/api/edge/route.ts

Here is a sample code snippet that you can use to instantiate PrismaClient and send a query to your database in the new app/api/edge/route.ts file you just created:

import { NextResponse } from "next/server";

import { PrismaClient } from "./generated/client";

import { PrismaNeon } from "@prisma/adapter-neon";

export const runtime = "nodejs"; // can also be set to 'edge'

export async function GET(request: Request) {

  const adapter = new PrismaNeon({ connectionString: process.env.POSTGRES_PRISMA_URL });

  const prisma = new PrismaClient({ adapter });

  const users = await prisma.user.findMany();

  return NextResponse.json(users, { status: 200 });

}

Run the app with the following command:

bun run dev

pnpm run dev

yarn dev

npm run dev

You can now access the Edge Function via http://localhost:3000/api/edge.

Run the following command to deploy your project with Vercel:

bunx vercel deploy

pnpm dlx vercel deploy

yarn dlx vercel deploy

npx vercel deploy

Note that once the project was created on Vercel, you will need to set the POSTGRES_PRISMA_URL environment variable (and if this was your first deploy, it likely failed). You can do this either via the Vercel UI or by running the following command:

bunx vercel env add POSTGRES_PRISMA_URL

pnpm dlx vercel env add POSTGRES_PRISMA_URL

yarn dlx vercel env add POSTGRES_PRISMA_URL

npx vercel env add POSTGRES_PRISMA_URL

At this point, you can get the URL of the deployed application from the Vercel Dashboard and access the edge function via the /api/edge route.

If you are using a PlanetScale database, you need to:

• use the @prisma/adapter-planetscale database adapter (learn more in PlanetScale)

First, ensure that the database connection is configured properly. Database connection URLs are configured in prisma.config.ts:

generator client {

  provider = "prisma-client"

  output   = "./generated"

}

datasource db {

  provider     = "mysql"

  relationMode = "prisma" // required for PlanetScale (as by default foreign keys are disabled)

}

import "dotenv/config";

import { defineConfig, env } from "prisma/config";

export default defineConfig({

  schema: "prisma/schema.prisma",

  datasource: {

    url: env("DATABASE_URL"),

  },

});

Next, you need to set the DATABASE_URL environment variable in your .env file that's used both by Prisma and Next.js to read your env vars:

DATABASE_URL="mysql://32qxa2r7hfl3102wrccj:password@us-east.connect.psdb.cloud/demo-cf-worker-ps?sslaccept=strict"

Next, install the required packages:

bun add @prisma/adapter-planetscale

pnpm add @prisma/adapter-planetscale

yarn add @prisma/adapter-planetscale

npm install @prisma/adapter-planetscale

Next, add a new key to the scripts section in your package.json:

{

  // ...

  "scripts": {

    // ...

    "postinstall": "prisma generate"

  }

}

If you ran npx prisma init above, you need to migrate your database schema to create the User table that's defined in your Prisma schema (if you already have all the tables you need in your database, you can skip this step):

bunx prisma db push

pnpm prisma db push

yarn prisma db push

npx prisma db push

If you created the project from scratch, you can create a new edge function as follows.

First, create a new API route, e.g. by using these commands:

mkdir src/app/api

mkdir src/app/api/edge

touch src/app/api/edge/route.ts

Here is a sample code snippet that you can use to instantiate PrismaClient and send a query to your database in the new app/api/edge/route.ts file you just created:

import { NextResponse } from "next/server";

import { PrismaClient } from "./generated/client";

import { PrismaPlanetScale } from "@prisma/adapter-planetscale";

export const runtime = "nodejs"; // can also be set to 'edge'

export async function GET(request: Request) {

  const adapter = new PrismaPlanetScale({ url: process.env.DATABASE_URL });

  const prisma = new PrismaClient({ adapter });

  const users = await prisma.user.findMany();

  return NextResponse.json(users, { status: 200 });

}

Run the app with the following command:

bun run dev

pnpm run dev

yarn dev

npm run dev

You can now access the Edge Function via http://localhost:3000/api/edge.

Run the following command to deploy your project with Vercel:

bunx vercel deploy

pnpm dlx vercel deploy

yarn dlx vercel deploy

npx vercel deploy

Note that once the project was created on Vercel, you will need to set the DATABASE_URL environment variable (and if this was your first deploy, it likely failed). You can do this either via the Vercel UI or by running the following command:

bunx vercel env add DATABASE_URL

pnpm dlx vercel env add DATABASE_URL

yarn dlx vercel env add DATABASE_URL

npx vercel env add DATABASE_URL

At this point, you can get the URL of the deployed application from the Vercel Dashboard and access the edge function via the /api/edge route.

If you are using a Neon database, you need to:

• use the @prisma/adapter-neon database adapter (learn more in Using driver adapters)

First, ensure that the database connection is configured properly. Database connection URLs are configured in prisma.config.ts:

generator client {

  provider = "prisma-client"

  output   = "./generated"

}

datasource db {

  provider = "postgresql"

}

import "dotenv/config";

import { defineConfig, env } from "prisma/config";

export default defineConfig({

  schema: "prisma/schema.prisma",

  datasource: {

    url: env("DATABASE_URL"),

  },

});

Next, you need to set the DATABASE_URL environment variable in your .env file that's used both by Prisma and Next.js to read your env vars:

DATABASE_URL="postgresql://janedoe:password@ep-nameless-pond-a23b1mdz.eu-central-1.aws.neon.tech/neondb?sslmode=require"

Next, install the required packages:

bun add @prisma/adapter-neon

pnpm add @prisma/adapter-neon

yarn add @prisma/adapter-neon

npm install @prisma/adapter-neon

Next, add a new key to the scripts section in your package.json:

{

  // ...

  "scripts": {

    // ...

    "postinstall": "prisma generate"

  }

}

If you ran npx prisma init above, you need to migrate your database schema to create the User table that's defined in your Prisma schema (if you already have all the tables you need in your database, you can skip this step):

bunx prisma migrate dev --name init

pnpm prisma migrate dev --name init

yarn prisma migrate dev --name init

npx prisma migrate dev --name init

If you created the project from scratch, you can create a new edge function as follows.

First, create a new API route, e.g. by using these commands:

mkdir src/app/api

mkdir src/app/api/edge

touch src/app/api/edge/route.ts

Here is a sample code snippet that you can use to instantiate PrismaClient and send a query to your database in the new app/api/edge/route.ts file you just created:

import { NextResponse } from "next/server";

import { PrismaClient } from "./generated/client";

import { PrismaNeon } from "@prisma/adapter-neon";

export const runtime = "nodejs"; // can also be set to 'edge'

export async function GET(request: Request) {

  const adapter = new PrismaNeon({ connectionString: process.env.DATABASE_URL });

  const prisma = new PrismaClient({ adapter });

  const users = await prisma.user.findMany();

  return NextResponse.json(users, { status: 200 });

}

Run the app with the following command:

bun run dev

pnpm run dev

yarn dev

npm run dev

You can now access the Edge Function via http://localhost:3000/api/edge.

Run the following command to deploy your project with Vercel:

bunx vercel deploy

pnpm dlx vercel deploy

yarn dlx vercel deploy

npx vercel deploy

Note that once the project was created on Vercel, you will need to set the DATABASE_URL environment variable (and if this was your first deploy, it likely failed). You can do this either via the Vercel UI or by running the following command:

bunx vercel env add DATABASE_URL

pnpm dlx vercel env add DATABASE_URL

yarn dlx vercel env add DATABASE_URL

npx vercel env add DATABASE_URL

At this point, you can get the URL of the deployed application from the Vercel Dashboard and access the edge function via the /api/edge route.

Fluid compute is Vercel's compute model for dynamic workloads such as streaming data and AI APIs. Vercel's Fluid compute supports both edge and Node.js runtimes. A common challenge in traditional serverless platforms is leaked database connections when functions are suspended and pools can't close idle connections. Fluid provides attachDatabasePool to ensure idle connections are released before a function is suspended.

Use attachDatabasePool together with Prisma's driver adapters to safely manage connections in Fluid:

import { Pool } from "pg";

import { attachDatabasePool } from "@vercel/functions";

import { PrismaPg } from "@prisma/adapter-pg";

import { PrismaClient } from "./generated/client";

const pool = new Pool({ connectionString: process.env.POSTGRES_URL });

attachDatabasePool(pool);

const prisma = new PrismaClient({

  adapter: new PrismaPg(pool),

});