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

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

By default Prisma Client returns all fields from a model. You can use [`select`](/orm/v6/prisma-client/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 [#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 [#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 [#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 [#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 [#ensuring-excluded-fields-dont-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 [#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](#how-to-select-a-previously-omitted-field).

## Related pages

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