Build a Domain Age Checker API with FastAPI and Python

FastAPI Mastery: Creating a Domain Age Checker API – I felt left behind when I discovered how quickly I could build a Restful API with FastAPI.

I’ve been using WordPress REST API for my API needs all these years, but since getting engaged more and more to Python, I found FastAPI to be a quicker and easier way to build an API.

In this comprehensive tutorial, I will guide you through the process of building a Domain Age Checker API using FastAPI, a modern web framework that supports Python 3.7+ and standard Python type hints.

You will learn how to set up your environment and deploy a fully functional API that retrieves domain WHOIS information and calculates the domain’s age in different units.

Introduction to API with FastAPI

APIs are the backbone of modern web applications, enabling different services to communicate seamlessly. FastAPI is a powerful Python framework that makes it easy to build APIs quickly and efficiently.

In this tutorial, we’ll leverage FastAPI to create an API that checks the age of a domain by retrieving its WHOIS information.

Understanding the age of a domain can be crucial for various reasons, such as SEO analysis, domain valuation, or cybersecurity assessments.

By the end of this tutorial, you’ll have a solid understanding of how to build and deploy a FastAPI application that provides comprehensive WHOIS data and domain age calculations.

Prerequisites

Before we begin, make sure you have the following:

• Python 3.7 or higher installed on your system.
• Basic knowledge of Python programming.
• Familiarity with virtual environments in Python.
• Internet connection to fetch WHOIS data.

Setting Up the Development Environment

To ensure a clean and manageable workspace, I recommend to set up a Python virtual environment for the project.

Creating a Virtual Environment

Open your command prompt or terminal and navigate to your desired project directory:

cd path\to\your\project\directory

Create a virtual environment named venv:

python -m venv venv

Activating the Virtual Environment

Activate the virtual environment to isolate project dependencies:

On Windows (Command Prompt):

venv\Scripts\activate

On Windows (PowerShell):

venv\Scripts\Activate.ps1

On macOS/Linux:

source venv/bin/activate

Installing Required Packages

With the virtual environment activated, install the necessary Python packages:

pip install fastapi uvicorn python-whois python-dateutil

• fastapi: The web framework for building the API.
• uvicorn: ASGI server for running the FastAPI app.
• python-whois: Library to fetch WHOIS data.
• python-dateutil: For advanced date calculations.

Or you can also save the following packages list inside a requirements.txt file:

annotated-types==0.7.0
anyio==4.4.0
click==8.1.7
colorama==0.4.6
fastapi==0.114.2
h11==0.14.0
idna==3.9
pydantic==2.9.1
pydantic_core==2.23.3
python-dateutil==2.9.0.post0
python-whois==0.9.4
six==1.16.0
sniffio==1.3.1
starlette==0.38.5
typing_extensions==4.12.2
uvicorn==0.30.6

Then you just need to run the following commands:

pip install -r requirements.txt

Building the Domain Age Checker API Using FastAPI and Python

Now that your environment is set up, let’s start building the API.

Project Structure

Create a new file named main.py in your project directory. This will be the entry point of our application.

domain-age-checker/
├── venv/
├── main.py

Writing the Main Application File

Open main.py in your favorite code editor and start coding.

Detailed Code Explanation

Let’s dive deep into the code, explaining each part thoroughly.

Importing Necessary Libraries

from fastapi import FastAPI, HTTPException, Query
import whois
from datetime import datetime
from dateutil.relativedelta import relativedelta
import re

Here’s the explanation:

• fastapi: Imports the FastAPI class to create the app and HTTPException for error handling.
• whois: Used to fetch WHOIS data for a given domain.
• datetime: Provides classes for manipulating dates and times.
• dateutil.relativedelta: Offers powerful extensions to the standard datetime module for calculating date differences.
• re: Regular expressions module for validating domain names.

Initializing the FastAPI App

app = FastAPI()

This initializes a new FastAPI application instance.

Defining the /domain/age Endpoint

The reason why I decided to use /domain/age endpoint is to allow for future API expansion. This approach enables us to easily add more domain checker endpoints as needed.

This is the definition of the endpoint:

@app.get("/domain/age")
def get_domain_age(domain: str = Query(
    ...,
    regex=r"^(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}$",
    description="The domain name to check (e.g., 'example.com')"
)):

Here’s the explanation:

• @app.get(“/domain/age”): Decorator that defines a GET endpoint at /domain/age.
• domain: str = Query(…): Specifies that domain is a required query parameter.
• regex: Validates the domain name using a regular expression.
• description: Provides a description for the Swagger UI documentation.

Before we delve into the function body, it’s essential to understand how the endpoint will process the incoming request.

Fetching WHOIS Data for the Domain Name

try:
    domain_info = whois.whois(domain)

• whois.whois(domain): Fetches the WHOIS information for the provided domain.
• domain_info: An object containing all the WHOIS data.

Handling Date Fields

WHOIS data can sometimes have multiple entries or missing information.

# Extract relevant WHOIS fields
creation_date = domain_info.creation_date
updated_date = domain_info.updated_date
expiration_date = domain_info.expiration_date
registrar = domain_info.registrar
name_servers = domain_info.name_servers
status = domain_info.status

# Handle cases where dates might be lists
if isinstance(creation_date, list):
    creation_date = creation_date[0]
if isinstance(updated_date, list):
    updated_date = updated_date[0]
if isinstance(expiration_date, list):
    expiration_date = expiration_date[0]

Here’s the explanation:

• creation_date, updated_date, expiration_date: Extract date fields.
• registrar, name_servers, status: Extract additional WHOIS fields.
• isinstance(creation_date, list): Checks if the date is a list and selects the first element.

Calculating Domain Age

# Check if creation_date was found
if creation_date is None:
    raise ValueError("Creation date not found for this domain.")

# Calculate the age of the domain
now = datetime.now()
age_delta = relativedelta(now, creation_date)
age_in_days = (now - creation_date).days
age_in_weeks = age_in_days // 7
age_in_months = age_delta.years * 12 + age_delta.months
age_in_years = age_delta.years

Here’s the explanation:

• creation_date is None: Raises an error if the creation date is missing.
• now: Gets the current date and time.
• age_delta: Calculates the difference between now and the creation date using relativedelta for accurate results.
• age_in_days: Total number of days since the domain was created.
• age_in_weeks: Total number of weeks, calculated by integer division.
• age_in_months: Calculates months considering years and months from age_delta.
• age_in_years: Number of years from age_delta.

Formatting the Response

# Format dates as strings
creation_date_str = creation_date.strftime('%Y-%m-%d') if creation_date else None
updated_date_str = updated_date.strftime('%Y-%m-%d') if updated_date else None
expiration_date_str = expiration_date.strftime('%Y-%m-%d') if expiration_date else None

# Ensure name_servers and status are lists
name_servers_list = list(name_servers) if name_servers else None
status_list = list(status) if status else None

# Build the response dictionary
response = {
    "domain": domain,
    "age": {
        "age_in_days": age_in_days,
        "age_in_weeks": age_in_weeks,
        "age_in_months": age_in_months,
        "age_in_years": age_in_years
    },
    "registrar": registrar,
    "creation_date": creation_date_str,
    "updated_date": updated_date_str,
    "expiration_date": expiration_date_str,
    "name_servers": name_servers_list,
    "status": status_list
}

return response

Here’s the explanation:

• strftime(‘%Y-%m-%d’): Formats the dates into readable strings.
• name_servers_list, status_list: Ensures these fields are lists for consistency.
• response: Constructs the final JSON response containing all relevant data.

Error Handling

except Exception as e:
    # Raise an HTTPException with a 400 status code and the error message
    raise HTTPException(status_code=400, detail=str(e))

Here’s the explanation:

• try-except block: Catches any exceptions that occur during the process.
• HTTPException: Returns an HTTP 400 error with the exception message.

Testing the Domain Age Checker API

With the application code ready, it’s time to test the API and see it in action.

Running the Application

Start the FastAPI application using Uvicorn:

uvicorn main:app --reload

• main:app: Specifies the application module and instance.
• –reload: Enables auto-reloading on code changes.

Using Swagger UI

FastAPI automatically generates interactive documentation.

• Access Swagger UI: Navigate to http://127.0.0.1:8000/docs
• Try It Out: Click on the /domain/age endpoint, then “Try it out“.
• Enter Domain: Input a domain name like google.com and click “Execute“.

Sample Requests and Responses

Here’s the sample request and response:

Request

A sample request to the API:

GET /domain/age?domain=google.com
HTTP/1.1 Host: 127.0.0.1:8000

Response

Here’s the full sample response we get:

{
  "domain": "google.com",
  "age": {
    "age_in_days": 9862,
    "age_in_weeks": 1408,
    "age_in_months": 324,
    "age_in_years": 27
  },
  "registrar": "MarkMonitor, Inc.",
  "creation_date": "1997-09-15",
  "updated_date": "2019-09-09",
  "expiration_date": "2028-09-14",
  "status": [
    "clientDeleteProhibited https://icann.org/epp#clientDeleteProhibited",
    "clientTransferProhibited https://icann.org/epp#clientTransferProhibited",
    "clientUpdateProhibited https://icann.org/epp#clientUpdateProhibited",
    "serverDeleteProhibited https://icann.org/epp#serverDeleteProhibited",
    "serverTransferProhibited https://icann.org/epp#serverTransferProhibited",
    "serverUpdateProhibited https://icann.org/epp#serverUpdateProhibited",
    "clientUpdateProhibited (https://www.icann.org/epp#clientUpdateProhibited)",
    "clientTransferProhibited (https://www.icann.org/epp#clientTransferProhibited)",
    "clientDeleteProhibited (https://www.icann.org/epp#clientDeleteProhibited)",
    "serverUpdateProhibited (https://www.icann.org/epp#serverUpdateProhibited)",
    "serverTransferProhibited (https://www.icann.org/epp#serverTransferProhibited)",
    "serverDeleteProhibited (https://www.icann.org/epp#serverDeleteProhibited)"
  ],
  "name_servers": [
    "NS1.GOOGLE.COM",
    "NS2.GOOGLE.COM",
    "NS3.GOOGLE.COM",
    "NS4.GOOGLE.COM",
    "ns4.google.com",
    "ns1.google.com",
    "ns2.google.com",
    "ns3.google.com"
  ]
}

This response provides comprehensive information about the domain, including its age in various units and WHOIS data.

Putting It All Together

Here is the complete Domain Age Checker API Python script using FastAPI:

from fastapi import FastAPI, HTTPException, Query
import whois
from datetime import datetime
from dateutil.relativedelta import relativedelta
import re

app = FastAPI()

@app.get("/domain/age")
def get_domain_age(domain: str = Query(
    ...,
    regex=r"^(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}$",
    description="The domain name to check (e.g., 'example.com')"
)):
    """
    Get WHOIS information and the age of a domain.

    - **domain**: The domain name to check.
    """
    try:
        # Retrieve WHOIS information for the domain
        domain_info = whois.whois(domain)

        # Extract relevant WHOIS fields
        creation_date = domain_info.creation_date
        updated_date = domain_info.updated_date
        expiration_date = domain_info.expiration_date
        registrar = domain_info.registrar
        name_servers = domain_info.name_servers
        status = domain_info.status

        # Handle cases where dates might be lists
        if isinstance(creation_date, list):
            creation_date = creation_date[0]
        if isinstance(updated_date, list):
            updated_date = updated_date[0]
        if isinstance(expiration_date, list):
            expiration_date = expiration_date[0]

        # Check if creation_date was found
        if creation_date is None:
            raise ValueError("Creation date not found for this domain.")

        # Calculate the age of the domain
        now = datetime.now()
        age_delta = relativedelta(now, creation_date)
        age_in_days = (now - creation_date).days
        age_in_weeks = age_in_days // 7
        age_in_months = age_delta.years * 12 + age_delta.months
        age_in_years = age_delta.years

        # Format dates as strings
        creation_date_str = creation_date.strftime('%Y-%m-%d') if creation_date else None
        updated_date_str = updated_date.strftime('%Y-%m-%d') if updated_date else None
        expiration_date_str = expiration_date.strftime('%Y-%m-%d') if expiration_date else None

        # Ensure name_servers and status are lists
        name_servers_list = list(name_servers) if name_servers else None
        status_list = list(status) if status else None

        # Build the response dictionary
        response = {
            "domain": domain,
            "age": {
                "age_in_days": age_in_days,
                "age_in_weeks": age_in_weeks,
                "age_in_months": age_in_months,
                "age_in_years": age_in_years
            },
            "registrar": registrar,
            "creation_date": creation_date_str,
            "updated_date": updated_date_str,
            "expiration_date": expiration_date_str,
            "name_servers": name_servers_list,
            "status": status_list
        }

        return response

    except Exception as e:
        # Raise an HTTPException with a 400 status code and the error message
        raise HTTPException(status_code=400, detail=str(e))

This FastAPI tutorial covers the creation of a fully functional Domain Age Checker API using FastAPI. It explains how to set up the environment, install required packages, write application code, and test the API.

The API retrieves WHOIS information and calculates the domain’s age in days, weeks, months, and years, providing useful data for various applications.

FastAPI offers several benefits for building APIs quickly and efficiently, including ease of use and automatic documentation generation.

The knowledge gained from this tutorial can be applied to expand the API, add new features, or integrate it into larger applications.

Happy Coding!