> This page location: Frontend & Frameworks > ORMs > Prisma
> Full Neon documentation index: https://neon.com/docs/llms.txt
# Connect from Prisma to Neon
Learn how to connect to Neon from Prisma
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.
## Prerequisites
- A [Neon account and project](https://neon.com/docs/get-started-with-neon/signing-up)
- Node.js 18+ installed
- A Node.js or TypeScript project (or create a new one)
## Setup
### Step 1: Install dependencies
```bash
npm install @prisma/client @prisma/adapter-neon dotenv
npm install prisma tsx --save-dev
```
### Step 2: Get your connection strings
From your Neon Console, click **Connect** and copy both connection strings:
- **Pooled connection** (has `-pooler` in the hostname): for your application
- **Direct connection**: for Prisma CLI commands (migrations, introspection)
Add them to your `.env` file:
```ini
# Pooled connection for your application
DATABASE_URL="postgresql://[user]:[password]@[endpoint]-pooler.[region].aws.neon.tech/[dbname]?sslmode=require"
# Direct connection for Prisma CLI
DIRECT_URL="postgresql://[user]:[password]@[endpoint].[region].aws.neon.tech/[dbname]?sslmode=require"
```
**Tip:** The pooled connection has `-pooler` in the hostname. The direct connection does not. Both are available in your Neon Console.
### Step 3: Configure your Prisma schema
If you don't have a Prisma schema yet, run `npx prisma init` to create one. Then update `prisma/schema.prisma`:
```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())
}
```
**Note:** In Prisma 7+, do not include a `url` property in the datasource block. The connection is configured via `prisma.config.ts` and the adapter.
### Step 4: Create prisma.config.ts
Create a `prisma.config.ts` file in your project root. This tells Prisma CLI where to connect for migrations and other commands:
```typescript
import 'dotenv/config'
import { defineConfig, env } from 'prisma/config'
export default defineConfig({
schema: 'prisma/schema.prisma',
datasource: {
url: env('DIRECT_URL'),
},
})
```
### Step 5: Create your Prisma Client
Create a file to instantiate Prisma Client with the Neon adapter (for example, `src/db.ts`):
```typescript
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 })
```
### Step 6: Generate client and push schema
```bash
npx prisma generate
npx prisma db push
```
You're connected. You can now use Prisma Client in your application:
```typescript
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:
```typescript
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:
```bash
npx tsx src/main.ts
```
## Why two connection strings?
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 connection (`DIRECT_URL`)**: Prisma CLI commands like `prisma migrate` and `prisma db push` need a direct connection for schema operations.
## Advanced configuration
### Using a non-public PostgreSQL schema
If you're using a PostgreSQL schema other than `public`, pass a `schema` option when creating the adapter:
```typescript
const adapter = new PrismaNeon(
{ connectionString: process.env.DATABASE_URL! },
{ schema: 'myPostgresSchema' }
)
```
### Setting the search path for raw SQL queries
For raw SQL queries that reference tables without schema qualification, use PostgreSQL's `options` parameter in your connection string:
```text
postgresql://[user]:[password]@[neon_hostname]/[dbname]?options=-c%20search_path%3Dmyschemaname
```
## Troubleshooting
**Connection timeouts**
If you see an error like:
```text
Error: P1001: Can't reach database server at `ep-example-123456.us-east-2.aws.neon.tech`:`5432`
```
This usually means the Prisma query engine timed out before Neon activated the compute. Neon computes scale to zero after inactivity and take a few seconds to wake up.
Add a `connect_timeout` parameter to your connection string:
```text
DATABASE_URL="postgresql://...?sslmode=require&connect_timeout=15"
```
A value of `0` means no timeout.
**Connection pool timeouts**
Prisma maintains its own connection pool. If you're seeing pool-related timeouts, you can configure:
- `connection_limit`: Number of connections in the pool (default: `num_cpus * 2 + 1`)
- `pool_timeout`: Seconds to wait for a connection from the pool (default: 10)
```text
DATABASE_URL="postgresql://...?sslmode=require&connection_limit=20&pool_timeout=15"
```
See Prisma's [connection management guide](https://www.prisma.io/docs/guides/performance-and-optimization/connection-management) for details.
**Using Prisma 6 or earlier**
In Prisma 6 and earlier, you configure the connection directly in `schema.prisma` instead of `prisma.config.ts`:
```prisma
datasource db {
provider = "postgresql"
url = env("DATABASE_URL")
directUrl = env("DIRECT_URL")
}
```
The `directUrl` property is available in Prisma 4.10.0 and higher.
## Next steps
- [Schema migrations with Prisma](https://neon.com/docs/guides/prisma-migrations): Full tutorial for building an app with migrations
- [Neon serverless driver](https://neon.com/docs/serverless/serverless-driver): Learn more about the driver powering the adapter
## Resources
- [Prisma documentation](https://www.prisma.io/docs/)
- [Prisma connection management](https://www.prisma.io/docs/guides/performance-and-optimization/connection-management)
- [PostgreSQL connector reference](https://www.prisma.io/docs/concepts/database-connectors/postgresql)
**Notes for AI-assisted setup**
- Import `PrismaClient` from `./generated/prisma` (or your configured `output` path), not from `@prisma/client`. The import path changed in Prisma 7.
- Do not install `@neondatabase/serverless` or `ws` as separate packages. The `@prisma/adapter-neon` package bundles everything needed for the Neon connection.
- In Prisma 7+, do not include a `url` property in the `prisma/schema.prisma` datasource block. The connection is configured via `prisma.config.ts` and the adapter.
- You need both a pooled connection (`DATABASE_URL`) for your application and a direct connection (`DIRECT_URL`) for Prisma CLI commands.
- Call `prisma.$disconnect()` in a `.finally()` block when running standalone scripts. Omitting this can leave connections open.
---
## Related docs (ORMs)
- [Django (Django ORM)](https://neon.com/docs/guides/django)
- [Drizzle](https://neon.com/docs/guides/drizzle)
- [Elixir Ecto](https://neon.com/docs/guides/elixir-ecto)
- [Kysely](https://neon.com/docs/guides/kysely)
- [Knex](https://neon.com/docs/guides/knex)
- [Laravel (Eloquent)](https://neon.com/docs/guides/laravel)
- [Ruby on Rails (ActiveRecord)](https://neon.com/docs/guides/ruby-on-rails)
- [SQLAlchemy](https://neon.com/docs/guides/sqlalchemy)
- [TypeORM](https://neon.com/docs/guides/typeorm)