Reference

$client->hello() -> ?HelloResponse

📝 Description

Returns basic information about the API server (useful for testing connectivity and version checks).

🔌 Usage

$client->hello();

Account Info

$client->accountInfo->checkAccountBalance() -> ?CheckAccountBalanceResponse

📝 Description

Returns the current account credit balance for the authenticated user.

🔌 Usage

$client->accountInfo->checkAccountBalance();

Accounts

$client->accounts->createAccount($request) -> ?CreateAccountResponse

📝 Description

Creates a new sub-account under your authenticated reseller account and returns API credentials for the new account. This endpoint is only available to approved reseller accounts. Contact name.com support to request access.

🔌 Usage

$client->accounts->createAccount(
    new CreateAccountRequest([
        'account' => new AccountRequest([
            'contacts' => new ContactsRequest([
                'registrant' => new RegistrantContactRequest([
                    'firstName' => 'Jane',
                    'lastName' => 'Doe',
                    'address1' => '123 Main St.',
                    'city' => 'Denver',
                    'state' => 'CO',
                    'zip' => '12345',
                    'country' => 'US',
                    'email' => 'admin@example.net',
                    'phone' => '+13035551212',
                ]),
            ]),
            'accountName' => 'reseller_subaccount',
            'password' => 'SecureP4ss!',
        ]),
        'apiTos' => true,
        'tos' => true,
    ]),
);

⚙️ Parameters

$account: AccountRequest — The account details for the new account being created.

$apiTos: bool — Must be set to true to indicate acceptance of the API Terms of Service.

$tos: bool — Must be set to true to indicate acceptance of the general Terms of Service.

Domains

$client->domains->listDomains($request) -> ?ListDomainsResponse

📝 Description

Lists all domains in your account (basic details for each domain).

🔌 Usage

$client->domains->listDomains(
    new ListDomainsRequest([]),
);

⚙️ Parameters

$perPage: ?int — Per Page is the number of records to return per request. Per Page defaults to 250.

$page: ?int — Page is which page to return.

$sort: ?string — Sort specifies which domain property to order by.

$dir: ?string — Dir indicates direction of sort. Possible values are 'asc' (default) or 'desc'.

$domainName: ?string — DomainName filters domains by exact domain name or wildcard (starts with '*').

$tld: ?string — Tld filters on specific tld.

$locked: ?bool — Locked filters on locked domains.

$createDate: ?string — CreateDate filters domains created on this date.

$createDateStart: ?string — CreateDateStart filters domains created on or after this date.

$createDateEnd: ?string — CreateDateEnd filters domains created on or before this date.

$expireDate: ?string — ExpireDate filters domains expiring on this date.

$expireDateStart: ?string — ExpireDateStart filters domains with expire date on or after this date.

$expireDateEnd: ?string — ExpireDateEnd filters domains with expire date on or before this date.

$privacyEnabled: ?bool — PrivacyEnabled indicates whether there is a privacy product associated with the domain.

$isPremium: ?bool — IsPremium indicates whether the domain is a premium domain.

$autorenewEnabled: ?bool — AutorenewEnabled indicates if the domain will attempt to renew automatically before expiration.

$orderId: ?int — OrderId specifies the order number of a domain purchase.

$includeRenewalPrice: ?bool — IncludeRenewalPrice indicates whether to include renewal pricing information in the response.

$client->domains->createDomain($request) -> ?CreateDomainResponse

📝 Description

Registers a new domain under your account. You must provide domain.domainName at minimum. This endpoint is commonly used to programmatically onboard new domains through user signup flows or checkout experiences.

If no contacts are passed in this request, the default contacts for your name.com account will be used.

Create Domain pricing

See the Domain purchase pricing guide for the full reference. Recommendation: For most integrations, scope discovery to purchaseType: registration. Other purchase types are supported but add complexity — details in the guide above.

Discovery (required before create): Call Search or Check Availability, not Get Pricing alone. Both return the same SearchResult fields (purchaseType, purchasePrice, premium, purchasable). Zone Check is designed for rapid availability checks only; it is not sufficient to complete a purchase.

Getting the price for Create Domain

Search or Check Availability → copy purchaseType, premium, note purchasePrice.
Branch on purchaseType:
- registration + premium: false — omit purchasePrice on create, set years. Optional: Get Pricing with same years to preview the total.
- registration + premium: true — Get Pricing with same years → pass purchasePrice exactly.
- aftermarket / expiring / backorder — use discovery purchasePrice (flat fee). Re-check discovery before create. Do not use Get Pricing for create price. years does not multiply price or guarantee registration length.
If purchasePrice is sent, it must match exactly or the request fails with 400 and "Purchase price does not match".

Years on acquisition types: For aftermarket_s, aftermarket_b, aftermarket_i, expiring, and backorder: omit years or pass the TLD default. Check domain.expireDate in the response; Renew to extend registration.

Best Practices For Domain Creates

In general, you should check that a domain is available prior to attempting to purchase a domain. You can use either the checkAvailability endpoint, or the Search endpoint to confirm that a domain is purchasable.

Important Note on Dropcatching and Abuse Prevention

The createDomain endpoint is designed for standard domain registrations and is not intended for automated dropcatching (i.e., mass or high-frequency attempts to register domains the moment they become available after expiration). The use of drop-catching tools or services to acquire expired domains is strictly prohibited. All domain acquisitions must go through approved channels to ensure fair and transparent access.

Contact Verification

When a new domain registration is created and a contact is submitted, name.com may need to validate the contact's email address in accordance with ICANN policy. This validation involves sending an email to the provided address, prompting the recipient to click a link to verify their email address.

🔌 Usage

$client->domains->createDomain(
    new CreateDomainRequest([
        'domain' => new DomainCreatePayload([
            'domainName' => 'example.com',
        ]),
    ]),
);

⚙️ Parameters

$domain: DomainCreatePayload

$purchasePrice: ?float — PurchasePrice is the price in USD for purchasing this domain for the minimum time period (typically 1 year). PurchasePrice is required if purchaseType is not "registration" or if it is a premium domain. If privacyEnabled is set, the regular price for Whois Privacy protection will be added automatically. If VAT tax applies, it will also be added automatically.

$purchaseType: ?string — PurchaseType indicates what kind of purchase this domain create is for. Defaults to registration if omitted. Recommended: Use registration unless you support acquisition types (aftermarket, expiring, backorder) — see the Domain purchase pricing guide. This value should be copied from the Search or Check Availability result. The value registration covers both standard and registry premium domains — use the premium flag from the discovery result to tell them apart. Aftermarket, expiring, and backorder types use flat acquisition fees from Search or Check Availability; see the Domain pricing guide.

$tldRequirements: ?array

TLDRequirements is a way to pass additional data that is required by some registries. You can check before registration by using the Domain Info API. As these requirements vary wildly between registries and TLDs, we are not attempting to document them here.

IDN Domains

This parameter is required for registering domains that contain non-ASCII characters. The value should be the specific code for the character set, such as ES for Spanish, or CYRL for Cyrillic. These abbreviations can vary between TLDs, and it is highly recommended that you use Domain Info API to ensure that the TLD allows for the specific IDN table, as well as the correct abbreviation.

$claims: ?DomainClaimsInfo

$years: ?int — Years specifies the registration term in years. Only affects price and registration length for purchaseType: registration. Defaults to each TLD's minimum if omitted (usually 1; 2 for .ai). Must be a supported registration term for the TLD when purchaseType is registration (commonly 1–10 years). For purchaseType: registration when purchasePrice is required, call Get Pricing with the same years value. For aftermarket, expiring, and backorder types: pass the TLD default — it does not multiply purchasePrice and does not guarantee a multi-year registration. Check domain.expireDate in the create response for actual expiry. To add registration time after acquisition, use Renew Domain.

$promoCode: ?string — PromoCode is an optional promotional code to apply to the domain purchase. Only one promo code can be applied per request.

$client->domains->getDomain($domainName) -> ?DomainResponsePayload

📝 Description

Retrieves detailed information for a specific domain in your account.

🔌 Usage

$client->domains->getDomain(
    'example.com',
);

⚙️ Parameters

$domainName: string — DomainName is the domain to retrieve.

$client->domains->updateDomain($domainName, $request) -> ?DomainResponsePayload

📝 Description

Allows updating of the autorenew, WhoIs Privacy and lock status of the specified domain. The request requires one, or any combination of the parameters in order to pass validation. If any of the requested updates failed, the domain will be returned to it's original state.

🔌 Usage

$client->domains->updateDomain(
    'domainName',
    new UpdateDomainRequest([
        'body' => new UpdateDomainRequestBodyAutorenewEnabled([
            'autorenewEnabled' => true,
        ]),
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain to update.

$request: UpdateDomainRequestBodyAutorenewEnabled|UpdateDomainRequestBodyPrivacyEnabled|UpdateDomainRequestBodyLocked

$client->domains->disableAutorenew($domainName, $request) -> ?Domain

📝 Description

Turns off automatic renewal for a domain. DEPRECATED This endpoint is deprecated in favor of the new UpdateDomain API. This will be removed in a future release.

🔌 Usage

$client->domains->disableAutorenew(
    'example.com',
    new DisableAutorenewRequest([
        'body' => new EmptyObject([]),
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain name to disable autorenew for.

$request: EmptyObject

$client->domains->disableWhoisPrivacy($domainName, $request) -> ?Domain

📝 Description

Disables WHOIS privacy protection on a domain. DEPRECATED This endpoint is deprecated in favor of the new UpdateDomain API. This will be removed in a future release.

🔌 Usage

$client->domains->disableWhoisPrivacy(
    'example.com',
    new DisableWhoisPrivacyRequest([
        'body' => new EmptyObject([]),
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain name to disable whoisprivacy for.

$request: EmptyObject

$client->domains->enableAutorenew($domainName, $request) -> ?Domain

📝 Description

Turns on automatic renewal for a domain. DEPRECATED This endpoint is deprecated in favor of the new UpdateDomain API. This will be removed in a future release.

🔌 Usage

$client->domains->enableAutorenew(
    'example.com',
    new EnableAutorenewRequest([
        'body' => new EmptyObject([]),
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain name to enable autorenew for.

$request: EmptyObject

$client->domains->enableWhoisPrivacy($domainName, $request) -> ?Domain

📝 Description

Enables WHOIS privacy protection on a domain. DEPRECATED This endpoint is deprecated in favor of the new UpdateDomain API. This will be removed in a future release.

🔌 Usage

$client->domains->enableWhoisPrivacy(
    'domainName',
    new EnableWhoisPrivacyRequest([
        'body' => new EmptyObject([]),
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain name to enable whoisprivacy for.

$request: EmptyObject

$client->domains->getAuthCodeForDomain($domainName) -> ?AuthCodeResponse

📝 Description

Retrieves the transfer authorization code (EPP code) for a domain.

🔌 Usage

$client->domains->getAuthCodeForDomain(
    'domainName',
);

⚙️ Parameters

$domainName: string — DomainName is the domain name to retrieve the authorization code for.

$client->domains->getPricingForDomain($domainName, $request) -> ?PricingResponse

📝 Description

Returns registration, renewal, and transfer pricing for a domain and term.

Not a discovery endpoint: Does not return purchaseType. Cannot determine whether a domain is acquired via registration vs aftermarket/expiring/backorder — call Search or Check Availability first.

Scope: purchasePrice and premium reflect standard and registry-premium registration only. They do not return aftermarket, expiring, or backorder acquisition prices. For those types, use purchasePrice from Search or Check Availability.

Registration create (purchaseType: registration): When create requires purchasePrice (registry premium), call with the same years you will send on create. Pass purchasePrice directly — it is the total for that term, not a per-year component.

Renew: Pass renewalPrice as purchasePrice on Renew Domain for premium renewals — not for computing Create Domain totals.

Transfer: Pass transferPrice as purchasePrice on Create Transfer for premium transfers. The years query parameter does not affect transferPrice.

See the Domain pricing guide for the full workflow.

🔌 Usage

$client->domains->getPricingForDomain(
    'domainName',
    new GetPricingForDomainRequest([
        'years' => 2,
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain to retrieve.

$years: ?int — Years specifies the registration term to price in years. Defaults to each TLD's minimum registration term if omitted — usually 1 year (2 for .ai). Must be a supported registration term for the TLD (commonly 1–10 years). Use the same value on Create Domain when passing purchasePrice for purchaseType: registration.

$client->domains->lockDomain($domainName, $request) -> ?Domain

📝 Description

Locks a domain to prevent it from being transferred. DEPRECATED This endpoint is deprecated in favor of the new UpdateDomain API. This will be removed in a future release.

🔌 Usage

$client->domains->lockDomain(
    'example.com',
    new LockDomainRequest([
        'body' => new EmptyObject([]),
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain name to lock.

$request: EmptyObject

$client->domains->purchasePrivacy($domainName, $request) -> ?PrivacyResponse

📝 Description

Adds or renews WHOIS privacy protection for a domain. This is used to ensure personal contact details remain hidden from public WHOIS lookups. If WHOIS privacy is already enabled, this will extend the protection. If it’s not yet active, this will both purchase and enable the service. This is a billable action unless covered by a bundled privacy plan.

🔌 Usage

$client->domains->purchasePrivacy(
    'domainName',
    new DomainsPurchasePrivacyBody([]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain to purchase Whois Privacy for.

$purchasePrice: ?float — PurchasePrice is the (prorated) amount you expect to pay.

$years: ?int — Years is the number of years you wish to purchase Whois Privacy for. Years defaults to 1 and cannot be more then the domain expiration date.

$client->domains->renewDomain($domainName, $request) -> ?RenewDomainResponse

📝 Description

Renews an existing domain for an additional registration period. Include the domain name and renewal term. Omit purchasePrice for standard (non-premium) renewals. For premium renewals, pass renewalPrice from Get Pricing with matching years as purchasePrice. Renewal pricing is separate from Create Domain registration/acquisition pricing. This is typically used to extend ownership before a domain’s expiration.

🔌 Usage

$client->domains->renewDomain(
    'domainName',
    new DomainsRenewDomainBody([]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain to renew.

$purchasePrice: ?float — PurchasePrice is the total USD renewal cost for the requested years, before VAT. VAT is applied when applicable and must not be included here. If sent, must match Get Pricing renewalPrice exactly. Omit for standard (non-premium) renewals. Required for premium renewals — use renewalPrice from Get Pricing with matching years.

$years: ?int — Years specifies the renewal term in years. Defaults to each TLD's minimum registration term if omitted — usually 1 year (2 for .ai). Must be a supported registration term for the TLD (commonly 1–10 years). For premium renewals, call Get Pricing with the same years value.

$client->domains->setContacts($domainName, $request) -> ?DomainResponsePayload

📝 Description

Updates WHOIS contact information for a domain. This includes the registrant, administrative, technical, and billing contacts. All contact objects must be complete — partial updates are not supported. You should fetch the existing contact data first (e.g., via GetDomain and modify only the values you wish to change. This call replaces all four contact sets at once.

Contact Verification

When registrant contact information is updated, validation may be triggered if the new contact information has not been previously validated. This validation is required by ICANN for all TLDs except country-code TLDs (ccTLDs). This validation involves sending an email to the provided address, prompting the recipient to click a link to verify their email address.

🔌 Usage

$client->domains->setContacts(
    'example.com',
    new DomainsSetContactsBody([]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain name to set the contacts for.

$contacts: ?ContactsRequest

$client->domains->setNameservers($domainName, $request) -> ?DomainResponsePayload

📝 Description

SetNameservers will set the nameservers for the Domain. This operation updates the DNS configuration by changing which nameservers are responsible for the domain's zone.

🔌 Usage

$client->domains->setNameservers(
    'example.com',
    new DomainsSetNameserversBody([
        'nameservers' => [
            'ns1.name.com',
            'ns2.name.com',
        ],
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain name to set the nameservers for.

$nameservers: array — Nameservers is a list of the nameservers to set. Nameservers should already be set up and hosting the zone properly as some registries will verify before allowing the change.

$client->domains->unlockDomain($domainName, $request) -> ?Domain

📝 Description

Unlocks a domain to allow it to be transferred. DEPRECATED This endpoint is deprecated in favor of the new UpdateDomain API. This will be removed in a future release.

🔌 Usage

$client->domains->unlockDomain(
    'domainName',
    new UnlockDomainRequest([
        'body' => new EmptyObject([]),
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain name to unlock.

$request: EmptyObject

$client->domains->checkAvailability($request) -> ?SearchResponse

📝 Description

Checks whether up to 50 domain names are purchasable and returns discovery pricing for each result.

Discovery endpoint: Returns SearchResult fields — purchaseType, purchasePrice, premium, purchasable. Search returns the same fields for keyword/suggestion flows. Use this endpoint to determine what to send on Create Domain.

When results show premium: true or a non-registration purchaseType, follow the Domain pricing guide before calling Create Domain. For non-registration types, re-check Check Availability immediately before create — acquisition prices can change.

🔌 Usage

$client->domains->checkAvailability(
    new AvailabilityRequest([
        'domainNames' => [
            'domainNames',
        ],
    ]),
);

⚙️ Parameters

$domainNames: array — DomainNames is the list of domains to check if they are available.

$purchaseType: ?string — Optional filter. Recommended: registration for most integrations — omit only if you support acquisition types. Non-matching domains are returned with purchasable: false (Search omits them instead). See the Domain purchase pricing guide.

$client->domains->search($request) -> ?SearchResponse

📝 Description

Searches for domain name suggestions based on a keyword or term. Important: Do not encode the : in the path. Use /core/v1/domains:search, not /core/v1/domains%3Asearch.

Discovery endpoint: Returns SearchResult fields — purchaseType, purchasePrice, premium, purchasable.

Recommendation: Set purchaseType to registration. Most resellers restrict results to domains with a purchaseType of registration to ensure predictable pricing and immediate fulfillment. Other purchase types (such as aftermarket) can introduce higher costs and non-instant transactions that may be delayed or declined by third parties. With purchaseType: registration, domains that do not match the filter are omitted from results (unlike Check Availability, which returns them with purchasable: false).

When results show premium: true or a non-registration purchaseType, follow the Domain pricing guide before calling Create Domain. For all types, re-check with Check Availability immediately before create — prices and availability can change.

🔌 Usage

$client->domains->search(
    new SearchRequest([
        'keyword' => 'mydomain',
    ]),
);

⚙️ Parameters

$keyword: string — Keyword is the search term to search for. It can be just a word, or a whole domain name.

$timeout: ?int

Timeout is a value in milliseconds on how long to perform the search for. Valid timeouts are between 500ms to 12,000ms. If not specified, timeout defaults to 12,000ms. Since some additional processing is performed on the results, a response may take longer then the timeout.

$tldFilter: ?array — TLDFilter will limit results to only contain the specified TLDs. There is a maximum of 50 TLDs that can be used in this filter

$purchaseType: ?string — Optional. Limits results to the given purchaseType. Recommended: registration for most integrations — omit only if you choose to support acquisition types. See the Domain purchase pricing guide.

$client->domains->zoneCheck($request) -> ?ZoneCheckResponse

📝 Description

Zone Check offers a rapid, preliminary check for domain availability by leveraging cached zone file data. Ideal for large-batch queries, it provides a high confidence indication of a domain's availability significantly faster than live registry checks. For definitive, real-time availability and pricing, you can follow up with the standard Check Availability call. The API normalizes and validates each submitted domain string. Domains that fail validation, use an unsupported TLD for this service, or are otherwise not eligible for zone check are removed from the request before the zone file lookup runs. The response includes only a numeric count of removed domains (removed); individual removed strings are not returned. A future API version may extend the contract to include details about removed domains.

For the best results and to avoid 400 Bad Request errors after cleaning, ensure each domain string meets the criteria described for domainNames in the request body schema.

If no valid domains remain after this process, the API returns a 400 Bad Request response. Note: The cached zone files used for this check are refreshed twice daily based on the latest available data from the registries.

🔌 Usage

$client->domains->zoneCheck(
    new ZoneCheckRequest([
        'domainNames' => [
            'example.com',
            'example.net',
            'example.org',
        ],
    ]),
);

⚙️ Parameters

$domainNames: array

Array of domain names to check. Each entry is normalized and validated before zone check runs. Entries that are not valid domain strings, that use unsupported TLDs for this service, or that fail other pre-validation rules are omitted from the check; the response removed field reports how many were omitted (not which values).

Valid domain string (after normalization) — for reliable results and to avoid errors once all entries are removed:

Allowed characters: ASCII letters (a–z), digits (0–9), and hyphens (-).
Hyphen rules: A domain (the part between dots) must not start or end with a hyphen (for example, -test.com and test-.com are invalid).
Domain length: Each domain must be between 1 and 63 characters.
Internationalized domains (IDNs): Non-ASCII characters (for example ö or ñ) should be submitted as Punycode (xn--...) for consistent registry resolution.

DNSSECs

$client->dnsseCs->listDnsseCs($domainName) -> ?ListDnsseCsResponse

📝 Description

Lists all DNSSEC (DS) records configured for a domain.

🔌 Usage

$client->dnsseCs->listDnsseCs(
    'domainName',
);

⚙️ Parameters

$domainName: string — DomainName is the domain name to list keys for.

$client->dnsseCs->createDnssec($domainName, $request) -> ?Dnssec

📝 Description

Adds (registers) a new DNSSEC DS record for a domain.

🔌 Usage

$client->dnsseCs->createDnssec(
    'domainName',
    new CreateDnssecBody([
        'algorithm' => 1,
        'digest' => 'digest',
        'digestType' => 1,
        'keyTag' => 1,
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain name to create keys for.

$algorithm: int

$digest: string — Digest is a digest of the DNSKEY RR that is registered with the registry.

$digestType: int

$keyTag: int

$client->dnsseCs->getDnssec($domainName, $digest) -> ?Dnssec

📝 Description

Retrieves details of a specific DNSSEC record for a domain.

🔌 Usage

$client->dnsseCs->getDnssec(
    'domainName',
    'digest',
);

⚙️ Parameters

$domainName: string — DomainName is the domain name.

$digest: string — Digest is the digest for the DNSKEY RR to retrieve.

$client->dnsseCs->deleteDnssec($domainName, $digest)

📝 Description

Deletes a DNSSEC record from a domain.

🔌 Usage

$client->dnsseCs->deleteDnssec(
    'domainName',
    'digest',
);

⚙️ Parameters

$domainName: string — DomainName is the domain name the key is registered for.

$digest: string — Digest is the digest for the DNSKEY RR to remove from the registry.

Email Forwardings

$client->emailForwardings->listEmailForwardings($domainName, $request) -> ?ListEmailForwardingsResponse

📝 Description

Returns a paginated list of all email forwarding rules for a domain.

🔌 Usage

$client->emailForwardings->listEmailForwardings(
    'domainName',
    new ListEmailForwardingsRequest([
        'perPage' => 100,
        'page' => 1,
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain to list email forwarded boxes for.

$perPage: ?int — (optional) Per Page is the number of records to return per request. Per Page defaults to 500 if not set.

$page: ?int — (optional) Page is which page to return. Default to page 1 if not set.

$client->emailForwardings->createEmailForwarding($domainName, $request) -> ?EmailForwarding

📝 Description

Creates a new email forwarding rule for a domain, such as redirecting info@example.com to an external inbox. If this is the first email forwarding rule created for the domain, the API may also update your MX records automatically to enable mail routing. The alias must not conflict with existing email services or MX records. To modify a forwarding rule later, use UpdateEmailForwarding.

🔌 Usage

$client->emailForwardings->createEmailForwarding(
    'example.com',
    new CreateEmailForwardingRequest([
        'emailBox' => 'admin',
        'emailTo' => 'webmaster@example.com',
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain part of the email address to forward.

$emailBox: string — EmailBox is the user portion of the email address to forward. If your email is "admin@example.com", it would just be "admin"

$emailTo: string — EmailTo is the entire email address to forward email to.

$client->emailForwardings->getEmailForwarding($domainName, $emailBox) -> ?EmailForwarding

📝 Description

Retrieves the details of a specific email forwarding entry.

🔌 Usage

$client->emailForwardings->getEmailForwarding(
    'domainName',
    'emailBox',
);

⚙️ Parameters

$domainName: string — DomainName is the domain to list email forwarded box for.

$emailBox: string — EmailBox is which email box to retrieve.

$client->emailForwardings->updateEmailForwarding($domainName, $emailBox, $request) -> ?EmailForwarding

📝 Description

Updates the destination email address for an existing forwarding rule.

🔌 Usage

$client->emailForwardings->updateEmailForwarding(
    'domainName',
    'emailBox',
    new EmailForwardingsUpdateEmailForwardingBody([]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain part of the email address to forward.

$emailBox: string — EmailBox is the user portion of the email address to forward.

$emailTo: ?string — EmailTo is the entire email address to forward email to.

$client->emailForwardings->deleteEmailForwarding($domainName, $emailBox)

📝 Description

Deletes an email forwarding rule from a domain.

🔌 Usage

$client->emailForwardings->deleteEmailForwarding(
    'domainName',
    'emailBox',
);

⚙️ Parameters

$domainName: string — DomainName is the domain to delete the email forwarded box from.

$emailBox: string — EmailBox is which email box to delete.

DNS

$client->dns->listRecords($domainName, $request) -> ?ListRecordsResponse

📝 Description

Lists all DNS records for a specified domain.

🔌 Usage

$client->dns->listRecords(
    'domainName',
    new ListRecordsRequest([]),
);

⚙️ Parameters

$domainName: string — DomainName is the zone to list the records for.

$perPage: ?int — Per Page is the number of records to return per request. Per Page defaults to 500.

$page: ?int — Page is which page to return.

$client->dns->createRecord($domainName, $request) -> ?Record

📝 Description

Adds a new DNS record to the specified domain zone. Provide the record type (e.g. A, MX, CNAME), host, value, and TTL. This is used for configuring domain-based services such as email, website hosting, or third-party verifications.

🔌 Usage

$client->dns->createRecord(
    'domainName',
    new DnsCreateRecordBody([
        'answer' => 'answer',
        'host' => 'host',
        'type' => DnsCreateRecordBodyType::A->value,
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the zone that the record belongs to.

$answer: string

Answer is either the IP address for A or AAAA records; the target for ANAME, CNAME, MX, or NS records; the text for TXT records. For SRV records, answer has the following format: "{weight} {port} {target}" e.g. "1 5061 sip.example.org".

$fqdn: ?string — FQDN is the Fully Qualified Domain Name. It is the combination of the host and the domain name. It always ends in a ".". FQDN is ignored in CreateRecord, specify via the Host field instead.

$host: string

Host is the hostname relative to the zone: e.g. for a record for blog.example.org, domain would be "example.org" and host would be "blog". An apex record would be specified by either an empty host "" or "@". A SRV record would be specified by "{service}.{protocol}.{host}": e.g. "_sip._tcp.phone" for _sip._tcp.phone.example.org.

$id: ?int — Unique record id. Value is ignored on Create, and must match the URI on Update.

$priority: ?int — Priority is only required for MX and SRV records, it is ignored for all others.

$ttl: ?int — TTL is the time this record can be cached for in seconds. name.com allows a minimum TTL of 300, or 5 minutes.

$type: string — Type is one of the following: A, AAAA, ANAME, CNAME, MX, NS, SRV, or TXT.

$client->dns->getRecord($domainName, $id) -> ?Record

📝 Description

Retrieves details of a specific DNS record.

🔌 Usage

$client->dns->getRecord(
    'domainName',
    1,
);

⚙️ Parameters

$domainName: string — DomainName is the zone the record exists in.

$id: int — ID is the server-assigned unique identifier for this record.

$client->dns->updateRecord($domainName, $id, $request) -> ?Record

📝 Description

Replaces an existing DNS record with new data. This is a full overwrite — all required fields (host, type, answer, ttl) must be included in the request body. If you omit a field, the existing value will not be preserved and the request may fail. Use GetRecord beforehand to retrieve the current values if you intend to modify just one field. The record ID must belong to a domain you manage.

🔌 Usage

$client->dns->updateRecord(
    'domainName',
    1,
    new DnsUpdateRecordBody([
        'answer' => 'answer',
        'type' => DnsUpdateRecordBodyType::A->value,
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the zone that the record belongs to.

$id: int — Unique record id. Value is ignored on Create, and must match the URI on Update.

$answer: string

$host: ?string

$priority: ?int — Priority is only required for MX and SRV records, it is ignored for all others.

$ttl: ?int — TTL is the time this record can be cached for in seconds. name.com allows a minimum TTL of 300, or 5 minutes.

$type: string — Type is one of the following: A, AAAA, ANAME, CNAME, MX, NS, SRV, or TXT.

$client->dns->deleteRecord($domainName, $id)

📝 Description

Removes a DNS record by ID. Often used during cleanup operations or when replacing outdated DNS settings with updated records.

🔌 Usage

$client->dns->deleteRecord(
    'domainName',
    1,
);

⚙️ Parameters

$domainName: string — DomainName is the zone that the record to be deleted exists in.

$id: int — ID is the server-assigned unique identifier for the Record to be deleted. If the Record with that ID does not exist in the specified Domain, an error is returned.

URL Forwardings

$client->urlForwardings->listUrlForwardings($domainName, $request) -> ?ListUrlForwardingsResponse

📝 Description

Returns all URL forwarding settings configured for a domain. Deprecated. Use List URL Forwardings by domain instead, which returns entries with an id for use with by-ID endpoints.

🔌 Usage

$client->urlForwardings->listUrlForwardings(
    'example.com',
    new ListUrlForwardingsRequest([
        'perPage' => 100,
        'page' => 1,
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain to list URL forwarding entries for.

$perPage: ?int — Per Page is the number of records to return per request. Per Page defaults to 500.

$page: ?int — Page is which page to return. Starts at 1 for first page.

$client->urlForwardings->createUrlForwarding($domainName, $request) -> ?UrlForwardingResponse

📝 Description

Sets up a new URL forwarding (redirect) for a domain or subdomain. If this is the first URL forwarding entry, it may modify the A records for the domain accordingly. Note that changes may take up to 24 hours to fully propagate.

🔌 Usage

$client->urlForwardings->createUrlForwarding(
    'example.com',
    new CreateUrlForwardingRequest([
        'body' => new UrlForwardingInput([
            'forwardsTo' => 'https://destination-site.com',
            'host' => 'www',
            'type' => UrlForwardingInputType::Masked->value,
        ]),
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain part of the hostname to forward.

$request: UrlForwardingInput

$client->urlForwardings->getUrlForwarding($domainName, $host) -> ?UrlForwardingResponse

📝 Description

Retrieves the details of a specific URL forwarding configuration. Deprecated. Use Get URL Forwarding by ID instead.

🔌 Usage

$client->urlForwardings->getUrlForwarding(
    'example.com',
    'www.example.org',
);

⚙️ Parameters

$domainName: string — DomainName is the domain to get the URL forwarding entry for.

$host: string — The full hostname, including subdomain.

$client->urlForwardings->updateUrlForwarding($domainName, $host, $request) -> ?UrlForwardingResponse

📝 Description

Modifies an existing URL forwarding rule. Changes may take up to 24 hours to fully propagate. Deprecated. Use Update URL Forwarding by ID instead.

🔌 Usage

$client->urlForwardings->updateUrlForwarding(
    'example.com',
    'www.example.org',
    new UpdateUrlForwardingRequest([
        'body' => new UrlForwardingInput([
            'forwardsTo' => 'https://destination-site.com',
            'host' => 'www',
            'type' => UrlForwardingInputType::Masked->value,
        ]),
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain part of the hostname to forward.

$host: string — The full hostname, including subdomain.

$request: UrlForwardingInput

$client->urlForwardings->deleteUrlForwarding($domainName, $host)

📝 Description

Removes a URL forwarding configuration from the domain. This operation cannot be undone. Deprecated. Use Delete URL Forwarding by ID instead.

🔌 Usage

$client->urlForwardings->deleteUrlForwarding(
    'example.com',
    'www.example.org',
);

⚙️ Parameters

$domainName: string — DomainName is the domain to delete the URL forwarding entry from.

$host: string — The full hostname, including subdomain.

$client->urlForwardings->listUrlForwardingsByDomain($domainName, $request) -> ?ListUrlForwardingsResponse

📝 Description

Returns all URL forwarding settings configured for a domain. Each entry includes an id that can be used with the URL Forwarding by-ID endpoints to get, update, or delete records.

🔌 Usage

$client->urlForwardings->listUrlForwardingsByDomain(
    'example.com',
    new ListUrlForwardingsByDomainRequest([
        'perPage' => 100,
        'page' => 1,
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain to list URL forwarding entries for. The domain must be owned by the authenticated account.

$perPage: ?int — Per Page is the number of records to return per request. Per Page defaults to 500.

$page: ?int — Page is which page to return. Starts at 1 for first page.

$client->urlForwardings->getUrlForwardingById($domainName, $id) -> ?UrlForwardingResponse

📝 Description

Retrieves the details of a specific URL forwarding configuration by ID. The domain must be owned by the authenticated account.

🔌 Usage

$client->urlForwardings->getUrlForwardingById(
    'example.com',
    12345,
);

⚙️ Parameters

$domainName: string — DomainName is the domain that owns the URL forwarding entry. Must be owned by the authenticated account.

$id: int — ID is the server-assigned unique identifier for the URL forwarding record (returned in list responses).

$client->urlForwardings->deleteUrlForwardingById($domainName, $id)

📝 Description

Removes a URL forwarding configuration by ID. The domain must be owned by the authenticated account. This operation cannot be undone.

🔌 Usage

$client->urlForwardings->deleteUrlForwardingById(
    'example.com',
    12345,
);

⚙️ Parameters

$domainName: string — DomainName is the domain that owns the URL forwarding entry. Must be owned by the authenticated account.

$id: int — ID is the server-assigned unique identifier for the URL forwarding record (returned in list responses).

$client->urlForwardings->updateUrlForwardingById($domainName, $id, $request) -> ?UrlForwardingResponse

📝 Description

Modifies an existing URL forwarding rule by ID. The domain must be owned by the authenticated account. Changes may take up to 24 hours to fully propagate.

🔌 Usage

$client->urlForwardings->updateUrlForwardingById(
    'example.com',
    12345,
    new UpdateUrlForwardingByIdRequest([
        'body' => new UrlForwardingInput([
            'forwardsTo' => 'https://destination-site.com',
            'host' => 'www',
            'type' => UrlForwardingInputType::Masked->value,
        ]),
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain that owns the URL forwarding entry. Must be owned by the authenticated account.

$id: int — ID is the server-assigned unique identifier for the URL forwarding record (returned in list responses).

$request: UrlForwardingInput

Vanity Nameservers

$client->vanityNameservers->listVanityNameservers($domainName, $request) -> ?ListVanityNameserversResponse

📝 Description

Lists all vanity nameserver hostnames configured for a domain.

🔌 Usage

$client->vanityNameservers->listVanityNameservers(
    'example.com',
    new ListVanityNameserversRequest([
        'perPage' => 50,
        'page' => 2,
    ]),
);

⚙️ Parameters

$domainName: string — The domain name to list vanity nameservers for.

$perPage: ?int — The number of records to return per page. Defaults to 500.

$page: ?int — The page number to return.

$client->vanityNameservers->createVanityNameserver($domainName, $request) -> ?VanityNameserverResponse

📝 Description

🔌 Usage

$client->vanityNameservers->createVanityNameserver(
    'example.com',
    new CreateVanityNameserverBody([
        'hostname' => 'ns1',
        'ips' => [
            '192.168.1.10',
            '2001:0db8:85a3:0000:0000:8a2e:0370:7334',
        ],
    ]),
);

⚙️ Parameters

$domainName: string — The domain name to create a vanity nameserver for.

$hostname: string — The subdomain portion of the nameserver hostname. The domain portion will be taken from the URL path. For example, to create 'ns1.example.com', specify 'ns1' when calling the endpoint for the domain 'example.com'.

$ips: array — IPs is a list of IP addresses that are used for glue records for this nameserver. These should be valid IPv4 or IPv6 addresses.

$client->vanityNameservers->getVanityNameserver($domainName, $hostname) -> ?VanityNameserverResponse

📝 Description

Retrieves details for a of a specific vanity nameserver (including its IP addresses).

🔌 Usage

$client->vanityNameservers->getVanityNameserver(
    'example.com',
    'ns1.example.com',
);

⚙️ Parameters

$domainName: string — The domain name associated with the vanity nameserver.

$hostname: string — The hostname of the vanity nameserver to retrieve.

$client->vanityNameservers->updateVanityNameserver($domainName, $hostname, $request) -> ?VanityNameserverResponse

📝 Description

Updates the glue record IP addresses for a vanity nameserver.

🔌 Usage

$client->vanityNameservers->updateVanityNameserver(
    'example.com',
    'ns1.example.com',
    new UpdateVanityNameserverBody([]),
);

⚙️ Parameters

$domainName: string — The domain name associated with the vanity nameserver.

$hostname: string — The hostname of the vanity nameserver to update.

$ips: ?array — IPs is the updated list of IP addresses to be used for glue records for this vanity nameserver. Providing an empty array will remove all existing IPs.

$client->vanityNameservers->deleteVanityNameserver($domainName, $hostname)

📝 Description

Deletes a vanity nameserver from the domain’s registry settings. This operation might fail if the registry detects the nameserver is still in use.

🔌 Usage

$client->vanityNameservers->deleteVanityNameserver(
    'example.com',
    'ns1.example.com',
);

⚙️ Parameters

$domainName: string — The domain name associated with the vanity nameserver.

$hostname: string — The hostname of the vanity nameserver to delete.

Webhook Notifications

$client->webhookNotifications->getSubscribedNotifications() -> ?ListSubscribedWebhooksResponse

📝 Description

Retrieves all active webhook subscriptions on the account.

🔌 Usage

$client->webhookNotifications->getSubscribedNotifications();

$client->webhookNotifications->subscribeToNotification($request) -> ?SubscribeToNotificationResponse

📝 Description

Creates a webhook subscription to receive real-time notifications about specific domain or account events (e.g. transfer completions, renewals). Pass the callback URL and event types. This allows external systems to stay in sync with name.com changes. Supported webhook event names:

account.credit.balance_change – account credit balance changes (increases or decreases).
account.domain.removal – domain removed from the subscribing account.
domain.lock.status_change – domain lock added or removed.
domain.transfer.status_change – domain transfer IN to name.com; status updates while name.com is the gaining registrar.
domain.transfer_out.status_change – domain transfer OUT from name.com; initiated, completed (domain removed), or canceled (no longer pending at the registry).
domain.transfer.internal_in - name.com domain transfers in to the subscribing account via internal transfer.
domain.transfer.internal_out - name.com domain transfers out of the subscribing account via internal transfer.
contact.verification.status_change - contact verification status changes (verified or unverified).
domain.registry.rejection – domain create failed after asynchronous registry processing (uncommon; most creates succeed at request time).
domain.expiration – domain has expired and entered the post-expiry grace period. This is informational only.

🔌 Usage

$client->webhookNotifications->subscribeToNotification(
    new SubscribeToNotification([
        'eventName' => AvailableWebhooks::AccountCreditBalanceChange->value,
        'url' => 'https://example.com',
        'active' => true,
    ]),
);

⚙️ Parameters

$eventName: string

$url: string — The URL we will send the notification data to

$active: bool — If the webhook should be active. This allows a webhook to be deactivated in our system. It may be useful to deactivate a webhook if the server that receives the POST request is undergoing scheduled maintenance, for example.

$client->webhookNotifications->modifySubscription($id, $request) -> ?ModifySubscriptionResponse

📝 Description

Updates an existing webhook’s configuration. This may include changing the callback URL or updating whether the webhook is currently active.

🔌 Usage

$client->webhookNotifications->modifySubscription(
    1,
    new ModifySubscriptionRequest([
        'body' => new ModifySubscriptionRequestBodyUrl([
            'url' => 'url',
        ]),
    ]),
);

⚙️ Parameters

$id: int — ID of the subscription to update.

$request: ModifySubscriptionRequestBodyUrl|ModifySubscriptionRequestBodyActive

$client->webhookNotifications->deleteSubscription($id)

📝 Description

Removes a webhook subscription from the account.

🔌 Usage

$client->webhookNotifications->deleteSubscription(
    1,
);

⚙️ Parameters

$id: int — ID of the subscription to delete.

Orders

$client->orders->listOrders($request) -> ?ListOrdersResponse

📝 Description

Retrieves a list of all orders placed in the account.

🔌 Usage

$client->orders->listOrders(
    new ListOrdersRequest([]),
);

⚙️ Parameters

$perPage: ?int — Per Page is the number of records to return per request. Per Page defaults to 500.

$page: ?int — Page is which page to return.

$dir: ?string — Dir indicates direction of list order. Possible values are 'asc' (default) or 'desc'.

$domainName: ?string — DomainName filters orders by domain name. Supports exact match or wildcard (starts with '*').

$tld: ?string — Tld filters orders by tld.

$createDateStart: ?string — CreateDateStart filters orders created on or after this date.

$createDateEnd: ?string — CreateDateEnd filters orders created on or before this date.

$type: ?string — Type filters orders by order item type (e.g., 'registration', 'renewal', 'transfer', 'whois_privacy').

$orderStatus: ?string — OrderStatus filters orders by status.

$client->orders->getOrder($orderId) -> ?Order

📝 Description

Fetches full details about a specific order using its ID. This includes domains, prices, and timestamps. Useful for confirming transactions, receipts, or generating invoices.

🔌 Usage

$client->orders->getOrder(
    1,
);

⚙️ Parameters

$orderId: int — OrderId is the unique identifier of the requested order.

Refunds

$client->refunds->processRefund($request) -> ?RefundResponse

📝 Description

Deletes eligible domains and security products during the Add Grace Period (AGP) and automatically issues refunds for the associated order items.

Eligibility Requirements

Product Types: Only registration and whois_privacy product types are eligible for refunds.
AGP Timing: Items must be within the Add Grace Period (typically 5 days from registration, varies by TLD).
Order Ownership: All orderItemIds must belong to the specified orderId.

Refund Processing

Refunds are processed in the following order:

Domain deletion is attempted for each eligible order item
Upon successful deletion, the refund is issued
Refunds are sent to the original payment method on file
If the original payment method is unavailable, the refund is credited to the account balance

Idempotency

This endpoint supports idempotent requests via the X-Idempotency-Key header. If you retry a request with the same idempotency key, you will receive the same response as the original request. This is useful for safely retrying requests without risk of processing duplicate refunds.

🔌 Usage

$client->refunds->processRefund(
    new RefundRequest([
        'orderId' => 123456,
        'orderItemIds' => [
            987654,
        ],
    ]),
);

⚙️ Parameters

$orderId: int — The unique identifier of the order containing the item(s) to be refunded. Use the List Orders endpoint to retrieve order IDs.

$orderItemIds: array — An array of order item IDs to be refunded. All items must belong to the specified order. Use the List Orders endpoint to retrieve order item IDs.

Transfers

$client->transfers->listTransfers($request) -> ?ListTransfersResponse

📝 Description

Returns all domain transfer requests for the account, including in-progress and recent transfers.

🔌 Usage

$client->transfers->listTransfers(
    new ListTransfersRequest([]),
);

⚙️ Parameters

$perPage: ?int — Per Page is the number of records to return per request. Per Page defaults to 500.

$page: ?int — Page is which page to return.

$client->transfers->createTransfer($request) -> ?CreateTransferResponse

📝 Description

Initiates a domain transfer into your name.com account from another registrar. You must provide the domain name and its valid transfer authorization code (EPP code). The domain must not be locked or under any transfer restrictions (e.g. clientTransferProhibited). If successful, the transfer is submitted and tracked through the ICANN transfer process. Once a transfer has been created, you can track its progress via the GetTransfer endpoint. Transfer pricing: Omit purchasePrice for standard (non-premium) transfers. For premium transfers, pass transferPrice from Get Pricing For Domain as purchasePrice. If sent, it must match Get Pricing transferPrice exactly or the request will fail. Premium transfers without purchasePrice will fail. See the Domain pricing guide for how Get Pricing transferPrice relates to the years query parameter.

🔌 Usage

$client->transfers->createTransfer(
    new CreateTransferRequest([
        'authCode' => 'ABC123',
        'domainName' => 'example.com',
    ]),
);

⚙️ Parameters

$authCode: string — AuthCode is the authorization code for the transfer. Not all TLDs require authorization codes, but most do.

$domainName: string — DomainName is the domain you want to transfer to name.com.

$privacyEnabled: ?bool — PrivacyEnabled is a flag on whether to purchase Whois Privacy with the transfer. If this flag is omitted from the request, the system will check the account's Whois Privacy auto-add settings. If auto-add is enabled in your account settings, Whois Privacy will be added by default, provided the TLD supports it.

$purchasePrice: ?float — PurchasePrice is the USD inbound transfer fee, before VAT. VAT is applied when applicable and must not be included here. If sent, must match Get Pricing transferPrice exactly or the request will fail.. Omit for standard (non-premium) transfers. Required for premium transfers — use transferPrice from Get Pricing.

$client->transfers->getTransfer($domainName) -> ?Transfer

📝 Description

Retrieves details of a specific domain transfer request.

🔌 Usage

$client->transfers->getTransfer(
    'domainName',
);

⚙️ Parameters

$domainName: string — DomainName is the domain you want to get the transfer information for.

$client->transfers->cancelTransfer($domainName, $request) -> ?Transfer

📝 Description

Cancels a pending transfer request. This can be used if the transfer was initiated in error or if the authorization code provided was incorrect. The price of the transfer will refund the amount to account credit.

Cancelable statuses:

pending
submitting_transfer
pending_new_auth_code
pending_unlock
pending_registry_unlock
rejected

Non-cancelable statuses:

pending_transfer
pending_insert
completed
failed
canceled
canceled_pending_refund

🔌 Usage

$client->transfers->cancelTransfer(
    'domainName',
    new CancelTransferRequest([
        'body' => new EmptyObject([]),
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain to cancel the transfer for.

$request: EmptyObject

$client->transfers->cancelOutboundTransfer($domainName, $request) -> ?CancelTransferOutResponse

📝 Description

Cancels an outbound transfer for the given domain. Use this when the domain is being transferred out of name.com (losing registrar) to another (gaining) registrar and the registrant or reseller wants to cancel that transfer. On success, subscribers receive domain.transfer_out.status_change with status canceled. The endpoint validates that the domain exists and belongs to the authenticated account. Only domains in a pending transfer (out) state can be canceled.

🔌 Usage

$client->transfers->cancelOutboundTransfer(
    'example.com',
    new CancelOutboundTransferRequest([
        'body' => new EmptyObject([]),
    ]),
);

⚙️ Parameters

$domainName: string — DomainName is the domain whose transfer out should be canceled.

$request: EmptyObject

$client->transfers->createInternalTransferIn($request) -> ?DomainResponsePayload

📝 Description

Pulls a domain from another name.com account into your reseller (gaining) account using a valid authorization code. This is an internal name.com-to-name.com move; it is separate from Create Transfer, which brings domains in from external registrars. Check if a TLD is eligible for internal transfer in by calling Tld Requirements for the TLD and checking property supportsInternalTransfer. This API is only available to approved reseller accounts. Contact name.com support to request access.

Losing account (dashboard only)

The party that holds the domain today must use the name.com dashboard on the losing account to unlock the domain (remove registrar transfer lock) and to copy the authorization code to provide to your integration. This endpoint does not unlock the domain or retrieve the auth code for the losing account.

Gaining account (this API)

Call this endpoint with domainName, authCode, and optional contacts using the gaining reseller's API credentials.

Contacts and post-transfer lock

If contacts is omitted, the gaining account's default contacts are applied. If contacts is provided, any roles included in the request are applied and omitted roles use the gaining account's default contacts (same pattern as Create Domain and Set Contacts). The 60-day contact-change transfer lock is enforced based on the gaining account's settings, consistent with Set Contacts.

Access

Restricted to approved enterprise resellers; other callers receive 403 Forbidden.

🔌 Usage

$client->transfers->createInternalTransferIn(
    new CreateInternalTransferInRequest([
        'domainName' => 'example.com',
        'authCode' => 'ABC123',
    ]),
);

⚙️ Parameters

$domainName: string — Fully qualified domain name to transfer in. The domain must be registered in another name.com account (the losing account).

$authCode: string — Transfer authorization code (EPP/auth code) for the domain. The losing account holder must obtain this code from the name.com dashboard; it is not exposed by this API for the losing account.

$contacts: ?ContactsRequest — WHOIS contacts to apply after the transfer. If omitted, the gaining account's default contacts are applied. If provided, include any roles to override; omitted roles use the gaining account's default contacts. Each supplied role must include complete contact fields. A registrar contact-change transfer lock may apply according to the gaining account's settings, consistent with the Set Contacts endpoint.

$client->transfers->getTransferEligibility($domainName) -> ?TransferEligibilityResponse

📝 Description

Returns whether a domain is currently registered at name.com and whether the TLD supports internal transfer between name.com accounts. Use this to decide whether to send your user through the Create Transfer external transfer flow or the Create Internal Transfer In flow before initiating a transfer-in.

Response semantics

atName is true if the domain is currently registered at name.com in any account. This information is also publicly available via RDAP.

supportsInternalTransfer mirrors the TLD-level value returned by Tld Requirements. It indicates whether the TLD is eligible for internal transfer between name.com accounts. It does not reflect per-account allowlist eligibility — if your account is not allowlisted for internal transfer in, calling Create Internal Transfer In will return 403 Forbidden.

Privacy

This endpoint never reveals which account a domain is in. To check whether a domain is in your own account, use Get Domain instead.

🔌 Usage

$client->transfers->getTransferEligibility(
    'domainName',
);

⚙️ Parameters

$domainName: string — The domain to check transfer eligibility for. Punycode is normalized server-side, so either ASCII or UTF-8 is accepted.

Domain Info

$client->domainInfo->getRequirement($tld) -> ?GetRequirementResponse

📝 Description

Returns the registration requirements some general information for a specific TLD. The response contains a detailed description of eligibility criteria and a fields object with all required and optional fields, including validation rules, conditional logic, and nested field structures. Provide the TLD as a path parameter to retrieve its complete registration requirements. Useful when you only need details for one TLD (e.g., when a user selects .fr from a dropdown).

🔌 Usage

$client->domainInfo->getRequirement(
    'fr',
);

⚙️ Parameters

$tld: string — TLD indicates which domain requirements to retrieve (without the dot prefix, e.g., 'fr' for .fr domains). For punycode TLDs, use the ASCII version instead of the UTF-8. So for the онлайн TLD, you would submit xn--80asehdb.

$client->domainInfo->checkDomainClaims($domain, $request) -> ?DomainClaimsCheckResponse

📝 Description

Performs the actual claims check for a specific domain. This endpoint checks if a specific domain has trademark claims against it, returning detailed information about any matching trademarks and their holders. Use this to verify if a domain can be registered without trademark conflicts. Please see the claims flow for information on how to use this endpoint in your domain purchase flow.

🔌 Usage

$client->domainInfo->checkDomainClaims(
    'tiktok.page',
    new DomainClaimsCheckRequest([]),
);

⚙️ Parameters

$domain: string — The domain name to check for trademark claims (e.g., 'tiktok.page', 'example.com'). Include the full domain name including the TLD.

$purchaseType: ?string — The type of purchase/registration for which to check claims. Defaults to 'registration'. Other values like 'landrush_eap', 'landrush_auction_a', 'landrush_reserve_a' may be used during new gTLD launches.

$client->domainInfo->getTldRequirementsV2($tld) -> ?RequirementsJsonSchema

📝 Description

Returns the registration requirements as a JSON Schema (Draft 7) document. This endpoint is designed for form generation and validation libraries that consume JSON Schema directly.

🔌 Usage

$client->domainInfo->getTldRequirementsV2(
    'fr',
);

⚙️ Parameters

TLD Pricing

$client->tldPricing->tldPriceList($request) -> ?TldPriceListResponse

📝 Description

This endpoint returns an alphabetical list of all TLDs supported by name.com, including pricing for each supported order type. All prices are in US Dollars (USD) and apply to non-premium domains. name.com provides three pricing types for each TLD:

Account-Level Pricing - Your price, including any applicable rebates, promotions, or account-level discounts. This is referenced as 'registrationprice', 'renewalprice', 'transferinprice' and 'domainrestorationprice' in this endpoint.
Original Pricing (No Discounts Applied) - The suggested retail price (MSRP) before any discounts are applied.
Retail Pricing (Public Site Pricing) - The current public retail price on name.com, including any public rebates or promotions, but before any account-level discounts.

Important Notes:

Promo codes are not supported through the API, and therefore are not reflected in any pricing values returned.
General TLD pricing only: This represents standard pricing for domains registered under the specified TLD. Pricing for specific domains may differ based on multiple factors (e.g., premium classifications, registry pricing rules). To retrieve pricing for an individual domain, use the GetPricingForDomain endpoint.
Availability: If a pricing value is returned as null, that product type is not currently supported for the TLD. (Example: registrationPrice = null means registrations are not currently available.)
If you do not have account level pricing, the retail price will always match your account level price. (e.g., registration price = registration retail price)

🔌 Usage

$client->tldPricing->tldPriceList(
    new TldPriceListRequest([
        'duration' => 1,
    ]),
);

⚙️ Parameters

$perPage: ?int — Per Page is the number of records to return per request. Per Page defaults to 25.

$page: ?int — Page is which page to return.

$duration: ?int — The number of years to get pricing for. The requested duration must be between 1 and 10 (inclusive). If the duration is not passed in the request, it will default to 1.

$tlds: ?string — A list of specific TLDs to get pricing for. Maximum of 25 TLDs can be requested at a time. When querying for IDN TLDs, due to character restrictions within a URL, they must be submitted in ASCII format. This means using "xn--9dbq2a" as opposed to it's unicode equivalent. The submitted TLDs will be checked for validity and support at name.com, and any invalid TLD will be removed from the submitted list. If all submitted TLDs are invalid or not supported by name.com, this will be considered a bad request, and a 400 Bad Request will be returned with an appropriate message.

Premium Domains

$client->premiumDomains->premiumDomainLists() -> ?PremiumDomainsDownloadResponse

📝 Description

Gets a pre-signed URL that will allow a user to download a list of premium domains, with their registration and renewal pricing. Please Note: The pre-signed URL will only be valid for 10 minutes. This endpoint is only available to approved reseller accounts. Contact name.com support to request access.

🔌 Usage

$client->premiumDomains->premiumDomainLists();

Contact Verification

$client->contactVerification->unverifiedContactsList($request) -> ?UnverifiedContactsResponse

📝 Description

Returns a list of contacts, related to domains within your account, that require verification as per ICANN procedures. When a new domain is created, unverified contacts are not immediately available in API responses. Records are added by a scheduled process that runs approximately every 10 minutes. As a result, there may be up to a 10-minute delay before unverified contacts appear in the API. This delay also applies to related events such as webhooks or other downstream systems that depend on contact verification data.

🔌 Usage

$client->contactVerification->unverifiedContactsList(
    new UnverifiedContactsListRequest([
        'perPage' => 100,
        'page' => 2,
    ]),
);

⚙️ Parameters

$perPage: ?int — PerPage is the number of records to return per request. If not passed in the request, the default value is 100 records.

$page: ?int — Page is which page to return. If not passed in the request, the default page is 1.

$client->contactVerification->verifyContact($verificationId, $request)

📝 Description

Use this API to verify a contact. This API is only available to approved reseller accounts. Contact name.com support to request access.

🔌 Usage

$client->contactVerification->verifyContact(
    1,
    new VerifyContactRequest([
        'body' => new EmptyObject([]),
    ]),
);

⚙️ Parameters

$verificationId: int — The VerificationId required to verify a specific contact.

$request: EmptyObject

$client->contactVerification->resendContactVerificationEmail($verificationId, $request) -> ?ContactVerificationResendResponse

📝 Description

Resend the contact verification email for a pending verification record.

Throttling

This endpoint enforces strict throttling to prevent abuse:

Per verificationId: max 1 resend per 15 minutes
Per reseller account: max 200 resends per rolling hour

nextEligibleAt is always returned so the client knows when it can try again.

On 429, the response uses the standard error envelope, and details contains the earliest retry time (RFC3339 UTC).

🔌 Usage

$client->contactVerification->resendContactVerificationEmail(
    1,
    new ResendContactVerificationEmailRequest([
        'body' => new EmptyObject([]),
    ]),
);

⚙️ Parameters

$verificationId: int — The verificationId for the pending contact verification record.

$request: EmptyObject

Uh oh!

FilesExpand file tree

reference.md

Latest commit

History

reference.md

File metadata and controls

Reference

📝 Description

🔌 Usage

Account Info

📝 Description

🔌 Usage

Accounts

📝 Description

🔌 Usage

⚙️ Parameters

Domains

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

Create Domain pricing

Getting the price for Create Domain

Best Practices For Domain Creates

Important Note on Dropcatching and Abuse Prevention

Contact Verification

🔌 Usage

⚙️ Parameters

IDN Domains

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

Contact Verification

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description

🔌 Usage

⚙️ Parameters

📝 Description