How to Exclude a Property from a Type in TypeScript

By the end of this page, you will understand how to remove properties from existing types in TypeScript, especially with Omit. You will also see related alternatives like Pick, learn when each is useful, and understand how this pattern is used in real codebases to shape safer object types.

In TypeScript, you often start with a type that describes a full object, then need a smaller version of it.

A common example is when one property should not be included in a new type:

• removing an id before creating a new record
• removing a password before returning a user object
• removing internal metadata from API output

Instead of rewriting the whole type manually, TypeScript lets you derive a new type from an existing one.

The standard utility type for this is Omit.

type XY = Omit<XYZ, "z">;

This means:

• start with XYZ
• omit the property named "z"
• produce a new type containing the remaining properties

This matters because derived types are:

• safer: fewer chances of inconsistencies
• easier to maintain: update the original type once
• clearer: they express intent directly

If XYZ changes later, your derived type updates automatically, except for the omitted keys.

Think of a TypeScript type like a checklist of fields on a form.

If the original form has:

• x
• y
• z

Using Omit<XYZ, "z"> is like photocopying the form and covering up the z field with tape before printing. The new form still has everything else, but z is gone.

So:

• Pick means keep only these fields
• Omit means remove these fields

Both create a new type from an old one without rewriting everything by hand.

Core syntax

type NewType = Omit<OriginalType, "propertyToRemove">;

To remove multiple properties:

type NewType = Omit<OriginalType, "a" | "b">;

Your example

interface XYZ {
  x: number;
  y: number;
  z: number;
}

type XY = Omit<XYZ, "z">;

XY becomes equivalent to:

type XY = {
  x: number;
  y: number;
};

Using the new type

Consider this example:

interface XYZ {
  x: number;
  y: number;
  z: number;
}

type XY = Omit<XYZ, "z">;

const value: XY = {
  x: 1,
  y: 2,
};

Here is what happens step by step:

1. XYZ defines an object type with three properties: x, y, and z.
2. Omit<XYZ, "z"> tells TypeScript to create a new type from XYZ without z.
3. The resulting type XY has only:
   • x: number
   • y: number
4. When is declared as , TypeScript checks that:

API responses

You may have a full database model but want to hide sensitive fields before returning data.

interface User {
  id: number;
  username: string;
  passwordHash: string;
}

type SafeUser = Omit<User, "passwordHash">;

Create requests

A record in the database may have an auto-generated id, but clients should not send it when creating a new item.

interface Product {
  id: string;
  name: string;
  price: number;
}

type NewProduct = Omit<Product, "id">;

UI view models

A frontend component may not need every backend field.

interface Article {
  : ;
  : ;
  : ;
  : ;
}

  = <,  | >;

In real projects, developers frequently derive types instead of rewriting them.

Common patterns

Hiding sensitive data

type PublicUser = Omit<User, "password" | "token">;

This is common in service layers and API handlers.

Request vs stored model

interface Order {
  id: string;
  total: number;
  createdAt: Date;
}

type CreateOrderInput = Omit<Order, "id" | "createdAt">;

The stored model has more fields than the input model.

Guarding function inputs

function createUser(input: Omit<User, "id">) {
  // create and assign id internally
}

This prevents callers from passing fields they should not control.

1. Rewriting the type manually

Beginners often do this:

interface XYZ {
  x: number;
  y: number;
  z: number;
}

type XY = {
  x: number;
  y: number;
};

This works, but it duplicates information. If x or y changes in XYZ, you must remember to update XY too.

Prefer:

type XY = Omit<XYZ, "z">;

2. Confusing Omit with Exclude

Broken example:

type XY = Exclude<XYZ, >;

Omit vs

// Remove one property
type Result = Omit<TypeName, "property">;

// Remove multiple properties
type Result = Omit<TypeName, "a" | "b">;

// Example
interface XYZ {
  x: number;
  y: number;
  z: number;
}

type XY = Omit<XYZ, "z">;

Quick rules

• Omit creates a new type from an existing type
• It does not remove properties at runtime
• The second argument is the property name or union of names to remove
• Use string literal keys like "z"

Related utility patterns

// Keep only some properties
type Small = Pick<XYZ,  | >;


  = < |  | , >;


  = <<, >>;

How do I remove one property from a type in TypeScript?

Use Omit:

type XY = Omit<XYZ, "z">;

Is Omit better than writing a new type manually?

Usually, yes. It avoids duplication and stays in sync with the original type.

Can I omit multiple properties at once?

Yes.

type PublicUser = Omit<User, "password" | "token">;

Does Omit remove the property from the actual object?

No. It only changes the TypeScript type. Use destructuring if you need runtime removal.

What is the difference between Omit and Pick?

• Omit removes named fields
• Pick keeps named fields

Both create a new type from an existing one.

• Pick — keeps only selected properties from an existing type.
• keyof — produces the union of property names of a type.
• Exclude — removes members from a union type.
• Partial — makes all properties optional, often combined with Omit.
• Required — makes all properties required, useful when shaping derived types.
• Mapped types — the underlying mechanism behind many utility types.
• Type aliases — useful for naming transformed types like Omit<XYZ, "z">.
• Interfaces — often the starting point for deriving new object types.