Admin tip: set rDNS / PTR on a crypto VPS

A PTR that matches the HELO is the first ticket most mail setups need: send the IP, the FQDN and the invoice code. Core runs $4.80/mo on the annual term.
A PTR that matches the HELO is the first ticket most mail setups need: send the IP, the FQDN and the invoice code. Core runs $4.80/mo on the annual term.
The one record you cannot set yourself
Nearly everything on a VPS bends to your editor, which makes the PTR record feel like an oversight: no panel field exists, and the omission is deliberate. Reverse DNS for an address block belongs to whoever owns the block, and the provider edits the pointer on request so tenants cannot scramble a neighborhood's collective standing on a whim. It is the one identity string on the box that arrives with a chaperone.
The mechanics: every IPv4 maps into the in-addr.arpa hierarchy defined for the domain system (RFC 1035 — RFC 1035), and the provider's nameservers hold authority for their shard of that tree. The change is therefore a desk action on records you can query but not write. Establish the baseline first with dig -x 203.0.113.10: a fresh machine answers with the allocator's generic label, which is expected behavior, not breakage — the checkout guide covers provisioning if you are not there yet.
IPv6 mirrors the structure through ip6.arpa, spelled out nibble by nibble across a /64, which is why providers set v6 pointers per address instead of handing over a zone file to edit. The reverse data simply lives deeper. Port 25 is open by policy on every plan here, so once the pointer agrees with your forward record, nothing else stands between the box and the mail system's front gate.
Why the chaperone matters economically: the pointer is shared infrastructure in the sense that receivers use it to police whole networks. Providers who let tenants self-serve arbitrary names get their blocks delisted faster; the ticket step adds friction exactly where abuse would otherwise flow freely. The delay you experience is the same control that keeps your own address credible once it is set — a rare case where bureaucracy and hygiene point in the same direction.
The typical mistake is concluding the feature is missing because the dashboard lacks a field, then either living with the generic label or attempting some resolver-side workaround around it. Neither survives contact with reality — receiving systems consult the authoritative reverse zone directly. The record is one ticket away, and every section after this one exists to make that ticket land completely, correctly, and in a single pass.
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 nowWhy receivers read the pointer before your prose
The counter-intuitive part: content filters are the last checkpoint, not the first. Before any filter weighs a syllable, the receiving mail system has already tested whether your address's reverse DNS pairs with a forward record — and a generic allocator label is the textbook signature of bulk sending, so an innocent message from an unpaired pointer begins its life carrying a penalty nobody announced.
What receivers actually grade is agreement: the PTR must resolve back to the name the address resolves forward to — the A/AAAA pair that RFC 1912 has advised keeping matched since 1995 (RFC 1912, section 2.1). SMTP adds a second string: the EHLO name your MTA announces, which RFC 5321 expects to be a resolvable, address-linked hostname (RFC 5321). Two of the four identity strings are therefore checked before a single header is parsed.
The grading is mechanical rather than hostile: a sender whose pointer reads like an allocator tag while its banner claims to be your mail host fails the coherence test that legitimate operators pass unconsciously. Rejections at this layer arrive as 5.7.x policy codes — the receiver never reached your content to judge it. The repair costs nothing once you understand that four strings must narrate one biography: pointer, banner, SPF, DKIM.
There is an asymmetry worth internalizing: receivers extend more suspicion to senders than to any other service class, because the protocol's default posture is trust-but-verify-everything. A web visitor never checks your reverse record; a mail receiver checks it on every single connection, at scale, automatically. That is why the same machine can serve a store flawlessly for years while its first newsletter disappears — the two protocols grade identity with entirely different severity.
The classic error is pointing the record at an elegant name that resolves nowhere yet — an unpaired reverse entry grades worse than a generic one, because now forward and reverse contradict each other on paper. Sequence correctly: forward record, then ticket, then MTA configuration, then the first send. Get the chain coherent and everything downstream becomes content, volume and hygiene rather than plumbing that quietly eats your invoices.
What to send the desk, and in what order
The ticket runs three lines, which is exactly why half of them bounce back for more: senders omit the invoice code on a fresh panel session, or ticket a hostname that resolves nowhere yet. The desk transcribes whatever you supply into the reverse zone, so the completeness of your ticket is the latency of your change — there is no cleverness that shortcuts a short message.
Supply three things: the IPv4, plus the IPv6 if you have published its AAAA; the FQDN that already points back at that address through an A record; and the invoice code if the session is new. The desk edits the pointer, forward and reverse agree, and receivers find the property they test. Order Core at $6/mo list — $4.80 on the annual term — and the ticket can leave the same hour the machine provisions, because panel ticketing opens with the plan.
For IPv6, include the complete address whose AAAA is live — the reverse delegation works per address inside the /64, so asking for the whole prefix is not an actionable request. Verification afterward is one command per family: dig +short -x against each address, expecting your hostname returned. Documentation ranges such as 203.0.113.0/24 exist precisely so examples never leak real space (RFC 5737 — RFC 5737).
A second pass usually costs a day, which is why the completeness discipline matters: if the desk answers, edits, and re-asks twice, your warm-up clock — which runs in weeks — has already lost a sixth of its runway. Batch the request instead. Include both families in one ticket, name the exact FQDN, paste the invoice code, and the change lands in a single human round-trip that you can verify within minutes of the reply.
The mistake that burns a day: ticketing the pointer while the hostname still aims at the previous machine during a move, so the desk faithfully records a name that resolves somewhere else. Sequence every step — forward record, ticket, MTA configuration — and one pass suffices. Spend the queue time hardening the login path to key-only per the sshd_config manual rather than refreshing the queue; the ticket needs no supervision once it is complete.
Four strings, one story: pointer, HELO, SPF, DKIM
The uncomfortable arithmetic of alignment: the pointer you just ticketed is one quarter of the identity receiving systems grade. Four strings must agree — reverse DNS, the SMTP banner name, your SPF record and your DKIM selector's domain — and a disagreement in any single one of them taxes deliverability regardless of how spotless the address history behind it happens to be.
Point the MTA's hostname at the same FQDN the pointer uses: in Postfix that is one line, postconf -e myhostname=mail.example.com, and the project's own walkthrough covers the identity settings around it (Postfix BASIC_CONFIGURATION_README). SPF then authorizes that name's address to send for your domain — the mechanism RFC 7208 specifies (RFC 7208) — via a record such as v=spf1 a mx -all once every legitimate source is known.
DKIM stamps each message with a signature whose key waits under a selector — mail._domainkey.example.com is the conventional shape — per the format RFC 6376 defines (RFC 6376). DMARC ties the pair to the visible From domain and instructs receivers what to do on failure (RFC 7489 — RFC 7489), while its aggregate reports email you proof of who is sending as you. Verify every layer with dig TXT before the first production send, not after the first complaint.
Publish the DMARC policy deliberately: start at p=none to watch reports without risk, graduate to quarantine once the reports show only your own sources, and reserve reject for the day the aggregate data has been quiet for a month. This staging converts a scary policy decision into a measured rollout — and the reports themselves, usually a weekly digest of XML summaries, are the only objective witness to how the four strings read from outside.
Where operators break it: renaming the host for a rebrand, updating the pointer, and forgetting SPF, DKIM and the MTA configuration in the same change. Receivers observe partial agreement, which reads as spoofing, and the bounce codes decline to explain why. Treat identity edits as one atomic transaction across all four layers — the agreement among them is the property being tested, never any individual string.
Warm-up: the physics no provider can sell you around
Here is the promise nobody can honor: a brand-new IPv4 with instant inbox placement. A fresh address carries zero history at every large receiver, and standing is compiled from observed behavior across weeks — no ticket, plugin or paid shortcut legislates that away. What remains under your control is the geometry of the ramp and the caliber of the mail riding down it.
The mechanics of a ramp: begin with low volume toward recipients who demonstrably open your mail — the most engaged slice of the list — hold bounces beneath a few percent, and let weeks rather than days set the gradient. Large receivers grade the domain and the address separately, so a domain with years of clean conduct carries a new IP uphill faster than the reverse journey ever goes. A cold blast on day one instructs every filter precisely the wrong lesson about you.
Observe the queue, not the sent folder: postqueue -p exposes deferrals stacking long before humans complain, and the Postfix project documents its queue tooling (Postfix documentation). Deferrals wearing 4xx codes during a ramp are ordinary weather; a climbing share of 5xx policy verdicts means stop, prune the list, resume smaller. postscreen — Postfix's connection triage layer, documented in its own README (POSTSCREEN_README) — shows you early which receivers are testing you before you invest volume there.
Keep the list machinery honest during the ramp: honor unsubscribes immediately (the one-click standard is RFC 8058 — RFC 8058), delete addresses that never engage, and treat acquisition lists from vendors as radioactive until proven otherwise. Bounce addresses written in VERP form make the cleanup mechanical instead of forensic. Engagement is the currency the large receivers actually bank; a ramp that impresses the filters also, not coincidentally, impresses the humans who taught those filters what wanted mail looks like.
The classic failure is importing a stale list from the shared-hosting era and firing it from the fresh address — the move keeps your domain, never your standing (the migration guide keeps the sequence honest). Decayed addresses that matured into spam traps do the harm, and the new IP absorbs a reputation it never earned. Warm with proven recipients and the address inherits a story receivers enjoy; the ramp is the standing toll for owning your own sender identity.
One job per address: splitting roles before buying metal
The cheapest deliverability upgrade is not a larger machine — it is a second address. When web, VPN egress and mail share one IPv4, one job's conduct taxes the others: a scanning cron on the tunnel exit makes the mail host look chatty, and a listing makes the storefront API suspicious to every gateway that keeps ledgers. Separation of duties costs an add-on, not a rack.
Extra IPv4s are a $3.50/mo add-on here, each with its own settable pointer, so the split is one ticket per address rather than a migration. Assign them at the interface with ip addr add — the command family is documented in the man page (ip(8) manual) — bind each daemon to its own address, and furnish each with a hostname plus a pointer that echoes its forward record exactly.
Numbers argue the case: three roles on three addresses never borrow each other's standing, and the /64 IPv6 block every plan includes supplies the same segregation on the v6 side at zero marginal cost — number subaddresses by function, publish AAAA only where a role actually serves traffic. A three-address setup still invoices like a hobby project while behaving like a small fleet with clear lines of accountability.
Write the mapping down somewhere that survives reboots — a comment block in the network config, a page in your runbook — because the failure mode is drift: six months later someone binds the monitoring agent to whatever address resolved first, and the mail identity starts shipping telemetry. Roles wander; reputations hold grudges. An hour of bookkeeping prevents the season of quiet score degradation that nobody can trace afterward.
The error to avoid: buying the second address and running crawls, scans or crypto peers from the mail IP anyway because capacity sat idle. Separate the addresses by duty, document which is which, and the dedicated-server conversation recedes by years — the class comparison will wait patiently for the day the measurements genuinely demand it. Address hygiene compounds further than most operators ever bother to test.
The IPv6 pointer and the unpaired AAAA penalty
Receiving systems inspect both address families, and an AAAA without a matching v6 pointer is its own deliverability fine. Worse, plenty of sending MTAs and policy engines prefer the v6 path whenever both exist, so the carefully aligned IPv4 identity never even gets exercised — the unaligned twin does the talking, and it flunks the coherence test you already paid to pass on the v4 side.
The mechanics mirror v4 with longer arithmetic: each address inside the /64 every plan ships maps into ip6.arpa, and the provider sets those pointers per address on ticket — same desk, same queue. Inventory what the machine actually announces with ip -6 addr show, publish the AAAA only for addresses that serve mail, and request those pointers in the same ticket as the v4 ones so both families go live together.
The addressing architecture underneath is RFC 4291 (RFC 4291). Keep banner resolution consistent: if the HELO name carries both an A and an AAAA, the receiving side may connect either way, and both families must resolve and match. Publishing AAAA only on the mail host — never on every name in the zone — keeps the surface small, the delegation shallow, and the biography single.
A test worth running before launch: force the v6 path once from a client that supports it and confirm the connection, the banner and the TLS handshake all present your hostname — the v4 checks going green proves nothing about the twin family. One deliberate verification now beats an intermittent bounce pattern later that you would otherwise blame on content, timing or luck before ever suspecting a pointer.
The typical error: enabling v6 in the MTA before ticketing the v6 pointer, then watching rejections from v6-preferring receivers while every v4 probe passes emerald. Test with the v6 route compelled, or simply ticket both pointers ahead of the first send and delete the branch entirely. One family, one narrative — the pointer rule does not grow harder with address length, only with the number of nibbles the zone delegates to you.
When the workload outgrows the slice
Nothing on this page changes on metal — the pointer is still a ticket, the alignment chain is still four strings — but the motives for moving change character. If you are adding addresses to quarantine duties, adding disks for archives, or adding cores because mail volume itself became the merchandise, the dedicated tiers are the same checkout with exclusive silicon behind the counter.
The entrance is Forge: a Ryzen 9 9950X at 16c/32t, 32 GB DDR5, 2×1 TB NVMe on RAID 0/1, a 1 Gbps unmetered port and IPMI. Order Forge at $49 list — $39.20 on the annual term — and the same pointer ticket covers its addresses; bulk archives and years-deep Maildirs belong on that class of disk, not on a slice you also serve the web from. The dedicated ledger prints every tier, and Monero settles bare metal exactly as it settles slices.
Metal contributes the out-of-band console: IPMI turns a wedged MTA at three in the morning into a remote console session instead of a plea, and L3/L4 DDoS scrubbing carries over from the VPS tiers. Provisioning spans 2-4 h rather than roughly a minute — racking and hand-over are physical labor — so choreograph the move like any other: build, copy, cut, hold the rollback window.
Jurisdiction travels with the chassis, too: the twelve-site map includes Reykjavik and Zurich for their legal regimes at published premiums of +20% and +35%, plus Amsterdam, Frankfurt, Tokyo, Singapore and the rest, with abuse adjudicated under the law of whichever facility houses the rack. If your mail carries regulatory weight, the destination city is part of the compliance answer, not a line item — choose it with the same care as the specs.
The error: scaling hardware before scaling reputation. A dedicated address with a cold history meets the same warm-up physics as a newborn VPS IP, so budget the ramp again and keep the volume curve candid while the newcomer settles. Move when volume, storage or console needs say so, never when boredom does — the slices were never the constraint while the mail was still climbing toward its own ceiling.
The PTR ticket, in the order to run it
Before ordering, elect the mail hostname — mail beneath your domain is the convention — and aim its A record at the address you will genuinely send from; sequence outranks speed at this stage. Then provision, settle the invoice, and while the machine images, draft the ticket: address, FQDN, invoice code — three lines, nothing left for the desk to reconstruct.
Dispatch the ticket the moment the panel opens: IPv4 plus IPv6 where the AAAA is published, the resolving FQDN, the invoice code. While it queues, spend the interval on the afternoon's hardening — key-only login per the sshd_config manual, a default-deny firewall — and set the MTA hostname with postconf -e myhostname= to the identical FQDN so the introduction is rehearsed before the record exists.
When dig +short -x answers with your hostname for both families, publish SPF and DKIM, set a DMARC policy, and mail a seed list you personally control. Read the authentication headers on arrival — every large provider surfaces them — and confirm the alignment you configured is the alignment receivers observe, since that outside view is the only version with consequences.
Then ramp with a schedule, not a mood: weeks, not days; the engaged cohort first; bounces under a few percent; the queue watched through postqueue -p. Keep a one-page log of dates, volumes and any policy rejections — it converts the vague art of warming into a repeatable recipe the next project inherits instead of rediscovering from scars.
Re-ticket the pointer whenever the hostname moves, updating banner and SPF inside the same change window — the concord among the four strings is what receivers actually grade, and maintaining it stays a two-minute checklist for the life of the address. Done in this order, the whole procedure costs one ticket, one afternoon of configuration, and a fortnight of patience — the cheapest reputation insurance in mail operations.
Does the PTR apply to IPv6 too?
Yes, for any address whose AAAA record is published. Include the IPv6 in the ticket alongside the IPv4 — receivers inspect both families, and an unpaired AAAA is its own deliverability fine, since many senders prefer the v6 path whenever both exist and the unaligned twin ends up doing the talking.
How fast does the change land?
It travels through the same support queue as every other ticket, plus DNS caching on top — usually quick, occasionally cached longer by resolvers you do not govern. It is a desk action rather than a self-serve panel field, so a complete ticket (IP, FQDN, invoice code) is what keeps the change to a single pass.
Does a web server need a PTR record?
Rarely. Browsers and search crawlers do not grade reverse DNS; the record matters to mail receivers, some FTP mirrors and a handful of API gateways. Set it once anyway — the ticket costs nothing and retires a variable you would otherwise be debugging in the middle of an integration, at the worst possible hour.
Can the PTR change again later?
Yes — re-ticket the address with the new FQDN whenever the hostname moves. Update the banner name and SPF inside the same change, since the concord between the strings is what receivers verify, not any single record standing alone in the zone.
Does rDNS alone fix deliverability?
No — it retires one known penalty, not all of them. Content caliber, volume ramp, list hygiene and authenticated headers (SPF, DKIM, DMARC) carry the remainder, and a warmed address stays clean only as long as the mail stays wanted by the humans receiving it.
Is port 25 open for sending?
Yes, by policy, on every plan, with a settable pointer once the ticket lands — so Mailcow or a plain Postfix stack runs without unblock petitions. Warm the address gradually and keep the mail IP separate from scanning or VPN egress so one job's reputation never taxes another's.
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.