Republishing rules

This is the one rule in these docs with consequences outside your own codebase, so it gets its own page. It comes down to a single field.

tier is the only field that says a name is public

As of 22 September 2026, 5,314 of the directory’s 17,713 listings are on the open shelf. If you are building anything public, tier=open is a server-side filter and you should be using it:

curl -s -G https://getrevised.com/api/v1/domains \
  -H "Authorization: Bearer $REVISED_KEY" \
  -d tier=open \
  -d limit=250

open is the only value that filter accepts. There is no way to ask the API for regular or featured rows specifically — but there is also nothing stopping them arriving in an unfiltered page, which is the whole reason for the rest of this page.

Three fields that look like the answer and are not

featured (the boolean) is not tier == "featured"

Each listing carries a featured boolean and a tier. The boolean reads the shelf rank and can disagree with the tier. It is not a permission field and it never was.

# WRONG — the boolean is a rank signal, not a shelf
if not row["featured"]:
    publish(row["domain"])

# RIGHT
if row["tier"] == "open":
    publish(row["domain"])

A non-null domain is not permission

Receiving the name means you are entitled to see it. It says nothing about republishing it. On a plan with no reveal ceiling every name arrives disclosed, on every tier — that plan buys you access, not publication rights.

# WRONG — "I can see it, so I can publish it"
if row["domain"]:
    publish(row["domain"])

mask_hint is not a discriminator

mask_hint is populated on every row, whether or not anything is masked. It is what to render when a name is withheld; it is not how you tell whether one was.

If you need to know whether you got a real name, read name_disclosed. If you need to know whether you may publish it, read tier. They answer different questions.

Why domain can be null

Two independent reasons, indistinguishable from the field itself:

1. Another account holds the listing — hold_state: "other". A hold masks the name for every reader, and an unlimited reveal allowance is not an exemption. hold_expires_at says when it comes back.
2. Your plan has a monthly reveal ceiling and you have not revealed this listing. POST /api/v1/domains/{id}/reveal buys one.

Render mask_hint either way. Neither reason has anything to do with whether the name may be republished — a masked regular listing and a revealed regular listing are equally off-limits.

The pattern: filter at the source, assert at the boundary

Filtering is not enough on its own. A filter lives at the top of a pipeline where a later edit can quietly widen it; the assertion lives immediately before the write, where nothing can get past it.

import json


def export_open_shortlist(rows, path):
    """Write a public CSV. Refuses outright if a non-open row got this far."""
    open_rows = [r for r in rows if r.get("status") == "active" and r["tier"] == "open"]

    # The guard. Immediately before the write, so no future edit to the filters
    # above can bypass it.
    assert all(r["tier"] == "open" for r in open_rows), (
        "refusing to export: non-open rows are disclosed under the API terms, "
        "not for republication"
    )

    with open(path, "w", encoding="utf-8") as handle:
        for row in open_rows:
            handle.write(json.dumps({"domain": row["domain"], "tier": row["tier"]}) + "\n")

    return len(open_rows)

With pandas, the same guard in one line before to_csv:

assert (df["tier"] == "open").all(), \
    "refusing to export: non-open rows are disclosed under the API terms, not for republication"

df.to_csv(filename, index=False)

And in a shell pipeline, where it is easiest to forget:

curl -s -G https://getrevised.com/api/v1/domains \
  -H "Authorization: Bearer $REVISED_KEY" \
  -d tier=open -d limit=250 \
  | jq -e '[.data[] | select(.status == "active")] | all(.tier == "open")' > /dev/null \
  || { echo "refusing to publish: non-open rows in the page" >&2; exit 1; }

refusing to publish: non-open rows in the page

jq -e exits non-zero when the last output is false or null, so the guard fails the pipeline rather than printing a warning nobody reads.

What counts as republishing

Treat anything another person can read as publication: a web page, a public API of your own, a downloadable file, a newsletter, a social post, a dataset, a dashboard shared outside your organisation, or model output you publish.

What you may do with any tier, on any plan:

• Read it, store it, rank it, and make decisions with it inside your own systems.
• Register the domain yourself, at any registrar. The restriction is on republishing Revised’s data, not on acting on it. Nothing in the directory is sold by Revised, and every listing is a name available to register.
• Tell your own users about a name you have registered. Once it is yours, it is yours.

Checklist before anything goes public

1. Filter server-side

   tier=open on the request. Cheapest possible place to drop a row you cannot use.

2. Drop tombstones

   Branch on status. A delisted row has no tier at all and will throw or, worse, compare falsely.

3. Assert immediately before the write

   assert all(r["tier"] == "open" ...). Not at the top of the function — at the boundary.

4. Re-check the stamp

   availability_checked_at is a last-checked timestamp, not a live check. A public list of “available” names that were registered last week is its own kind of problem. See Evaluating a domain.

5. Date the output

   Stamp the export with the synced_at watermark it came from, so a reader knows how old it is.

The full terms are at getrevised.com/terms.