Prisma Client Extensions: 15 Practical Examples

Prisma Client extensions let you add custom, fully type-safe behavior to Prisma ORM: computed fields, validation, query hooks, row-level security, retries, and your own model or client methods, all through one $extends call. This article catalogs 15 practical extension patterns with runnable code for each.

Updated (July 2026): Prisma Client extensions announced here in Preview have long been generally available (since Prisma 4.16.0) and require no preview flag. On Prisma 7, extensions are also the replacement for middleware ($use), which was removed. The setup section below reflects Prisma 7; the example catalog is maintained in the prisma-client-extensions repo.

Introduction

Prisma Client extensions add custom functionality to Prisma in a type-safe manner. You can create flexible solutions to problems the ORM does not cover natively, define extensions in TypeScript or JavaScript, compose them, and create multiple lightweight Prisma Client instances with different extensions.

When you're ready, you can share your extensions with the community as code snippets or by packaging them and publishing them to npm. This article will show you what's possible with extensions and hopefully inspires you to create and share your own!

Using Prisma Client extensions

Prisma Client extensions are generally available and need no feature flag. On Prisma 7, your generator block looks like this (the prisma-client generator writes the Client into your project, and you import it from that output path rather than from @prisma/client):

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

You can then call the $extends method on a Prisma Client instance. This will return a new, "extended" client instance without modifying the original instance. You can chain calls to $extends to use multiple extensions, and create separate instances with different extensions:

const prisma = new PrismaClient();
const extendedPrisma = prisma.$extends(myExtensionA).$extends(myExtensionB);

The components of an extension

There are four different types of components that can be included in an extension:

Model components allow you to add new methods to models. This is a convenient way to add new operations alongside default methods like findMany, create, etc. You can use this as a repository of common query methods, encapsulate business logic for models, or do anything you might do with a static method on a class.
Client components can be used to add new top-level methods to Prisma Client itself. Use this to extend the client with functionality that isn't tied to specific models.
Query components let you hook into the query lifecycle and perform side effects, modify query arguments, or alter the results in a type-safe way. They replaced middleware ($use), which was removed in Prisma ORM, and provide full type safety while being applicable ad-hoc to different extended client instances.
Result components add custom fields and methods to query result objects. These allow you to implement virtual / computed fields, define business logic for model instances in a single place, and transform the data returned by your queries.

A single extension can include one or more components, as well as an optional name to display in error messages:

const prisma = new PrismaClient().$extends({
  name: "myExtension",
  model: { /* ... */ },
  client: { /* ... */ },
  query: { /* ... */ },
  result: { /* ... */ },
});

To see the full syntax for defining each type of extension component, please refer to the docs.

You can use the Prisma.defineExtension utility to define an extension that can be shared with other users:

import { Prisma } from "@prisma/client";

export default Prisma.defineExtension({
  model: {
    $allModels: {
      // new method
      findOrCreate(...) { } // code for the new method goes inside the brackets
    },
  },
});

When publishing shared extensions to npm, we recommend using the prisma-extension-<package-name> convention. This will make it easier for users to find and install your extension in their apps.

For example, if you publish an extension with the package name prisma-extension-find-or-create, users can install it like:

npm install prisma-extension-find-or-create

And then use the extension in their app:

import { PrismaClient } from "@prisma/client";
import findOrCreate from "prisma-extension-find-or-create";

const prisma = new PrismaClient().$extends(findOrCreate);
const user = await prisma.user.findOrCreate({ /* ... */ });

Read our documentation on sharing extensions for more details.

Sample use cases

We have compiled a list of use cases that might be solved with extensions, and we've created some examples of how these extensions could be written. Let's take a look at these use cases and their implementations:

Note: The examples below import from @prisma/client, matching the examples repo. On Prisma 7 with the prisma-client generator, import PrismaClient and Prisma from your configured output path instead, and pass a driver adapter. Where an example has caveats, they are listed in its README on GitHub.

View example code

View example code

View example code

View example code

View example code

View example code

View example code

View example code

View example code

View example code

View example code

View example code

View example code

View example code

View example code

Are Prisma Client extensions still in Preview?

What replaced Prisma middleware ($use)?

Do extensions modify the original Prisma Client instance?

Keep reading

Search encrypted data with Prisma 8 and CipherStash

See Your Migration History in Prisma Studio

Build your next app with Prisma

Share this article