diff --git a/content/(account)/pricing.mdx b/content/(account)/pricing.mdx index 4b575b3..57f0b19 100644 --- a/content/(account)/pricing.mdx +++ b/content/(account)/pricing.mdx @@ -44,7 +44,7 @@ The first two are real usage from the last 30 days. | Domain | Price | Counts toward your limit | | --- | --- | --- | -| Registered through Spacefast | At cost: registry price plus ICANN fee | No | +| [Registered through Spacefast](/registration) | At cost: registry price plus ICANN fee | No | | Registered through WordPress.com, or on Spacefast DNS | Free to connect | No | | Any other domain | Free to connect | Yes | diff --git a/content/(serve)/domains.mdx b/content/(serve)/domains.mdx index f6875d2..3793a95 100644 --- a/content/(serve)/domains.mdx +++ b/content/(serve)/domains.mdx @@ -6,6 +6,8 @@ sidebar: { order: 2 } A domain you own can be pointed at a Space and promoted to its primary, live address. +Don't have one yet? [Register a domain](/registration) through Spacefast and skip the DNS steps below: it runs on Spacefast DNS, so the records are written for you. + A domain belongs to a **team**, not to a Space. You add it once to the team's inventory, then assign it to a Space. One hostname serves exactly one Space; one Space can hold many hostnames. ## Connect a domain diff --git a/content/meta.ts b/content/meta.ts index bd34520..3f889ab 100644 --- a/content/meta.ts +++ b/content/meta.ts @@ -9,6 +9,7 @@ export default defineMeta({ "concepts", "publish", "serve", + "registration", "dynamic", "infrastructure", "account", diff --git a/content/registration/contacts-and-privacy.mdx b/content/registration/contacts-and-privacy.mdx new file mode 100644 index 0000000..9fc9179 --- /dev/null +++ b/content/registration/contacts-and-privacy.mdx @@ -0,0 +1,76 @@ +--- +title: Owner details and privacy +description: The contact details a registered domain needs, who owns it, and what WHOIS shows about you +sidebar: { order: 2 } +--- + +Every registered domain needs valid owner details. [ICANN](https://www.icann.org/), the organization that sets the rules for domain names, requires them. They identify who owns the domain and are used to settle ownership disputes. Spacefast hides them from the public by default, at no extra cost. + +## What you need to provide + +The first time you buy a domain, checkout asks for the **Domain owner**: + +| Field | Required | +| --- | --- | +| First and last name | Yes | +| Organization | No. Fill it in when a company owns the domain. | +| Street address, city, state or region, postal code, country | Yes. State or region is required for every country. | +| Email address | Yes | +| Phone number | Yes | + +Spacefast saves these details and fills them in next time, so you type them once. Use a real person or company: registries can suspend a domain registered to made-up details. + +:::tip[Pick an email address that doesn't depend on the domain] +Avoid an address on the domain itself, like `admin@yourgroovydomain.com` for `yourgroovydomain.com`. If the domain stops working, so does that inbox, and that's where the important mail goes. +::: + +From the terminal, save owner details from a JSON file, then list them: + +```bash +sf domains contacts add --file contact.json +sf domains contacts ls +``` + +The file takes `firstName`, `lastName`, `organization`, `address1`, `address2`, `city`, `state`, `postalCode`, `countryCode` (two letters), `email`, and `phone`. Pass the saved contact to a purchase with `--contact dcon_...`. Without it, the newest contact you saved is used. + +## Who owns the domain + +Saved owner details belong to the person who saved them, not to the whole team. That matters: + +- **Only that person can change the name, organization, or email address** on them. Anyone who can buy domains for the team can fix the street address or phone number. +- **Changes reach the registry.** Editing saved details updates every domain registered to them. To register a domain to other saved details, its owner sends `contactId` with `updateDomainRegistration`. +- **A new owner locks the domain for 60 days.** Changing the owner's name, organization, or email is a change of owner under ICANN's rules, so the registrar keeps the domain from moving to another registrar for 60 days. +- **API keys can't save owner details.** An owner is always a person, so a team API key gets `domain_contact_requires_person`. Sign in as a person, or save the details in the dashboard first. + +An agent buying a domain for you should ask you for these details and never invent them. To keep them out of the chat, save them yourself (in the dashboard's domain search or with `sf domains contacts add`) and let the agent reuse the saved contact. + +## Verify your email address + +ICANN requires registrars to confirm the owner's email address. If you get an email asking you to verify the contact details for your domain, open it and click the link. Registries can suspend a domain whose owner details stay unverified. +## Privacy protection + +Privacy protection is on by default for every domain you register through Spacefast, at no extra cost. Public WHOIS and RDAP lookups don't show your name, address, email, or phone number. Those fields come back redacted. + +You can turn privacy off on the domain's **Registration** card (or with `privacySetting` on the API). The owner details then become public in WHOIS. Turn it off only when you want them listed, for example for a business that publishes its address anyway. + +Your details still exist, and in a few cases they can be shared: + +- **To run the domain.** The registry for the extension, the registrar, and the data escrow provider that ICANN requires all hold a copy. +- **To settle a dispute.** When someone files a [UDRP](https://www.icann.org/resources/pages/help/dndr/udrp-en) or [URS](https://www.icann.org/resources/pages/urs-2014-01-09-en) complaint about the domain, ICANN requires the registrar to reveal the owner details to the dispute provider, privacy or not. +- **Through tiered access.** ICANN lets parties with a legitimate purpose, such as law enforcement, request registrant data from the registrar. The registrar reviews each request case by case. + +## Who the registrar is + +Spacefast registers domains through Automattic Inc., the same registrar behind WordPress.com. Automattic is the ICANN-accredited registrar of record you'll see in WHOIS. + +To report spam, phishing, malware, or other abuse on a domain registered through Spacefast, email the registrar's abuse contact at `domainabuse@automattic.com`. + +## Errors you might see + +| Code | What happened | What to do | +| --- | --- | --- | +| [`domain_contact_not_found`](/errors/domain_contact_not_found) | The contact ID doesn't exist, or belongs to another team. | List contacts with `sf domains contacts ls` and use one from there. | +| `domain_contact_not_owned` | The contact belongs to someone else, so you can't register a domain to it. | Save your own details, or ask that person to buy it. | +| `domain_contact_identity_locked` | Only the person who saved the contact can change its name, organization, or email address. | Ask them, or save new details. | +| `domain_contact_requires_person` | A team API key tried to save owner details. | Use a personal sign-in, or let a person fill them in at checkout. | +| [`registrant_contact_invalid`](/errors/registrant_contact_invalid) | The registrar rejected the owner details. Your payment for the domain was refunded. | Fix the details (a full street address, a valid phone with country code) and buy again. | diff --git a/content/registration/dns-and-nameservers.mdx b/content/registration/dns-and-nameservers.mdx new file mode 100644 index 0000000..71c1700 --- /dev/null +++ b/content/registration/dns-and-nameservers.mdx @@ -0,0 +1,120 @@ +--- +title: DNS and nameservers +description: Manage DNS records for a domain registered through Spacefast, set up email, and move DNS to another provider +sidebar: { order: 4 } +--- + +A domain you register through Spacefast uses Spacefast DNS from day one. Its nameservers are `ns1.spacefast.com` and `ns2.spacefast.com`, and you manage its records in the dashboard or the CLI. Agents connected over MCP can manage them too. + +## What's in a new zone + +A freshly registered domain starts with an empty zone: only the SOA and NS records every zone needs. It doesn't point anywhere yet. + +When you [add the domain to a Space](/domains), Spacefast writes the records that make it serve, including the `www` twin. You don't add those by hand. In the DNS list they're marked as managed for you. Remove the domain from the Space and those records go with it. + +Everything else (email, verification records for other services, subdomains that point somewhere else) you add yourself. + +## Add, edit, or delete records + + + + +1. Open your team's **Domains** and click the domain. +2. In the **DNS** section, click **Add record**, or click an existing record to edit or delete it. +3. Your changes are drafts until you click **Review changes**, check the diff, and click **Apply changes**. All changes in a batch apply together, or none do. + +To set up a mail provider in one go, click **Add a service** and pick it. Google Workspace, Microsoft 365, Fastmail, Proton Mail, Zoho Mail, iCloud Mail, and Resend are built in. + + + + +```bash +sf domains dns ls yourgroovydomain.com +sf domains dns add yourgroovydomain.com --type MX --name @ --value mail.example.com --priority 10 +sf domains dns add yourgroovydomain.com --type TXT --name @ --value "v=spf1 include:_spf.example.com ~all" +``` + +Use `sf domains dns update` and `sf domains dns rm` to change or remove a record, and `sf domains dns batch` to apply several changes at once. + + + + +### Supported record types + +| Type | What it's for | +| --- | --- | +| `A` | Points a name to an IPv4 address. | +| `AAAA` | Points a name to an IPv6 address. | +| `ALIAS` | Points the apex to another hostname, like a CNAME that's allowed at the root. | +| `CNAME` | Makes one hostname an alias of another. | +| `MX` | Routes email for this name to a mail server. Takes a priority. | +| `TXT` | Holds verification, SPF, DKIM, DMARC, or other text values. | +| `SRV` | Publishes a service with priority, weight, and port. | +| `CAA` | Limits which certificate authorities can issue certificates. | +| `NS` | Delegates a subdomain to other nameservers. | + +TTL goes from 60 seconds to one day, and defaults to one hour. Use a short TTL while you're setting things up and a longer one once it's stable. + +### Import and export + +Moving from another DNS provider? Export a BIND zone file there, then click **Import zone** and paste it in. Records become drafts you review before applying. Turn on **Remove records not in the file** to replace the zone instead of adding to it. Lines with unsupported record types are skipped and listed. + +**Export zone** downloads the zone as a `.zone` file or copies it. **Copy for AI agent** copies it in a form you can paste straight into a chat. + +From the terminal: + +```bash +sf domains dns export yourgroovydomain.com +``` + +## Set up email + +A domain registered through Spacefast doesn't come with a mailbox. Use any email provider and add the records it gives you: + +- **MX records** route incoming mail to the provider. +- **SPF** (a `TXT` record at `@` starting `v=spf1`) lists the servers allowed to send as your domain. +- **DKIM** (a `TXT` or `CNAME` record your provider names) signs outgoing mail. +- **DMARC** (a `TXT` record at `_dmarc`) tells receivers what to do with mail that fails the checks. Gmail and Yahoo require it for anyone sending more than 5,000 messages a day. + +Only one email provider can receive mail for a domain at a time. Remove the old MX records when you switch. + +Your website and your email are separate. The records Spacefast writes for your Space never touch MX, SPF, DKIM, or DMARC. + +## Use other nameservers + +You can delegate the whole domain to another DNS provider (Cloudflare, Route 53, your mail host's DNS) by changing its nameservers. + +First copy your records to the new provider, or the site and email stop working when the nameservers change. Export them with `sf domains dns export yourgroovydomain.com`, import the file at the new provider, and check that every record arrived, including MX, SPF, DKIM, and DMARC. Then change the nameservers: + +```bash +sf domains nameservers set yourgroovydomain.com ns1.example-dns.com,ns2.example-dns.com +``` + +Give at least two nameservers. The command asks before it moves DNS off Spacefast. Your records in Spacefast DNS are kept, so you can come back. + +Once the domain uses other nameservers: + +- **Spacefast stops answering for it.** Records you add in Spacefast DNS no longer apply. Manage everything at the new provider. +- **To serve a Space, add the records Spacefast asks for there.** See [Custom domains](/domains) for the records and verification. +- **The registration doesn't move.** You still renew the domain through Spacefast. + +To bring DNS back to Spacefast, set the nameservers to Spacefast's pair: + +```bash +sf domains nameservers set yourgroovydomain.com ns1.spacefast.com,ns2.spacefast.com +``` + +Check the current setup with `sf domains nameservers yourgroovydomain.com`. + +:::note[Changes take time to show up] +Nameserver changes can take up to 48 hours to reach every network, and record changes up to the record's TTL. During that window some visitors see the old setup and some see the new one. Clearing your device's DNS cache or trying another network helps you see the change sooner. +::: + +## Errors you might see + +| Code | What happened | What to do | +| --- | --- | --- | +| [`dns_zone_awaiting_registration`](/errors/dns_zone_awaiting_registration) | You changed DNS before the registration finished. The change is saved, and Spacefast DNS serves it once the domain is registered. | Wait for the registration to complete. | +| [`nameservers_required`](/errors/nameservers_required) | A domain registered through Spacefast leaves Spacefast DNS only by naming other nameservers. | Pass the new provider's nameservers to `sf domains nameservers set`. | +| [`registrar_nameservers_refused`](/errors/registrar_nameservers_refused) | The registry refused the nameserver change. Nothing changed. | Check the nameserver hostnames exist and resolve, then try again. | +| [`registrar_writes_disabled`](/errors/registrar_writes_disabled) | Registrar changes are briefly paused. Nothing changed. | Try again later. | diff --git a/content/registration/index.mdx b/content/registration/index.mdx new file mode 100644 index 0000000..5ca1774 --- /dev/null +++ b/content/registration/index.mdx @@ -0,0 +1,133 @@ +--- +title: Register a domain +description: Buy a domain name through Spacefast, what happens after you pay, and which extensions you can register +sidebar: { order: 1 } +--- + +You can register a domain name (for example, `yourgroovydomain.com`) through Spacefast and point it at any of your Spaces. The domain belongs to your team, sits next to any domains you connected yourself, and runs on Spacefast DNS from the moment it registers. + +Already own a domain somewhere else? You don't need to register it again. [Connect it](/domains) instead. + +## Register a new domain name + + + + +1. Open your team and select **Domains**. +2. Click **Buy domain**. +3. Type the name you want, or describe your project to get suggestions. You can search by keyword and pick different extensions like `.com`, `.blog`, `.app`, or `.dev`. +4. Pick up to ten names and continue to **Review and buy**. +5. Fill in the **Domain owner** details, or keep the saved ones. These go to the registry, so use a real person or company and an email address you can read. See [Owner details and privacy](/registration/contacts-and-privacy). +6. Check **Total today** and click **Buy 1 domain** (or **Buy 2 domains**, and so on). +7. Pay with the team's saved payment method, or add one when asked. + + + + +Find a name, then buy it: + +```bash +sf domains search "a ceramics studio in Porto" +sf domains registration purchase yourgroovydomain.com +``` + +The purchase command holds the names for 24 hours, shows the total, and prints a link. Open it to pay: nothing is charged and nothing is registered until someone with purchasing power pays there. Pass `--contact-file contact.json` to save new owner details on the way. + +To make sure the price is what you agreed to, add `--expect-total 12.00`. If the total before tax isn't exactly that, the purchase is refused and nothing is held. You still pay at the printed link. See the [CLI reference](/cli/reference) for every flag. + + + + +Ask your agent: "Is yourgroovydomain.com available?", "Suggest some names for a bakery in Dublin," or "Get me a checkout link for yourgroovydomain.com." + +Over MCP the agent opens the domain search with `show_domains`, where you pick names, fill in the owner details, and pay. Over the API the agent saves owner details you give it, calls `purchaseDomain`, and gets back a `confirmUrl` for an owner or admin to open and pay. Agents never see the card. + +An agent only pays on its own when you've explicitly given it purchasing power for the team. Without it, a person always confirms the charge. + + + + +Only team owners and admins can buy domains. An agent or API key without purchasing power can hold the names, but an owner or admin confirms the charge. + +## How pricing works + +- **Prices are in US dollars, plus tax.** Search results show the first-year price per name. The [pricing page](/pricing#domains) explains what that price covers. +- **One year at a time.** Every registration and renewal is for one year. +- **A checkout holds for 24 hours.** An unpaid purchase keeps its names and quote for a day, then expires. If the registry's price moved by the time the registration goes through, that name is refunded automatically. +- **Renewals cost the current price.** A renewal is charged at that extension's registration price on the day it renews, not what you paid the first time. +- **Registered domains are free to connect.** They don't count against your plan's custom domain limit. + +## After you register + +### Wait for the registration to finish + +Spacefast asks the registry for the name the moment your payment clears. The domains list shows "Paid. Registering your domains now." until the registry confirms. Check one from the terminal: + +```bash +sf domains registration yourgroovydomain.com +``` + +If the registry turns a name down (someone grabbed it first, the price changed, or the registry is down for maintenance), that name is **refunded automatically**, tax included. Nothing else to do. The domain's **Registration** card shows the refund. + +### Point it at a Space + +A new domain lands in your team's **Domains** list, ready for any of your Spaces. It isn't attached to one yet. Add it to a Space to serve your site there: + +```bash +sf domains add yourgroovydomain.com --space my-site --role primary +``` + +Because the domain is on Spacefast DNS, Spacefast writes the records for you. There's nothing to copy into a DNS panel. See [Custom domains](/domains) for primary addresses, redirects, and certificates. + +### Wait for it to resolve everywhere + +Your new domain should start working almost immediately, but DNS caches around the world can take up to 48 hours to catch up. This waiting period is called propagation. During that window, the domain may not load the same everywhere. + +## Which extensions you can register + +Spacefast sells more than 370 generic extensions, including `.com`, `.org`, `.net`, `.blog`, `.app`, `.dev`, `.page`, `.shop`, `.studio`, and `.xyz`. Search shows each name's live price and whether it can be bought. + +A few limits: + +- **No country-code extensions.** Two-letter extensions such as `.co`, `.me`, `.io`, `.uk`, or `.de` can't be registered through Spacefast. Register them elsewhere and [connect them](/domains). +- **No premium names.** Registries price some short or popular names as premium. Those can't be bought through Spacefast; search marks them as unavailable. +- **Apex names only.** You buy `yourgroovydomain.com`, not `shop.yourgroovydomain.com`. Subdomains are free: add them as DNS records once you own the domain. + +### .app, .dev, and .page need HTTPS + +Browsers load `.app`, `.dev`, and `.page` domains only over HTTPS. The rule is built into every major browser for these extensions. Spacefast issues a certificate for every hostname it serves, so this works out of the box. It matters if you point one of these domains at a server somewhere else: that server needs a valid certificate, or browsers refuse to load it. + +## Transfers + +Moving a domain registration to Spacefast from another registrar, or from Spacefast to another registrar, isn't available yet. To use a domain registered elsewhere, keep it where it is and [connect it](/domains). + +When transfers open, they follow ICANN's rules for every registrar: + +- **60-day lock after registration.** A domain can't move to another registrar for 60 days after it's registered or transferred, and for 60 days after its owner's name, organization, or email changes. +- **Only team owners and admins can transfer a domain out**, and an agent asks you first. +- **The authorization code goes to the owner's email address**, never to the person who asked for it. + +## Cancelling + +Before you pay, you can cancel a purchase from its checkout page with **Cancel purchase**. Nothing is charged. An unpaid purchase also expires on its own after 24 hours. + +Once a domain is registered, there is no cancel button. If you no longer want it, turn off [auto-renew](/registration/renewal-and-expiration) and let the registration run out at the end of its year. Spacefast won't let you delete a domain from your team while its registration is active, so a renewal can't slip past you. + +## Errors you might see + +| Code | What happened | What to do | +| --- | --- | --- | +| [`domain_not_purchasable`](/errors/domain_not_purchasable) | A name in the cart can't be bought: taken, premium, an unsupported extension, or its registry is in maintenance. One bad name refuses the whole cart. | Remove that name and try again. | +| [`domain_purchase_apex_required`](/errors/domain_purchase_apex_required) | You tried to buy a subdomain. | Buy the apex, then add the subdomain as a DNS record. | +| [`domain_cart_duplicate`](/errors/domain_cart_duplicate) | The same name is in the cart twice. | Remove the duplicate. | +| `purchase_total_changed` | The price moved since you looked. Nothing was charged. | Check the new total and buy again. | +| `purchase_pending` | Another unfinished purchase already holds some of these names. | Finish or cancel that one, or wait 24 hours for it to expire. | +| [`domain_unavailable`](/errors/domain_unavailable) | Someone registered the name first. Your payment for it was refunded. | Pick another name. | +| [`registrar_unavailable`](/errors/registrar_unavailable) | The registrar didn't answer. Nothing was charged. | Try again in a minute. | +| [`registrar_writes_disabled`](/errors/registrar_writes_disabled) | Registrations are briefly paused. Nothing was charged. | Try again later. | + +## Next steps + +- [Owner details and privacy](/registration/contacts-and-privacy): who the domain is registered to and what WHOIS shows. +- [Renewal and expiration](/registration/renewal-and-expiration): keep the domain, or let it go on purpose. +- [DNS and nameservers](/registration/dns-and-nameservers): add email records, or move DNS elsewhere. diff --git a/content/registration/meta.ts b/content/registration/meta.ts new file mode 100644 index 0000000..56f78b7 --- /dev/null +++ b/content/registration/meta.ts @@ -0,0 +1,8 @@ +import { defineMeta } from "blume"; + +export default defineMeta({ + title: "Domain registration", + collapsed: false, + order: 4.5, + pages: ["index", "contacts-and-privacy", "renewal-and-expiration", "dns-and-nameservers"], +}); diff --git a/content/registration/renewal-and-expiration.mdx b/content/registration/renewal-and-expiration.mdx new file mode 100644 index 0000000..0b923fb --- /dev/null +++ b/content/registration/renewal-and-expiration.mdx @@ -0,0 +1,108 @@ +--- +title: Renewal and expiration +description: How auto-renew works, renewing by hand, and what happens when a registered domain expires +sidebar: { order: 3 } +--- + +A registration lasts one year. To keep the domain, renew it before it expires. Auto-renew is on by default and does this for you. + +## Auto-renew + +As long as **Auto-renew** is on, the domain renews itself for another year before it expires. Here's the timeline: + +| When | What happens | +| --- | --- | +| 60 days before expiry | The team's owners and admins get an email and a notification: the domain renews on this date, for this price. | +| 30 days before expiry | Spacefast charges the team's saved payment method and adds a year to the registration. | +| If the charge fails | Owners and admins are told what went wrong (declined card, no card, bank verification needed), with a link to fix it. Spacefast tries again on its own, several times, until the expiry date. | +| On the expiry date | Nothing more is tried. The domain [expires](#when-a-domain-expires). | + +If you buy a domain, or turn auto-renew on, less than 37 days before it expires, the charge waits at least a week after the notice. The **Registration** card shows the exact date with "Auto-renew charges the saved payment method from…". When that week would end after the expiry date, auto-renew can't renew this year in time: [renew by hand](#renew-by-hand) instead. + +The renewal price is the extension's registration price on the day it renews, in US dollars plus tax. It may differ from what you paid the first time. + +We strongly recommend leaving auto-renew on. Once a domain expires, getting it back can be hard, and someone else may register it first. + +### Turn auto-renew off or on + + + + +Open your team's **Domains**, click the domain, and flip the **Auto-renew** switch on the **Registration** card. Only team owners and admins can change it. + + + + +`PATCH /v1/domains/{domainId}/registration` with `{"autoRenew": false}`. The registration's `autoRenewChargesFrom` gives the earliest charge date, or `null` when auto-renew can't renew this term. + + + + +Turning auto-renew off cancels any automatic renewal that hasn't been charged yet. + +## Renew by hand + +You can renew a domain yourself at any time before it's gone. The dashboard shows the button from 30 days before expiry; the CLI renews whenever you ask. + + + + +Open the domain and click **Renew for 1 year** on the **Registration** card. You go to checkout to pay. + + + + +```bash +sf domains registration renew yourgroovydomain.com +``` + +This prints a checkout link. Nothing is charged until someone pays there. + + + + +A renewal adds one year to the current expiry date, so renewing early never costs you days. After paying, the page says "Paid. Renewing now; the new expiry shows up in a minute." + +If a renewal can't go through at the registry, it's refunded automatically and the **Registration** card says so. + +## When a domain expires + +Spacefast sends no renewal charge after the expiry date. The domain's status turns to **Expired**, and the card says "Expired on [date]. Renew it soon, before someone else can register it." + +### The redemption window + +Spacefast keeps an expired domain renewable for about **30 days** after it expires. During that window: + +- **Your Space keeps serving** on the domain as long as the registry keeps it in the DNS. Some registries park or stop resolving an expired name sooner. Your site content is never deleted. +- **You can renew** with **Renew for 1 year** or `sf domains registration renew`, the same way as before it expired. + +The exact grace and redemption rules come from the registry for each extension. A name the registry has already moved into its own redemption period may not renew through Spacefast. If the renewal is refused, your payment is refunded. + +### After the window + +If the domain isn't renewed, Spacefast checks with the registrar once the window ends: + +- If the registration was renewed or restored at the registrar, Spacefast picks up the new expiry date. +- If the registry released the name, the registration is marked as deleted and Spacefast DNS stops answering for it. The domain stays in your team's list as a regular, unregistered domain. + +Once a name goes back on the market, anyone can register it, often within seconds. Back-order services wait for exactly that. Never let a domain you care about expire. + +## Check when a domain expires + +Open your team's **Domains**. Each registered domain shows "Expires [date]", and you can sort by **Expires soonest**. Badges flag **Renewal due** and **Expired**. + +From the terminal: + +```bash +sf domains registration yourgroovydomain.com +``` + +## Errors you might see + +| Code | What happened | What to do | +| --- | --- | --- | +| [`domain_registration_not_renewable`](/errors/domain_registration_not_renewable) | The registration isn't active or expired (it's still registering, failed, or was released), so there's nothing to renew. | Check the registration with `sf domains registration`. | +| `purchase_pending` | A renewal for this domain is already waiting to be paid. | Finish that one from the **Registration** card. | +| `purchase_in_progress` | The domain is paid for, and its renewal or refund is still going through. | Wait a minute and check again. | +| [`registration_expiring`](/errors/registration_expiring) | Diagnostic: the registration expires soon. | Renew it, or make sure auto-renew is on with a working payment method. | +| [`registration_expired`](/errors/registration_expired) | Diagnostic: the registration has expired. | Renew it before the redemption window ends. | diff --git a/scripts/pricing-next.mjs b/scripts/pricing-next.mjs index 890ea49..ad6d171 100644 --- a/scripts/pricing-next.mjs +++ b/scripts/pricing-next.mjs @@ -144,7 +144,7 @@ const FEATURES = [ row("Managed HTTPS", null, all(YES)), row("Custom domains", null, ["20", "100", "500", "Custom"]), row("Register and renew domains at cost", null, all(YES)), - row("Wildcard domains", null, [NO, NO, YES, YES]), + row("Wildcard domains", null, [NO, NO, SOON, SOON]), row("Global edge cache and purge", null, all(YES)), row("Redirects and header rules", null, ["500 per Space", "1,000 per Space", "1,500 per Space", "Custom"]), row("Firewall and cache rules", null, ["10 per Space", "25 per Space", "50 per Space", "Custom"]), diff --git a/styles/Spacefast/spelling-exceptions.txt b/styles/Spacefast/spelling-exceptions.txt index 44f1646..587d6f3 100644 --- a/styles/Spacefast/spelling-exceptions.txt +++ b/styles/Spacefast/spelling-exceptions.txt @@ -73,6 +73,7 @@ ETag exif extensionless failover +Fastmail Favicon fetchable Figma @@ -321,3 +322,4 @@ wordmark wp WP www +Zoho