Understanding TypeScript Record<K, T>: Definition, Usage, and Examples

By the end of this page, you will understand that Record<K, T> is a TypeScript utility type for building an object type whose keys come from K and whose values all have type T. You will also see how it compares to writing object types by hand, how extra keys behave, and when Record is useful in real code.

Record<K, T> is a utility type that creates an object type.

Its meaning is:

• use the set of property names in K
• for each of those property names, assign the value type T

The common mental reading is:

"An object with keys K, where every listed key stores a value of type T."

The core definition is:

type Record<K extends keyof any, T> = {
  [P in K]: T;
}

A simpler form is often shown as:

type Record<K extends string, T> = {
  [P in K]: T;
}

What K does

K is the set of allowed property names that this type will create.

For example:

Think of Record<K, T> like making a row of labeled storage boxes.

• K is the list of labels to print on the boxes
• T is the kind of item each box is allowed to hold

Example:

Record<'name' | 'email' | 'city', string>

This means:

• make a box labeled name
• make a box labeled email
• make a box labeled city
• every box must contain a string

So it is like a template for an object shape.

If you try to put a number into one of those boxes, TypeScript complains. If you forget one of the required boxes, TypeScript complains. If you add an unexpected box in a direct object literal, TypeScript often complains too.

Core syntax

Record<K, T>

• K = the property names
• T = the type for each property value

Basic example

type Settings = Record<'theme' | 'language', string>;

const appSettings: Settings = {
  theme: 'dark',
  language: 'en'
};

This is the same as:

type Settings = {
  theme: string;
  language: string;
};

Number values example

type Scores = Record<'alice' | 'bob', number>;

 :  = {
  : ,
  : 
};

Consider this example:

type Fields = Record<'firstName' | 'lastName', string>;

const person: Fields = {
  firstName: 'Ada',
  lastName: 'Lovelace'
};

Step 1: Evaluate the keys

K is:

'firstName' | 'lastName'

That means the object type must include these two properties.

Step 2: Evaluate the value type

T is:

string

That means each property created from K must have a string value.

Step 3: Expand the mapped type mentally

TypeScript treats this roughly like:

type Fields = {
  : ;
  : ;
}

Lookup tables

type Route = 'home' | 'about' | 'contact';
const paths: Record<Route, string> = {
  home: '/',
  about: '/about',
  contact: '/contact'
};

Useful when an app has a fixed set of route names.

Status labels

type Status = 'idle' | 'loading' | 'success' | 'error';
const labels: Record<Status, string> = {
  idle: 'Idle',
  loading: 'Loading...',
  success: 'Success',
  error: 'Error'
};

This ensures every status has a label.

Feature flags

In real TypeScript projects, Record is often used when developers want a key-to-value mapping with known keys.

Common patterns

Configuration objects

type Environment = 'development' | 'production';

const apiBaseUrl: Record<Environment, string> = {
  development: 'http://localhost:3000',
  production: 'https://api.example.com'
};

Enum-like mappings

type Role = 'admin' | 'user' | 'guest';

const permissions: Record<Role, number> = {
  admin: 3,
  user: 2,
  guest: 1
};

Validation result storage

  =  | ;

 (): <, > {
   {
    : values..() ?  : ,
    : values.. >=  ?  : 
  };
}

1. Thinking Record<K, T> means any string key

Broken assumption:

type Person = Record<'name' | 'email', string>;

This does not mean all string keys are allowed. It specifically creates name and email.

To represent arbitrary string keys, use:

type StringMap = Record<string, string>;

2. Forgetting required keys

Broken code:

type Config = Record<'host' | 'port', string>;

const config: Config = {
  host: 'localhost'
};

Problem:

• port is required but missing

Record vs manually written object type

Record vs index signature

Quick definition

type X = Record<K, T>

Creates an object type with:

• keys from K
• values of type T

Expansion rule

Record<'a' | 'b', number>

becomes:

{
  a: number;
  b: number;
}

When to use it

Use Record when:

• you know the keys ahead of time
• all those keys have the same value type

Common examples

type Labels = Record<'save' | 'cancel', string>;
type Flags = Record< | , >;
  = < | , >;

What is Record<K, T> in TypeScript?

It is a utility type that creates an object type with keys from K and values of type T.

Is Record<'a' | 'b', string> the same as { a: string; b: string }?

Yes. In practice, those two types are equivalent.

What does the K in Record<K, T> represent?

K represents the property names, usually as a union such as 'a' | 'b' | 'c'.

Does Record allow extra properties?

Direct object literals usually get an error for extra properties. But values stored in variables may still be assignable if they include the required keys.

Does Record<K, T> mean every property on the object must be type T?

It means every property listed in K must have type T. It does not globally describe every possible property in every situation.

When should I use Record instead of a normal object type?

• Mapped types — Record is built using a mapped type.
• Union types — K is often a union of string literal keys.
• Index signatures — useful to compare with Record<string, T>.
• Partial — often combined with Record to make keys optional.
• Readonly — often combined with Record to make mappings immutable.
• Pick — another utility type for selecting properties from an existing type.
• Structural typing — explains why extra properties may sometimes still be assignable.
• Object types — Record is just a concise way to build object types.