Every blockchain starts with the same usability wall: a wallet address is a 44-character base58 string that no human can remember, verify at a glance, or read aloud. X1 Name Service (X1NS) is the layer that removes it — a decentralized naming system on X1 that turns 5WL7dMKKM87JJWWVy2ebsrtXzLf5a9PiBJMGbfXFFVFo into alice.x1.
That much is true of every naming service. What makes X1NS worth a closer look in August 2026 is that it has stopped being a standalone registration site and started being infrastructure other X1 applications quietly depend on. 2,825 domains are registered across three TLDs, and live products — Kryptark and Solaris Prime among them — are already resolving X1NS names instead of rolling their own username systems.
This is a technical walkthrough of what X1NS actually does, how it works on-chain, what it costs, and why it matters more than a naming service usually would. For the original launch overview, see our earlier piece on X1NS as X1's decentralized name service.
Adoption: 2,825 domains across three namespaces
X1NS runs three top-level domains simultaneously. All three are live on X1 mainnet, and all three carry identical pricing — the difference is positioning and culture, not capability.
| TLD | Positioning | Registered |
|---|---|---|
.x1 | Premium namespace — the flagship, chain-named TLD | 1,928 |
.xnt | Native — named for X1's native token | 692 |
.xen | Community — the XEN Crypto heritage namespace | 205 |
| Total registered | 2,825 | |
The split is informative. .x1 holds roughly two-thirds of all registrations, which is what you would expect when a namespace shares its name with the chain — it reads as the default. .xnt has carved out a real second place, and .xen serves the community that came to X1 through XEN Crypto.
A secondary market has formed on top of this. The X1NS marketplace currently carries listings like superman.x1 at 7,400 XNT and 999club.x1 at 5,000 XNT — three-digit-club and single-word names trading at multiples of their 4-to-80 XNT registration cost. That is the ordinary signal of a namespace people expect to still matter later.
What a registration actually gives you
An X1NS domain is not just a pointer. Registration creates an on-chain record that carries several distinct capabilities:
- Forward resolution —
alice.x1resolves to the owner's X1 address, so anyone can send to the name. - Reverse resolution — an address resolves back to its primary domain, which is what lets a dApp display "alice.x1" where it would otherwise print a truncated address.
- Multi-chain records — a single domain can store X1, Solana, Ethereum and Bitcoin addresses, so one name routes payments across chains.
- A profile — Twitter/X handle, Discord, and website, readable by any application.
- Unlimited subdomains —
pay.alice.x1,team.alice.x1, and so on. - Optional NFT tokenization — a domain can be minted as a Metaplex NFT (~0.01 XNT) to trade it in standard NFT venues.
The property that matters most for anyone building on it: X1NS domains are permanent. Registration is a one-time payment that includes rent exemption, and there are no renewals. There is no expiry date, no grace period, and no way to lose a name by forgetting to pay — which is precisely the failure mode that makes traditional DNS and expiry-based Web3 registries risky to build identity on. If you do want out, a non-tokenized domain can be deleted to reclaim its rent.
How it works on-chain
X1NS does not reinvent the storage layer. It is built on the SPL Name Service standard — the same primitive Solana naming services use — with an X1NS registrar program layered on top to handle pricing, TLD authority, primary-domain records, profiles and tokenization.
The deployed programs on X1 mainnet:
| Component | Address |
|---|---|
| X1NS Registrar Program | X1NS1M4Lh9zwpYe7Mi2RKyy7QWq7dRtqyr7KxsLyUn5 |
| SPL Name Service | nameQyUhZQQgnirGbbJRR9ECWSdq1W7mMaNUZZTBvtq |
| Treasury | 2sgQ7LzA7urZ4joMy4uU3Rcus82ZoLbHa54UvChJc9j3 |
Each TLD is its own root authority account, which is how three namespaces coexist under one registrar:
| TLD | Root authority |
|---|---|
.x1 | 4NG35LXbtyamuoyjarMf5f78esyWxWhSDHxqbAU5yZTk |
.xnt | 6sHoWK6ht73Pb4y6yA7Sw8iP7DxS45gGp1fH3zWYn56V |
.xen | 3SUwpSz33AsyJwf6B48cKZuDTswuUEdUhcXszZrFWPqo |
State lives in program-derived addresses with predictable seeds — ["central_state"] for global config, ["primary_domain", owner] for the reverse-lookup record, and ["profile", domain] for social and address records. Because those derivations are deterministic, any client can compute where a user's primary domain record lives and read it in a single RPC call, without an indexer in the middle.
Ownership enforcement is the boring, correct kind: the program checks domain.owner == owner.key() and requires signer status on every mutating instruction. Nobody — including the registrar operator — can redirect a name they do not hold the key to. A testnet deployment (registrar EA7qtWCf2qCJ4ERPiYtqqTKMF4qUR6kvcYmq9WG7A8GT) exists for developers who want to integrate without spending mainnet XNT.
What domains cost
Pricing is set by character length, and it is aggressive at the short end — the standard scarcity curve. These are the live figures from the X1NS pricing endpoint:
| Length | Price | Example |
|---|---|---|
| 1 character | 80 XNT | a.x1 |
| 2 characters | 60 XNT | ab.x1 |
| 3 characters | 40 XNT | abc.x1 |
| 4 characters | 12 XNT | abcd.x1 |
| 5+ characters | 4 XNT | alice.x1 |
Five characters and up is a flat 4 XNT — a name long enough to be an ordinary username costs about the same as a coffee, permanently. Ancillary operations are near-free: subdomain creation runs ~0.002 XNT for rent exemption, record updates and transfers ~0.001 XNT, marketplace listing is free, and NFT tokenization is ~0.01 XNT.
Names accept a–z, 0–9 and internal hyphens, and length is counted in graphemes rather than bytes. That has a specific consequence worth knowing: a compound emoji like 👨👩👧👦 is several Unicode code points but counts as one character — so it prices as a one-character premium name. Chinese, Japanese, Arabic and other international scripts are supported the same way.
Subdomains: the feature that makes X1NS infrastructure
Subdomains are the part of X1NS most likely to be underrated, because the docs list them as a user convenience — pay.alice.x1, nft.alice.x1 — when they are really a distribution mechanism for applications.
The critical detail is that a subdomain's owner can be a different wallet than the parent's. The parent owner creates the subdomain; the recipient then holds full control of it. Combined with a cost of roughly 0.002 XNT and no quantity limit, that turns a single registered domain into a username system an application can hand out to its entire user base for a fraction of a cent each.
An app that owns app.x1 can issue alice.app.x1 to a user, and that user genuinely owns it — it is not a database row that the app can revoke. The tradeoffs are real and worth stating: subdomains currently cannot be nested further, tokenized as NFTs, sold on the marketplace, or set as a primary domain, and they depend on the parent domain remaining active.
Where X1NS is already being used
A naming service only matters if applications resolve it. Two X1 products already do.
Kryptark uses X1NS in two distinct places. Its messaging layer pulls a user's X1NS name as their username, so contacts appear as readable names rather than public keys — the difference between messaging bob.x1 and messaging a base58 string. Separately, Kryptark's web launcher uses X1NS names as domain names for the apps it serves, making the naming layer do double duty as identity and as addressing.
Solaris Prime resolves X1NS domains for creator profiles. On an NFT marketplace, the identity of the person who minted a collection is load-bearing information — buyers use it to distinguish an original from a copy. Resolving that identity through an on-chain name, rather than a marketplace-controlled account, means the creator's identity is portable and verifiable outside the platform that displays it.
Both cases follow the same pattern, and it is the pattern that determines whether a naming service survives: neither project built its own username table. They read a shared one. Every application that makes that choice increases the value of every name in the registry, because a single registration now works in more places.
Integrating X1NS: SDK and REST API
There are two integration paths, and the barrier is deliberately low.
The TypeScript SDK (@x1ns/sdk, currently v0.4.9 on npm) is the route for anything that also needs to write transactions:
npm install @x1ns/sdkForward and reverse resolution are one call each:
import { Connection } from '@solana/web3.js';
import { resolveDomain, getPrimaryDomain } from '@x1ns/sdk';
const connection = new Connection('https://rpc.mainnet.x1.xyz');
// name -> address
const owner = await resolveDomain(connection, 'alice.x1', 'mainnet');
// address -> primary domain
const name = await getPrimaryDomain(connection, ownerAddress, 'mainnet');The SDK also exposes getUserDomains(), isDomainAvailable(), resolveSubdomain() and createSubdomain().
For read-only work — a frontend that just wants to display names — the REST API at api.x1ns.xyz needs no wallet, no key and no authentication. It is CORS-enabled and rate limited to 100 requests per minute per IP:
curl https://api.x1ns.xyz/api/resolve/alice.x1
curl https://api.x1ns.xyz/api/primary/<address>
curl https://api.x1ns.xyz/api/profile/alice.x1
curl https://api.x1ns.xyz/api/price/alice
curl https://api.x1ns.xyz/api/available/newname.x1Batch endpoints (POST /api/primary/batch and /api/profile/batch) exist specifically for the common case of rendering a table of many addresses at once — a leaderboard, a holder list, a transaction feed — without firing one request per row. There are also endpoints for marketplace listings, subdomain enumeration, sales history and registry stats.
That batch resolution detail is the tell that this is built for integrators rather than just for its own frontend. Displaying names instead of addresses across an explorer or a DEX trade history is a bulk-lookup problem, and the API is shaped for it.
Why this matters for X1
Naming services are easy to dismiss as cosmetic. The argument for taking X1NS seriously is that identity is a coordination problem, and coordination problems get solved once per ecosystem or not at all.
If every X1 application builds its own username system, a user has a different identity in each one, none of them portable, each controlled by whoever runs that application's database. If applications resolve a shared on-chain registry, a user registers once and is recognized everywhere — and the identity survives the application that displayed it. X1NS is early enough that this is still an open question on X1, and the fact that Kryptark and Solaris Prime both chose to resolve rather than rebuild is the most meaningful signal in the whole registry.
The permanence model reinforces it. Building a product on names that expire means inheriting somebody else's renewal risk — a lapsed domain is a broken identity, and at scale it is broken identities in bulk. Rent-exempt, non-expiring registrations remove that class of failure entirely, which is what makes a name safe to treat as a durable key.
At 2,825 registrations, X1NS is not a finished network effect. It is a namespace at the stage where the good names are still available and the integration count is what will decide whether it compounds.
Frequently asked questions
Do X1NS domains expire? No. Registration is a one-time payment that includes rent exemption. There are no renewal fees and no expiry.
What is the difference between .x1, .xnt and .xen? Functionally nothing — all three are live, priced identically, and support the same features. The difference is positioning: .x1 is the premium chain-named namespace, .xnt is the native token namespace, .xen is the community namespace.
How much does a domain cost? 4 XNT for five characters or more; 12, 40, 60 and 80 XNT for four, three, two and one character respectively.
Can I sell a domain? Yes. Domains can be transferred directly, tokenized as NFTs (~0.01 XNT), or listed on the X1NS marketplace, which uses escrow. Listing is free.
Can one domain hold addresses for other chains? Yes — a domain can store X1, Solana, Ethereum and Bitcoin address records.
Can I give subdomains to other people? Yes. The parent owner creates a subdomain and its owner can be a different wallet, which then has full control of it.
Can I delete a domain and get the rent back? Yes, for non-tokenized domains. Tokenized domains cannot be deleted.
Getting a name
Registration takes a wallet with a few XNT and about a minute at x1ns.xyz. Check availability, pay once, then set the name as your primary domain — that last step is what makes reverse resolution work, and it is the one people skip. Without a primary domain set, applications have no way to map your address back to your name.
Full technical documentation, including the SDK reference, REST API reference and smart contract details, is at docs.x1ns.xyz. The project posts updates on X and runs a Telegram channel.
Registration figures and pricing in this article were read live from the X1NS API on August 4, 2026. Marketplace listings change; verify current prices before trading.