Domani

run.domaniPublished by domani.runOfficial publisherv0.4.15Updated Oct 24, 2026

Internet identity for AI agents: register or broker domains, email, DNS - pay by card or USDC.

VerifiedStreamable HTTPWeb executableCloud & InfrastructureCommunication & CollaborationBusiness & Commerce

Overview

AI-generated overview

Domani gives an AI assistant typed tools to search, buy and manage domains, edit DNS, and create, send and receive email on its own domains.

What you can do
  • Search, suggest, buy, renew, transfer and list domains, with pricing and WHOIS lookups
  • Read, add, delete, snapshot and restore DNS records, set nameservers and auto-configure DNS for hosting or mail providers
  • Create, delete and list mailboxes, read inboxes and folders, send, forward, archive, trash and star messages
  • Set up inbound email webhooks and test them, and check domain health for DNS, SSL, email and expiry
  • Manage account settings such as auto-renew, WHOIS privacy, parking pages, tokens, invoices and notifications
When to use it
Useful when an assistant should obtain and configure its own internet identity: registering a domain, wiring DNS to a host, and running a mailbox it can send from and receive into. Also fits agents that need to provision a domain, mailbox and inbound webhook in one flow.
Requirements
A remote endpoint at domani.run with OAuth login required. A Domani account with a saved payment method is needed for purchases; the CLI path uses DOMANI_API_KEY or a keychain login, and DOMANI_ACCOUNT selects among saved accounts.
Before you install
Buying, renewing and transferring domains charges the saved card, so confirm the account and price first. DNS edits, mailbox deletion, message sending and webhook configuration change live data. API keys and webhook auth headers are secrets; the README recommends scoped, expiring tokens and keeping secrets in environment variables rather than prompts or shell history.

Installation

In SourceWeft

  1. Open Domani in the dashboard and add it to a workspace.
  2. Connect the required credentials. They are stored privately and never shown on public pages.
  3. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/run.domani%2Fdomani/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config. The client completes OAuth sign-in on first connect.

{
  "mcpServers": {
    "domani": {
      "type": "http",
      "url": "https://domani.run/mcp"
    }
  }
}

README

domani

Domains and email - for humans and AI agents.

Register domains, manage DNS, create mailboxes, send and receive email. From your terminal, your agent, or the web.

[npm version] [license]

How it works

domani gives you one account and multiple ways in:

  • Web - Dashboard with a full inbox (compose, reply, threads), DNS editor, domain management
  • CLI - This package. Everything the web app does, from your terminal
  • MCP Server - typed tools for Claude Code, Cursor, Codex, and any MCP-compatible agent
  • OpenClaw - openclaw skills install @gwendall/domani
  • Agent Skill - Step-by-step guide your agent can follow. Install with npx skills add domani.run
  • REST API - Direct HTTP access to everything

All interfaces share the same API key and the same data.

Install

bash
npm install -g domani-cli

Secure MCP bridge

Agent plugins can use Domani without placing an API key in a prompt, shell history, or editor configuration:

bash
domani login --surface mcpdomani mcp serve

domani login stores the credential in the operating-system keychain when one is available. The stdio bridge resolves it locally and forwards MCP requests to https://domani.run/mcp; stdout remains reserved for JSON-RPC messages. To pin the bridge to one of several saved accounts, start it with DOMANI_ACCOUNT=<name> domani mcp serve (or domani --account <name> mcp serve).

For an agent acting on someone else's behalf, request a scoped, expiring credential instead of their account key:

bash
domani login --scopes domains:read,search --label "Project agent" --expires-in 86400

The approval screen shows the requested access and the resulting credential is stored in the keychain without being printed.

After login, prove one complete inbound loop before browsing other tools or buying a domain:

bash
domani email create [email protected]domani email webhook [email protected] --url https://my-agent.example/webhookdomani email webhook-test [email protected]

Use --surface plugin, --surface skill, or --surface api when that is the entry point. This keeps activation attribution consistent without exposing a credential.

This installs the domani command. Or run directly with npx:

bash
npx domani-cli search myapp .com .dev .ai

Quick start

bash
# Domaindomani search myapp .com .io .dev     # Check availabilitydomani buy myapp.dev                  # Purchase a domaindomani connect myapp.dev vercel       # Auto-configure DNS for Vercel
# Emaildomani email create [email protected]               # Create [email protected]domani email send [email protected] \  --to [email protected] --subject "Hello" --body "Sent from my terminal"domani email forward [email protected] \  --forward-to [email protected]                        # Forward inbound to personal email
# Healthdomani status myapp.dev               # DNS, SSL, email, expiry check

Examples

bash
# Find available domains with a budgetdomani search startup --expand --max-price 20
# AI-powered name suggestionsdomani suggest "minimalist productivity app" --style brandable --tlds com,dev,ai
# Buy multiple domains at oncedomani buy startup.dev startup.ai --yes
# Set up Vercel + Google Workspace in two commandsdomani connect startup.dev verceldomani connect startup.dev google-workspace
# Full email workflow: create, send, check inbox, forwarddomani email create [email protected]domani email send [email protected] \  --to [email protected] --subject "Deck" --body "Here's our deck."domani email inbox [email protected] --direction indomani email forward [email protected] --forward-to [email protected]
# Webhook for inbound emails (for bots, support systems, etc.)# CURSOR_AUTH contains the complete value, e.g. "Bearer sender-key"domani email webhook [email protected] --url https://myapp.dev/hooks/email \  --authorization-env CURSOR_AUTHdomani email webhook-test [email protected]
# Provision domain + mailbox + authenticated event webhook in one call.# The secret stays in the environment; only its variable name is in argv.AGENT_AUTH="Bearer sender-key" domani provision agent.dev \  --webhook https://agent.example/inbox --authorization-env AGENT_AUTH
# Export DNS records before making changesdomani dns startup.dev snapshotdomani dns startup.dev set TXT @ "v=spf1 include:_spf.google.com ~all"
# Pipe to jq (auto-JSON when piped, no --json needed)domani list | jq '.domains[] | {domain, expires_at}'
# Introspect command schemas for agent integrationdomani schema buy --json

Commands

Domains

domani search <name> [tlds...]    Check availability across TLDs (--expand for 30+)domani suggest <prompt>           AI-powered domain suggestions (--style, --lang, --tlds)domani buy <domains...>           Purchase one or more domainsdomani adopt <domain>             Inspect and plan a safe connection or transferdomani transfer <domain>          Transfer registration, preserving current nameserversdomani renew <domain>             Renew a domain (--years 1-10)domani import <domain>            Import a domain you own elsewhere (DNS monitoring only)domani list                       List your domainsdomani status <domain>            Health check (DNS, SSL, email, expiry)domani tlds                       List all TLDs with pricing (--sort, --max-price)domani whois <domain>             WHOIS/RDAP lookupdomani deals [id]                 Marketplace deals (--role, --status, --limit, --cursor) or one deal

Email

domani email list                    List all mailboxesdomani email create user@domain      Create a mailboxdomani email delete user@domain      Delete a mailboxdomani email inbox user@domain       List messages (--folder, --view, --direction, --since, --until, --cursor)domani email folders user@domain     List folder and view countsdomani email contacts                Address book (--q, --cursor; --order created for a full sync)domani email archive user@domain --message-ids m1,m2domani email trash user@domain --message-ids m1domani email restore user@domain --message-ids m1domani email read|unread|star|unstar user@domain --message-ids m1,m2domani email send user@domain        Send an email (--to, --subject, --body, --cc, --bcc)domani email forward user@domain     Forward inbound to a personal address (--forward-to)domani email webhook user@domain     Forward inbound as JSON (--url, --authorization-env, --api-key-env, --clear-headers)domani email webhook-test user@domain Deliver one signed test event to the configured webhookdomani email setup --domain <domain>       Auto-configure MX, SPF, DKIM, DMARCdomani email status --domain <domain>      Check email DNS healthdomani email connect --domain <domain> <provider>   Connect external provider (Gmail, Fastmail, Proton)

Mailzero assistant (private preview)

domani assistant today               Now, Needs you, Waiting, Upcoming, Handleddomani assistant settings            Opt-in state, consent, and mailbox scopedomani assistant set                 Change settings (--enable, --shadow, --pause, --mailboxes, --none, --days)domani assistant preview             Record consent and start a background history import (--mailboxes, --consent)domani assistant backfill|retry      Follow the import or requeue its terminal failuresdomani assistant item <id>           One work item with its Decision and optionsdomani assistant choose <id>         Record a decision (--item-version, --decision, --decision-version, --option)domani assistant instruct|snooze|ignore|take-over|correct <id>domani assistant plan <id>           Exact preview of a prepared reply; nothing is sent by the CLIdomani assistant activity            Content-free interaction and receipt logdomani assistant rules               The standing delegations (match, assignee, level, grants)domani assistant approvals           The plans waiting for you and the questions your agents askeddomani assistant suggestions         The rules the assistant proposes from what recurreddomani assistant metrics             The seven numbers per account and per rule (--days)domani assistant task <id>           The task envelope an assignee works fromdomani assistant lease|release|effects|escalate|report <id>domani assistant export|delete       Export or delete derived data (source mail is never touched)

Tokens need assistant:read for reads and assistant:write for changes.

DNS

domani dns <domain> get            List all DNS recordsdomani dns <domain> set <type> <name> <value>   Add/update a recorddomani dns <domain> delete <type> <name>        Remove a recorddomani dns <domain> snapshot       Export DNS to filedomani dns <domain> restore        Restore DNS from snapshotdomani nameservers <domain>        Get or set nameservers (--reset for defaults)domani connect <domain> <target>   Auto-configure DNS for a providerdomani route [action] [id]         Short-lived HTTP routes (list: --domain, --status, --limit, --cursor)

Supported providers: Vercel, Netlify, Cloudflare Pages, GitHub Pages, Fly.io, Railway, Render, Google Workspace, Fastmail, Proton Mail.

Settings

domani settings <domain>           View/update auto-renew, WHOIS privacy, security lockdomani contact [view|set]          Manage WHOIS contact infodomani parking <domain>            Manage parking page (enable/disable/price)domani analytics <domain>          View parking analyticsdomani auth-code <domain>          Get EPP auth code for outbound transferdomani transfer-away <domain>      Check outbound transfer status

Account

domani login                       Log in to domani.run (opens browser)domani logout                      Forget the current account's login (--account <name> for another)domani accounts                    List saved accounts, * marks the one in usedomani use <name>                  Switch the active accountdomani me                          Show account info and the CLI account in usedomani billing                     Add or update payment method (opens browser)domani invoices                    List payment invoicesdomani notifications               List notifications (--unread, --limit, --cursor; --read marks all read)domani token                       Print your API keydomani tokens [list|create|revoke] Manage API tokens (scoped, expiring)domani webhooks [action]           Manage webhook endpoints (auth headers via --authorization-env/--api-key-env)

Introspection

domani schema [command]            Show command schemas for AI agent integrationdomani update                      Update to the latest versiondomani uninstall                   Remove domani CLI and config

Agent integration

Built for AI agents and scripts, not just humans.

TTY auto-detect: When stdout is not a terminal, the CLI automatically switches to JSON output and skips confirmation prompts. No --json flag needed.

bash
domani list | jq '.domains[].domain'

Paging: list commands print More: --cursor <next_cursor> when another page exists (in JSON mode, read next_cursor); pass it back with --cursor to get the next page.

Structured errors: In JSON mode, errors include code, hint, and fix_command for auto-recovery:

json
{ "error": "Not logged in", "code": "auth_required", "fix_command": "domani login" }
CodeFixDescription
auth_requireddomani loginNot logged in
payment_requireddomani billingNo payment method on file
contact_requireddomani contact setWHOIS contact info missing
validation_errorRead hintInvalid input
not_found-Domain doesn't exist or not owned
rate_limitedWait Retry-AfterToo many requests

Flags:

FlagDescription
--jsonForce JSON output
--fields <f>Filter JSON fields (comma-separated)
--dry-runPreview mutations without executing
--yesSkip confirmation prompts

Input hardening: All inputs are validated against path traversal, control characters, query strings, and double encoding - common agent hallucinations.

Schema introspection: Run domani schema <command> --json to get parameter types, constraints, and enums before constructing a command.

Payments

Domains are charged to your saved card. Add one at domani.run/dashboard or with domani card add.

bash
domani buy myapp.dev                     # Charged to saved card

Authentication

MethodDescription
domani loginInteractive login (opens browser)
$DOMANI_API_KEYAPI key as environment variable
OS keychainCredential saved by domani login when available
~/.domani/config.jsonNon-secret CLI settings, plus legacy fallback on systems without a keychain

The CLI checks $DOMANI_API_KEY first, then falls back to the saved login.

bash
domani login                             # Interactive (opens browser)export DOMANI_API_KEY=domani_sk_...      # Or set env var

Several accounts

The CLI can keep more than one Domani account, each under a name, with its own keychain entry:

bash
domani login --account work              # save a second account as "work"domani accounts                          # list them; * marks the one in usedomani use work                          # make "work" the active accountdomani --account personal list           # use another account for one commandDOMANI_ACCOUNT=work domani mcp serve     # pin an agent's MCP bridge to "work"domani logout --account work             # forget that login only

The credential a command uses is, in order: DOMANI_API_KEY, --account, DOMANI_ACCOUNT, then the active account. domani me shows the account in use, and the buy, renew and transfer confirmations name it before anything is charged. A login saved by an earlier CLI version becomes the account default, with nothing to redo.

Scoped API tokens can be created with domani tokens create --scopes read,dns --expires-in 86400.

Environment variables

VariableDescription
DOMANI_API_KEYAPI key (takes precedence over saved config)
DOMANI_ACCOUNTSaved CLI account to use (below --account, above domani use)
DOMANI_CONFIG_DIRConfig directory (default ~/.domani)

License

MIT

Source: README.md at commit 98c95fa

Tools

0
This server asks you to sign in, so SourceWeft could not read its tools without an account and has not indexed them. What a connected account sees can depend on that account and its permissions.

Version history

1
  1. v0.4.15LatestSep 16, 2026

Score

85% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts