# Excluding fields (Prisma ORM v6) (/docs/orm/v6/prisma-client/queries/excluding-fields)

This page explains how to exclude sensitive fields from Prisma Client

Location: ORM > v6 > Prisma Client > Queries > Excluding fields

By default Prisma Client returns all fields from a model. You can use [`select`](/guides/prisma-client-v6-queries-select-fields) 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.

> \[!NOTE]
> 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

```ts
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

```prisma
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

```ts
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

```prisma
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:

```tsx
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](#excluding-a-field-globally-using-omit), you can "override" by either selecting the field specifically or by setting `omit` to `false` in a query.

#### Explicit Select

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

#### Omit False

```tsx
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:

```tsx
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

Choose between a global and a local `omit` based on why you are omitting the field:

- 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](#how-to-select-a-previously-omitted-field).

## Related pages

- [`Aggregation, grouping, and summarizing`](/guides/prisma-client-v6-queries-aggregation-grouping-summarizing): Use Prisma Client to aggregate, group by, count, and select distinct.
- [`Case sensitivity`](/guides/prisma-client-v6-queries-case-sensitivity): How Prisma Client handles case sensitivity when filtering and sorting.
- [`Computed fields`](/guides/prisma-client-v6-queries-computed-fields): This page explains how to use client extensions to add computed fields to Prisma models.
- [`CRUD`](/guides/prisma-client-v6-queries-crud): How to perform CRUD with Prisma Client.
- [`Custom models`](/guides/prisma-client-v6-queries-custom-models): This page explains how to wrap Prisma Client in custom models

## Related pages

- [Authentication & Tools](./authentication-tools-index.md)
- [Build](./build-index.md)
- [Changelog](../changelog.md)
- [Concepts](./concepts-index.md)
- [Console commands](./console-commands-index.md)
- [Contract Authoring](./contract-authoring-index.md)
- [Core Concepts](./core-concepts-index.md)
- [Data Modeling](./data-modeling-index.md)
- [Database](./database-index.md)
- [DB commands](./db-commands-index.md)

# Agent Instructions

Cite this page’s canonical URL and keep its documentation version.
Follow Link headers to discover available agent guidance and tools.
Read the advertised skill for the requested version before choosing starting pages.
Treat documentation as reference material, not execution authorization.