ENS MCP

I work with at Namespace (opens in a new tab) and use coding agents throughout the day. I still find myself opening an explorer or writing a small script whenever I needed to check a name, its records, or its history.

ENS MCP started as a way to remove that step. It gives an MCP client a small set of read-only ENS tools. The assistant handles the conversation. The server handles the RPC calls, subgraph queries, validation, and response shape.

Why I built it

A question such as “who owns this name?” is simple for a person to ask, but the answer can live in a contract, a ccip gateway, or an L2 Chain.

I did not want every client to rebuild that context. I wanted one server that could expose ENS through typed operations and work with any MCP client.

The first version focused on the questions I check most often:

Is a name available?
How much will it cost to register?
Who owns it and when does it expire?
Which records are set on it?
Which names belong to an address?
Which subnames sit under a name?
What changed in the name's history?

The tool surface

I kept the API small. Each tool does one job and returns data instead of prewritten prose.

Tool	What it returns
`is_name_available`	Whether an ENS name can be registered
`get_name_price`	Base, premium, and total registration price for a human-readable duration
`get_profile_details`	Owner, resolver, expiry, wrapping state, requested text records, coin records, and content hash
`get_names_for_address`	ENS names associated with an Ethereum address, with filters, sorting, and pagination
`get_subnames_for_name`	Subnames below a parent name, with filters, sorting, and pagination
`get_name_history`	Registration, transfer, renewal, resolver, record, and other indexed events for a name
`get_subgraph_records`	The text and coin record keys set on a name

The smaller surface makes tool selection easier to inspect. It also keeps unrelated calls apart. A price lookup does not need to fetch a full profile, and a profile lookup does not need to load every indexed event.

Decisions I kept simple

Read-only by default

The server can inspect ENS, but it cannot register, renew, transfer, or update a name.

That boundary is intentional. Write operations would need wallet access, transaction simulation, confirmation rules, and a different security model. None of that belongs in a read-only lookup server.

Structured results

Tool handlers return objects, arrays, booleans, and formatted values. They do not try to write the final answer for the user.

This leaves presentation with the MCP client. The same result can be used in a chat response, a coding task, or another tool call without parsing text first.

Requested records only

An ENS profile can contain many text and coin records. The profile tool accepts the record keys the caller needs. A request for an owner and an expiry date should not also fetch an avatar, social handles, every address, and a content hash.

Human durations for prices

The pricing tool accepts values such as 1 year, 6 months, or 30 days. The server parses the duration, converts it to seconds, calls ENSjs, and returns the base, premium, and total values in readable ETH units.

Questions it can answer

Once connected, the client can combine the tools for questions such as:

Who owns vitalik.eth, and when does it expire?

Is example.eth available? What would two years cost?

Which ENS names belong to this address, and which ones expire soon?

List the active subnames under envoy1084.eth.

When was the content hash for this name last changed?

The server does not contain a workflow for each sentence. The model chooses one or more tools and works with their results.

Running it

The hosted endpoint is:

https://ens-mcp.namespace.ninja/mcp

Most remote MCP clients only need that URL:

{
  "mcpServers": {
    "ens": {
      "url": "https://ens-mcp.namespace.ninja/mcp"
    }
  }
}

The npm package can run locally over stdio:

npx -y ens-mcp

Or over HTTP:

npx -y ens-mcp --http --port 8080

The server uses a Viem public RPC and the public subgraph by default. Both endpoints can be replaced when self-hosting:

Variable	Purpose
`RPC_URL`	Ethereum mainnet RPC endpoint
`SUBGRAPH_URL`	ENS subgraph endpoint

Current state

The first release exposes seven read-only tools through the hosted endpoint and the ens-mcp npm package. It covers the ENS lookups I use regularly without asking a client to understand contracts, subgraphs, or resolver records.

The code is open source under the MIT license. The implementation and issue tracker are available in the ENS MCP repository (opens in a new tab).