<!-- mobian-agent-page publisher="dailydev" canonical="https://daily.dev/posts/what-s-the-difference-between-type-and-interface-in-typescript--k7yr5ybi5" -->

---
title: What’s the difference between Type and Interface in...
description: Explores the key differences between TypeScript&#x27;s `type` and `interface` keywords. Covers extensibility (interfaces can be reopened and merged, types cannot),...
canonical: https://daily.dev/posts/what-s-the-difference-between-type-and-interface-in-typescript--k7yr5ybi5
twitter:card: summary_large_image
twitter:site: @dailydotdev
og:type: website
og:site_name: daily.dev
og:title: What’s the difference between Type and Interface in TypeScript? | daily.dev
og:description: Explores the key differences between TypeScript&#x27;s `type` and `interface` keywords. Covers extensibility (interfaces can be reopened and merged, types cannot),...
og:url: https://daily.dev/posts/what-s-the-difference-between-type-and-interface-in-typescript--k7yr5ybi5
og:image: https://api.daily.dev/og/posts/k7yR5YBI5.png
og:image:alt: What’s the difference between Type and Interface in TypeScript?
og:image:width: 1200
og:image:height: 630
og:locale: en
---

> ## Documentation Index
> Fetch the complete documentation index at: https://daily.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# What’s the difference between Type and Interface in TypeScript?

**[Anatoly Nevzorov](https://daily.dev/sources/jvpzarqiwzmpaq2t2z7ys)** · [@anatolynevzorov](https://daily.dev/anatolynevzorov) · 6 min read · 605 upvotes · 66 comments

## Summary

Explores the key differences between TypeScript's `type` and `interface` keywords. Covers extensibility (interfaces can be reopened and merged, types cannot), flexibility (types handle unions and complex structures better), performance considerations, and practical usage guidelines. Recommends using interfaces for object shapes and extensible APIs, and types for unions, tuples, and complex type logic.

## Content

```text
Attention! This article has been edited with the help of AI. If that fact makes you twitch or you have a personal grudge against AI, if you’re worried it might bruise your fragile soul, if you’re dead sure Skynet started the same way, or if your backside is already overheating - just stop here. Go meditate, bake a pie, or yell at some clouds instead. Preserve your inner peace and channel that energy into something useful. Thanks!
```

Ever stared at a TypeScript file and thought: *“Wait… why did I just use `type` here instead of `interface`?”* Yeah. Me too. And honestly? It’s not always obvious. Feels like choosing between ketchup and mustard on a hot dog — both kinda work, but someone out there will judge you *hard*.  

Let’s cut through the noise. No fluff. Just real talk, weird analogies, and a few hot takes. We’re diving into the **Type vs Interface** tango in TypeScript. Not the textbook way. The *way* — like explaining quantum physics using pizza toppings.

---

Imagine you're building a Lego city.  
`interface`? That’s your modular Lego baseplate. You snap pieces together. Want to extend a house? Just click another block on top. Need a balcony? Attach it. Tomorrow? Add solar panels. It’s *open-ended*. Evolves. Grows. Like a Tamagotchi, but less tragic when you forget it.

Now `type`? That’s your custom 3D-printed Lego piece. Precise. Sharp edges. Does *exactly* what you designed. But once it’s printed? No modifications. Want changes? Recreate the whole thing. Brutal. Efficient. Final.

That’s the vibe.

---

### So What’s the Real Difference?

Let’s not sugarcoat it — in 90% of cases, they do *almost* the same thing. You can define object shapes, functions, even unions. But the devil’s in the details. And TypeScript’s devil wears Prada and judges your code style.

#### 1. **Extensibility: The Big One**

`interface` can be **reopened**. Like a restaurant that closes at 3 PM and magically reopens at 7 with a new menu.

```ts
interface Cat {
  meow: () => string;
}

// Later, somewhere else in your code...
interface Cat {
  purr: () => string;
}

// Boom. Cat now has both meow AND purr.
// TypeScript just… merged them. No drama.
```

Try that with `type`? Nope. Compiler throws a fit. *"Cannot redeclare ‘Cat’"*. It’s a one-shot deal. Like a tattoo you regret at 2 AM.

```ts
type Dog = {
  bark: () => string;
};

type Dog = {
  wagTail: () => void;
}; // ❌ Error. TypeScript says: "Nah, bro. Pick one."
```

So if you’re building a library, or expect your types to evolve across files? `interface` is your BFF.

---

#### 2. **Flexibility in Shape**

`type` doesn’t play by the same rules. It’s… wilder. Can represent **unions**, **tuples**, **mapped types**, **conditional types** — stuff `interface` just can’t handle.

```ts
type Status = 'loading' | 'success' | 'error';
type Coordinates = [number, number];
type Maybe<T> = T | null | undefined;
```

Try doing that with `interface`? Good luck. You’ll end up with 17 interfaces and a therapist.

`interface` is strict. It likes objects. It likes structure. It drinks black coffee and reads the spec before bed.

`type`? It’s the one at the party doing handstands on the couch, yelling, *“I can be a string OR a function OR a recursive tree — deal with it!”*

---

#### 3. **Merging vs. Intersection**

`interface` merges automatically. Like two rivers joining.

```ts
interface User {
  id: number;
}

interface User {
  name: string;
}

// User now has id + name. Magic? Or just TypeScript being slick?
```

`type`? No merging. But you can **intersect**:

```ts
type Id = { id: number };
type Name = { name: string };
type User = Id & Name; // Same result, but manual work.
```

It’s like building a sandwich. `interface` hands you a fully stacked one. `type` gives you ingredients and a knife. You do the slicing.

---

#### 4. **Performance & Tooling**

Here’s a spicy take: **interfaces are slightly better for large-scale projects**. Why? Because TS can optimize them. Faster autocomplete. Smoother refactoring. Less "TS Server is thinking..." moments.

Types? They’re heavier. Especially complex unions. Can slow down IDEs. Not a dealbreaker. But if you’re working on a codebase the size of a small moon? Every millisecond counts.

---

### So… What Should You Use?

Let’s get real. There’s no *one* answer. But here’s my rule of thumb — forged in fire, broken builds, and late-night debugging:

> **Use `interface` for public APIs, objects, and things that might grow.**  
> **Use `type` when you need flexibility — unions, tuples, or complex logic.**

Examples?

✅ **Go for `interface`:**
- Shapes of objects (users, config, API responses)
- Classes implementing contracts
- Libraries or shared code
- Anything you might extend later

✅ **Go for `type`:**
- Union types (`'dark' | 'light'`)
- Tuples (`[string, number]`)
- Function signatures with overloads
- Conditional or mapped types
- When you need `&` or `|` in the definition

And hey — don’t overthink it. If you’re just starting? Pick `interface` for objects. It’s safer. More predictable. Like wearing socks with sandals — functional, even if not trendy.

---

### A Few Curveballs

You *can* extend an `interface` from a `type` — but only if the type is object-like.

```ts
type Animal = { sound: string };
interface Dog extends Animal { breed: string; } // ✅ Works
```

But not the other way around if the type uses unions or primitives.

And `type` can mimic `interface` using `&`, but it’s clunkier. Like using duct tape to fix a Rolex.

---

### Final Thoughts?

It’s not about which is *better*. It’s about **fit**.

Think of `interface` as a well-tailored suit — clean, structured, meant to be built upon.  
`type`? That’s your Swiss Army knife. Not pretty, but damn useful when things get weird.

Use both. Respect both. And for the love of linting, **don’t religiously stick to one**. That way lies madness.

Oh, and if your teammate insists `interface` is *always* superior? Ask them to define a union with it… then walk away slowly.

## Community discussion

Top comments from developers on daily.dev.

**@ed1nh0** · 22 upvotes

> I enjoyed the informal style of explaining the diffs between them, but I still couldn't quite grasp it. I truly believe that, in my case, `type` will always serve ~~the~~ **my** purpose.

**@duke\_silver** · 3 upvotes

> Great article, love the way this is written!

**@akkitto** · 2 upvotes

> Everyone is complimenting that writing style, but it very strongly reminds me of ChatGPT. Did you write this on your own or did you use help? :)

**@muriithigakuru** · 2 upvotes

> Great piece. However, I found it rather hard to relate to the lego analogy

**@kavinda1995** · 2 upvotes

> 7+ years in JS/TS land - And this is the best explanation I've seen throughout! Kudos 🎉🔥
>
> Nicely summarized at the end -
> `Use interface for public APIs, objects, and things that might grow. Use type when you need flexibility — unions, tuples, or complex logic.`

## Similar posts on daily.dev

- [Don’t just attend KubeCon \+ CloudNativeCon, Merge Forward your experience\!](https://daily.dev/posts/don-t-just-attend-kubecon-cloudnativecon-merge-forward-your-experience--l0rpp73x8) · CNCF · 1 upvotes · 0 comments
- [Announcing H2 2026 KCDs](https://daily.dev/posts/announcing-h2-2026-kcds-m96goajm1) · CNCF · 1 upvotes · 0 comments
- [Two months of Open Community Groups](https://daily.dev/posts/two-months-of-open-community-groups-asf52zhbs) · CNCF · 0 upvotes · 0 comments

---

Tags: [#webdev](https://daily.dev/tags/webdev), [#javascript](https://daily.dev/tags/javascript), [#typescript](https://daily.dev/tags/typescript)

[View this post on daily.dev](https://daily.dev/posts/what-s-the-difference-between-type-and-interface-in-typescript--k7yr5ybi5)

```json
{"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]}
{"@context":"https://schema.org","@type":"DiscussionForumPosting","mainEntityOfPage":"https://daily.dev/posts/what-s-the-difference-between-type-and-interface-in-typescript--k7yr5ybi5","headline":"What’s the difference between Type and Interface in TypeScript?","text":"Explores the key differences between TypeScript's `type` and `interface` keywords. Covers extensibility (interfaces can be reopened and merged, types cannot), flexibility (types handle unions and complex structures better), performance considerations, and practical usage guidelines. Recommends using interfaces for object shapes and extensible APIs, and types for unions, tuples, and complex type logic.","url":"https://daily.dev/posts/what-s-the-difference-between-type-and-interface-in-typescript--k7yr5ybi5","datePublished":"2025-08-06T19:43:21.982Z","dateModified":"2025-09-10T15:28:16.180Z","author":{"@type":"Person","name":"Anatoly Nevzorov","url":"https://daily.dev/anatolynevzorov","image":"https://media.daily.dev/image/upload/s--Z8r74PPz--/f_auto/v1752003046/avatars/avatar_JvPzARQiWzmPAq2T2z7YS?_a=BAMClqZW0","interactionStatistic":{"@type":"InteractionCounter","interactionType":{"@type":"EndorseAction"},"userInteractionCount":1150}},"image":"https://media.daily.dev/image/upload/s--mzDZMOG2--/f_auto/v1754509844/posts/k7yR5YBI5?_a=BAMClqZW0","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":605},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":66}],"comment":[{"@type":"Comment","text":"I enjoyed the informal style of explaining the diffs between them, but I still couldn’t quite grasp it. I truly believe that, in my case, type will always serve the my purpose.","datePublished":"2025-08-08T12:27:34.858Z","url":"https://daily.dev/posts/k7yR5YBI5#c-NZnXnpxGh","author":{"@type":"Person","name":"Edson Simão Jr","url":"https://daily.dev/ed1nh0","image":"https://media.daily.dev/image/upload/s--X_mpCbNx--/f_auto/v1763031241/avatars/avatar_OOw9XxPIvvQflUj8Ikoxq?_a=BAMAK+ZW0"},"interactionStatistic":{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":22}},{"@type":"Comment","text":"Great article, love the way this is written!","datePublished":"2025-08-10T08:10:39.960Z","url":"https://daily.dev/posts/k7yR5YBI5#c-ExnCtp7bD","author":{"@type":"Person","name":"Nick","url":"https://daily.dev/duke_silver","image":"https://media.daily.dev/image/upload/s--O0TOmw4y--/f_auto/v1715772965/public/noProfile"},"interactionStatistic":{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":3}},{"@type":"Comment","text":"Everyone is complimenting that writing style, but it very strongly reminds me of ChatGPT. Did you write this on your own or did you use help? :)","datePublished":"2025-08-20T17:50:02.187Z","url":"https://daily.dev/posts/k7yR5YBI5#c-A3P3cvrZY","author":{"@type":"Person","name":"Daniel","url":"https://daily.dev/akkitto","image":"https://media.daily.dev/image/upload/s--FtwJqX4c--/f_auto/v1754900041/avatars/avatar_29TCpY2hJR72V3BlxPXzX?_a=BAMClqZW0"},"interactionStatistic":{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":2}},{"@type":"Comment","text":"Great piece. However, I found it rather hard to relate to the lego analogy","datePublished":"2025-08-11T06:31:27.269Z","url":"https://daily.dev/posts/k7yR5YBI5#c-vcXXUgaJR","author":{"@type":"Person","name":"Antony Gakuru","url":"https://daily.dev/muriithigakuru","image":"https://media.daily.dev/image/upload/s--2Ht2dsXL--/f_auto/v1754820640/avatars/avatar_AnvjoAe3UipNGHQzuezK4?_a=BAMClqZW0"},"interactionStatistic":{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":2}},{"@type":"Comment","text":"7+ years in JS/TS land - And this is the best explanation I’ve seen throughout! Kudos 🎉🔥\nNicely summarized at the end -\nUse interface for public APIs, objects, and things that might grow. Use type when you need flexibility — unions, tuples, or complex logic.","datePublished":"2025-08-17T15:14:29.188Z","url":"https://daily.dev/posts/k7yR5YBI5#c-kzZ0n65At","author":{"@type":"Person","name":"Kavinda Jayakody","url":"https://daily.dev/kavinda1995","image":"https://avatars0.githubusercontent.com/u/19621533?v=4"},"interactionStatistic":{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":2}}],"isPartOf":{"@type":"WebPage","url":"https://daily.dev/sources/jvpzarqiwzmpaq2t2z7ys","name":"Anatoly Nevzorov"}}
{"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Anatoly Nevzorov","item":"https://daily.dev/sources/jvpzarqiwzmpaq2t2z7ys"},{"@type":"ListItem","position":3,"name":"What’s the difference between Type and Interface in TypeScript?"}]}
```