# Show domain ending with prices

> One top level domain with minimum term and list prices, net and gross - for end customers and resellers.

- Effect: Read - Changes nothing.
- Idempotent: yes
- Stability: stable
- MCP tool: `manitu_public_domain_tld_get` on https://mcp.manitu.de/mcp
- REST: `POST https://api.manitu.de/v1/public/domain/tld/get`
- Signed-in callers use: [Show domain ending with the account's prices](/reference/domain/tld/get.md)
- Page: /reference/public/domain/tld/get/

## MCP tool

`manitu_public_domain_tld_get`

### Description for the model

Tells for one top level domain (.de, .com, ...) what a domain under it costs at manitu by the price list, and its minimum term (term). Two prices: enduser - with a web hosting package, where web, mail and support come from manitu; reseller - domain and DNS only, for those who run their own servers, practically without support. Which one applies depends on what the domain is ordered with - name both when unsure. Each price is a list of charges: the setup fee once (domain_setup_fee, only where there is one) and the running fee per billed period (domain_fee, e.g. per year), each amount with net, gross, the side that is binding (binding: show that one) and the tax - as a consumer in Germany is billed (DE 19 %). Do not work out a price per month yourself; summary says it where the invoice bills so. A customer account may have a special price or another tax (another country, a VAT id): an order ([`manitu_webhosting_domain_order`](/reference/webhosting/domain/order.md)) names the price that is billed. The same for everyone, about no account. Read-only; nothing is ordered.

### Arguments

- `tld` (string, required) - The TLD, e.g. de, .com or köln. (minLength `1`; maxLength `64`; pattern `"^\\.?[^\\x00-,./:-@[-`{-\\x7F]+$"`)

### Example

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "manitu_public_domain_tld_get",
    "arguments": {
      "tld": "string"
    }
  }
}
```

## REST

`POST https://api.manitu.de/v1/public/domain/tld/get`

### Description

Returns for one top level domain (.de, .com, ...) its minimum term (term) and what a domain under it costs at manitu by the price list - the same for everyone, about no account. Two prices: enduser, with a web hosting package; reseller, domain and DNS only, practically without support. Each price is a list of charges - the setup fee once (domain_setup_fee, only where there is one) and the running fee per billed period (domain_fee) -, each amount with net, gross, the side that is binding (binding) and the tax, as a consumer in Germany is billed (DE 19 %); summary says the price as the invoice bills it. An account may have a special price or another tax; an order ([`POST /v1/webhosting/domain/order`](/reference/webhosting/domain/order.md)) names the price billed. Changes nothing.

### Authentication

None - this operation needs no credential.

### Request body

JSON; unknown fields are refused.

- `tld` (string, required) - The TLD, e.g. de, .com or köln. (minLength `1`; maxLength `64`; pattern `"^\\.?[^\\x00-,./:-@[-`{-\\x7F]+$"`)

### Response

In `data`; the rest of the body as on every call.

- `tld` (string, required) - The TLD without dot, with international characters, e.g. de, com, köln.
- `tld_ascii` (string, required) - The same in ASCII, e.g. xn--kln-sna.
- `group` (string, required) - cctld: of a country; gtld: generic. (one of `"cctld"`, `"gtld"`)
- `country_code` (string | null, required) - ISO 3166-1 alpha-2 of the country, for a ccTLD.
- `country_name` (object | null, required) - The country of a ccTLD; null for a generic TLD.
  - `country_name.de` (string, required) - In German, e.g. Deutschland.
  - `country_name.en` (string, required) - In English, e.g. Germany.
  - `country_name.native` (string | null, required) - In the country's own language and script, e.g. Deutschland, Österreich, 日本 - null where it is not known.
- `sld_regex` (string, required) - What the name before the TLD may be - a PCRE with delimiters, on the lower case name.
- `term` (object, required) - The minimum term of a registration (minimum) - empty where it is not known.
  - `term.minimum` (object) - The least it runs.
    - `term.minimum.unit` (string, required) - hour, day, month, year, or the unit a usage charge counts in - an open set of lower_snake_case codes. A reader that does not know one shows the price by its summary. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
    - `term.minimum.length` (integer, required) - How many of the unit, at least 1. (minimum `1`)
  - `term.renewal` (object) - By how much it renews when it is not ended.
    - `term.renewal.unit` (string, required) - hour, day, month, year, or the unit a usage charge counts in - an open set of lower_snake_case codes. A reader that does not know one shows the price by its summary. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
    - `term.renewal.length` (integer, required) - How many of the unit, at least 1. (minimum `1`)
  - `term.notice` (object) - How long before its end it has to be ended.
    - `term.notice.unit` (string, required) - hour, day, month, year, or the unit a usage charge counts in - an open set of lower_snake_case codes. A reader that does not know one shows the price by its summary. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
    - `term.notice.length` (integer, required) - How many of the unit, at least 1. (minimum `1`)
- `price` (object, required) - The list prices - an account with a special price is billed that instead, and its order names it. Which applies depends on what the domain is ordered with.
  - `price.enduser` (object | null, required) - The list price with a web hosting package (web, mail and support at manitu) - gross is binding - charges: the setup fee once (domain_setup_fee, only where there is one) and the running fee per billed period (domain_fee), each with net, gross, the side that is binding and the tax. As a consumer in Germany is billed: the tax is the German one; an account is billed with the tax of its invoice, and a special price it may have. null: no price to tell.
    - `price.enduser.charges` (array of object, required) - The charges, at least one - e.g. a prorated amount now and the new plan per year. (minItems `1`)
      - `price.enduser.charges[].code` (string, required) - What the charge is for, a lower_snake_case code of the backend, e.g. domain_fee, plan_fee - the reader translates it. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
      - `price.enduser.charges[].billing` (object, required) - How the charge is billed.
        - `price.enduser.charges[].billing.kind` (string, required) - one_time: charged once; recurring: charged per period; usage: charged by use, per unit, settled per period. An open set: a reader that does not know a kind shows the price by its summary. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
        - `price.enduser.charges[].billing.period` (object) - The billing period - with recurring and usage, not with one_time.
          - `price.enduser.charges[].billing.period.unit` (string, required) - hour, day, month, year, or the unit a usage charge counts in - an open set of lower_snake_case codes. A reader that does not know one shows the price by its summary. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
          - `price.enduser.charges[].billing.period.length` (integer, required) - How many of the unit, at least 1. (minimum `1`)
        - `price.enduser.charges[].billing.per` (object) - The unit a usage charge counts, e.g. 1 hour - with usage, and only there.
          - `price.enduser.charges[].billing.per.unit` (string, required) - hour, day, month, year, or the unit a usage charge counts in - an open set of lower_snake_case codes. A reader that does not know one shows the price by its summary. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
          - `price.enduser.charges[].billing.per.length` (integer, required) - How many of the unit, at least 1. (minimum `1`)
      - `price.enduser.charges[].usage` (object) - What bounds a usage charge - with usage only.
        - `price.enduser.charges[].usage.cap` (any) - The most the charge comes to per billing period - binding, with the digits of the currency.
        - `price.enduser.charges[].usage.included` (object) - How much of the unit is in the price before the rate applies - in the unit of billing.per.
          - `price.enduser.charges[].usage.included.unit` (string, required) - hour, day, month, year, or the unit a usage charge counts in - an open set of lower_snake_case codes. A reader that does not know one shows the price by its summary. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
          - `price.enduser.charges[].usage.included.length` (integer, required) - How many of the unit, at least 1. (minimum `1`)
      - `price.enduser.charges[].condition` (string) - When the charge is due at all, a lower_snake_case code: on_success - only when what it is for succeeds. An open set; not there: always. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
      - `price.enduser.charges[].service_period` (object) - The days the charge covers, the first and the last both included - e.g. the rest of a period on a change of plan.
        - `price.enduser.charges[].service_period.from` (string, required) - The first day. (format `date`)
        - `price.enduser.charges[].service_period.to` (string, required) - The last day. (format `date`)
      - `price.enduser.charges[].phases` (array of object, required) - What the charge amounts to, phase by phase, in order: each begins where the one before it ends. A one_time charge has one phase, without cycles; the last phase of a recurring or usage charge has cycles null, and only that one. (minItems `1`)
        - `price.enduser.charges[].phases[].kind` (string, required) - trial, promo or regular. An open set: a reader that does not know a kind shows the price by its summary. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
        - `price.enduser.charges[].phases[].cycles` (integer | null) - How many billing periods the phase lasts; null: without end. Not there with one_time. (minimum `1`)
        - `price.enduser.charges[].phases[].period` (object) - The billing period of this phase, where it differs from billing.period - e.g. three months free of a yearly plan.
          - `price.enduser.charges[].phases[].period.unit` (string, required) - hour, day, month, year, or the unit a usage charge counts in - an open set of lower_snake_case codes. A reader that does not know one shows the price by its summary. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
          - `price.enduser.charges[].phases[].period.length` (integer, required) - How many of the unit, at least 1. (minimum `1`)
        - `price.enduser.charges[].phases[].amount` (any, required) - What is charged per period of the phase - never per month unless the period is one. With usage: per unit of billing.per, and it may have more digits than the currency.
    - `price.enduser.summary` (string) - The whole price in one sentence, in the language of the answer, as the backend writes it - what a reader shows where it does not know a code. Never instead of the charges. (minLength `1`; maxLength `1000`)
  - `price.reseller` (object | null, required) - The list price of domain and DNS only, for those who rent a server from manitu - practically no support; net is binding - charges: the setup fee once (domain_setup_fee, only where there is one) and the running fee per billed period (domain_fee), each with net, gross, the side that is binding and the tax. As a consumer in Germany is billed: the tax is the German one; an account is billed with the tax of its invoice, and a special price it may have. null: no price to tell.
    - `price.reseller.charges` (array of object, required) - The charges, at least one - e.g. a prorated amount now and the new plan per year. (minItems `1`)
      - `price.reseller.charges[].code` (string, required) - What the charge is for, a lower_snake_case code of the backend, e.g. domain_fee, plan_fee - the reader translates it. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
      - `price.reseller.charges[].billing` (object, required) - How the charge is billed.
        - `price.reseller.charges[].billing.kind` (string, required) - one_time: charged once; recurring: charged per period; usage: charged by use, per unit, settled per period. An open set: a reader that does not know a kind shows the price by its summary. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
        - `price.reseller.charges[].billing.period` (object) - The billing period - with recurring and usage, not with one_time.
          - `price.reseller.charges[].billing.period.unit` (string, required) - hour, day, month, year, or the unit a usage charge counts in - an open set of lower_snake_case codes. A reader that does not know one shows the price by its summary. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
          - `price.reseller.charges[].billing.period.length` (integer, required) - How many of the unit, at least 1. (minimum `1`)
        - `price.reseller.charges[].billing.per` (object) - The unit a usage charge counts, e.g. 1 hour - with usage, and only there.
          - `price.reseller.charges[].billing.per.unit` (string, required) - hour, day, month, year, or the unit a usage charge counts in - an open set of lower_snake_case codes. A reader that does not know one shows the price by its summary. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
          - `price.reseller.charges[].billing.per.length` (integer, required) - How many of the unit, at least 1. (minimum `1`)
      - `price.reseller.charges[].usage` (object) - What bounds a usage charge - with usage only.
        - `price.reseller.charges[].usage.cap` (any) - The most the charge comes to per billing period - binding, with the digits of the currency.
        - `price.reseller.charges[].usage.included` (object) - How much of the unit is in the price before the rate applies - in the unit of billing.per.
          - `price.reseller.charges[].usage.included.unit` (string, required) - hour, day, month, year, or the unit a usage charge counts in - an open set of lower_snake_case codes. A reader that does not know one shows the price by its summary. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
          - `price.reseller.charges[].usage.included.length` (integer, required) - How many of the unit, at least 1. (minimum `1`)
      - `price.reseller.charges[].condition` (string) - When the charge is due at all, a lower_snake_case code: on_success - only when what it is for succeeds. An open set; not there: always. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
      - `price.reseller.charges[].service_period` (object) - The days the charge covers, the first and the last both included - e.g. the rest of a period on a change of plan.
        - `price.reseller.charges[].service_period.from` (string, required) - The first day. (format `date`)
        - `price.reseller.charges[].service_period.to` (string, required) - The last day. (format `date`)
      - `price.reseller.charges[].phases` (array of object, required) - What the charge amounts to, phase by phase, in order: each begins where the one before it ends. A one_time charge has one phase, without cycles; the last phase of a recurring or usage charge has cycles null, and only that one. (minItems `1`)
        - `price.reseller.charges[].phases[].kind` (string, required) - trial, promo or regular. An open set: a reader that does not know a kind shows the price by its summary. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
        - `price.reseller.charges[].phases[].cycles` (integer | null) - How many billing periods the phase lasts; null: without end. Not there with one_time. (minimum `1`)
        - `price.reseller.charges[].phases[].period` (object) - The billing period of this phase, where it differs from billing.period - e.g. three months free of a yearly plan.
          - `price.reseller.charges[].phases[].period.unit` (string, required) - hour, day, month, year, or the unit a usage charge counts in - an open set of lower_snake_case codes. A reader that does not know one shows the price by its summary. (pattern `"^[a-z0-9]+(_[a-z0-9]+)*$"`)
          - `price.reseller.charges[].phases[].period.length` (integer, required) - How many of the unit, at least 1. (minimum `1`)
        - `price.reseller.charges[].phases[].amount` (any, required) - What is charged per period of the phase - never per month unless the period is one. With usage: per unit of billing.per, and it may have more digits than the currency.
    - `price.reseller.summary` (string) - The whole price in one sentence, in the language of the answer, as the backend writes it - what a reader shows where it does not know a code. Never instead of the charges. (minLength `1`; maxLength `1000`)

### Statuses

- `200` Success.
- `400` The input is wrong, or the request itself (INVALID_INPUT). Each entry names its field and its reason - correct the input and call again.
- `429` Too many calls. The Retry-After header says when to try again.
- `500` The server failed. Nothing about the request was wrong. Whether a change took effect is not known - check before trying it again.
- `503` The channel this operation forwards through is unavailable.

### Example

```sh
curl -X POST \
  'https://api.manitu.de/v1/public/domain/tld/get' \
  -H 'Content-Type: application/json' \
  -d '{"tld":"string"}'
```

## Example result

```json
{
  "tld": "string",
  "tld_ascii": "string",
  "group": "cctld",
  "country_code": "string",
  "country_name": {
    "de": "string",
    "en": "string",
    "native": "string"
  },
  "sld_regex": "string",
  "term": {
    "minimum": {
      "unit": "string",
      "length": 1
    },
    "renewal": {
      "unit": "string",
      "length": 1
    },
    "notice": {
      "unit": "string",
      "length": 1
    }
  },
  "price": {
    "enduser": {
      "charges": [
        {
          "code": "string",
          "billing": {
            "kind": "string",
            "period": {
              "unit": "string",
              "length": 1
            },
            "per": {
              "unit": "string",
              "length": 1
            }
          },
          "usage": {
            "cap": "string",
            "included": {
              "unit": "string",
              "length": 1
            }
          },
          "condition": "string",
          "service_period": {
            "from": "2026-10-23",
            "to": "2026-10-23"
          },
          "phases": [
            {
              "kind": "string",
              "cycles": 1,
              "period": {
                "unit": "string",
                "length": 1
              },
              "amount": "string"
            }
          ]
        }
      ],
      "summary": "string"
    },
    "reseller": {
      "charges": [
        {
          "code": "string",
          "billing": {
            "kind": "string",
            "period": {
              "unit": "string",
              "length": 1
            },
            "per": {
              "unit": "string",
              "length": 1
            }
          },
          "usage": {
            "cap": "string",
            "included": {
              "unit": "string",
              "length": 1
            }
          },
          "condition": "string",
          "service_period": {
            "from": "2026-10-23",
            "to": "2026-10-23"
          },
          "phases": [
            {
              "kind": "string",
              "cycles": 1,
              "period": {
                "unit": "string",
                "length": 1
              },
              "amount": "string"
            }
          ]
        }
      ],
      "summary": "string"
    }
  }
}
```
