How to fix Error: getaddrinfo ENOTFOUND invalid-hostname.local in Node.js

// ❌ Wrong - includes protocol and port in hostname
const options = {
  hostname: 'https://api.example.com:443',
  path: '/data'
};

// ✅ Correct - only the domain name
const options = {
  hostname: 'api.example.com',
  port: 443,
  path: '/data'
};

// With fetch - use full URL
const response = await fetch('https://api.example.com/data');

const hostname = process.env.API_HOSTNAME;
console.log('Using hostname:', hostname);
console.log('Hostname type:', typeof hostname);
console.log('Hostname length:', hostname?.length);

const dns = require('dns');
const { promisify } = require('util');

const lookup = promisify(dns.lookup);

async function testHostname(hostname) {
  try {
    const result = await lookup(hostname);
    console.log('✓ DNS resolved successfully:');
    console.log('  Hostname:', hostname);
    console.log('  Address:', result.address);
    console.log('  Family:', result.family === 4 ? 'IPv4' : 'IPv6');
  } catch (err) {
    console.error('✗ DNS lookup failed:');
    console.error('  Error code:', err.code);
    console.error('  Hostname:', err.hostname);
    console.error('  Message:', err.message);
  }
}

testHostname('api.example.com');

# Using nslookup
nslookup api.example.com

# Using dig for detailed information
dig api.example.com

# Using host command
host api.example.com

# Test connectivity to the domain
ping api.example.com

# On Windows, use nslookup
nslookup api.example.com

# Test connection to Google DNS
ping 8.8.8.8

# Check your system's configured DNS servers
cat /etc/resolv.conf          # Linux/macOS
ipconfig /all                 # Windows (look for DNS Servers)

# Try to resolve a known working domain
nslookup google.com

# View current hosts file
cat /etc/hosts

# Edit hosts file (requires sudo)
sudo nano /etc/hosts

# Ensure these entries exist:
127.0.0.1       localhost
::1             localhost

# For custom domains, add entries like:
127.0.0.1       api.local
127.0.0.1       db.local

# File location: C:\Windows\System32\drivers\etc\hosts
# Open as Administrator:
127.0.0.1       localhost
::1             localhost

# macOS
sudo dscacheutil -flushcache
sudo killall -HUP mDNSResponder

# Linux (systemd)
sudo systemd-resolve --flush-caches

# Windows (run as Administrator)
ipconfig /flushdns

const dns = require('dns');
const { Resolver } = dns;

// Create a custom resolver with public DNS servers
const resolver = new Resolver();
resolver.setServers([
  '8.8.8.8',       // Google DNS
  '8.8.4.4',       // Google DNS (backup)
  '1.1.1.1',       // Cloudflare DNS
  '1.0.0.1'        // Cloudflare DNS (backup)
]);

// Now use this resolver for DNS lookups
const { promisify } = require('util');
const resolve4 = promisify(resolver.resolve4.bind(resolver));

async function lookupWithCustomDNS(hostname) {
  try {
    const addresses = await resolve4(hostname);
    console.log('Resolved to:', addresses[0]);
  } catch (err) {
    console.error('Failed to resolve:', err.message);
  }
}

lookupWithCustomDNS('api.example.com');

sudo networksetup -setdnsservers Wi-Fi 8.8.8.8 8.8.4.4

sudo nano /etc/systemd/resolved.conf
# Add: DNS=8.8.8.8 1.1.1.1
sudo systemctl restart systemd-resolved

const https = require('https');
const axios = require('axios');

// Example 1: Using native HTTP module
function makeRequest(hostname, path) {
  const options = {
    hostname: hostname,
    port: 443,
    path: path,
    method: 'GET'
  };

  const req = https.request(options, (res) => {
    console.log('Status:', res.statusCode);
  });

  req.on('error', (err) => {
    if (err.code === 'ENOTFOUND') {
      console.error('DNS lookup failed!');
      console.error('Hostname:', err.hostname);
      console.error('Check hostname spelling and DNS configuration');
      // Implement retry logic or fallback
    } else if (err.code === 'ECONNREFUSED') {
      console.error('Connection refused - service may be down');
    } else if (err.code === 'ETIMEDOUT') {
      console.error('Request timed out');
    } else {
      console.error('Request error:', err.message);
    }
  });

  req.end();
}

// Example 2: Using axios
async function makeRequestWithAxios(url) {
  try {
    const response = await axios.get(url);
    console.log('Success:', response.status);
  } catch (err) {
    if (err.code === 'ENOTFOUND') {
      console.error('DNS failed for:', err.hostname);
      // Retry with different hostname or use fallback
    } else {
      console.error('Error:', err.message);
    }
  }
}

// Example 3: Using fetch (Node.js 18+)
async function makeRequestWithFetch(url) {
  try {
    const response = await fetch(url);
    console.log('Success:', response.status);
  } catch (err) {
    if (err.code === 'ENOTFOUND') {
      console.error('Hostname not found:', err.hostname);
    } else {
      console.error('Request failed:', err.message);
    }
  }
}

const dns = require('dns');
const { promisify } = require('util');

// Simple DNS cache implementation
class DNSCache {
  constructor(ttl = 300000) { // 5 minutes default
    this.cache = new Map();
    this.ttl = ttl;
  }

  async lookup(hostname) {
    // Check if cached and not expired
    if (this.cache.has(hostname)) {
      const entry = this.cache.get(hostname);
      if (Date.now() < entry.expiry) {
        console.log('DNS cache hit for:', hostname);
        return entry.address;
      }
      this.cache.delete(hostname);
    }

    // Perform actual DNS lookup
    const lookup = promisify(dns.lookup);
    try {
      const result = await lookup(hostname);
      const address = result.address;

      // Cache the result
      this.cache.set(hostname, {
        address,
        expiry: Date.now() + this.ttl
      });

      console.log('DNS cache miss, resolved:', hostname, 'to', address);
      return address;
    } catch (err) {
      console.error('DNS lookup failed for:', hostname);
      throw err;
    }
  }
}

// Usage
const dnsCache = new DNSCache(300000); // 5 minute TTL

async function testCaching() {
  try {
    const ip1 = await dnsCache.lookup('api.example.com');
    console.log('First lookup:', ip1);

    const ip2 = await dnsCache.lookup('api.example.com');
    console.log('Second lookup (cached):', ip2);
  } catch (err) {
    console.error('Error:', err.message);
  }
}

testCaching();

const https = require('https');
const axios = require('axios');

// Create agent with keep-alive
const httpsAgent = new https.Agent({
  keepAlive: true,
  keepAliveMsecs: 10000,
  maxSockets: 50
});

// Use with axios
const client = axios.create({
  httpsAgent,
  timeout: 5000
});

// Use with fetch (Node.js 18+)
const response = await fetch('https://api.example.com/data', {
  agent: httpsAgent
});