Use Prisma Postgres with Prisma ORM

Prisma Postgres is a fully managed PostgreSQL database that scales to zero and integrates smoothly with both Prisma ORM and Prisma Studio. In this guide, you will learn how to set up a new TypeScript project from scratch, connect it to Prisma Postgres using Prisma ORM, and generate a Prisma Client for easy, type-safe access to your database.

Prerequisites​

You need:

• Node.js v20.19+, v22.12+, or v24.0+ installed on your machine
• Basic knowledge of JavaScript or TypeScript

1. Create a new project​

Create a project directory and navigate into it:

mkdir hello-prisma
cd hello-prisma

Initialize a TypeScript project:

npm init -y
npm install typescript tsx @types/node --save-dev
npx tsc --init

2. Install required dependencies​

Install the packages needed for this quickstart:

npm install prisma @types/node --save-dev 
npm install @prisma/client @prisma/adapter-pg dotenv

Here's what each package does:

• prisma - The Prisma CLI for running commands like prisma init, prisma migrate, and prisma generate
• @prisma/client - The Prisma Client library for querying your database
• @prisma/adapter-pg - The node-postgres driver adapter that connects Prisma Client to your database
• dotenv - Loads environment variables from your .env file

3. Configure ESM support​

Update tsconfig.json for ESM compatibility:

{
  "compilerOptions": {
    "module": "ESNext",
    "moduleResolution": "node",
    "target": "ES2023",
    "strict": true,
    "esModuleInterop": true,
    "ignoreDeprecations": "6.0"
  }
}

Update package.json to enable ESM:

{
  "type": "module",
}

4. Initialize Prisma ORM and create a Prisma Postgres database​

Next, set up your Prisma ORM project by creating your Prisma Schema file with the following command:

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

This command does a few things:

• Creates a prisma/ directory with a schema.prisma file containing your database connection and schema models
• Creates a new Prisma Postgres database (when using --db flag)
• Creates a .env file in the root directory for environment variables
• Generates the Prisma Client in the generated/prisma/ directory
• Creates a prisma.config.ts file for Prisma configuration

The generated prisma.config.ts file looks like this:

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

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

The generated schema uses the ESM-first prisma-client generator with a custom output path:

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

datasource db {
  provider = "postgresql"
}

5. Define your data model​

Open prisma/schema.prisma and add the following models:

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

datasource db {
  provider = "postgresql"
}

model User {
  id    Int     @id @default(autoincrement())
  email String  @unique
  name  String?
  posts Post[]
}

model Post {
  id        Int     @id @default(autoincrement())
  title     String
  content   String?
  published Boolean @default(false)
  author    User    @relation(fields: [authorId], references: [id])
  authorId  Int
}

6. Create and apply your first migration​

Create your first migration to set up the database tables:

npx prisma migrate dev --name init

This command creates the database tables based on your schema.

Now run the following command to generate the Prisma Client:

npx prisma generate

7. Instantiate Prisma Client​

Now that you have all the dependencies installed, you can instantiate Prisma Client. You need to pass an instance of Prisma ORM's driver adapter to the PrismaClient constructor:

import "dotenv/config";
import { PrismaPg } from '@prisma/adapter-pg'
import { PrismaClient } from '../generated/prisma/client'

const connectionString = `${process.env.DATABASE_URL}`

const adapter = new PrismaPg({ connectionString })
const prisma = new PrismaClient({ adapter })

export { prisma }

8. Write your first query​

Create a script.ts file to test your setup:

import { prisma } from './lib/prisma'

async function main() {
  // Create a new user with a post
  const user = await prisma.user.create({
    data: {
      name: 'Alice',
      email: '[email protected]',
      posts: {
        create: {
          title: 'Hello World',
          content: 'This is my first post!',
          published: true,
        },
      },
    },
    include: {
      posts: true,
    },
  })
  console.log('Created user:', user)

  // Fetch all users with their posts
  const allUsers = await prisma.user.findMany({
    include: {
      posts: true,
    },
  })
  console.log('All users:', JSON.stringify(allUsers, null, 2))
}

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

Run the script:

npx tsx script.ts

You should see the created user and all users printed to the console!

9. Explore your data with Prisma Studio​

Prisma Studio is a visual editor for your database. Launch it with:

npx prisma studio --config ./prisma.config.ts

This opens a web interface where you can view and edit your data.

Next steps​

You've successfully set up Prisma ORM. Here's what you can explore next:

• Learn more about Prisma Client: Explore the Prisma Client API for advanced querying, filtering, and relations
• Database migrations: Learn about Prisma Migrate for evolving your database schema
• Performance optimization: Discover query optimization techniques
• Build a full application: Check out our framework guides to integrate Prisma ORM with Next.js, Express, and more
• Join the community: Connect with other developers on Discord

More info​

• Prisma Postgres documentation
• Prisma Config reference
• Database connection management
• Cache your queries