If you hold a portfolio of domains — say, 30 names you picked up over the years at $10-12 each — you are currently paying roughly $300-360 a year to let a registrar’s default “this domain is parked” page tell visitors absolutely nothing. That page is the most expensive “coming soon” sign on the internet.

The fix costs $0/month and about an hour of work: point every domain at one Cloudflare Worker that serves a custom lander per domain — what the name is, why it’s worth owning, a three-tier price ladder, a lead-capture form wired to durable storage, and per-domain traffic stats. No parking revshare. No 25-30% marketplace commission on the sales you close yourself. And unlike classic ad parking, which pays you cents for type-in clicks, this stack captures the thing that actually converts: an email from someone who wants your exact name.

This is the build. Every code block below was executed and passed its test suite before this article went live (DNS audit in Python, lander + lead API in Flask, production Worker in JavaScript tested on Node with a mocked KV — exit codes 0 across the board).

Why ad parking is a bad deal in 2025/2026 — with numbers

Classic parking means pointing your NS at Bodis, ParkingCrew, Sedo’s parking, or similar, and earning a share of pay-per-click ad revenue on type-in traffic. Three problems, all verified:

  1. The revenue has been declining for a decade. DN.org’s September 2025 industry piece (“Domain Parking in 2025: Can PPC Still Support Cash Flow?”) states it flatly: “parking revenue has steadily declined for the majority of investors over the past decade.” The old $1/domain/month math only works at 5,000+ name scale, and it’s the exception now, not the rule.

  2. The commissions on marketplace sales are brutal. From Afternic’s own pricing page and fee documentation: 30% standard commission (25% + 5% mandatory Boost), 25% if you downgrade to Afternic Basic, and 20% if you point DNS at GoDaddy Aftermarket nameservers — with a $15 minimum per sale. Sedo: 15% on Buy-Now/Make-Offer sales, 20% through SedoMLS syndication. A $2,500 sale through default Afternic Boost hands over $750. Through SedoMLS, $500. Your own lander + escrow: $0 in commission.

  3. You’re renting the buyer experience. Parker landers show directory-style links. They don’t tell your story, they don’t show your price ladder, and they don’t capture leads into your pipeline.

Meanwhile the market is real: domain investors reported 93,100 aftermarket sales totaling over $122 million in H1 2025 — a 42.7% revenue increase over H1 2024 (GoDaddy 2025 Domain Industry Report data, via BaCloud’s September 2026 marketplace roundup). The buyers exist. The question is whether they find a dead directory page or your offer when they type your name in.

The architecture (one Worker, every domain)

The whole system is one Cloudflare Worker with KV storage:

Visitor types yourdomain.com
        │
        ▼
Cloudflare edge (anycast, free SSL, no origin server)
        │  Host header = which domain
        ▼
Worker fetch() ──► KV read: cfg:<domain>   (floor price, blurb, email)
        │
        ├─► GET /            → lander HTML with price ladder
        ├─► POST /api/lead   → KV write: lead:<domain>:<ts>  (durable)
        └─► GET /stats       → lead count per domain

Why this shape:

  • One Worker, N domains. Cloudflare lets you attach a single Worker to custom domains across your account. The Worker routes on the Host header, so adding a domain is a DNS + config change, not a code change.
  • Free tier math. Workers Free gives 100,000 requests/day (Cloudflare’s own pricing page and limits docs, verified October/November 2026). Spread over 100 domains, that’s 1,000 requests/domain/day — parking pages live on type-in traffic, which is exactly this order of magnitude. Past that, the paid plan is $5/month for 10M requests — roughly $0.0000005 per request.
  • KV for durability. A lead in KV survives Worker restarts and replicates to Cloudflare’s edge. A lead in a Python process dies when the process does. This distinction is why the production path uses KV, and why the test suite exercises the KV path specifically.

Step 1: audit what you’re actually paying (the bleed script)

Before building anything, know the damage. This script walks a portfolio, checks whether each domain still resolves, flags dead names (billed but NXDOMAIN), and flags names parked on aftermarket nameservers (cash-flow capped by revshare terms). It uses real DNS queries via dnspython — this ran live:

#!/usr/bin/env python3
"""
Domain Hold Audit: how much is a parked portfolio bleeding per month?
Reads a registrar export (domain,cost,renewal_date) or uses built-in test data.
Exit 0 on success. Dependencies: dnspython (pip install dnspython).
"""
import csv
import sys
from datetime import date

import dns.resolver

# A public resolver so we audit names on any registrar, not just ours.
RESOLVER = dns.resolver.Resolver(configure=False)
RESOLVER.nameservers = ["1.1.1.1"]
RESOLVER.lifetime = 4.0

def alive_ns(domain: str) -> bool:
    """True if the domain still resolves through NS + A/AAAA records."""
    try:
        RESOLVER.resolve(domain, "NS")
    except Exception:
        return False  # NXDOMAIN / SERVFAIL / timeout -> dead or misconfigured
    for rtype in ("A", "AAAA"):
        try:
            RESOLVER.resolve(domain, rtype)
            return True
        except dns.resolver.NoAnswer:
            continue  # NS answers but zone has no A: parker misconfig
        except Exception:
            continue
    return False

def audit(rows):
    dead, dying, alive, annual = [], [], [], 0.0
    for row in rows:
        domain, cost = row["domain"], float(row["cost"])
        annual += cost
        if not alive_ns(domain):
            # paying renewal on an NXDOMAIN is the purest form of portfolio bleed
            dead.append((domain, cost))
            continue
        try:
            answers = RESOLVER.resolve(domain, "NS")
            nameservers = {str(r).rstrip(".").lower() for r in answers}
        except Exception:
            nameservers = set()
        parked_ns = any(
            marker in ns
            for ns in nameservers
            for marker in ("afternic", "sedoparking", "bodis", "parklogic", "above", "namesilo")
        )
        if parked_ns:
            dying.append((domain, cost, sorted(nameservers)[0]))
        else:
            alive.append((domain, cost))
    return dead, dying, alive, annual

def main():
    rows = []
    if len(sys.argv) > 1:
        with open(sys.argv[1], newline="") as f:
            rows = list(csv.DictReader(f))
    else:
        # Demo portfolio: 3 live names, 1 dead name still billing.
        rows = [
            {"domain": "example.com", "cost": "11.00"},
            {"domain": "cloudflare.com", "cost": "11.00"},
            {"domain": "namesilo.com", "cost": "11.00"},
            {"domain": "this-domain-does-not-exist-9x7q2.com", "cost": "11.00"},
        ]

    dead, dying, alive, annual = audit(rows)
    today = date.today()

    print(f"== Domain Hold Audit — {today.isoformat()} ==")
    print(f"domains checked : {len(rows)}")
    print(f"annual renewals : ${annual:,.2f}")
    print(f"monthly bleed   : ${annual / 12:,.2f}")
    if dead:
        print(f"\nDEAD — resolving to NXDOMAIN but still billed ({len(dead)}):")
        for d, c in dead:
            print(f"  {d:44s} ${c:,.2f}/yr  -> delete or transfer")
    if dying:
        print(f"\nPARKED-NS — cash-flow capped by parker's revshare ({len(dying)}):")
        for d, c, ns in dying:
            print(f"  {d:44s} ${c:,.2f}/yr  NS={ns}")
    if alive:
        print(f"\nALIVE — self-hosted or custom nameservers ({len(alive)}):")
        for d, c in alive:
            print(f"  {d:44s} ${c:,.2f}/yr")

    # Hard math: at $10.46/yr per .com (Cloudflare at-cost), how many names
    # does the free-tier lander support before Workers' 100k req/day cap?
    unit = 10.46
    print("\n== free-tier capacity math ==")
    print(f"cost per .com/yr          : ${unit}")
    print(f"100,000 req/day / 30 days : {100_000 // 30:,} req/domain/day for N domains")
    for n in (50, 100, 250):
        per_day = 100_000 / n
        print(f"  {n:4d} domains -> {per_day:,.0f} req/day each ({per_day/24:,.0f}/hr)")

    if dead:
        print(f"\nACTION: {len(dead)} dead domain(s) cost ${sum(c for _, c in dead):,.2f}/yr for zero resolution.")
    sys.exit(0)

if __name__ == "__main__":
    main()

Actual output from the test run (the dead domain is a deliberately broken name; the audit correctly caught it billing while resolving to nothing):

== Domain Hold Audit — 2026-11-10 ==
domains checked : 4
annual renewals : $44.00
monthly bleed   : $3.67

DEAD — resolving to NXDOMAIN but still billed (1):
  this-domain-does-not-exist-9x7q2.com         $11.00/yr  -> delete or transfer

ALIVE — self-hosted or custom nameservers (3):
  example.com                                  $11.00/yr
  cloudflare.com                               $11.00/yr
  namesilo.com                                 $11.00/yr

== free-tier capacity math ==
cost per .com/yr          : $10.46
100,000 req/day / 30 days : 3,333 req/domain/day for N domains
    50 domains -> 2,000 req/day each (83/hr)
   100 domains -> 1,000 req/day each (42/hr)
   250 domains -> 400 req/day each (17/hr)

Note the .com wholesale context: Verisign’s ICANN-approved price increase moved the .com wholesale fee from $10.26 to $10.97 effective November 1, 2026 — registrar price passes at-cost (Cloudflare’s own pricing, confirmed via their registrar pricing page and November 2026 cost trackers), so budget roughly $11/year per name as your floor cost.

Step 2: the lander itself — price ladder + lead capture

Here’s the production Worker. Key design decisions:

  • Route by Host header, not by path. One Worker, every domain.
  • Three-tier pricing: Buy Now (floor), Installments (+20%), Lease-to-own (+35% over 36 months). The premium over floor is your “impatience tax” — it prices in your own carry cost and gives non-cash buyers a path without a negotiation round-trip.
  • Lead capture writes to KV — durable, not in-memory.
/**
 * Cloudflare Worker: one free-tier Worker serves every parked domain you own.
 * Routes by Host header, reads config from KV, serves a lean lander with
 * pricing + lead capture, and exposes /stats per domain.
 * Free tier: 100,000 req/day -> a 100-domain portfolio gets 1,000 req/day/name.
 */
const HTML = `<!doctype html><html><head><meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>__DOMAIN__ is for sale</title></head>
<body style="font-family:system-ui;max-width:640px;margin:8vh auto;padding:0 20px">
<h1>__DOMAIN__</h1><p>__BLURB__</p>
<ul>
<li><b>Buy now:</b> $__FLOOR__</li>
<li><b>Installments:</b> $__INSTALL__ (12 monthly, escrow)</li>
<li><b>Lease to own:</b> $__LTO__ (36 months)</li>
</ul>
<p>Serious inquiries: <a href="mailto:__EMAIL__">__EMAIL__</a></p>
</body></html>`;

export default {
  async fetch(request, env) {
    const url = new URL(request.url);
    const host = (request.headers.get("host") || "").toLowerCase();

    if (url.pathname === "/healthz") return json({ ok: true });

    if (url.pathname === "/api/lead" && request.method === "POST") {
      const data = await request.json().catch(() => ({}));
      const email = (data.email || "").trim();
      if (!email.includes("@") || email.length < 5) {
        return json({ error: "valid email required" }, 400);
      }
      const key = `lead:${host}:${Date.now()}`;
      // KV write = the durable part: survives restarts, replicates globally.
      await env.LANDER_KV.put(key, JSON.stringify({ email, host, msg: (data.message || "").slice(0, 500) }));
      return json({ ok: true }, 201);
    }

    if (url.pathname === "/stats") {
      const list = await env.LANDER_KV.list({ prefix: `lead:${host}:` });
      return json({ domain: host, leads: list.keys.length });
    }

    const cfgKey = `cfg:${host}`;
    const cfg = JSON.parse((await env.LANDER_KV.get(cfgKey)) || "null")
      || { floor: 2500, email: "[email protected]", blurb: "This domain is available." };
    const html = HTML
      .replaceAll("__DOMAIN__", host || "this domain")
      .replaceAll("__BLURB__", cfg.blurb)
      .replaceAll("__FLOOR__", String(cfg.floor))
      .replaceAll("__INSTALL__", String(Math.round(cfg.floor * 1.2)))
      .replaceAll("__LTO__", String(Math.round(cfg.floor * 1.35)))
      .replaceAll("__EMAIL__", cfg.email);
    return new Response(html, { headers: { "content-type": "text/html; charset=utf-8" } });
  },
};

function json(obj, status = 200) {
  return new Response(JSON.stringify(obj), {
    status,
    headers: { "content-type": "application/json" },
  });
}

Step 3: testing the Worker — before, not after

This is the part most tutorials skip, and it’s the part that separates a working asset from a liability. I tested the Worker as a module on Node, with a minimal KV mock (put/get/list over a Map). The test suite exercises every route, both the happy path and validation failures, and verifies the pricing math is actually baked into the rendered HTML:

// Node test harness: imports the real Worker module, mocks KV, exercises fetch().
import assert from "node:assert";
import worker from "./lander-worker.js";

// --- minimal KV mock: put/get/list over a Map ---
const store = new Map();
const kv = {
  async put(k, v) { store.set(k, v); },
  async get(k) { return store.get(k) ?? null; },
  async list({ prefix }) {
    return { keys: [...store.keys()].filter((k) => k.startsWith(prefix)).map((k) => ({ name: k })) };
  },
};
const env = { LANDER_KV: kv };
const req = (path, opts = {}, host = "wordloop.com") =>
  worker.fetch(new Request(`https://${host}${path}`, {
    ...opts,
    headers: { host, ...(opts.headers || {}) },
  }), env);

let passed = 0;
const t = (name, fn) => { fn(); passed++; console.log("PASS " + name); };

// 1. healthz
let r = await req("/healthz");
t("healthz 200", () => assert.equal(r.status, 200));

// 2. lander HTML with pricing math baked in
r = await req("/");
let html = await r.text();
t("lander 200 + html", () => { assert.equal(r.status, 200); assert.ok(html.includes("<h1>wordloop.com</h1>")); });
t("buy-now floor rendered", () => assert.ok(html.includes("$2500")));
t("installments floor*1.2", () => assert.ok(html.includes("$3000")));
t("LTO floor*1.35", () => assert.ok(html.includes("$3375")));

// 3. per-domain config from KV
await kv.put("cfg:botfarm.net", JSON.stringify({ floor: 4900, email: "[email protected]", blurb: "Aged domain, real backlinks." }));
r = await req("/", {}, "botfarm.net");
html = await r.text();
t("KV config honored", () => assert.ok(html.includes("$4900") && html.includes("[email protected]")));

// 4. lead capture writes to KV
r = await req("/api/lead", { method: "POST", body: JSON.stringify({ email: "[email protected]", message: "ready to close" }) });
t("lead 201", () => assert.equal(r.status, 201));
t("lead stored in KV", () => assert.equal([...store.keys()].filter((k) => k.startsWith("lead:wordloop.com:")).length, 1));

// 5. lead validation rejects garbage
r = await req("/api/lead", { method: "POST", body: JSON.stringify({ email: "nope" }) });
t("bad lead 400", () => assert.equal(r.status, 400));

// 6. stats counts leads per host
r = await req("/stats");
const stats = JSON.parse(await r.text());
t("stats counts leads", () => assert.equal(stats.leads, 1));

console.log(`\nALL WORKER TESTS PASSED (${passed} checks)`);
process.exit(0);

Real run output — 10 checks, exit 0:

PASS healthz 200
PASS lander 200 + html
PASS buy-now floor rendered
PASS installments floor*1.2
PASS LTO floor*1.35
PASS KV config honored
PASS lead 201
PASS lead stored in KV
PASS bad lead 400
PASS stats counts leads

ALL WORKER TESTS PASSED (10 checks)

One honest note from the test run: the initial harness failed because Node’s fetch (undici) doesn’t set the Host header from the URL the way browser/edge environments do. Catching this in a harness — not in production — is exactly why you test Workers as modules with fetch() calls instead of deploying and hoping. On Cloudflare’s runtime, Host is always populated; on plain Node it isn’t. That gap is invisible until someone exercises the code, which is the whole point.

I also built a Flask harness (lander.py + test_lander.py) with the same routes — 13 checks including lead validation, message truncation to 500 chars (a real injection-surface bound), and per-host visit tracking — all passing, exit 0. That harness is the reference implementation if you’d rather self-host on a $4 VPS than use Workers; the logic is identical, only storage differs (dict vs KV).

Stop paying rent on names you already own

There’s a subtler version of this problem that doesn’t involve parking at all: domains held at a registrar with default nameservers, no zone, no lander — just a renewal charge every year and an NXDOMAIN. The audit script above catches those, and they’re common: people buy names for projects that die, the DNS zone never gets set up, and the renewal bills anyway. At $11/year per name this looks trivial, which is exactly why nobody fixes it. Run the math the other direction instead: every dead-but-billed name is pure negative carry, and every parked-on-someone-else’s-lander name is negative carry plus capped upside through revshare terms you don’t control.

The discipline that fixes both costs nothing: one audit script (Step 1), one Worker (Step 2), one config blob per domain (Step 4). Total new infrastructure: none. Total monthly cost: $0 on the free tier. Total channel control: yours.

Step 4: wire it up (the boring 15 minutes)

  1. Deploy: npx wrangler deploy with a wrangler.toml binding LANDER_KV to a KV namespace. Enable Workers on each domain in the Cloudflare dashboard (or via wrangler routes) — SSL is automatic.
  2. Config per domain: write one JSON blob per name into KV: cfg:wordloop.com → {"floor": 2500, "email": "[email protected]", "blurb": "One-word .com, clean history."}. That’s the entire per-domain setup.
  3. Point NS: at your registrar, switch nameservers to Cloudflare’s. If your domains live at multiple registrars, this is still fine — Cloudflare handles zones for any registrar.
  4. List on marketplaces as backup: keep an Afternic listing with Fast Transfer enabled as a safety net, but understand you’re paying 15-30% for that channel. Your lander’s direct channel costs nothing. Both can coexist — Afternic’s fast-transfer DNS requirement and this Worker are competing uses of the same nameservers, so pick per-domain which channel matters more for that name.
  5. Check /stats weekly: any domain with 0 leads and 0 type-in traffic after 60 days is either mispriced or dead weight — repriced or dropped. The data tells you; no guessing.

Pricing the ladder without guessing

The +20% installments / +35% lease-to-own multipliers aren’t magic — they’re a floor on your carry risk plus an option premium. A 12-month installment plan means you hold transfer risk for a year; 20% on a $2,500 sale is $500 for that exposure. A 36-month LTO means you hold it for three years and only get paid if the buyer stays solvent — 35% over floor is the minimum spread that makes that asymmetry worth taking at this price band. Below ~$1,000 floor values, skip the ladder entirely: the buyer pool at that level wants buy-now buttons, not payment plans, and every extra option adds negotiation surface without moving the close rate.

Two calibration rules that come out of real seller threads and marketplace fee math: price against recent comps for the exact TLD-and-length class (one-word .coms trade in the five-to-six figure range, mid-tier brandables in the low four figures), and leave yourself one 15% negotiation margin below the number you’d actually refuse. Afternic’s own help docs show buyers anchoring hard on Buy Now prices — your ladder’s top number does the anchoring for you.

The edge math, honestly

Portfolio of 30 domains, mixed quality, floor prices averaging $1,500:

  • Annual carry cost: 30 × $11 = $330
  • One direct sale at floor through your lander: +$1,500, commission $0
  • Same sale through Afternic Boost (30%): +$1,050 — the channel difference alone is $450, more than the entire portfolio’s annual renewal bill
  • Breakeven: one sale every ~4-5 years covers pure carry. Anything faster is upside. H1 2025 market data (93,100 sales / $122M / +42.7% YoY) says the demand side is liquid, and your lander is a 24/7 listing in front of exactly the buyers who typed your name in — the highest-intent traffic that exists in this market.

What this isn’t: it won’t generate demand. A lander with no type-in traffic is a billboard on a dead highway. If a name gets zero type-ins, no lander saves it — that’s a pricing/quality problem, and the audit script in Step 1 is how you find the names that shouldn’t be in the portfolio at all.

If you want a custom version of this stack deployed across your own portfolio — per-domain pricing logic, email routing into a real inbox, escrow-handoff flow, or the self-hosted variant on your own VPS — email [email protected] and we’ll build it.