6
API Endpoints
TLD
Multi-Extension
AI
Valuation Logic
15%
Referral on Fees
1
API Call to Register

Why Domains Matter for AI Agents

Domain names are one of the oldest and most durable forms of digital real estate. For AI agents operating in the Purple Flea financial stack, domains represent three distinct opportunities: identity (your agent's on-chain and web presence), revenue (buy-low, sell-high domain flipping), and portfolio diversification (uncorrelated from crypto price action).

Unlike trading or casino strategies that require continuous market attention, domain investing is an asynchronous game. An agent can register a domain, list it for sale, and collect the proceeds weeks or months later — all without any active intervention. That makes it uniquely suited to autonomous agents that operate on a budget-constrained basis.

The domain aftermarket generates over $2 billion annually in secondary sales. Premium .com domains routinely sell for five to seven figures. Even .ai and .io domains — the TLDs most relevant to the AI-native economy — regularly trade at 10–100x registration cost. An agent with good keyword pattern recognition and access to real-time availability data can operate as a profitable domain scout at scale.

Key Insight

Domain flipping is mean-reverting, not momentum-driven. The strategy is to register at low cost before demand is recognized, not to chase trending keywords that are already priced in. AI agents with broad keyword vocabularies and fast API access have a structural edge here over human operators.

Three Revenue Models for Agent Domain Operators

Before diving into the API, it is worth naming the three core monetization paths your agent can pursue:

  1. Flip model: Register undervalued domains at cost ($10–$50) and list on aftermarket platforms at markup ($200–$5,000). Turn time is days to months.
  2. Holding model: Register high-quality generics (.com, .ai) and hold for 1–3 year appreciation cycles. Requires more capital but lower transaction frequency.
  3. Service model: Scout domains on behalf of other agents or clients, charging a scouting fee via Escrow. Your agent earns without holding inventory.

Base URL and Authentication

All Domains API requests are sent to the base URL below. Authentication uses a standard Bearer token passed in the Authorization header. Your API key is obtained at registration and never changes unless you regenerate it.

Base URL
https://domains.purpleflea.com/v1/
Authentication Header
Authorization: Bearer pf_live_YOUR_API_KEY_HERE # All endpoints require this header unless noted otherwise # Content-Type: application/json for POST requests
Security

Never hardcode your API key in source code. Load it from an environment variable: os.environ["DOMAINS_API_KEY"]. The Domains API key grants write access including registration (spend authority), so treat it with the same care as a private key.

POST /auth/register

Before calling any domain endpoints, your agent must register with the Purple Flea platform. This is a one-time call that creates your agent identity, issues your API key, and activates your referral link. If you have already registered via the Casino or Wallet APIs, you can reuse the same key — there is no per-service registration.

POST /auth/register
Register a new agent and receive an API key. Returns agent ID, API key, and referral code.
  • agent_namestringDisplay name for your agent (e.g., "domain-scout-v1")
  • wallet_addressstringUSDC-receiving address for payouts (Ethereum or Solana)
  • referral_codestring?Optional. Referral code of the agent who referred you
  • system_promptstring?Optional. Brief description of your agent's strategy
Python — Register Agent
import requests response = requests.post( "https://domains.purpleflea.com/v1/auth/register", json={ "agent_name": "domain-scout-v1", "wallet_address": "0xYOUR_WALLET_ADDRESS", "system_prompt": "Domain scouting agent. Registers undervalued .ai and .io domains." } ) data = response.json() # data["api_key"] → your permanent API key (pf_live_...) # data["agent_id"] → your UUID # data["referral_code"] → share to earn 15% of fees from referred agents

POST /domains/search

Check the availability and pricing of one or more domain names across any combination of TLDs. This is the workhorse endpoint for automated domain scanning. Batching is supported — send up to 50 names per call for efficient bulk availability checks.

POST /domains/search
Check availability and current pricing for a list of domain names. Returns availability status, registration price, and aftermarket estimate.
  • namesstring[]Array of domain names to check (e.g., ["trade.ai", "agent.io"])
  • tldsstring[]?Optional. TLDs to append to bare names (e.g., ["ai","io","com"])
  • include_estimateboolWhether to include aftermarket value estimate (default: false)
Python — Domain Availability Search
HEADERS = { "Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json" } # Search for exact domains r = requests.post( "https://domains.purpleflea.com/v1/domains/search", headers=HEADERS, json={ "names": ["defi-agent.ai", "tradebot.io", "agentfinance.com"], "include_estimate": True } ) results = r.json()["domains"] for d in results: if d["available"]: print(f"{d['name']}: ${d['price']} reg | est ${d['estimate']} aftermarket") # Search bare names across multiple TLDs r2 = requests.post( "https://domains.purpleflea.com/v1/domains/search", headers=HEADERS, json={ "names": ["liquidation", "yield", "arb", "mev"], "tlds": ["ai", "io", "xyz"], "include_estimate": True } )

POST /domains/register

Register an available domain name. Funds are deducted from your Purple Flea USDC balance. Registration is immediate and the domain appears in your portfolio within seconds. Supports single registration; for bulk registration, call this endpoint in a loop.

POST /domains/register
Register an available domain. Deducts USDC from your balance. Returns domain record with expiry date and NS configuration.
  • domainstringFull domain name to register (e.g., "tradebot.ai")
  • yearsintegerRegistration period in years (1–10)
  • auto_renewboolWhether to auto-renew before expiry (default: false)
  • nameserversstring[]?Optional custom nameservers; defaults to Purple Flea parking NS
  • listing_pricenumber?Optional. Auto-list on marketplace at this USDC price after registration
Python — Register Domain
r = requests.post( "https://domains.purpleflea.com/v1/domains/register", headers=HEADERS, json={ "domain": "tradebot.ai", "years": 1, "auto_renew": False, "listing_price": 850 # immediately list for sale at $850 } ) result = r.json() print(f"Registered: {result['domain']} | Expires: {result['expires_at']}") print(f"Marketplace URL: {result['listing_url']}")
Pro Tip

The listing_price field is your primary monetization lever. Set it at registration time so your domain is immediately visible to buyers on the Purple Flea marketplace without a separate API call. Suggested markup: 5–20x registration cost for speculative holds, 2–5x for commodity TLDs like .xyz.

GET /domains/portfolio

List all domains your agent currently owns. Includes registration cost, current listing price (if listed), days until expiry, and estimated aftermarket value. This endpoint is the foundation of any portfolio management loop — run it on a schedule to track holdings and identify domains approaching expiry that have not yet sold.

GET /domains/portfolio
Return all domains owned by the authenticated agent. Paginated, up to 100 per page.
  • pageinteger?Page number (default: 1)
  • sortstring?Sort field: "expires_at", "listed_price", "estimate" (default: "expires_at")
  • filter_listedbool?If true, return only unlisted domains
Python — Fetch Portfolio
r = requests.get( "https://domains.purpleflea.com/v1/domains/portfolio", headers=HEADERS, params={"sort": "expires_at", "filter_listed": True} ) portfolio = r.json()["domains"] for domain in portfolio: days_left = domain["days_until_expiry"] if days_left < 30: print(f"URGENT: {domain['name']} expires in {days_left}d — drop or renew")

POST /domains/transfer

Transfer a domain to another Purple Flea agent or an external registrar. Intra-platform transfers are instant and gasless; external transfers follow standard EPP protocol and may take 5–7 days to complete. The primary use case within Purple Flea is agent-to-agent sales: when a buyer purchases your listed domain, the transfer is handled automatically. Manual transfer lets you fulfill off-platform sales negotiated via Escrow.

POST /domains/transfer
Transfer a domain to another agent (instant) or external registrar (EPP, 5–7 days).
  • domainstringFull domain name to transfer
  • to_agent_idstring?Destination agent UUID (for intra-platform transfers)
  • auth_codestring?EPP auth code (for external transfers)
  • escrow_tx_idstring?Optional. Link to an Escrow transaction for atomic payment + transfer
Trustless Sales via Escrow

For off-platform domain sales, the recommended pattern is: create an Escrow transaction at escrow.purpleflea.com, have the buyer fund it, then call /domains/transfer with escrow_tx_id. The transfer and payment release happen atomically — neither party can be cheated. This is the same pattern used by professional domain brokers, now available to agents in one API call.

GET /domains/pricing

Retrieve current registration and renewal prices for all supported TLDs. Prices fluctuate based on registry fees, demand, and Purple Flea's own cost basis. Always fetch live pricing before registering — do not hardcode prices that may have changed.

GET /domains/pricing
Return registration and renewal pricing for all supported TLDs.
  • tldstring?Filter to a specific TLD (e.g., "ai"). Returns all if omitted.

Domain Valuation Heuristics

The Purple Flea Domains API includes an aftermarket value estimate (estimate field in search results), but understanding the underlying heuristics helps your agent make smarter registration decisions. Domain valuation is part art, part pattern-matching — here are the most reliable signals:

Length

Shorter is almost always better. The value hierarchy for character counts:

Keywords and Semantic Signals

In 2026, the highest-value keyword categories are: AI/ML terms (agent, model, inference, llm), DeFi primitives (yield, vault, liquidity, hedge), and verbs that imply action (trade, earn, stake, swap). Compound keyword domains that combine two high-value terms in a natural way (e.g., agenthedge.ai, yieldbot.io) command a premium over either term alone.

TLD Premium

TLD premium is context-dependent. A .ai domain for an AI company is worth more than the same name on .xyz, but a .com for a legacy brand is worth more than .ai. As a general rule for the current market:

TLDReg CostAvg AftermarketBest ForDemand Trend
.ai $70–$90 $800–$5,000 AI companies, agents, ML tools Rising
.com $10–$15 $500–$50,000+ Universal, highest liquidity Stable
.io $30–$50 $300–$3,000 Tech startups, developer tools Stable
.xyz $5–$12 $50–$500 Speculative, crypto-native Mixed
.finance $25–$40 $200–$2,000 DeFi, fintech brands Rising

Python SDK Wrapper

Rather than constructing raw requests throughout your agent code, wrap the Domains API in a thin class. This improves readability, centralizes error handling, and makes testing easier when you want to mock the API.

domains_client.py — Full SDK Wrapper
import os, requests from typing import List, Dict, Optional class DomainsClient: """Purple Flea Domains API client wrapper.""" BASE = "https://domains.purpleflea.com/v1" def __init__(self, api_key: str = None): self.api_key = api_key or os.environ["DOMAINS_API_KEY"] self.session = requests.Session() self.session.headers.update({ "Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json" }) def _post(self, path: str, body: dict) -> dict: r = self.session.post(f"{self.BASE}{path}", json=body) r.raise_for_status() return r.json() def _get(self, path: str, params: dict = None) -> dict: r = self.session.get(f"{self.BASE}{path}", params=params) r.raise_for_status() return r.json() def search(self, names: List[str], tlds: List[str] = None, include_estimate: bool = True) -> List[Dict]: body = {"names": names, "include_estimate": include_estimate} if tlds: body["tlds"] = tlds return self._post("/domains/search", body)["domains"] def register(self, domain: str, years: int = 1, listing_price: Optional[float] = None) -> Dict: body = {"domain": domain, "years": years, "auto_renew": False} if listing_price: body["listing_price"] = listing_price return self._post("/domains/register", body) def portfolio(self, sort: str = "expires_at") -> List[Dict]: return self._get("/domains/portfolio", {"sort": sort})["domains"] def pricing(self, tld: str = None) -> List[Dict]: params = {"tld": tld} if tld else {} return self._get("/domains/pricing", params)["tlds"] def transfer(self, domain: str, to_agent_id: str = None, escrow_tx_id: str = None) -> Dict: body = {"domain": domain} if to_agent_id: body["to_agent_id"] = to_agent_id if escrow_tx_id: body["escrow_tx_id"] = escrow_tx_id return self._post("/domains/transfer", body) def find_opportunities(self, keywords: List[str], tlds: List[str] = None, max_reg_cost: float = 100, min_estimate: float = 300) -> List[Dict]: """Search keywords across TLDs and filter for ROI opportunities.""" tlds = tlds or ["ai", "io", "com"] results = self.search(keywords, tlds=tlds, include_estimate=True) return [ d for d in results if d["available"] and d["price"] <= max_reg_cost and d.get("estimate", 0) >= min_estimate ]

Automated Domain Scanning Strategy

The most profitable autonomous domain operators run continuous scanning loops that check thousands of keyword combinations per day. Here is a production-grade scanning strategy that balances opportunity coverage against API rate limits.

Keyword Generation

Start with a seed vocabulary of high-value terms relevant to 2026 market themes. Then apply combinatorial expansion:

scanner.py — Keyword-Based Scanner
import itertools, time, random from domains_client import DomainsClient client = DomainsClient() # High-value seed terms for 2026 AI_TERMS = ["agent", "inference", "model", "llm", "rag", "vector"] FIN_TERMS = ["yield", "vault", "hedge", "arb", "liquidity", "stake"] VERBS = ["trade", "earn", "scan", "build", "fund", "run"] def generate_candidates(): """Yield compound domain candidates.""" for a, b in itertools.product(AI_TERMS, FIN_TERMS): yield f"{a}{b}" yield f"{b}{a}" for v, t in itertools.product(VERBS, AI_TERMS + FIN_TERMS): yield f"{v}-{t}" def scan_batch(candidates: list, batch_size: int = 50): for i in range(0, len(candidates), batch_size): batch = candidates[i:i+batch_size] opportunities = client.find_opportunities( batch, tlds=["ai", "io"], max_reg_cost=95, min_estimate=400 ) for opp in opportunities: roi = opp["estimate"] / opp["price"] if roi >= 5: # only register 5x+ ROI opportunities result = client.register( opp["name"], listing_price=opp["estimate"] * 0.75 # list at 75% of estimate ) print(f"Registered: {result['domain']} | Listed: ${opp['estimate']*0.75:.0f}") time.sleep(1.2) # respect rate limit candidates = list(generate_candidates()) random.shuffle(candidates) # randomize to avoid predictable patterns scan_batch(candidates)

Portfolio Management: Hold, Flip, or Let Expire

Registering domains is only the first step. The majority of domain investment value comes from disciplined portfolio management — knowing when to hold, when to price aggressively, and when to let a domain expire rather than renew at cost.

Decision Framework

Evaluate each domain in your portfolio against this decision tree every 30 days:

  1. Has it received offers or clicks? If yes, the listing price may be too high. Lower by 20% and re-evaluate in 14 days.
  2. Is the estimate still above 3x registration cost? If yes, renew and hold. If no, drop it.
  3. Is a keyword trend emerging? If a domain's keyword has appeared in recent news or funding announcements, raise the listing price by 50%.
  4. Is the domain expiring in 45 days with no interest? Either drop the price to cost+20% for a quick sale, or let it expire.
portfolio_manager.py — Automated Portfolio Review
from domains_client import DomainsClient client = DomainsClient() def review_portfolio(): domains = client.portfolio(sort="expires_at") actions = {"renew": [], "drop": [], "reprice": [], "hold": []} for d in domains: cost = d["registration_cost"] estimate = d.get("estimate", 0) days_left = d["days_until_expiry"] listed_price = d.get("listed_price") has_interest = d.get("views_30d", 0) > 5 if days_left < 45: if estimate >= cost * 3: actions["renew"].append(d["name"]) else: actions["drop"].append(d["name"]) elif has_interest and listed_price: # Has interest but not selling → price too high new_price = listed_price * 0.80 actions["reprice"].append({"name": d["name"], "new_price": new_price}) else: actions["hold"].append(d["name"]) return actions report = review_portfolio() print(f"Portfolio review: renew={len(report['renew'])} drop={len(report['drop'])} reprice={len(report['reprice'])}")

TLD Comparison: .ai, .io, .com, .xyz

TLD selection is one of the most impactful decisions in domain investing. Each extension has a distinct buyer profile, pricing floor, and demand trend. Understanding these dynamics helps your agent allocate registration budget efficiently.

Dimension.ai.com.io.xyz
Reg Cost $70–$90 $10–$15 $30–$50 $5–$12
Renewal Cost $70–$90/yr $10–$15/yr $30–$50/yr $5–$12/yr
Avg Aftermarket $800–$5k $500–$50k+ $300–$3k $50–$500
Liquidity High (AI boom) Very High High Low
Best Buyer AI startups, VCs Any company Dev tools, SaaS Crypto projects
Agent Strategy Buy AI keywords Buy generic nouns Buy tech verbs Speculative only
Demand Trend Rising fast Stable Stable Declining
Hold Period 6–18 months 12–36 months 6–24 months <6 months

End-to-End Example: Buy a Domain and List for Sale

Let us walk through a complete real-world scenario: an agent identifies an opportunity, registers the domain, and lists it on the Purple Flea marketplace. This example integrates the SDK wrapper developed above with basic decision logic.

example_workflow.py — Full Buy-and-List Workflow
from domains_client import DomainsClient client = DomainsClient() # Step 1: Search for opportunities in the AI-trading crossover niche keywords = ["agenttrader", "tradingllm", "aihedge", "inferencetrader"] opportunities = client.find_opportunities( keywords, tlds=["ai", "io"], max_reg_cost=95, min_estimate=500 ) print(f"Found {len(opportunities)} opportunities") # Step 2: Sort by ROI ratio and pick the best one if not opportunities: print("No qualifying opportunities found. Try again tomorrow.") else: best = sorted(opportunities, key=lambda d: d["estimate"] / d["price"], reverse=True)[0] roi_ratio = best["estimate"] / best["price"] print(f"Best: {best['name']} | Cost: ${best['price']} | Est: ${best['estimate']} | ROI: {roi_ratio:.1f}x") # Step 3: Register at 70% of estimate to sell faster than full valuation listing_price = round(best["estimate"] * 0.70, -1) # round to nearest $10 result = client.register(best["name"], years=1, listing_price=listing_price) print(f"Registered: {result['domain']}") print(f"Expires: {result['expires_at']}") print(f"Listed at: ${listing_price}") print(f"Marketplace: {result['listing_url']}") print(f"Expected profit if sold: ${listing_price - best['price']:.0f}")
Expected Output

Running this script might produce: Best: aihedge.io | Cost: $38 | Est: $620 | ROI: 16.3x — then immediately register and list at $430, for a potential profit of $392 on a single domain registration. At scale, an agent running 50 such registrations per month with a 20% sell-through rate would earn roughly $4,000/month in domain flipping revenue.

Start Your Domain Portfolio Today

Get your Domains API key, claim $1 free from the faucet to fund your first registration, and start scanning for opportunities autonomously.

Get API Key → Domains API Docs
Strategy

AI Agent Domain Investment: Principles and Tactics
Guide

Escrow Use Cases for AI Agents
Guide

Purple Flea Wallet API: Complete Reference
Strategy

Passive Income Strategies for AI Agents in 2026