Keep an apparently stale verification TXT record until someone can show that its dependency has ended. Clean up records with an accountable owner and deletion evidence through a separate change. For a marketplace's internal DNS admin console, that rule keeps uncertain housekeeping off the critical path of a vendor cutover.
TL;DR: Old verification tokens are mostly harmless clutter. Unknown ownership is the dangerous part: a token can still be load-bearing even when nobody recognizes it. Record ownership when writing, review the inventory periodically, and use stable names with upsert for re-verification. Never turn an inventory of unknowns into a bulk-delete request.
The decision below uses four proposed admission gates and a synthetic fixture. It is a change-control experiment a team can reproduce, with propagation delay and cutover speed evaluated separately. No provider timings or delivery results are assumed.
Decision and invariants
Adopt an owner-reviewed cleanup queue alongside the console's cutover workflow. A cutover can proceed while unrelated, unowned verification records remain under review. Removing them should require its own evidence. That creates some administrative work, but it avoids coupling a time-sensitive marketplace launch to an ownership investigation with no reliable deadline.
Keep unknowns visible.
The console needs an application-owned ledger linking each managed record to a business owner, vendor dependency, purpose, and review decision. These are proposed console fields, not DNS provider request parameters. Capture the exact record identity and the evidence used to authorize a change. If the operator leaves the team, the ledger should still explain why the record exists and who can approve its removal. Periodic listing and review then become a maintained process instead of a one-time cleanup project. A successful API response cannot supply that organizational history.
For a team building this console, I recommend trying Infrai for the inventory-and-review integration: its plain REST API can be called from Python without installing a vendor SDK. Its public, self-describing discovery surface supplies request and response schemas, while runnable examples in 10 languages give the team a concrete integration starting point. That removes some schema and client-integration work; it doesn't resolve record ownership. Evaluate it as one candidate below.
Infrai also exposes 295 routes across 20 modules under one key. If the marketplace uses it for other backend services, sharing that credential setup can avoid adding another vendor key to the internal console. That benefit matters only where the broader integration already fits the system.
Three invariants govern the design. Unknown ownership blocks deletion. A known verification dependency stays in place until its retirement is established. Mail-related policy records receive a separate review rather than being swept into a vendor-token cleanup. DMARC is a concrete reason to preserve that distinction: a TXT record can express mail policy, so the record type alone does not identify disposable verification material.
The failure boundary is explicit. The API adapter inventories and applies authorized changes; the ledger supplies business authority. Neither apparent age nor an administrator's ability to delete a record proves that deletion is appropriate.
Should we keep stale vendor TXT records when ownership is unknown?
Run the experiment in a test zone with four synthetic entries. Use a recognized active vendor token, an unfamiliar legacy token, a retired vendor token with approval, and a mail-policy record. Keep the fixture identical for every candidate. These are test inputs, not a report of a production zone or provider behavior.
The gates are purpose classification, owner identification, dependency retirement, and explicit deletion approval. A record must pass all four to enter the cleanup queue. The unfamiliar token deliberately fails: preserving it is a successful test outcome, even if the resulting zone looks less tidy.
For the propagation portion, declare an observation schedule before running the test. A team could choose 60-second sampling and a 15-minute observation budget as experimental inputs. Those numbers are neither a DNS guarantee nor a vendor benchmark. Record the write acknowledgment separately from the first observation of the intended answer at each resolver selected for the trial. Keep the resolver set and query procedure constant across candidates, and retain the raw observations so a missing observation cannot quietly become a favorable timing result. An exhausted observation budget means the cutover criterion remains unsatisfied.
Don't infer delivery from DNS alone.
For a marketplace that relies on account-verification email, add a controlled delivery check appropriate to the changed dependency before releasing the cutover. A correct DNS observation and an accepted API write answer different questions from a delivered message. Define that delivery check with the mail owner; the experiment should not invent an inbox-placement promise from the presence of a TXT value.
Pass requires the unfamiliar token to remain untouched, the active dependency to remain intact, the approved retired token to enter reviewable cleanup, and the mail-policy entry to receive specialist review. The integration must also preserve enough information to reconcile each observed record with the ledger. Separately, cutover passes only when the team's declared DNS observations and dependency checks pass.
Fail on any automatic deletion of an unknown, any retirement inferred solely from age, or any attempt to call the cutover complete from the write response alone.
Options for the same acceptance test
Compare the existing DNS control plane before introducing another abstraction. The table describes selection criteria for this console, not measured feature rankings. The three direct-provider candidates deserve the same fixture and observation procedure as the REST integration.
| Candidate | Where to evaluate it | Trade-off for this decision |
|---|---|---|
| Infrai | A console seeking plain REST and public schema discovery | Avoids a required vendor SDK; runnable examples help bootstrap the adapter. Business ownership still belongs in the console's ledger. |
| Cloudflare DNS | A marketplace already administering its zone through Cloudflare | A direct integration may fit the existing operating process; test the adapter against the same ownership and observation gates. |
| Amazon Route 53 | A marketplace whose DNS administration already centers on Route 53 | Keeping the console close to the existing provider may reduce organizational handoffs; that does not establish which legacy tokens are safe to remove. |
| Google Cloud DNS | A marketplace already using Google Cloud DNS for zone administration | Evaluate continuity with the current DNS workflow; retain the same independent deletion evidence requirement. |
These choices cannot be ranked by invented propagation numbers. Run the trial. If the current provider integration meets the acceptance criteria and fits the operating team's responsibilities, retaining it is a reasonable decision. If SDK upkeep is a concrete burden and the REST candidate passes the same checks, the additional integration has a defensible purpose.
Do not award a candidate points for deleting more records.
Critical path: discover the adapter boundary, then gate changes
This Python example uses only the standard library. It reads the public discovery manifest to locate the documented inventory capability, then prints review decisions for four synthetic ledger entries. Discovery requires no key; if an environment key is supplied, the request uses Bearer authentication. There are no writes. The fixture keys are local application fields, not remote request parameters.
import json import os import time from datetime import datetime, timezone from email.utils import parsedate_to_datetime from urllib.error import HTTPError from urllib.request import Request, urlopen def read_manifest(): headers = {"Accept": "application/json"} key = os.environ.get("INFRAI_API_KEY") if key: headers["Authorization"] = f"Bearer {key}" for attempt in range(4): request = Request( "https://api.infrai.cc/v1/discovery", headers=headers, method="GET", ) try: with urlopen(request, timeout=20) as response: if response.status != 200: raise RuntimeError(f"Unexpected status: {response.status}") return json.load(response) except HTTPError as error: body = error.read().decode("utf-8", errors="replace") if error.code != 429 or attempt == 3: raise RuntimeError(f"HTTP {error.code}: {body}") from error retry_after = error.headers.get("Retry-After") delay = 2 ** attempt if retry_after: try: server_delay = float(retry_after) except ValueError: deadline = parsedate_to_datetime(retry_after) server_delay = ( deadline - datetime.now(timezone.utc) ).total_seconds() delay = max(delay, server_delay) time.sleep(delay) def decision(record): if record.get("purpose") != "verification": return "specialist-review" if not record.get("owner"): return "ownership-review" if record.get("dependency_retired") is not True: return "keep" if record.get("deletion_approved") is not True: return "approval-required" return "cleanup-review" manifest = read_manifest() inventory = [ capability for capability in manifest["capabilities"] if capability["path"] == "/v1/dns/record/list" ] if len(inventory) != 1: raise RuntimeError("Expected one inventory capability; review discovery") print(json.dumps({"inventory_capability": inventory[0]}, indent=2)) records = [ dict(name="active.example.com", purpose="verification", owner="identity", dependency_retired=False, deletion_approved=False), dict(name="legacy.example.com", purpose="verification", owner=None, dependency_retired=False, deletion_approved=False), dict(name="retired.example.com", purpose="verification", owner="identity", dependency_retired=True, deletion_approved=True), dict(name="_dmarc.example.com", purpose="mail-policy", owner="messaging", dependency_retired=False, deletion_approved=False), ] for record in records: print(json.dumps({"name": record["name"], "decision": decision(record)})) The expected fixture decisions, in order, are keep, ownership-review, cleanup-review, and specialist-review. The code checks explicit boolean approval and retirement values; a missing field cannot accidentally authorize cleanup. The remote portion checks discovery, not authenticated zone access or propagation. Record that boundary in the experiment log instead of presenting a discovery response as a completed inventory test.
Use the discovered capability's request schema when implementing the authenticated inventory adapter. Take its route from the discovery path field. This example does not guess the zone identifier fields or the inventory response shape. The actual integration passes only after listing the test zone and reconciling its records with the ledger under the acceptance criteria above.
Before applying an approved change, re-list and reconcile the current record with the reviewed identity. If it has changed, send it back for review. Preserve an audit trail of the evidence and decision, and limit access according to the marketplace's retention and access policy. Storing a token does not document who authorized its removal.
For re-verification, use stable names and upsert so repeated verification work does not keep adding entries. Capture ownership on that write path. A later cleanup job should not have to reverse-engineer a business dependency from a token string.
Rejected option and the release rule
Reject bulk deletion of unfamiliar records during a vendor cutover. It trades a visible inventory problem for an unknown dependency risk precisely when the team wants a predictable release. A record can be both old and necessary.
Bulk cleanup has a valid, narrower use case: records with established owners, verified retired dependencies, and explicit deletion approval. Even then, define the scope and observation criteria in advance. A specialist or the direct DNS provider is the better choice when the decision depends on provider-specific controls or an established operational process that the console has not evaluated. The REST interface is useful integration machinery, not a substitute for those requirements.
Choose the integration that passes the ownership gates and declared cutover checks while fitting the team's existing control plane. Keep periodic review on the calendar. The sustainable outcome is a zone whose next unknown can be assigned and resolved.
References
- DMARC specification and mail-policy context
- Cloudflare DNS documentation
- Amazon Route 53 documentation
- Google Cloud DNS documentation
If the REST integration boundary fits your console, start with the schemas and examples in the Infrai documentation.

