This post was created originally on my website.
Have you ever wondered how you find any domain name information? I think you did! and it's pretty easy to google it in seconds to find a bunch of websites that offer domain name information, but in this article, we're going to create our own NodeJs and ExpressJs API that will return us the info of any given domain name.
The structure of our API will have an apiController
that has a getDomainInfo
method, an apiRoute
, and the entry point of our API which is server.js
--This is just how I like to organize my code, otherwise, you can write all the logic in one file, but I don't recommend it:)
Sound exciting enough? so Let's get right into it!
The project folder structure:
domain_checker_api/
|- node_modules/
|- .env
|- routes/
| |- apiRoute.js
|- controllers/
| |- apiController.js
|- package.json
|- package-lock.json
|- server.js
If you want to follow up make sure to have NodeJs installed on your machine, or you can install it from here.
So the first step is to install some dependencies express
, dotenv
and whois-json
In your terminal run:
npm install express whois-json dotenv
In our server.js
file let's set up our Express server:
First, we require express module and create an express app instance using the express( )
function, and define the port that our server will listen to.
const express=require("express")
const app=express()
const PORT = process.env.PORT || 3000;
The port will be in a separate file and we access it by process.env.PORT.
PORT=8080
Set up the route for the request that starts with"/api/v1/domain"
.
we use app.use()
to mount the router that will be defined in"./routes/apiRoute"
The apiRoute
file will be created later on.
app.use("/api/v1/domain",require("./routes/apiRoute"))
Start the server and listen to any incoming requests on the specified port.
app.listen(PORT,()=>console.log(`Server is Running on the Port ${PORT}`))
The server.js
should look something like this:
const express=require("express")
const app=express()
const PORT=8080
app.use("/api/v1/domain",require("./routes/apiRoute"))
app.listen(PORT,()=>console.log(`Server is Running on the Port ${PORT}`))
Now our server is up and running, let’s create apiController.js
file that has a getDomainInfo method that will retrieve the domain info.
first thing first let’s require the necessary modules;
dns
is a built-in NodeJs module that resolves domain names to IP addresses and the whois-json
is a third-party library that allows us to retrieve WHOIS information in JSON format.
const dns = require("dns");
const whois = require("whois-json");
We define a method called getDomainInfo
that takes as a parameter req
and res
objects
then we extract the domain from the request parameters and store it in the domain
variable.
we use dns.lookup
method to resolve the domain into an IP address.
If there is an error we return the 400 status code with the error message as JSON.
var data;
const getDomainInfo = async (req, res) => {
const domain = req.params.domain;
dns.lookup(domain, (err, address) => {
if (err) {
res.status(400).json({
error: err.message,
});
}
data = { domain, address };
});
If everything went okay we store the domain and the ip address in the data
variable.
Now that we have the IP address we can use the whois-json
module to retrieve additional information about the domain.
const results = await whois(`${domain}`);
and return the info as a JSON object like follow:
res.status(200).json({
domain: data.domain,
registrarUrl: results.registrarUrl,
nameServer: results.nameServer,
creationDate: results.creationDate,
updatedDate: results.updatedDate,
expirationDate: results.registrarRegistrationExpirationDate,
registrantName: results.registrantName,
registrantCountry: results.registrantCountry,
adminName: results.adminName,
adminPhone: results.adminPhone,
});
};
defining a welcome
method that returns a JSON welcome message to the user.
const welcome = (req, res) => {
res.status(200).json({
message:
"Welcome to the domain name API checker, hit the endpoint /api/v1/domain/ and type your domain name without https:// to get the domain info.",
});
};
Finally, we export the getDomainInfo
and the welcome
methods so that we can use them in the router.
module.exports = {
getDomainInfo,
welcome
};
the apiController.js
file should look like this:
const dns = require("dns");
const whois = require("whois-json");
var data;
const getDomainInfo = async (req, res) => {
const domain = req.params.domain;
dns.lookup(domain, (err, address) => {
if (err) {
res.status(400).json({
error: err.message,
});
}
data = { domain, address };
});
// whois domain info
const results = await whois(`${domain}`);
res.status(200).json({
domain: data.domain,
ip: data.address,
registrarUrl: results.registrarUrl,
nameServer: results.nameServer,
creationDate: results.creationDate,
updatedDate: results.updatedDate,
expirationDate: results.registrarRegistrationExpirationDate,
registrantName: results.registrantName,
registrantCountry: results.registrantCountry,
adminName: results.adminName,
adminPhone: results.adminPhone,
});
};
module.exports = {
getDomainInfo,
welcome
};
Now let’s work on the route.
In theapiRoute.js
file we require getDomainInfo
from apiController
file, express and create a router
instance using express.Router()
method.
const express = require("express");
const { getDomainInfo } = require("../controllers/apiController");
const router = express.Router();
Set up a GET route for the endpoint "/api/v1/domain/:domain"
. When a GET request is made to this endpoint the router will call the getDomainInfo
passing in the domain parameter from the request URL.
router.get("/api/v1/domain/:domain", getDomainInfo);
the root of the API is a welcome message when a request is made to the root “/”
the welcome method gets called.
router.get("/", welcome);
The apiRoute.js
file should look something like this:
const express = require("express");
const { getDomainInfo, welcome } = require("../controllers/apiController");
const router = express.Router();
router.get("/api/v1/domain/:domain", getDomainInfo);
router.get("/", welcome);
module.exports = router;
to test our API we run:
node server
and go to our browser and type:http://localhost:8080
you should see something like this.
Let’s say that we want to get information about my domain name yassinebenkhay.com
we hit the endpoint :http://localhost:8080/api/v1/domain/yassinebenkhay.com
and we should see the information below:
The final step is to deploy this API to a hosting service, I think the easiest way to do so is with Heroku, so let’s go with that.
In your Heroku account create a new app like this:
now we need to push the project from our local machine to GitHub.
in your GitHub account create a new repo and push the project to it.
Don’t remove node_modules when you upload the project to the repo, otherwise, the API won’t work once we link the repo with Heroku.
Also, you need to add the node js version in your package.json file in order for Heroku to download it.
...
"engines": {
"node": "v16.x"
}
now go to Heroku and like the repo, with the app, we have just created.
After the repo and the app are linked click deploy as shown below:
Wait for the process to finish, If everything went well you will have your API link just like this:
https://domain-name-checker-api.herokuapp.com/
I hope that this Tutorial was helpful, if you have any suggestions please consider dropping them in the comments section below.
Top comments (0)