GET /v1/valuation/{domain}

Domain Valuation

Learn more: Domain Valuation API — marketing overview and use cases.

Estimate the market value of any domain name. Returns a price estimate range, confidence score, comparable sales data, and key valuation factors. Available in two tiers: quick (fast estimate) and full (detailed analysis with comparables and explanation).

Pricing

This is a paid endpoint using x402 (HTTP 402) micropayments with USDC on Base.

Tier	Price
`quick`	$0.02 per request
`full`	$0.08 per request

See Pricing for details on how x402 payments work.

Endpoint

GET https://api.robotdomainsearch.com/v1/valuation/{domain}

Parameters

Parameter	Type	Required	Description
`domain`	string	Yes	Full domain name to value (e.g., `example.com`). Passed as a path parameter.
`tier`	string	No	Valuation tier: `quick` (default) or `full`

Request

Quick valuation (default)

curl "https://api.robotdomainsearch.com/v1/valuation/example.com"

Full valuation

curl "https://api.robotdomainsearch.com/v1/valuation/example.com?tier=full"

Response

Quick Tier

A concise valuation with estimate range and confidence:

{
  "domain": "example.com",
  "tier": "quick",
  "estimate": {
    "low": 5000,
    "mid": 12000,
    "high": 25000,
    "currency": "USD"
  },
  "confidence": 0.78,
  "factors": [
    "short_length",
    "dot_com",
    "dictionary_word",
    "high_search_volume"
  ],
  "timestamp": "2026-03-07T15:30:00Z"
}

Full Tier

Detailed analysis with comparable sales, explanation, and key factors:

{
  "domain": "example.com",
  "tier": "full",
  "estimate": {
    "low": 5000,
    "mid": 12000,
    "high": 25000,
    "currency": "USD"
  },
  "confidence": 0.82,
  "factors": [
    "short_length",
    "dot_com",
    "dictionary_word",
    "high_search_volume"
  ],
  "explanation": "example.com is a premium single-word .com domain. Short dictionary-word .com domains consistently command five-figure prices in the aftermarket. Comparable sales of similar single-word .com domains range from $8,000 to $50,000 depending on commercial appeal and search volume.",
  "comparables": [
    {
      "domain": "sample.com",
      "sale_price": 15000,
      "sale_date": "2025-09-15",
      "source": "namebio"
    },
    {
      "domain": "instance.com",
      "sale_price": 9500,
      "sale_date": "2025-06-22",
      "source": "namebio"
    },
    {
      "domain": "demo.com",
      "sale_price": 28000,
      "sale_date": "2025-03-10",
      "source": "namebio"
    }
  ],
  "key_factors": {
    "length": 7,
    "tld": "com",
    "is_dictionary_word": true,
    "has_hyphens": false,
    "has_numbers": false,
    "category": "technology"
  },
  "timestamp": "2026-03-07T15:30:00Z"
}

Response Fields

Top-Level Fields

Field	Type	Description
`domain`	string	The domain that was valued
`tier`	string	Valuation tier used: `quick` or `full`
`estimate`	object	Price estimate range
`confidence`	number	Confidence score (0.0–1.0)
`factors`	array	Valuation factors that influenced the estimate
`explanation`	string	Human-readable analysis (full tier only)
`comparables`	array	Comparable domain sales (full tier only)
`key_factors`	object	Structured domain attributes (full tier only)
`timestamp`	ISO 8601	When the valuation was generated

Estimate Object

Field	Type	Description
`low`	integer	Low end of the estimated value (USD)
`mid`	integer	Mid-point estimate (USD)
`high`	integer	High end of the estimated value (USD)
`currency`	string	Currency code (always `USD`)

Comparable Object (full tier only)

Field	Type	Description
`domain`	string	Domain that was sold
`sale_price`	integer	Sale price in USD
`sale_date`	string	Date of the sale (YYYY-MM-DD)
`source`	string	Data source for the sale record

Key Factors Object (full tier only)

Field	Type	Description
`length`	integer	Number of characters in the domain name
`tld`	string	Top-level domain extension
`is_dictionary_word`	boolean	Whether the name is a dictionary word
`has_hyphens`	boolean	Whether the name contains hyphens
`has_numbers`	boolean	Whether the name contains numbers
`category`	string	Detected domain category (if any)

Valuation Factors

Factor	Description
`short_length`	Domain name is short (≤6 characters)
`dot_com`	.com TLD (highest demand)
`dictionary_word`	Name is a common English word
`high_search_volume`	Name has significant search volume
`brandable`	Name is catchy and easy to brand
`premium_tld`	TLD has premium market value (.io, .ai, etc.)
`exact_match`	Name matches a high-value keyword exactly
`numeric`	Domain contains numbers (usually lowers value)
`hyphenated`	Domain contains hyphens (usually lowers value)
`long_name`	Name is long (≥15 characters, usually lowers value)

Tier Comparison

Feature	Quick ($0.02)	Full ($0.08)
Price estimate range	✓	✓
Confidence score	✓	✓
Valuation factors	✓	✓
Comparable sales	—	✓
Detailed explanation	—	✓
Key factors breakdown	—	✓

Payment Flow (x402)

This endpoint uses x402 micropayments. When you make a request without a payment header, the API returns a 402 Payment Required response with pricing details:

# 1. Request without payment → get pricing
curl -i "https://api.robotdomainsearch.com/v1/valuation/example.com"

# Response: 402 Payment Required
# Headers include payment details (amount, recipient, network)

To make a paid request, use the x402 client SDK to handle payment automatically:

import { paymentMiddleware } from "x402-axios";
import axios from "axios";

const client = axios.create();
client.use(paymentMiddleware("YOUR_WALLET_PRIVATE_KEY"));

// Payment is handled automatically
const response = await client.get(
  "https://api.robotdomainsearch.com/v1/valuation/example.com?tier=full"
);
console.log(response.data);

See the Pricing page for complete x402 integration details.

Errors

Code	Error	Description
400	`invalid_domain`	Domain format is invalid or missing TLD
400	`invalid_tier`	Tier must be `quick` or `full`
402	`payment_required`	x402 payment required for this endpoint
405	`method_not_allowed`	Only GET method is allowed
503	`service_unavailable`	Valuation service temporarily unavailable

Code Examples

curl

# Quick valuation
curl "https://api.robotdomainsearch.com/v1/valuation/example.com"

# Full valuation
curl "https://api.robotdomainsearch.com/v1/valuation/example.com?tier=full"

Python

import requests

response = requests.get(
    "https://api.robotdomainsearch.com/v1/valuation/example.com",
    params={"tier": "full"}
)
data = response.json()

print(f"Domain: {data['domain']}")
print(f"Estimate: ${data['estimate']['low']:,} – ${data['estimate']['high']:,}")
print(f"Mid-point: ${data['estimate']['mid']:,}")
print(f"Confidence: {data['confidence']:.0%}")

if data.get("explanation"):
    print(f"\nAnalysis: {data['explanation']}")

if data.get("comparables"):
    print("\nComparable Sales:")
    for comp in data["comparables"]:
        print(f"  {comp['domain']}: ${comp['sale_price']:,} ({comp['sale_date']})")

JavaScript

const response = await fetch(
  "https://api.robotdomainsearch.com/v1/valuation/example.com?tier=full"
);
const data = await response.json();

console.log(`Domain: ${data.domain}`);
console.log(`Estimate: $${data.estimate.low.toLocaleString()} – $${data.estimate.high.toLocaleString()}`);
console.log(`Confidence: ${(data.confidence * 100).toFixed(0)}%`);

if (data.explanation) {
  console.log(`\nAnalysis: ${data.explanation}`);
}

data.comparables?.forEach(comp => {
  console.log(`  ${comp.domain}: $${comp.sale_price.toLocaleString()} (${comp.sale_date})`);
});

Go

resp, err := http.Get("https://api.robotdomainsearch.com/v1/valuation/example.com?tier=full")
if err != nil {
    log.Fatal(err)
}
defer resp.Body.Close()

var data struct {
    Domain     string `json:"domain"`
    Tier       string `json:"tier"`
    Estimate   struct {
        Low      int    `json:"low"`
        Mid      int    `json:"mid"`
        High     int    `json:"high"`
        Currency string `json:"currency"`
    } `json:"estimate"`
    Confidence  float64 `json:"confidence"`
    Factors     []string `json:"factors"`
    Explanation string   `json:"explanation,omitempty"`
    Comparables []struct {
        Domain    string `json:"domain"`
        SalePrice int    `json:"sale_price"`
        SaleDate  string `json:"sale_date"`
        Source    string `json:"source"`
    } `json:"comparables,omitempty"`
    Timestamp string `json:"timestamp"`
}

if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
    log.Fatal(err)
}

fmt.Printf("Domain: %s\n", data.Domain)
fmt.Printf("Estimate: $%d – $%d (mid: $%d)\n", data.Estimate.Low, data.Estimate.High, data.Estimate.Mid)
fmt.Printf("Confidence: %.0f%%\n", data.Confidence*100)

for _, comp := range data.Comparables {
    fmt.Printf("  %s: $%d (%s)\n", comp.Domain, comp.SalePrice, comp.SaleDate)
}

Notes

Domain names are automatically normalized to lowercase
The quick tier is faster and cheaper — good for bulk screening
The full tier provides actionable intelligence for purchasing decisions
Comparable sales data is sourced from public domain sale records
Confidence scores above 0.7 indicate a reliable estimate
Estimates are in USD and reflect aftermarket/resale value, not registration cost
This endpoint requires x402 payment — see Pricing for details

📄 Raw markdown: /docs/api/valuation.md