Cheap Developer Domain API: Register Domains in Code at Wholesale + $1

A cheap developer domain API costs the wholesale price of the domain plus a $1 flat fee. With Domainee's Buy a Domain API you get 500+ TLDs and one API call: POST /v1/domain-purchases. No percentage markup. No contact-sales.
One thing up front: Domainee is not a registrar. We register the domain at the upstream registrar (Namecheap and friends) using the registrant contact information you pass in the API call. Your end user ends up as the legal owner. You skip the registrar contracts.
The short answer: what a cheap developer domain API costs
The formula is short:
- Price: wholesale + $1 flat fee.
- Coverage: 500+ TLDs.
- Calls to buy: one.
- Registrant on WHOIS: your end user.
"Cheap" here means a published, predictable margin over wholesale. Not a low sticker price that grows a surprise fee later. Every price and limit is on the pricing page, and none of it is hidden behind a sales call.
Who this fits: SaaS products that want users to buy a domain inside the product. Website builders, store builders, link-in-bio tools, course platforms. Anyone tired of sending users to a registrar tab and hoping they come back.
Who it doesn't fit: someone who wants a handful of domains for themselves. A registrar panel does that fine. This API is for selling domains to your users, not for managing a personal portfolio.
What a domain registrar API actually is
Here is what a domain API is: the interface a registrar exposes for registering, renewing, transferring and managing domain names in code instead of a control panel.
It manages the registration. Who owns the name, when it expires, which registrar holds it, which nameservers it delegates to.
Here is the most useful thing to know before you integrate one. Every domain API is a wrapper over EPP. Almost no registrar documentation says it out loud. The JSON or XML you call is a skin over a handful of EPP commands: check, create, info, renew, transfer, update, delete.
Three terms get mixed up, so here they are side by side:
| API type | What it handles |
|---|---|
| Domain API | The registration itself: owner, expiry, registrar, nameservers |
| DNS API | The records inside a zone (A, CNAME, TXT) |
| Custom domains API | Routing traffic and SSL for a domain someone already owns |
This article is about the first one: buying and managing registrations in code.
What "cheap" really means: wholesale + $1
The pricing model has one line. Wholesale price plus a $1 flat fee. We won't quote per-TLD wholesale prices here. You can get the real number before you charge anyone.
Check availability and price with the authenticated endpoint. It tells you whether the name is free and what it costs. Show that to your user, then buy.
For a quick lookup with no account, there's a free domain availability checker. It is a public REST endpoint too: no key, 30 requests/min and 500/day per IP, CORS-enabled. Use it for lookups and prototypes. Use the authenticated endpoint when you need the price inside your product.
You are only charged on success. The mechanics are Stripe hold and capture:
- Your API call lands.
- We place a hold on your workspace's Stripe card, off-session.
- The domain registers.
- Only then is the card charged.
A card must be on file before the first domain. Without one, the API returns 402 billing_required, even for the first domain. Under the free tier, that card is charged $0.
Register a domain with one API call
You create a purchase with one POST. One call charges your card, registers the domain with your end user as legal owner, sets DNS and connects it to your app.
The API is REST at https://api.domainee.dev/v1, JSON only, with Bearer keys (sk_live_…). The request looks like this:
curl https://api.domainee.dev/v1/domain-purchases \
-H "Authorization: Bearer sk_live_…" \
-H "Idempotency-Key: order-123" \
-d '{ "originUrl": "https://acme.fly.dev", … }'
The … stands for the domain, the registrant contact fields and the autoConnect option. Take their exact names and shapes from the createPurchase docs page, not from us guessing in a blog post.
The response returns three things: domain, registrant and invoice_id.
autoConnect: buy and connect in one POST
Pass autoConnect with an originUrl and the domain is registered, DNS set, edge provisioned and TLS issued. One POST. No second flow.
Your customer never opens a registrar panel and never pastes a record.
Compare that to connecting a domain someone already owns. That always ends with them in a registrar panel adding a record. Buying through the API skips that step.
Retries without double-buying
Send an Idempotency-Key header. We honor it for 24 hours. A retried call after a timeout doesn't buy the domain twice. Your finance team will thank you on a Tuesday.
Who owns the domain? Your end user does
The end user is the legal registrant. WHOIS shows their contact info. Not yours. Not ours.
That has three consequences for you:
- No hostage-taking. The name belongs to the person who bought it.
- No registrar contracts of your own. You pass contact info in the call. We handle the upstream registrar.
- Users can leave. There's a transfer-out auth code endpoint, so a user can take their domain elsewhere.
Yes, that last one means a user can walk. That's the point. Domains should be portable.
The lifecycle your code has to handle after the purchase
Buying is the easy part. Domains live for years, and your code has to follow them. The purchase endpoints cover:
| Need | What you get |
|---|---|
| Check price | Check availability and price |
| Buy | POST /v1/domain-purchases |
| See purchases | List and get purchases |
| Control renewal | Cancel or auto-renew, renew |
| Inspect | Live details, DNS records, nameservers |
| Let users leave | Transfer-out auth code |
| Wire up the app | Connect to app |
Webhooks for renewals
Subscribe to these events:
domain_purchase.completeddomain_purchase.faileddomain_purchase.reneweddomain_purchase.renewal_failed
Each delivery is signed with HMAC-SHA256 in the x-domainee-signature header. Failed deliveries retry 6 times: immediately, then +1 min, +5 min, +30 min, +2 h and +12 h.
Lapses are not cheap
A domain your customer lets lapse is not gone at expiry. And it is not cheap after redemption starts. If your product renews domains on customers' behalf, an alert 30 days before expiry costs nothing.
That's why domain_purchase.renewal_failed deserves a real handler. Email the user. Show a banner. Don't let it sit in a log.
Rate limits
The default is 60 requests per minute per key. Keep your own lookups inside that budget, or send quick checks to the free public endpoint.
Build it yourself vs call the API
Selling domains without running a registrar sounds simple until you list the work:
- Registrar contracts
- EPP status modelling
- Grace-period clocks
- Renewal billing
- ICANN compliance
None of that is your product. It's undifferentiated work that nobody thanks you for. If the goal is to sell domains to your users rather than to run a registrar, calling an API is the shorter route.
Be honest about the limit, though. This is for selling domains to your users. It does not replace a registrar account for your own personal portfolio. Different job.
Domainee is a product of Common Ninja, and Common Ninja, Embeddable and Vidocu run on Domainee in production. Boring infrastructure, in daily use.
Ready to try it
Read the Buy a Domain API docs and run your first POST /v1/domain-purchases. Sign up free at https://domainee.dev/sign-up.
FAQ
What domain registrar has the best API?
Every domain API is a wrapper over EPP, so the useful questions are practical ones. Can you see the price before you charge? Can you retry safely? Do you get renewal events? If you want to sell domains inside your product without running registrar contracts, Domainee's Buy a Domain API is built for that.
Is Domainee a domain registrar?
No. Domainee registers the domain at the upstream registrar (Namecheap and friends) using the registrant contact information you pass in the API call. You get the API and skip the registrar contracts.
How much does the Buy a Domain API cost?
The wholesale price of the domain plus a $1 flat fee. There's no percentage markup. Use the check availability and price endpoint to see the exact figure before you buy.
How do I register a domain with an API?
Send POST /v1/domain-purchases to https://api.domainee.dev/v1 with your Bearer key. The response returns domain, registrant and invoice_id. Add an Idempotency-Key header so a retry doesn't buy twice.
Who is the legal owner of a domain bought through the API?
Your end user. They are the legal registrant, and WHOIS shows their contact info. It doesn't show yours or Domainee's.
Can I connect the domain to my app in the same API call?
Yes. Pass autoConnect with an originUrl. The domain is registered, DNS is set, the edge is provisioned and TLS is issued in one POST.
Is a domain API the same as a DNS API?
No. A domain API manages the registration: owner, expiry, registrar and nameservers. A DNS API manages the records inside a zone. A custom domains API routes traffic and SSL for a domain someone already owns.
What happens when a purchased domain expires or fails to renew?
A lapsed domain isn't gone at expiry, and it isn't cheap once redemption starts. Domainee sends domain_purchase.renewed and domain_purchase.renewal_failed webhooks, so your code can warn the user early.
Do I need a card on file to buy domains through the API?
Yes. Without a card, the API returns 402 billing_required, even for the first domain. Under the free tier, the card is charged $0. For a purchase, a hold lands on it when the call arrives, and the charge happens only once the domain is registered.
Can my users transfer their domain out?
Yes. There's a transfer-out auth code endpoint. The user is the legal registrant, so the domain is theirs to move.
How many TLDs are supported?
500+ TLDs, all at wholesale plus the $1 flat fee.