Excluding fields

By default Prisma Client returns all fields from a model. You can use select to narrow the result set, but that can be unwieldy if you have a large model and you only want to exclude a small number of fields.

info

As of Prisma ORM 6.2.0, excluding fields is supported via the omit option that you can pass to Prisma Client. From versions 5.16.0 through 6.1.0, you must use the omitApi Preview feature to access this option.

Excluding a field globally using omit

The following is a type-safe way to exclude a field globally (i.e. for all queries against a given model):

Code

const prisma = new PrismaClient({
  omit: {
    user: {
      password: true
    }
  }
})

// The password field is excluded in all queries, including this one
const user = await prisma.user.findUnique({ where: { id: 1 } })

Schema

model User {
  id        Int      @id @default(autoincrement())
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
  firstName String
  lastName  String
  email     String   @unique
  password  String
}

Excluding a field locally using omit

The following is a type-safe way to exclude a field locally (i.e. for a single query):

Code

const prisma = new PrismaClient()

// The password field is excluded only in this query
const user = await prisma.user.findUnique({
  omit: {
    password: true
  },
  where: { 
    id: 1 
  } 
})

Schema

model User {
  id        Int      @id @default(autoincrement())
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
  firstName String
  lastName  String
  email     String   @unique
  password  String
}

How to omit multiple fields

Omitting multiple fields works the same as selecting multiple fields: add multiple key-value pairs to the omit option. Using the same schema as before, you could omit password and email with the following:

const prisma = new PrismaClient()

// password and email are excluded
const user = await prisma.user.findUnique({
  omit: {
    email: true,
    password: true,
  },
  where: {
    id: 1,
  },
})

Multiple fields can be omitted locally and globally.

How to select a previously omitted field

If you omit a field globally, you can "override" by either selecting the field specifically or by setting omit to false in a query.

Explicit Select

const user = await prisma.user.findUnique({
  select: {
    firstName: true,
    lastName: true,
    password: true // The password field is now selected.
  },
  where: {
    id: 1
  }
})

Omit False

const user = await prisma.user.findUnique({
  omit: {
    password: false // The password field is now selected.
  },
  where: {
    id: 1
  }
})

Ensuring excluded fields don't appear in TypeScript types

While the omit option correctly removes fields from the runtime result, TypeScript sometimes does not reflect these omissions in the inferred types, especially when the omit configuration is not strictly typed.

If you define your omit config in a separate variable and do not use as const, TypeScript infers the type as { [key: string]: boolean }, which is too broad for Prisma to know which fields are truly omitted. This results in the omitted fields still appearing in the type system, even though they are not present at runtime.

The recommended fix is to use as const to ensure the type is exact:

const omitConfig = {
  profile: { email: true },
  user: { password: true },
} as const;

const prisma = new PrismaClient({ omit: omitConfig });

This ensures TypeScript knows exactly which fields are omitted and will reflect that in the types.

When to use omit globally or locally

It's important to understand when to omit a field globally or locally:

• If you are omitting a field in order to prevent it from accidentally being included in a query, it's best to omit it globally. For example: Globally omitting the password field from a User model so that sensitive information doesn't accidentally get exposed.
• If you are omitting a field because it's not needed in a query, it's best to omit it locally.

Local omit (when an omit option is provided in a query) only applies to the query it is defined in, while a global omit applies to every query made with the same Prisma Client instance, unless a specific select is used or the omit is overridden.