TypeScript keyof: Get Object Keys as a Type, with Examples

keyof takes an object type and produces the union of its property names. keyof User below is the type "id" | "name" | "email", so a variable of that type can only hold one of those three strings.

interface User {
  id: number;
  name: string;
  email: string;
}

type UserKey = keyof User; // "id" | "name" | "email"

const key: UserKey = "name"; // OK
// @ts-expect-error: "age" is not one of the keys of User
const wrong: UserKey = "age";

function printField(user: User, field: keyof User) {
  console.log(`${field}: ${user[field]}`);
}

const ada: User = { id: 1, name: "Ada", email: "ada@example.com" };
printField(ada, "email"); // email: ada@example.com
printField(ada, key);     // name: Ada

keyof exists only in the type system. It is erased when the code compiles, so it never checks anything at runtime. What it gives you is a compile-time guarantee that a key names a real property: rename email in the interface and every "email" typed as keyof User becomes an error.

keyof typeof: Keys of a Plain Object

keyof works on types, not values. For an object you wrote as a value, first get its type with typeof, then take the keys:

const colors = {
  red: "#ff0000",
  green: "#00ff00",
  blue: "#0000ff",
};

type Color = keyof typeof colors; // "red" | "green" | "blue"

function hex(color: Color): string {
  return colors[color];
}

console.log(hex("green")); // #00ff00
// hex("purple") would be error TS2345:
// Argument of type '"purple"' is not assignable to parameter of type '"blue" | "green" | "red"'.

Read it from the inside out: typeof colors is { red: string; green: string; blue: string }, and keyof of that is the key union. Writing keyof colors without typeof fails with error TS2749: 'colors' refers to a value, but is being used as a type here. Did you mean 'typeof colors'?.

This is the usual way to derive a union from a lookup table: add a color to the object and the Color type grows with it. typeof has a second, runtime meaning too; the typeof page covers both.

Typed Property Access with Generics

The most common use of keyof is a generic constraint. K extends keyof T says "K is one of the keys of T", and T[K] is the type of the property at that key:

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const book = { title: "Dune", pages: 412, inStock: true };

const pages = getProperty(book, "pages"); // number
const title = getProperty(book, "title"); // string

console.log(pages + 1);           // 413
console.log(title.toUpperCase()); // DUNE
// getProperty(book, "author") would be error TS2345

The second type parameter matters. With key: keyof T and no K, the return type is T[keyof T], the union of every property type (string | number | boolean here), so title.toUpperCase() would fail with error TS2339: Property 'toUpperCase' does not exist on type 'string | number | boolean'. Capturing the exact key in K keeps the exact property type. T[K] is an indexed access type, described on the indexed access types page.

Indexing with a Plain string

A very common error appears when you index an object with a string that came from somewhere else:

// This does not compile: a plain string is not a key of Settings
interface Settings {
  theme: string;
  fontSize: number;
}

const settings: Settings = { theme: "dark", fontSize: 14 };

function read(name: string) {
  return settings[name];
}

console.log(read("theme"));

The compiler prints:

index.ts(10,10): error TS7053: Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'Settings'.
  No index signature with a parameter of type 'string' was found on type 'Settings'.

Any string could reach read, including "colour", and Settings says nothing about that key. Two fixes: accept only real keys, or check an unknown string before using it.

interface Settings {
  theme: string;
  fontSize: number;
}

const settings: Settings = { theme: "dark", fontSize: 14 };

// Fix 1: only accept real keys
function read(name: keyof Settings) {
  return settings[name];
}
console.log(read("fontSize")); // 14

// Fix 2: narrow a string you do not control
function isSettingsKey(name: string): name is keyof Settings {
  return Object.hasOwn(settings, name);
}

for (const input of ["theme", "colour"]) {
  if (isSettingsKey(input)) {
    console.log(input, "=", settings[input]);
  } else {
    console.log(input, "is not a setting");
  }
}
// theme = dark
// colour is not a setting

name is keyof Settings is a type predicate: when the function returns true, TypeScript treats input as a key inside the if. The type guards page explains predicates in detail.

keyof with Index Signatures: string | number

For a type with an index signature, keyof returns the index type, and a string index signature gives string | number, not just string:

type Scores = { [player: string]: number };

type ScoreKey = keyof Scores; // string | number

const scores: Scores = { ada: 3 };
scores[42] = 7; // allowed: a number key is a valid key

console.log(Object.keys(scores)); // [ '42', 'ada' ]

type OnlyStrings = Extract<keyof Scores, string>; // string
const k: OnlyStrings = "ada";
console.log(k);

JavaScript converts every numeric property key to a string, so scores[42] and scores["42"] are the same property. TypeScript models that by including number. The output also shows a JavaScript rule: integer-like keys are listed first, in ascending order, before the other string keys. When a generic function needs string keys only, write Extract<keyof T, string> or string & keyof T; Exclude and Extract have their own page.

keyof Results at a Glance

The union and intersection rows look backwards at first. A value of a union type might be either member, so only keys present in both are safe. A value of an intersection has everything from both, so it has all the keys.

Why Object.keys Returns string[]

Object.keys(obj) is typed as string[], never (keyof T)[]. The reason is structural typing: a value can carry more properties than its declared type.

interface Point {
  x: number;
  y: number;
}

const point3d = { x: 1, y: 2, z: 3 };
const p: Point = point3d; // allowed: extra properties are fine here

console.log(Object.keys(p)); // [ 'x', 'y', 'z' ]

// When you know the object has exactly its declared keys, cast:
const origin = { x: 0, y: 0 };
for (const key of Object.keys(origin) as (keyof typeof origin)[]) {
  console.log(key, origin[key]);
}
// x 0
// y 0

p is typed Point, yet it has a z key at runtime. If Object.keys promised ("x" | "y")[], code relying on that would be wrong for p. The cast is safe for object literals you created yourself; for objects that arrive from outside, keep the keys as string and check them.

keyof in Mapped Types

keyof is also how you loop over the keys of a type to build a new type. This is how the built-in Partial and Readonly utility types are written:

type MyPartial<T> = { [K in keyof T]?: T[K] };
type MyReadonly<T> = { readonly [K in keyof T]: T[K] };

interface User {
  id: number;
  name: string;
}

type UserDraft = MyPartial<User>; // { id?: number; name?: string }

[K in keyof T] visits each key, and T[K] reads the property type at that key. Mapped types have their own page with modifiers and key remapping.