Skip to main content

Generators

A Prisma schema can have one or more generators, represented by the generator block:

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

A generator determines which assets are created when you run the prisma generate command.

There are two generators for Prisma Client:

  • prisma-client (recommended): Newer and more flexible version of prisma-client-js with ESM support; it outputs plain TypeScript code and requires a custom output path (read more about it here)
  • prisma-client-js: Generates Prisma Client into node_modules

Alternatively, you can configure any npm package that complies with our generator specification.

prisma-client-js​

The prisma-client-js is the default generator for Prisma ORM 6.X versions and before. It requires the @prisma/client npm package and generates Prisma Client into node_modules.

Field reference​

The generator for Prisma's JavaScript Client accepts multiple additional properties:

  • previewFeatures: Preview features to include
  • binaryTargets: Engine binary targets for prisma-client-js (for example, debian-openssl-1.1.x if you are deploying to Ubuntu 18+, or native if you are working locally)
generator client {
  provider        = "prisma-client-js"
  previewFeatures = ["sample-preview-feature"]
  binaryTargets   = ["debian-openssl-1.1.x"] // defaults to `"native"`
}

Binary targets​

note

As of v6.16.0, Prisma ORM can be used without Rust engines in production applications. Learn more here.

When enabled, your Prisma Client will be generated without a Rust-based query engine binary:

generator client {
  provider   = "prisma-client-js" // or "prisma-client"
  output     = "../src/generated/prisma"
  engineType = "client"           // no Rust engine
}

Note that driver adapters are required if you want to use Prisma ORM without Rust engines.

When using Prisma ORM without Rust, the binaryTargets field is obsolete and not needed.

You can read about the performance and DX improvements of this change on our blog.

The prisma-client-js generator uses several engines. Engines are implemented in Rust and are used by Prisma Client in the form of executable, platform-dependent engine files. Depending on which platform you are executing your code on, you need the correct file. "Binary targets" are used to define which files should be present for the target platform(s).

The correct file is particularly important when deploying your application to production, which often differs from your local development environment.

The native binary target​

The native binary target is special. It doesn't map to a concrete operating system. Instead, when native is specified in binaryTargets, Prisma Client detects the current operating system and automatically specifies the correct binary target for it.

As an example, assume you're running macOS and you specify the following generator:

prisma/schema.prisma
generator client {
  provider      = "prisma-client-js"
  binaryTargets = ["native"]
}

In that case, Prisma Client detects your operating system and finds the right binary file for it based on the list of supported operating systems . If you use macOS Intel x86 (darwin), then the binary file that was compiled for darwin will be selected. If you use macOS ARM64 (darwin-arm64), then the binary file that was compiled for darwin-arm64 will be selected.

Note: The native binary target is the default. You can set it explicitly if you wish to include additional binary targets for deployment to different environments.

prisma-client​

The new prisma-client generator offers greater control and flexibility when using Prisma ORM across different JavaScript environments (such as ESM, Bun, Deno, ...).

It generates Prisma Client into a custom directory in your application's codebase that's specified via the output field on the generator block. This gives you full visibility and control over the generated code. It also splits the generated Prisma Client library into multiple files.

This generator ensures you can bundle your application code exactly the way you want, without relying on hidden or automatic behaviors.

Here are the main differences compared to prisma-client-js:

  • Requires an output path; no "magic" generation into node_modules any more
  • Doesn't load .env at runtime; use dotenv or set environment variables manually instead
  • Supports ESM and CommonJS via the moduleFormat field
  • More flexible thanks to additional fields
  • Outputs plain TypeScript that's bundled just like the rest of your application code

The prisma-client generator has been Generally Available since v6.16.0 will become the new default with Prisma ORM v7.

Getting started​

Follow these steps to use the new prisma-client generator in your project.

1. Configure the prisma-client generator in schema.prisma​

Update your generator block:

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

The output option is required and tells Prisma ORM where to put the generated Prisma Client code. You can choose any location suitable for your project structure. For instance, if you have the following layout:

.
├── package.json
├── prisma
│   └── schema.prisma
├── src
│   └── index.ts
└── tsconfig.json

Then ../src/generated/prisma places the generated code in src/generated/prisma relative to schema.prisma.

2. Generate Prisma Client​

Generate Prisma Client by running:

npx prisma generate

This generates the code for Prisma Client (including the query engine binary) into the specified output folder.

3. Exclude the generated directory from version control​

The new generator includes both the TypeScript client code and the query engine. Including the query engine in version control can cause compatibility issues on different machines. To avoid this, add the generated directory to .gitignore:

.gitignore
# Keep the generated Prisma Client + query engine out of version control
/src/generated/prisma
note

In the future, you can safely include the generated directory in version control when Prisma ORM is fully transitioned from Rust to TypeScript.

4. Use Prisma Client in your application​

Importing Prisma Client​

After generating the Prisma Client, import it from the path you specified:

src/index.ts
import { PrismaClient } from "./generated/prisma/client";

const prisma = new PrismaClient();

Prisma Client is now ready to use in your project.

Importing generated model types​

If you're importing types generated for your models, you can do so as follows:

src/index.ts
import { UserModel, PostModel } from "./generated/prisma/models";

Importing generated enum types​

If you're importing types generated for your enums, you can do so as follows:

src/index.ts
import { Role, User } from "./generated/prisma/enums";

Importing in browser environments​

If you need to access generated types in your frontend code, you can import them as follows:

src/index.ts
import { Role } from "./generated/prisma/browser";

Note that ./generated/prisma/browser does not expose a PrismaClient.

Field reference​

Use the following options in the generator client { ... } block. Only output is required. The other fields have defaults or are inferred from your environment and tsconfig.json.

schema.prisma
generator client {
  // Required
  provider = "prisma-client"
  output   = "../src/generated/prisma"

  // Optional
  engineType             = "client"
  runtime                = "nodejs"
  moduleFormat           = "esm"
  generatedFileExtension = "ts"
  importFileExtension    = "ts"
}

Below are the options for the prisma-client generator:

OptionDefaultDescription
output (required)Directory where Prisma Client is generated, e.g. ../src/generated/prisma.
runtimenodejsTarget runtime environment.
Supported values:
nodejs, deno, bun, workerd (alias cloudflare), vercel-edge (alias edge-light), react-native.
moduleFormatInferred from environmentModule format (esm or cjs). Determines whether import.meta.url or __dirname is used.
generatedFileExtensiontsFile extension for generated TypeScript files (ts, mts, cts).
importFileExtensionInferred from environmentFile extension used in import statements. Can be ts, mts, cts, js, mjs, cjs, or empty (for bare imports).
note

nodejs, deno, and bun all map to the same internal codepath but are preserved as separate user-facing values for clarity.

Importing types​

The new prisma-client generator creates individual .ts files which allow for a more fine granular import of types. This can improve compile and typecheck performance and be useful for tree-shaking, too. You can still use the top level barrel files that export all types through a single import.

The overall structure of the generated output looks like this:

generated/
└── prisma
    ├── browser.ts
    ├── client.ts
    ├── commonInputTypes.ts
    ├── enums.ts
    ├── internal
    │   ├── ...
    ├── models
    │   ├── Post.ts
    │   └── User.ts
    └── models.ts

client.ts​

For use in your server code.

  • Provides access to the PrismaClient instance and all model and utility types.
  • Provides best compatibility with the prisma-client-js generated output.
  • Contains transitive dependencies on server only-packages, so cannot be used in browser contexts.

Example:

import { Prisma, type Post, PrismaClient } from "./generated/prisma/client"

browser.ts​

For using types in your frontend (i.e. code that runs in the browser).

  • Contains no transitive dependencies on Node.js or other server-only packages.
  • Contains no real PrismaClient constructor.
  • Contains all model and enum types and values.
  • Provides access to various utilities like Prisma.JsonNull and Prisma.Decimal.
  • Available since v6.16.0.
note

The old prisma-client-js generator created a node_modules package and used export maps to dynamically provide a browser compatible export of the generated Prisma Client library. As the new prisma-client generator creates direct TypeScript source code and no package.json file anymore, this approach is not possible. Hence you need to be explicit about your imports and whether things run on server or client!

You can still wrap the generated code in a package and use a similar approach as with prisma-client-js on your own.

Example:

import { Prisma, type Post } from "./generated/prisma/browser"

enums.ts​

Isolated access to user defined enum types and values.

  • Contains no transitive dependencies and is very slim.
  • Can be used on backend and frontend.
  • Prefer this for optimal tree shaking and typecheck performance when accessing enums.

Example:

import { MyEnum } from "./generated/prisma/enums"

models.ts​

Isolated access to all model types.

  • Can be used on backend and frontend.
  • Contains all models including their derived utility types like <ModelName>WhereInput or <ModelName>UpdateInput>.
note

Plain model types are exposed here as <ModelName>Model (e.g. PostModel). This is in contrast to the exposed name in client.ts and browser.ts which is simply <ModelName> (e.g. Post).

This is necessary due to internal constraints to avoid potential naming conflicts with internal types.

Example:

import type { UserModel, PostModel, PostWhereInput, UserUpdateInput } from "./generated/prisma/models"

models/<ModelName>.ts​

Isolated access to the types for an individual model.

  • Can be used on backend and frontend.
  • Contains the models including its derived utility types like <ModelName>WhereInput or <ModelName>UpdateInput>.
note

The plain model type is exposed here as <ModelName>Model (e.g. PostModel).

Example:

import type { UserModel, UserWhereInput, UserUpdateInput } from "./generated/prisma/models/User"

commonInputTypes.ts​

Provides shared utility types that you should rarely directly need.

Example:

import type { IntFilter } from "./generated/prisma/commonInputTypes"

internal/*​

warning

Do not directly import from these files! They are not part of the stable API of the generated code and can change at any time in breaking ways.

Usually anything you might need from there is exposed via browser.ts or client.ts under the Prisma namespace.

Breaking changes from prisma-client-js​

  • Requires an output path on the generator block
  • No Prisma.validator function; you can use TypeScript native satisfies keyword instead

Examples​

To see what the new prisma-client generator looks like in practice, check out our minimal and ready-to-run examples:

ExampleFrameworkBundlerRuntimeMonorepo
nextjs-starter-webpackNext.js 15WebpackNode.jsn/a
nextjs-starter-turbopackNext.js 15Turbopack (alpha)Node.jsn/a
nextjs-starter-webpack-monorepoNext.js 15WebpackNode.jspnpm
nextjs-starter-webpack-with-middlewareNext.js 15WebpackNode.js (main pages), vercel-edge (middleware)n/a
nextjs-starter-webpack-turborepoNext.js 15WebpackNode.jsturborepo
react-router-starter-nodejsReact Router 7Vite 6Node.jsn/a
react-router-starter-cloudflare-workerdReact Router 7n/a
nuxt3-starter-nodejsNuxt 3Vite 6Node.jsn/a
nuxt4-starter-nodejsNuxt 4Vite 7Node.jsn/a
bunNoneNoneDeno 2n/a
denoNoneNoneDeno 2n/a

Community generators​

note

Existing generators or new ones should not be affected if you are using a multi-file Prisma schema, unless a generator reads the schema manually.

The following is a list of community created generators.

Open in
Copy as Markdown
Open in Claude
Open in ChatGPT
Open in T3.chat
Edit in GitHub