Skip to main content

​
Overview

These common structures appear in multiple RDAP object types and represent standard metadata like links, notices, events, and public identifiers. Represents a hyperlink to related resources.
​
value
Option<String>
Value context for the link
​
rel
Option<String>
Relationship type (e.g., “self”, “related”, “alternate”)
​
href
String
required
The link URL
​
hreflang
Vec<String>
Language tags for the linked resource
​
title
Option<String>
Human-readable title for the link
​
media
Option<String>
Media type hint
​
link_type
Option<String>
MIME type of the linked resource (mapped from JSON field “type”)

​
Example

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

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = RdapClient::new()?;
    let request = RdapRequest::new(QueryType::Domain, "example.com");
    let result = client.query(&request).await?;
    
    if let RdapObject::Domain(domain) = result {
        for link in &domain.links {
            println!("Link: {}", link.href);
            if let Some(rel) = &link.rel {
                println!("  Rel: {}", rel);
            }
        }
    }
    
    Ok(())
}

​
Notice

Informational message about the RDAP response or object.
​
title
Option<String>
Short title for the notice
​
notice_type
Option<String>
Type classification for the notice (mapped from JSON field “type”)
​
description
Vec<String>
Array of description lines
​
links
Vec<Link>
Related links for more information

​
Example

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

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = RdapClient::new()?;
    let request = RdapRequest::new(QueryType::Domain, "example.com");
    let result = client.query(&request).await?;
    
    if let RdapObject::Domain(domain) = result {
        for notice in &domain.notices {
            if let Some(title) = &notice.title {
                println!("Notice: {}", title);
            }
            for line in &notice.description {
                println!("  {}", line);
            }
        }
    }
    
    Ok(())
}

​
Remark

Type alias for Notice. Remarks are structurally identical to notices but are used for object-specific information rather than response-level notices. 
pub type Remark = Notice;

​
Event

Represents a significant event in an object’s lifecycle.
​
action
String
required
Event action (e.g., “registration”, “expiration”, “last changed”, “last update of RDAP database”)
​
actor
Option<String>
Entity handle responsible for the event
​
date
String
required
ISO 8601 timestamp of the event
​
links
Vec<Link>
Related links

​
Common Event Actions

  • registration - Initial registration date
  • expiration - Expiration date
  • last changed - Last modification date
  • last update of RDAP database - When RDAP data was last updated
  • reregistration - Re-registration after deletion
  • reinstatement - Restoration after suspension
  • transfer - Ownership transfer
  • locked - When object was locked
  • unlocked - When object was unlocked

​
Example

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

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = RdapClient::new()?;
    let request = RdapRequest::new(QueryType::Domain, "example.com");
    let result = client.query(&request).await?;
    
    if let RdapObject::Domain(domain) = result {
        for event in &domain.events {
            println!("{}: {}", event.action, event.date);
        }
    }
    
    Ok(())
}

​
PublicId

Public identifier for an object (e.g., IANA Registrar ID).
​
id_type
String
required
Type of identifier (mapped from JSON field “type”)
​
identifier
String
required
The identifier value

​
Example

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

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = RdapClient::new()?;
    let request = RdapRequest::new(QueryType::Domain, "example.com");
    let result = client.query(&request).await?;
    
    if let RdapObject::Domain(domain) = result {
        for entity in &domain.entities {
            for public_id in &entity.public_ids {
                println!("{}: {}", public_id.id_type, public_id.identifier);
            }
        }
    }
    
    Ok(())
}

​
Status

Type alias for a vector of status strings. 
pub type Status = Vec<String>;
Common status values include:
  • validated - Signifies that the data has been validated
  • renew prohibited - Renewal not allowed
  • update prohibited - Update not allowed
  • transfer prohibited - Transfer not allowed
  • delete prohibited - Deletion not allowed
  • proxy - Object has privacy/proxy enabled
  • private - Some data is private
  • removed - Object has been removed
  • obscured - Some data has been obscured
  • associated - Object has associations
  • active - Object is active
  • inactive - Object is inactive
  • locked - Object is locked
  • pending create - Pending creation
  • pending renew - Pending renewal
  • pending transfer - Pending transfer
  • pending update - Pending update
  • pending delete - Pending deletion

​
See Also

Build docs developers (and LLMs) love

Get started for freeTalk to us