An account that is only a hex string

Mint an account from one hex string: zero inboxes, zero documents, a coin-settled invoice. Entry slices from $4.80/mo when prepaid for a year.
Mint an account from one hex string: zero inboxes, zero documents, a coin-settled invoice. Entry slices from $4.80/mo when prepaid for a year.
The inbox quietly runs the account
Plenty of providers advertise identity-light signup while archiving a mailbox anyway — and that one string rewrites the account's legal anatomy. It receives resets, so whoever controls it controls you. It surrenders smoothly under legal requests, since handing over a mailbox requires touching none of your machines. And it glues your presence here to every breach list where the same address already circulates.
The plumbing is unromantic. A mailbox is a person-pointer: password resets land there, invoices land there, warnings land there. Formats standardized in RFC 5322 feel disposable, yet mail platforms retain the metadata binding an address to devices and phone numbers, and requesters know the paperwork. Removing the address deletes an entire disclosure category before anyone promises you secrecy.
Here, the inbox is optional equipment. An account may consist of nothing besides a 32-character hex string — no email slot filled, no recovery destination, nothing addressable at any mail provider. Add a mailbox only when invoices should arrive by delivery; attaching one later is a settings edit, not a migration. The string authenticates, and the string is the account.
Mistaking this for a vacuum seal is the standard error. The invoice ledger persists: coin, amount, destination, txid, timestamp. Settings changes remain on file; connection records survive at most ≤24h; packet contents and guest traffic are never recorded. Minimization shrinks the ledger rather than emptying it, and plans built around what remains stay realistic.
The trade, concretely: surrender a recovery channel and invoice delivery, gain the removal of hosting's most-requested identifier. What follows is logistics — minting the string, funding the account, keeping the single secret alive — but first confirm the string branch actually suits you, because a second branch exists and it is no trap. Every mailbox imports its own mortality, too: a purged or abandoned inbox turns each future reset into a lockout, a failure the string cannot have by construction.
VPS from $4.80* — Core on the annual term (list $6/mo), one invoice for 12 months, no auto-charges. Dedicated with IPMI from $39.20/mo. Crypto invoice, no KYC.
Launch nowString versus mailbox: choose your failure
Counter-intuitive again: the string branch is not automatically superior. Mailbox-plus-password delivers two goods no string can — invoices arriving unrequested, and a rescue path when the password dies. For accounts whose loss would cost an annoying afternoon, the mailbox is not a weakness but insurance. Privacy here is a dial, and you set it per account rather than per religion.
Mechanically the branches differ in exactly one organ. Both are no-KYC — no passport, phone or card at any point. Mailbox accounts pair an address with a password of at least 12 characters; string accounts pair nothing with a credential shown a single time at creation. Billing, plans, cities and checkout behave identically downstream of that fork, so the choice costs you nothing but thought.
Decide by failure mode, never by ideology. Lost mailbox password: reset, minutes, done. Lost string: the account is finished by design, and the remedy is a fresh string plus repointed DNS — minutes of provisioning, but the configuration is gone. One branch forgives; the other memorializes. That difference is the entire comparison.
Errors run in both directions. Mailbox users, convinced the address betrays them, endure string setups they cannot operate; string users, convinced records vanished, behave looser than facts allow. Both stem from treating signup as a privacy verdict rather than a recovery decision. Ask which loss you dread more: control of the account, or an address that others can demand.
If the mailbox wins, register with a provider you trust, set the long password, and skip the rest of this page's string logistics. If the string wins, the next section is your runbook — exact order, plus the spot where each step bites. Either way the whole procedure costs minutes, not evenings. Whichever branch you pick, decide before the form opens — it asks nothing about identity, so the only wrong answer is one chosen by default.
Minting the string (and surviving minute one)
Danger lives after the form, not in it. The panel prints your credential exactly once, into a tab destined to close, and every disaster story here begins with "I'll copy it in a second." Treat it as a wallet's recovery words: not a login to memorize but a secret to store — with the storage existing before the tab dies.
Flow: open the deploy page (../../deploy/ here), choose the string branch — the form carries no email slot — and the panel prints the 32-character value once. Park it immediately in a credentials vault plus one offline encrypted file, never the browser session. Size the machine in the same breath: the entry plan carries 2 vCPU, 4 GB DDR5 ECC, 80 GB NVMe, and every city bills the same base number.
Geography stays price-neutral by design: Amsterdam, Tokyo, Helsinki — identical base cost, with Iceland +20% and Switzerland +35% as the only listed surcharges. Those two exist for their jurisdictions — Reykjavik under Icelandic law without retention duties, Zurich under the Swiss FADP — and the surcharge buys the paperwork those regimes waive. Everything else rides at list.
Size the job before the invoice prints: take the entry plan at $6/mo list — $4.80/mo on the yearly prepay — while the workload fits two cores and four gigs, and refuse to buy headroom you cannot yet name. Annual billing means one invoice covering 12 months, nothing automatic — a decent match for an account whose only leash is a string.
Storage is where minting goes wrong: the screenshot landing in a phone whose camera roll syncs to a consumer cloud; the paste into a chat "to move it over". Both hand the secret to a stranger's disk within a minute of creation. Copy into a vault you govern, paste back once to verify, then let the tab close — funding comes next, and the coin choice writes more onto the record than signup did.
The coin writes the trail
Coin selection inscribes more than signup did. A string-only account funded by a custodial exchange withdrawal carries — at that exchange — the identity behind the withdrawal account. The link lives on their books, not at the host, yet it exists. Funding is where nameless accounts quietly win or lose, and the menu offers genuine alternatives rather than one blessed path.
Nineteen coins settle invoices. Monero hides counterparties and amounts on its ledger by construction — the project's site explains the cryptography properly — while a dollar-pegged rail like USDT-TRC20 holds the quoted figure steady between issue and confirmation. Between those poles: BTC, ETH, BNB, SOL, LTC, TRX, XRP, DOGE, DASH, ADA, GRAM on TON, plus USDT across seven ledgers — TRC-20, ERC-20, BEP-20, SPL, Polygon, Arbitrum, Optimism.
The invoice prices at the then-current market rate, binds to one address created for it alone, and watches the chain: exact matches credit themselves with no human and no waiting. Confirmation to a live shell prompt takes about 60 seconds — the number worth remembering, because the sluggish part of any setup is never the provider.
Two errors dominate funding cases. Rail mismatch: dollars dispatched across a ledger the invoice never named, converting an automatic credit into a manual review. Shortfall: the rate drifted or an exchange clipped its fee, and the arriving total misses the quote — usually repairable onto the original invoice after a person inspects it. Ten seconds of address scrutiny prevents both.
Match coin to purpose: Monero when the trail matters most, a dollar rail when the figure must hold, anything else when neither concern binds. Once funds confirm, the account exists in full — and the machine's front door, not the invoice page, deserves first attention, because careless SSH erases every earlier precaution.
The front door: keys before everything
A nameless signup means nothing once the machine inside answers password prompts from the entire internet. Hardening must reach the operating system within the first 10 minutes, while the box is boring and nothing aboard resists a restart. This is the step everyone postpones and then forgets — maximum privacy coinciding, briefly, with maximum exposure.
Generate the key locally: ssh-keygen -t ed25519 -C "". That empty comment matters — a default key embeds user@host, a string that then rides into every authorized list and screenshot it touches. The ssh-keygen manual covers the flags; the gist is that an identifying comment is a leak you simply decline to write.
Aboard the box: public half into ~/.ssh/authorized_keys, then PasswordAuthentication no in the daemon config, validated by sshd -t before any reload — a typo there is a classic self-lockout. Keep a second live session open until the first reconnects cleanly; the sshd manual details every directive, and the password line is today's only mandatory one.
The canonical break is the lockout: reload with a syntax error, close the only console, own a paperweight with an invoice attached. The mandated order exists for that reason — key in, config validated, second session proven, only then passwords off. The inverse sin is leaving password login enabled "temporarily" on a box whose purpose was the opposite; scanners enumerate fresh IPv4 addresses within minutes.
Keys in, passwords out — account and machine now tell one story: minimal identity at birth, minimal surface at runtime. What hardening cannot alter is what traffic announces: destinations log the box's address, and the provider's short-lived record still exists inside its day-long window. The next section charts that remainder honestly. The payoff compounds, too: every later machine repeats the same four moves — key, config, validate, second session — inside the first ten minutes of its life.
What the string cannot conceal
Minimization is not camouflage, and operations feel the difference. Checks, crawls and API calls depart from the box's IPv4; every destination writes that address into its own logs, limits and alerting — a record no host can prune for you. The account hides its owner; the network edge announces the machine. Plan for a quiet address, never an absent one.
The provider-side ledger, plainly: invoices and settings changes persist by design; connection records last at most ≤24h; packet contents and guest traffic go unrecorded — boundaries stated on the privacy page. RFC 6973 catalogs the risk classes this design prunes; one read calibrates what "minimal" actually purchased. The dossier stays short because the design never collects the fat rows — no name, no billing address, no card trace exist to write down.
Re-linking arrives from your side, never from either ledger. Open the quiet panel from the browser carrying your daily identity: shared fingerprint. Attach a WHOIS-named domain: shared name. Route alerts through a personal messenger: shared number. Each bridge is one settings decision — reversible before it matters, almost never after. A quarterly audit keeps it that way: inventory the browser profiles, domains and alert channels reaching the login, then delete whatever exists only by habit.
The archetype is the incident page or alert webhook born from an existing identity "just to get it running". A public page on a named domain publishes the pairing of discreet watcher and known operator; a webhook keyed to your main bot token signatures every alert with the same hand. Mint channel identities from nothing, or skip the public surface entirely.
Disk privacy pairs with account privacy: a sealed volume inside the box covers the states nobody watches, which the LUKS guide walks end to end. Account, disk, network — each layer trims a different record, and the network layer bows least to you. Which is why the final decision here, where the string itself lives, admits no undo.
One secret, zero second chances
No queue resurrects what it never saw. A string account offers no mailbox for resets, no identity for verification, no escrowed duplicate — the design you purchased, intact on your worst day. Lose the string and the account is over; the remedy is a new string and a rebuilt machine. The ticket flow described in the support guide covers billing and hardware — never credentials — and that wall is load-bearing.
So custody is yours from day one, on two media. A vault entry serves as the working copy; an offline encrypted file — gpg -c produces one from any terminal — survives a vault lockout. The GnuPG documentation covers symmetric mode on its opening pages; five minutes of habit outlasts every browser session you will ever close.
Rebuilding costs less than folklore claims, which argues against over-insuring one account. Provisioning runs about 60 seconds from payment to shell, so a replacement account is minutes old while the kettle boils. The expensive part is reconfiguration — cured by a setup script or image you maintain, not by a second copy of the very secret you swore to guard singly.
Failure patterns are boringly consistent: the sole copy living in the tab that created it; the paste into a messenger "for safekeeping"; the plaintext txt file inside a synced folder. The subtle variant is custody behind the same vault master password as the mailbox of the identity this account was meant to separate — one phishing page then opens both worlds. Segregate secrets the way you segregate accounts.
Hold the string as a key with exactly one lawful copy, and everything afterwards is ordinary operations. The closing section compresses the entire path — decide, mint, store, fund, harden, rehearse — into running order, so the next account costs minutes and zero second chances. It is a checklist you will reuse for years.
The signup, in the order to run it
Decide first: string or mailbox, by whichever failure you would rather manage. Choosing the string means the next hour matters; choosing the mailbox lets you skip straight to sizing. String path: stage the storage before the form — vault open in one window, offline encrypted file waiting — because the credential prints once and the countdown starts instantly.
Create the account on the string branch of the deploy page; park the 32-character value into both stores immediately; verify one paste-back before anything else. Size in the same sitting — two cores, four gigs of ECC memory, eighty gigs of flash carry most jobs — and select the city for latency or law, remembering that only two flags carry surcharges.
Fund from the wallet already reasoned about: Monero for the quietest chain, a dollar rail when the figure must hold. The market-priced quote does its single-address job; confirmation to shell follows in about a minute. Ten seconds of address scrutiny beforehand eliminates both repairable funding cases — wrong ledger, short total. Screenshot the quote before paying, too: its two values, amount and destination, anchor every later funding conversation.
Harden while the box holds nothing worth taking: locally generated key with an empty comment, public half into authorized_keys, password logins disabled, config validated, second session proven. Then rehearse recovery deliberately — string out of the vault, login, rebuild from your notes. An unrestored backup is a wish, and this one has no vendor safety net beneath it.
Attach a mailbox later only if delivered invoices earn their keep — the string keeps working either way, and the account stays document-free in both shapes. When work outgrows the slice, the same credential climbs to larger tiers or iron without a second identity, and every future box repeats this order: decide, mint, store, fund, harden, rehearse.
Can a lost credential be re-issued?
It cannot. A string account files no address, so nothing exists to reset against or to verify you with. Durable storage before the tab closes is the whole recovery plan — that copy is the only one that will ever be made.
Adding a mailbox afterwards — allowed?
Yes. The address remains optional equipment: the string keeps authenticating either way, and a mailbox only adds delivered invoices plus a reset path. The account stays document-free in both configurations.
Are string signup and no-KYC identical?
They are distinct. Skipping documents at checkout is the no-KYC half; carrying no mailbox is the string half. This platform provides both simultaneously, but either exists alone at hosts promising less.
And if the string disappears?
The account ends — the price of holding the sole credential personally. Open a replacement, repoint DNS, rebuild from scripts; provisioning needs roughly a minute, so the real loss is configuration, not clock time.
Which coin fits best?
Monero leaves the faintest public trace and suits the tightest trails; a dollar-pegged rail keeps the figure stable from quote to confirmation. Either settles the same market-priced invoice, and nineteen coins are accepted overall.
Primary sources
More ways to pay
Pay with Bitcoin · Pay with Monero · Pay with USDT (TRC-20/ERC-20/SPL) · Pay with Litecoin · Pay with Ethereum · Pay with Solana · Pay with x402 · Pay with Dogecoin · Pay with XRP · Pay with TRX · Monero on bare metal · Dedicated servers with crypto · Pick the jurisdiction first.
Ready to launch?
Build the box — VPS or bare metal — create the password, pay the invoice that follows.