# MCP Resources vs Resource Templates: The Simple Difference

> Source: <https://blog.devgenius.io/mcp-resources-vs-resource-templates-the-simple-difference-715fb848ff22?source=rss----4e2c1156667e---4>
> Published: 2026-08-27 20:46:01+00:00

MCP has **Resources** and **Resource Templates**.

They sound almost identical.

But there’s one simple difference:

A Resource points to a specific piece of data. A Resource Template describes a pattern for finding many pieces of data.

Once you understand that, the whole concept becomes much easier.

An MCP Resource represents something specific that a client can access.

For example:

```
file:///docs/getting-started.md
```

This points to one particular resource: getting-started.md.

Another example could be:

```
user://123/profile
```

Here, 123 identifies a specific user.

The important part is that the URI is **concrete**.

You know exactly which resource you’re referring to.

Think of it like an address:

“Give me the document at this exact address.”

That’s a Resource.

Now imagine you don’t want to define a separate resource for every user.

You could have:

```
user://{user_id}/profile
```

This is a **Resource Template**.

The {user_id} is a variable.

So the same template could resolve to:

```
user://123/profileuser://456/profileuser://789/profile
```

Instead of describing one resource, you’re describing a **pattern for addressing resources**.

Think of it like:

“Give me the profile for whichever user ID I provide.”

That’s a Resource Template.

Think about a URL.

A specific URL:

```
/users/123
```

points to one thing.

A URL pattern:

```
/users/{user_id}
```

describes how to access many things.

MCP Resources and Resource Templates work with essentially the same mental model.

Imagine a company with offices.

A Resource would be:

New York Office

A Resource Template would be:

Office in{city}

The first points to one specific thing.

The second tells you how to identify different things.

That’s the difference.

Use a **Resource** when you already know the specific resource you want to expose.

For example:

```
docs://getting-started
```

Use a **Resource Template** when the resource depends on some variable.

For example:

```
user://{user_id}/orders
```

The client can then construct a URI for the particular user it needs.

A Resource Template doesn’t mean you’ve created every possible resource upfront.

You’re defining the **URI pattern** that can be used to identify resources dynamically.

That’s why templates are particularly useful when your MCP server exposes data such as:

Instead of registering thousands of individual resources, you can describe the pattern once.

You don’t need to memorize complicated definitions.

Just remember:

Resource = a specific thing.

Resource Template = a pattern for finding things.

Once you see it this way, the difference between the two becomes pretty obvious.

[MCP Resources vs Resource Templates: The Simple Difference](https://blog.devgenius.io/mcp-resources-vs-resource-templates-the-simple-difference-715fb848ff22) was originally published in [Dev Genius](https://blog.devgenius.io) on Medium, where people are continuing the conversation by highlighting and responding to this story.