Building a Lightweight RDAP Client in Python

The Registration Data Access Protocol (RDAP) provides a modern, secure, and structured method for querying domain name, IP address, autonomous system number, and nameserver registration data. For developers and researchers who want to integrate RDAP lookups into their tools, building a lightweight RDAP client in Python is a practical and accessible approach. Python’s standard library and widely available packages offer all the functionality needed to handle RDAP’s HTTP-based requests, parse JSON responses, and process network or domain-related inputs with minimal overhead.

At its core, an RDAP client needs to perform a few essential tasks: accept user input for the type of resource being queried, determine the appropriate RDAP server using bootstrap information if necessary, construct the correct query URL, send an HTTPS request, and parse the resulting JSON. Python’s requests library is well-suited for making HTTPS requests, while the ipaddress module helps in determining whether a query string is a valid IP address or CIDR block. For domain names and autonomous system numbers, the client must follow the correct URL pattern as defined by the RDAP specification.

To get started, a simple RDAP client begins by parsing the input to identify the resource type. If the input is an IP address, the client must consult the IANA-maintained bootstrap files to determine the correct RDAP server. These JSON files, available at https://data.iana.org/rdap/, contain mappings for IPv4, IPv6, and ASN resources, as well as top-level domains for domain name queries. The client downloads the appropriate file, parses it using Python’s json module, and matches the input against the CIDR or ASN ranges listed. Once a match is found, the client extracts the corresponding RDAP base URL and appends the specific path needed to complete the query.

For example, if the user provides an IP address like 203.0.113.45, the client identifies it as an IPv4 address, downloads the IPv4 bootstrap JSON, and searches for the smallest matching CIDR range that includes the given address. This process involves using Python’s ipaddress module to compare and contain IP ranges. Once the responsible RDAP server is located, such as https://rdap.apnic.net/, the client constructs a query URL like https://rdap.apnic.net/ip/203.0.113.45 and sends a GET request to that address.

For domain names, the process is slightly different. The client extracts the top-level domain from the query, such as .org from example.org, and consults the IANA domain bootstrap file. This file maps TLDs to RDAP URLs, so the client looks up .org, finds the corresponding RDAP endpoint, and builds a query URL in the format https://rdap.public-interest-registry.net/rdap/domain/example.org. Autonomous system numbers are handled in a similar fashion, with their own dedicated bootstrap file and path prefix, typically /autnum/.

After constructing and sending the HTTPS request, the client receives a JSON-formatted response that adheres to the RDAP object structure. This response includes standardized keys such as “objectClassName”, “handle”, “status”, “events”, “entities”, and “links”. The Python json module is used to parse the response into a dictionary, allowing for easy access to fields of interest. A user-friendly client will format and display key data, such as registration status, registrar or allocation organization, contact entities, and important timestamps like creation and last update.

Security is also a consideration. The RDAP client must ensure all requests are made over HTTPS, validate SSL certificates by default, and handle exceptions gracefully. The requests library handles certificate validation automatically unless explicitly disabled, which should never be done in production. In cases where the RDAP server is misconfigured or unavailable, the client should catch exceptions such as timeouts, connection errors, or HTTP errors, and provide informative messages to the user rather than crashing.

To support extensibility, the client can be structured with modular functions—one for determining the resource type, one for retrieving and parsing bootstrap data, one for constructing the query URL, one for sending requests, and one for rendering the output. This modular design facilitates testing, debugging, and future enhancements, such as supporting authentication headers, pagination, or customized output formats. Additional features might include caching the bootstrap files to reduce repeated downloads, supporting batch queries, or integrating with logging systems for audit purposes.

A lightweight Python RDAP client can be implemented in under 200 lines of code while offering robust capabilities and compliance with the RDAP specification. Such a client empowers developers, analysts, and network operators to incorporate RDAP into security tools, automation pipelines, and research applications with minimal effort. As RDAP continues to supplant WHOIS in internet governance and operations, lightweight clients will play a crucial role in promoting adoption and supporting a more transparent and privacy-aware internet infrastructure.

The Registration Data Access Protocol (RDAP) provides a modern, secure, and structured method for querying domain name, IP address, autonomous system number, and nameserver registration data. For developers and researchers who want to integrate RDAP lookups into their tools, building a lightweight RDAP client in Python is a practical and accessible approach. Python’s standard library…