Skip to content
RFC Editor - Official home of RFCs

RFC 9083: STD 95: JSON Responses for the Registration Data Access Protocol (RDAP)

  • S. Hollenbeck,  
  • A. Newton
Internet Standard

Abstract

This document describes JSON data structures representing registration information maintained by Regional Internet Registries (RIRs) and Domain Name Registries (DNRs). These data structures are used to form Registration Data Access Protocol (RDAP) query responses. This document obsoletes RFC 7483.

Status of This Memo

This is an Internet Standards Track document.

This document is a product of the Internet Engineering Task Force (IETF). It represents the consensus of the IETF community. It has received public review and has been approved for publication by the Internet Engineering Steering Group (IESG). Further information on Internet Standards is available in Section 2 of RFC 7841.

Information about the current status of this document, any errata, and how to provide feedback on it may be obtained at .

1. Introduction

This document describes responses in the JSON [] format for the queries as defined by the Registration Data Access Protocol Query Format []. A communication protocol for exchanging queries and responses is described in []. This document obsoletes RFC 7483.

1.1. Terminology and Definitions

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [] [] when, and only when, they appear in all capitals, as shown here.

The following list describes terminology and definitions used throughout this document:

DNR:
Domain Name Registry or Domain Name Registrar
LDH:
letters, digits, hyphen
member:
data found within an object as defined by JSON []
object:
a data structure as defined by JSON []
object class:
the definition of members that may be found in JSON objects described in this document
object instance:
an instantiation or specific instance of an object class
RDAP:
Registration Data Access Protocol
RIR:
Regional Internet Registry

1.2. Data Model

The data model for JSON responses is specified in five sections:

  1. simple data types conveyed in JSON primitive types (strings, numbers, booleans, and null)
  2. data structures specified as JSON arrays or objects that are used repeatedly when building up larger objects
  3. object classes representing structured data corresponding to a lookup of a single object
  4. arrays of objects representing structured data corresponding to a search for multiple objects
  5. the response to an error

The object classes represent responses for two major categories of data: responses returned by RIRs for registration data related to IP addresses, reverse DNS names, and Autonomous System numbers and responses returned by DNRs for registration data related to forward DNS names. The following object classes are returned by both RIRs and DNRs:

  1. domains
  2. nameservers
  3. entities

The information served by both RIRs and DNRs for these object classes overlap extensively and are given in this document as a unified model for both classes of service.

In addition to the object classes listed above, RIRs also serve the following object classes:

  1. IP networks
  2. Autonomous System numbers

Object classes defined in this document represent a minimal set of what a compliant client/server needs to understand to function correctly; however, some deployments may want to include additional object classes to suit individual needs. Anticipating this need for extension, Section 2.1 of this document defines a mechanism for extending the JSON objects that are described in this document.

Positive responses take two forms. A response to a lookup of a single object in the registration system yields a JSON object, which is the subject of the lookup. A response to a search for multiple objects yields a JSON object that contains an array of JSON objects that are the subject of the search. In each type of response, other data structures are present within the topmost JSON object.

2. Use of JSON

2.1. Naming

Clients of these JSON responses SHOULD ignore unrecognized JSON members in responses. Servers can insert members into the JSON responses, which are not specified in this document, but that does not constitute an error in the response. Servers that insert such unspecified members into JSON responses SHOULD have member names prefixed with a short identifier followed by an underscore followed by a meaningful name. It has been observed that these short identifiers aid software implementers with identifying the specification of the JSON member, and failure to use one could cause an implementer to assume the server is erroneously using a name from this specification. This allowance does not apply to jCard [] objects. The full JSON name (the prefix plus the underscore plus the meaningful name) SHOULD adhere to the character and name limitations of the prefix registry described in []. Failure to use these limitations could result in slower adoption as these limitations have been observed to aid some client programming models.

Consider the following JSON response with JSON members, all of which are specified in this document.

{
  "handle" : "ABC123",
  "remarks" :
  [
    {
      "description" :
      [
        "She sells sea shells down by the sea shore.",
        "Originally written by Terry Sullivan."
      ]
    }
  ]
}
Figure 1

If The Registry of the Moon desires to express information not found in this specification, it might select "lunarNIC" as its identifying prefix and insert, as an example, the member named "lunarNIC_beforeOneSmallStep" to signify registrations occurring before the first moon landing and the member named "lunarNIC_harshMistressNotes" that contains other descriptive text.

Consider the following JSON response with JSON names, some of which should be ignored by clients without knowledge of their meaning.

{
  "handle" : "ABC123",
  "lunarNIC_beforeOneSmallStep" : "TRUE THAT!",
  "remarks" :
  [
    {
      "description" :
      [
        "She sells sea shells down by the sea shore.",
        "Originally written by Terry Sullivan."
      ]
    }
  ],
  "lunarNIC_harshMistressNotes" :
  [
    "In space,",
    "nobody can hear you scream."
  ]
}
Figure 2

Insertion of unrecognized members ignored by clients may also be used for future revisions to this specification.

Clients processing JSON responses need to be prepared for members representing registration data specified in this document to be absent from a response. In other words, servers are free to omit unrequired/optional JSON members containing registration data based on their own policies.

Finally, all JSON names specified in this document are case sensitive. Both servers and clients MUST transmit and process them using the specified character case.

3. Common Data Types

JSON [] defines the data types of a number, character string, boolean, array, object, and null. This section describes the semantics and/or syntax reference for common, JSON character strings used in this document.

handle:
DNRs and RIRs have registry-unique identifiers that may be used to specifically reference an object instance. The semantics of this data type as found in this document are to be a registry-unique reference to the closest enclosing object where the value is found. The data type names "registryId", "roid", "nic-handle", "registrationNo", etc., are terms often synonymous with this data type. In this document, the term "handle" is used. The term exposed to users by clients is a presentation issue beyond the scope of this document. This value is a simple character string.
IPv4 addresses:
The representation of IPv4 addresses in this document uses the dotted-decimal notation. An example of this textual representation is "192.0.2.0".
IPv6 addresses:
The representation of IPv6 addresses in this document follow the forms outlined in []. An example of this textual representation is "2001:db8::1:0:0:1".
country codes:
Where the identity of a geopolitical nation or country is needed, these identities are represented with the alpha-2 or two-character country code designation as defined in [ISO.3166.2020]. The alpha-2 representation is used because it is freely available, whereas the alpha-3 and numeric-3 standards are not.
LDH names:
Textual representations of DNS names where the labels of the domain are all "letters, digits, hyphen" labels as described by []. Trailing periods are optional.
Unicode names:
Textual representations of DNS names where one or more of the labels are U-labels as described by []. Trailing periods are optional.
dates and times:
The syntax for values denoting dates and times is defined in [].
URIs:
The syntax for values denoting a Uniform Resource Identifier (URI) is defined by [].

Contact information is defined using jCards as described in []. The "fn" member is required and MUST NOT be null according to []. An empty "fn" member MAY be used when the contact name does not exist or is redacted.

4. Common Data Structures

This section defines common data structures used in responses and object classes.

4.1. RDAP Conformance

The data structure named "rdapConformance" is an array of strings, each providing a hint as to the specifications used in the construction of the response. This data structure MUST appear in the topmost JSON object of a response and MUST NOT appear anywhere else. A response to a "help" request will include identifiers for all of the specifications supported by the server. A response to any other request will include only identifiers for the specifications used in the construction of the response. The set of returned identifiers MAY vary depending on the authorization level of the client.

An example rdapConformance data structure:

"rdapConformance" :
[
  "rdap_level_0"
]
Figure 3

The string literal "rdap_level_0" signifies conformance with this specification. When custom JSON values are inserted into responses, conformance to those custom specifications MUST be indicated by including a unique string literal value registered in the IANA RDAP Extensions registry specified in []. For example, if the fictional Registry of the Moon wants to signify that their JSON responses are conformant with their registered extensions, the string used might be "lunarNIC_level_0". These registered values aid the identification of specifications for software implementers, and failure to use them could result in slower adoption of extensions.

Example rdapConformance structure with custom extensions noted:

"rdapConformance" :
[
  "rdap_level_0",
  "lunarNIC_level_0"
]
Figure 4

The "links" array is found in data structures to signify links to other resources on the Internet. The relationship of these links is defined by the IANA registry described by [].

The following is an example of the link structure:

    {
      "value" : "https://example.com/context_uri",
      "rel" : "self",
      "href" : "https://example.com/target_uri",
      "hreflang" : [ "en", "ch" ],
      "title" : "title",
      "media" : "screen",
      "type" : "application/json"
    }
Figure 5

The JSON name/values of "rel", "href", "hreflang", "title", "media", and "type" correspond to values found in of []. The "value" JSON value is the context URI as described by []. The "value", "rel", and "href" JSON values MUST be specified. All other JSON values are OPTIONAL. A "related" link relation MUST NOT include an "href" URI that is the same as the "self" link relation "href" URI to reduce the risk of infinite client processing loops. Internationalized Domain Names (IDNs) returned in URIs SHOULD be consistently returned in LDH name format to allow clients to process these IDNs according to their capabilities.

This is an example of the "links" array as it might be found in an object class:

    "links" :
    [
        {
          "value" : "https://example.com/ip/2001:db8::123",
          "rel" : "self",
          "href" : "https://example.com/ip/2001:db8::123",
          "type" : "application/rdap+json"
        },
        {
          "value" : "https://example.com/ip/2001:db8::123",
          "rel" : "up",
          "href" : "https://example.com/ip/2001:db8::/48",
          "type" : "application/rdap+json"
        }

    ]
Figure 6