Deno (Prisma ORM v7) (/docs/guides/v7/runtimes/deno)

For the complete Prisma documentation index, see llms.txt. A markdown version of any docs page is available by appending .md to its URL.

Learn how to use Prisma ORM in a Deno application with Prisma Postgres

Location: Guides > v7 > Runtimes > Deno

Deno is a secure JavaScript and TypeScript runtime built on V8 with built-in TypeScript support, a permissions system, and web-standard APIs. In this guide, you will set up a Deno project with Prisma ORM and a Prisma Postgres database. You will create a small HTTP server that reads from the database and returns the results.

How to use Prisma ORM with Deno and Prisma Postgres

• Deno v2.0 or later installed on your system
• A Prisma Postgres database (created during setup)
• Basic knowledge of JavaScript/TypeScript
• Deno extension for VS Code (recommended)

First, create a directory for your project and navigate to it:

mkdir deno-prisma
cd deno-prisma

Then, initialize a new Deno project:

deno init

This creates a basic Deno project with a deno.json configuration file and a main.ts file.

Update the deno.json file with the following configuration to set up Node.js compatibility, import maps, and Prisma-related task scripts:

{
  "nodeModulesDir": "auto",
  "compilerOptions": {
    "lib": ["deno.window"],
    "types": ["node"]
  },
  "imports": {
    "@prisma/adapter-pg": "npm:@prisma/adapter-pg@^7.0.0",
    "@prisma/client": "npm:@prisma/client@7",
    "prisma": "npm:prisma@prev"
  },
  "tasks": {
    "dev": "deno run -A --env=.env --watch main.ts",
    "db:generate": "deno run -A --env=.env npm:prisma@prev generate",
    "db:push": "deno run -A --env=.env npm:prisma@prev db push",
    "db:migrate": "deno run -A --env=.env npm:prisma@prev migrate dev",
    "db:seed": "deno run -A --env=.env npm:prisma@prev db seed"
  }
}

[!NOTE] The nodeModulesDir: "auto" setting allows Deno to automatically manage a node_modules directory, which is needed for Prisma's generated client. The import map entries let you use bare specifiers like @prisma/client in your code.

Initialize Prisma ORM with Prisma Postgres in your project:

deno run -A npm:prisma@prev init

[!NOTE] prisma init creates the Prisma scaffolding and a local DATABASE_URL. In the next step, you will create a Prisma Postgres database and replace that value with a direct postgres://... connection string.

This command creates:

• A prisma/ directory with your schema.prisma file
• A prisma.config.ts file
• A .env file with your DATABASE_URL

Open the generated prisma.config.ts file. Since Deno loads environment variables using the --env=.env flag (configured in deno.json tasks), you can remove the dotenv/config import if it was generated:

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"),  },});

Create a Prisma Postgres database and replace the generated DATABASE_URL in your .env file with the postgres://... connection string from the CLI output:

npx create-db

Update your .env file:

DATABASE_URL="postgres://..."

Open prisma/schema.prisma and update it to include the Deno runtime and your data model:

generator client {  provider = "prisma-client"  output   = "../generated/prisma"  runtime  = "deno"}datasource db {  provider = "postgresql"}model User {  id    Int     @id @default(autoincrement())  email String  @unique  name  String?}

[!NOTE] The runtime = "deno" setting in the generator block is required for Prisma Client to work correctly with the Deno runtime.

Generate the Prisma Client and apply your schema to the database:

deno task db:migrate --name init
deno task db:generate

This command:

• Creates the database tables based on your schema
• Generates the Prisma Client in the generated/prisma directory

Create a db.ts file in your project root to configure PrismaClient:

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

const adapter = new PrismaPg({
  connectionString: Deno.env.get("DATABASE_URL")!,
});

export const prisma = new PrismaClient({
  adapter,
});

Create a seed script in the prisma folder to populate your database with sample data:

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

const adapter = new PrismaPg({
  connectionString: Deno.env.get("DATABASE_URL")!,
});

const prisma = new PrismaClient({
  adapter,
});

async function main() {
  // Create multiple users
  await prisma.user.createMany({
    data: [
      { email: "alice@example.com", name: "Alice" },
      { email: "bob@example.com", name: "Bob" },
      { email: "charlie@example.com", name: "Charlie" },
      { email: "diana@example.com", name: "Diana" },
      { email: "eve@example.com", name: "Eve" },
      { email: "frank@example.com", name: "Frank" },
      { email: "grace@example.com", name: "Grace" },
      { email: "henry@example.com", name: "Henry" },
      { email: "isabella@example.com", name: "Isabella" },
      { email: "jack@example.com", name: "Jack" },
    ],
    skipDuplicates: true, // prevents errors if you run the seed multiple times
  });

  console.log("Seed data inserted!");
}

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

Update the prisma.config.ts file to include the seed command:

import { defineConfig, env } from "prisma/config";export default defineConfig({  schema: "prisma/schema.prisma",  migrations: {    path: "prisma/migrations",    seed: "deno run -A --env=.env ./prisma/seed.ts",  },  datasource: {    url: env("DATABASE_URL"),  },});

Run the seed script to populate your database:

deno task db:seed

Replace the main.ts file contents with the following code to build a small HTTP server that uses Prisma ORM to fetch and display users:

import { prisma } from "./db.ts";

async function handler(req: Request): Promise<Response> {
  const { pathname } = new URL(req.url);

  // Skip favicon route
  if (pathname === "/favicon.ico") {
    return new Response(null, { status: 204 });
  }

  // Return all users
  const users = await prisma.user.findMany();

  // Count all users
  const count = await prisma.user.count();

  // Format the response with JSON
  return new Response(
    JSON.stringify({
      users: users,
      totalUsers: count,
    }),
    { headers: { "Content-Type": "application/json" } },
  );
}

Deno.serve({ port: 8000 }, handler);

Start your Deno server:

deno task dev

You should see the server running on http://localhost:8000 in the console. When you visit http://localhost:8000 in your browser, you'll see a JSON response with all the users in your database and the total count.

Now that you have a Deno application connected to a Prisma Postgres database, you can continue by:

• Extending your Prisma schema with additional models and relationships
• Implementing authentication and authorization
• Adding input validation with Zod
• Exploring Deno's built-in testing tools
• Deploying your application to Deno Deploy

• Deno Documentation
• Prisma Config File
• Prisma Postgres

• Bun: Learn how to use Prisma ORM in a Bun application with Prisma Postgres