For developers

API

A hosted read API and signing endpoint are in progress. Everything the API will offer is already readable directly from the contracts today.

Hosted API The public REST API is not live yet. This page is a placeholder with the intended shape so integrators can plan against it — treat every endpoint below as subject to change until it ships.

What you can do right now, without us

Nothing in the protocol requires our infrastructure. Every read below is a get method on a deployed contract, and any TON RPC provider will serve it.

You want	Call this	On
Does this name exist?	`isRegistered(nameHash)`	Registrar
Can I register it?	`isAvailable(nameHash)`	Registrar
Who owns it?	`ownerOf(nameHash)`	Registrar
When does it expire?	`expiresAt(nameHash)`	Registrar
What does it cost?	`priceRegister(count, years)`	Registrar
What does it resolve to?	`dnsresolve(subdomain, category)`	Resolver
What is the live auction state?	`auctionOf(nameHash)`	Registrar
What tier is this name?	`emojiUnitsOf(rawName)`	Registrar

See Integration for the full list. A read-only integration needs no API key, no rate limit negotiation and no dependency on us staying online.

What the API will add

The API exists to make the things that are awkward on-chain easy. It is a convenience layer, never a source of truth.

Indexed queries. The registry is a map with point lookups only — there is no on-chain way to ask "which names expire this week" or "what does this wallet own". The API will index the message stream and answer those.
Attestation issuing. Registration requires a signature over the canonical name. The signing endpoint normalises the input, refuses anything the chain would refuse, and returns an attestation bound to the registrar you name.
Spoofing risk lookups. The confusability model described in Risks needs the live registry to answer "does this name impersonate something that already exists". That check belongs in a service, and it is deliberately built to evolve independently of the frozen on-chain rules.
Metadata. Resolved names, tiers and marketplace content, cached and CDN-served.

Intended shape

GET  /v1/name/:name           → normalized form, tier, availability, price
GET  /v1/name/:name/records   → resolved records
GET  /v1/name/:name/risk      → spoofing risk band + neighbours
GET  /v1/owner/:address       → names held by an address
GET  /v1/auctions             → live lots
POST /v1/attest               → signed attestation for a registration

Verify on-chain before you move money When the API ships, treat it as a convenience layer. Anything that decides where funds go — the address a name resolves to, whether a name is really owned by who you think — should be confirmed against the contract. That is true of every hosted indexer in crypto, ours included.

Rate limits, keys and SLAs

Published with the API. Read endpoints will be free at reasonable volume; the attestation endpoint is tied to the registrar deployment it signs for.

In the meantime

The TypeScript wrappers in the repository cover message construction, storage layouts, name hashing and the full normalization module. They are what our own front end uses, so they are exercised by the same test suite. If you are integrating before the API lands, import those rather than reimplementing the encodings — see Integration and Contact if you need a hand.