Complete Guide to Getting Request Hostname in Node.js Express

Introduction

In web development, obtaining the client's request hostname is a common requirement, particularly when needing to provide differentiated services based on different domains or implementing access control. Node.js Express framework offers multiple solutions for this purpose, with different methods suitable for different scenarios.

Core Method: Getting Hostname Through Request Headers

In Express applications, the most direct and commonly used method to obtain the request hostname is through the request object's headers property. Specifically, request.headers.host can be used to retrieve the complete hostname (including port number) used by the client during the request.

Here is a complete example code:

const express = require('express');
const app = express();

app.get('/', (req, res) => {
    const hostname = req.headers.host;
    console.log('Request hostname:', hostname);
    res.send(`You are accessing host: ${hostname}`);
});

app.listen(3000, () => {
    console.log('Server running on port 3000');
});

When a client accesses http://example.com:3000, req.headers.host will return "example.com:3000". If you need to get only the hostname without the port, you can use string manipulation methods:

const hostnameWithoutPort = req.headers.host.split(':')[0];
console.log('Pure hostname:', hostnameWithoutPort);

Alternative Approach: Using OS Module

Another method to obtain hostname is using Node.js built-in os module:

const os = require('os');
const systemHostname = os.hostname();
console.log('System hostname:', systemHostname);

However, this approach has important limitations:

• os.hostname() returns the server's own hostname, not the hostname used by the client in the request
• In multi-NIC environments, it's impossible to determine which network interface the request came from
• DNS aliases may cause multiple domain names to point to the same server

Practical Application Scenarios Analysis

In real web application development, request.headers.host is typically the most appropriate choice as it directly reflects the client's access intent. Here are some typical application scenarios:

Multi-tenant Applications

In SaaS or multi-tenant systems, customized services can be provided based on different subdomains:

app.use((req, res, next) => {
    const host = req.headers.host;
    const subdomain = host.split('.')[0];
    
    if (subdomain === 'admin') {
        // Handle admin interface
        req.tenant = 'admin';
    } else if (subdomain === 'api') {
        // Handle API requests
        req.tenant = 'api';
    } else {
        // Default tenant handling
        req.tenant = 'default';
    }
    next();
});

Domain Redirection

Ensuring users access the correct domain:

app.use((req, res, next) => {
    const expectedHost = 'www.example.com';
    
    if (req.headers.host !== expectedHost) {
        return res.redirect(301, `https://${expectedHost}${req.url}`);
    }
    next();
});

Security Considerations and Best Practices

When using hostname information, the following security aspects need attention:

• Input Validation: Always validate and sanitize data obtained from request headers
• Proxy Configuration: When running behind reverse proxies, trust proxy settings may need configuration
• DNS Spoofing Protection: Do not rely entirely on hostnames for authentication of sensitive operations

Complete trust proxy configuration example:

app.set('trust proxy', true);

app.get('/client-info', (req, res) => {
    const clientInfo = {
        hostname: req.hostname, // Convenient property provided by Express
        ip: req.ip,
        protocol: req.protocol
    };
    res.json(clientInfo);
});

Performance Optimization Recommendations

When handling high-concurrency requests, hostname resolution can become a performance bottleneck:

• Cache frequently accessed domain name resolution results
• Avoid complex string operations in every request
• Use Express built-in req.hostname property instead of manual parsing

Conclusion

In Node.js Express applications, request.headers.host is the most reliable and direct method for obtaining request hostnames. While the os module provides system-level hostname information, it's generally not the best choice in web request contexts. Developers should choose appropriate methods based on specific requirements and always follow security best practices.

By properly utilizing various hostname-related properties provided by the Express framework, more robust and secure web applications can be built. In practical development, it's recommended to combine specific business scenarios and security requirements to select the most suitable hostname acquisition strategy.