Skip to main content
The RDAP library supports all standard RDAP query types defined in RFC 7482.

​
QueryType Enum

The QueryType enum defines all available query operations: 
pub enum QueryType {
    Domain,
    Tld,
    Ip,
    Autnum,
    Entity,
    Nameserver,
    Help,
    DomainSearch,
    DomainSearchByNameserver,
    DomainSearchByNameserverIp,
    NameserverSearch,
    NameserverSearchByIp,
    EntitySearch,
    EntitySearchByHandle,
}
Source reference: src/request.rs:8

​
Lookup Queries

Lookup queries retrieve a single object by its identifier.

​
Domain

Query a domain name: 
use rdap::{RdapRequest, QueryType};

let request = RdapRequest::new(QueryType::Domain, "example.com");
URL format: {base}/domain/example.com Returns: RdapObject::Domain

​
Tld

Query a top-level domain: 
let request = RdapRequest::new(QueryType::Tld, "com");
URL format: {base}/domain/com Returns: RdapObject::Domain
TLD queries are automatically routed to IANA’s RDAP service.

​
Ip

Query an IP address or network: 
let request = RdapRequest::new(QueryType::Ip, "192.0.2.1");
URL format: {base}/ip/192.0.2.1
Returns: RdapObject::IpNetwork

​
Autnum

Query an Autonomous System Number: 
// With AS prefix
let request = RdapRequest::new(QueryType::Autnum, "AS15169");

// Without AS prefix
let request = RdapRequest::new(QueryType::Autnum, "15169");
URL format: {base}/autnum/15169 Returns: RdapObject::Autnum
The library automatically strips the “AS” prefix if present.
Source reference: src/request.rs:96

​
Entity

Query an entity (registrant, contact): 
let request = RdapRequest::new(QueryType::Entity, "ENTITY-HANDLE");
URL format: {base}/entity/ENTITY-HANDLE Returns: RdapObject::Entity

​
Nameserver

Query a nameserver: 
let request = RdapRequest::new(QueryType::Nameserver, "ns1.example.com");
URL format: {base}/nameserver/ns1.example.com Returns: RdapObject::Nameserver

​
Help

Query server help information: 
let request = RdapRequest::new(QueryType::Help, "");
URL format: {base}/help Returns: RdapObject::Help

​
Search Queries

Search queries return multiple matching objects.

​
DomainSearch

Search for domains by name: 
let request = RdapRequest::new(QueryType::DomainSearch, "example*.com");
URL format: {base}/domains?name=example*.com Returns: RdapObject::DomainSearch Source reference: src/request.rs:107

​
DomainSearchByNameserver

Search for domains by nameserver name: 
let request = RdapRequest::new(
    QueryType::DomainSearchByNameserver,
    "ns1.example.com"
);
URL format: {base}/domains?nsLdhName=ns1.example.com Returns: RdapObject::DomainSearch Source reference: src/request.rs:110

​
DomainSearchByNameserverIp

Search for domains by nameserver IP: 
let request = RdapRequest::new(
    QueryType::DomainSearchByNameserverIp,
    "192.0.2.1"
);
URL format: {base}/domains?nsIp=192.0.2.1 Returns: RdapObject::DomainSearch Source reference: src/request.rs:113

​
NameserverSearch

Search for nameservers by name: 
let request = RdapRequest::new(QueryType::NameserverSearch, "ns*.example.com");
URL format: {base}/nameservers?name=ns*.example.com Returns: RdapObject::NameserverSearch Source reference: src/request.rs:116

​
NameserverSearchByIp

Search for nameservers by IP address: 
let request = RdapRequest::new(QueryType::NameserverSearchByIp, "192.0.2.1");
URL format: {base}/nameservers?ip=192.0.2.1 Returns: RdapObject::NameserverSearch Source reference: src/request.rs:119

​
EntitySearch

Search for entities by full name: 
let request = RdapRequest::new(QueryType::EntitySearch, "Example Corp");
URL format: {base}/entities?fn=Example%20Corp Returns: RdapObject::EntitySearch Source reference: src/request.rs:122

​
EntitySearchByHandle

Search for entities by handle: 
let request = RdapRequest::new(QueryType::EntitySearchByHandle, "EXAMPLE-*");
URL format: {base}/entities?handle=EXAMPLE-* Returns: RdapObject::EntitySearch Source reference: src/request.rs:125

​
Auto-Detection

The library can automatically detect the query type: 
use rdap::RdapRequest;

// Domain
let qt = RdapRequest::detect_type("example.com")?;
// QueryType::Domain

// IPv4
let qt = RdapRequest::detect_type("8.8.8.8")?;
// QueryType::Ip

// IPv6
let qt = RdapRequest::detect_type("2001:db8::1")?;
// QueryType::Ip

// AS Number (with prefix)
let qt = RdapRequest::detect_type("AS15169")?;
// QueryType::Autnum

// AS Number (without prefix)
let qt = RdapRequest::detect_type("15169")?;
// QueryType::Autnum
Source reference: src/request.rs:134

​
Detection Logic

The auto-detection follows this priority:
1

AS Number

Strings starting with “AS” followed by digits, or pure numeric strings.
2

IP Address

IPv4 or IPv6 patterns, including CIDR notation.
3

TLD

Single word (no dots) matching a known TLD.
4

Domain

Default fallback for all other strings.
Source reference: src/request.rs:139

​
URL Building

The library automatically constructs the correct RDAP URL: 
use rdap::RdapRequest;
use url::Url;

let base_url = Url::parse("https://rdap.example.com/")?;
let request = RdapRequest::new(QueryType::Domain, "example.com");
let url = request.build_url(&base_url)?;
// https://rdap.example.com/domain/example.com
Source reference: src/request.rs:88
Query strings are automatically URL-encoded for safe transmission.

​
Complete Example

use rdap::{RdapClient, RdapRequest, QueryType};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = RdapClient::new()?;
    
    // Try different query types
    let queries = vec![
        (QueryType::Domain, "example.com"),
        (QueryType::Ip, "8.8.8.8"),
        (QueryType::Autnum, "AS15169"),
        (QueryType::Entity, "IANA"),
        (QueryType::DomainSearch, "example*.com"),
    ];
    
    for (query_type, query) in queries {
        println!("\n=== {:?}: {} ===", query_type, query);
        
        let request = RdapRequest::new(query_type, query);
        
        match client.query(&request).await {
            Ok(result) => println!("✓ Success: {:?}", result),
            Err(e) => eprintln!("✗ Error: {}", e),
        }
    }
    
    Ok(())
}

​
Next Steps

Working with Results

Learn how to extract data from query results

Error Handling

Handle errors and edge cases

Build docs developers (and LLMs) love

Get started for freeTalk to us