Connect from Prisma to Neon

Pre-built prompt for connecting Node/TypeScript applications to Neon using Prisma ORM.

Prisma is an open-source, next-generation ORM for Node.js and TypeScript. This guide shows you how to connect a Prisma application to Neon using the recommended setup with the Neon serverless driver adapter.

• A Neon account and project
• Node.js 18+ installed
• A Node.js or TypeScript project (or create a new one)

npm install @prisma/client @prisma/adapter-neon dotenv
npm install prisma tsx --save-dev

From your Neon Console, click Connect and copy both connection strings:

• Pooled connection (has -pooler in the hostname): for your application
• Direct (unpooled) connection: for Prisma CLI commands (migrations, introspection)

Add them to your .env file:

# Pooled connection for your application
DATABASE_URL="postgresql://[user]:[password]@[endpoint]-pooler.[region].aws.neon.tech/[dbname]?sslmode=require"

# Direct (unpooled) connection for Prisma CLI
DATABASE_URL_UNPOOLED="postgresql://[user]:[password]@[endpoint].[region].aws.neon.tech/[dbname]?sslmode=require"

The pooled connection has -pooler in the hostname. The direct (unpooled) connection does not. Both are available in your Neon Console.

If you don't have a Prisma schema yet, run npx prisma init to create one. Then update prisma/schema.prisma:

generator client {
  provider = "prisma-client-js"
  output   = "../src/generated/prisma"
}

datasource db {
  provider = "postgresql"
}

model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  name      String?
  createdAt DateTime @default(now())
}

In Prisma 7+, do not include a url property in the datasource block. The connection is configured via prisma.config.ts and the adapter.

Create a prisma.config.ts file in your project root. This tells Prisma CLI where to connect for migrations and other commands:

import 'dotenv/config'
import { defineConfig, env } from 'prisma/config'

export default defineConfig({
  schema: 'prisma/schema.prisma',
  datasource: {
    url: env('DATABASE_URL_UNPOOLED'),
  },
})

Create a file to instantiate Prisma Client with the Neon adapter (for example, src/db.ts):

import 'dotenv/config'
import { PrismaClient } from './generated/prisma'
import { PrismaNeon } from '@prisma/adapter-neon'

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

export const prisma = new PrismaClient({ adapter })

npx prisma generate
npx prisma db push

You're connected. You can now use Prisma Client in your application:

import { prisma } from './db'

const users = await prisma.user.findMany()

To verify the full setup, create a src/main.ts script that exercises CRUD operations:

import { prisma } from './db'

async function main() {
  // CREATE
  const newUser = await prisma.user.create({
    data: { name: 'Alice', email: `alice-${Date.now()}@example.com` },
  })
  console.log('Created user:', newUser)

  // READ
  const foundUser = await prisma.user.findUnique({ where: { id: newUser.id } })
  console.log('Found user:', foundUser)

  // UPDATE
  const updatedUser = await prisma.user.update({
    where: { id: newUser.id },
    data: { name: 'Alice Smith' },
  })
  console.log('Updated user:', updatedUser)

  // DELETE
  await prisma.user.delete({ where: { id: newUser.id } })
  console.log('Deleted user.')
}

main()
  .catch((error) => {
    console.error(error)
    process.exit(1)
  })
  .finally(async () => {
    await prisma.$disconnect()
  })

Run it with:

npx tsx src/main.ts

Neon uses connection pooling to efficiently manage database connections in serverless environments:

• Pooled connection (DATABASE_URL): Your application connects through Neon's connection pooler, which is optimal for serverless functions that create many short-lived connections.
• Direct (unpooled) connection (DATABASE_URL_UNPOOLED): Prisma CLI commands like prisma migrate and prisma db push need a direct connection for schema operations.

If you're using a PostgreSQL schema other than public, pass a schema option when creating the adapter:

const adapter = new PrismaNeon(
  { connectionString: process.env.DATABASE_URL! },
  { schema: 'myPostgresSchema' }
)

For raw SQL queries that reference tables without schema qualification, use PostgreSQL's options parameter in your connection string:

postgresql://[user]:[password]@[neon_hostname]/[dbname]?options=-c%20search_path%3Dmyschemaname

Error: P1001: Can't reach database server at `ep-example-123456.us-east-2.aws.neon.tech`:`5432`

DATABASE_URL="postgresql://...?sslmode=require&connect_timeout=15"

DATABASE_URL="postgresql://...?sslmode=require&connection_limit=20&pool_timeout=15"

datasource db {
  provider  = "postgresql"
  url       = env("DATABASE_URL")
  directUrl = env("DATABASE_URL_UNPOOLED")
}

• Schema migrations with Prisma: Full tutorial for building an app with migrations
• Neon serverless driver: Learn more about the driver powering the adapter

• Set up Managed Better Auth: Add managed authentication that branches with your database
• Add Object Storage: S3-compatible file storage that branches with your database
• Deploy a Function: Run backend compute next to your database, no separate hosting needed
• Call an LLM with AI Gateway: Access foundation models from Anthropic, OpenAI, Google, and more with one credential

• Prisma documentation
• Prisma connection management
• PostgreSQL connector reference

Join our Discord Server to ask questions or see what others are doing with Neon. For paid plan support options, see Support.