How to fix Error: NOTFOUND (no answers section) in Node.js

# Check if domain is accessible
curl -I https://example.com

# Or try to ping it
ping example.com

# Check domain registration
whois example.com

# Query A records
dig example.com A

# Query AAAA records (IPv6)
dig example.com AAAA

# Query with a specific DNS server
dig @8.8.8.8 example.com

# Get verbose output showing the answer section
dig +noall +answer example.com

# Check DNS propagation using common DNS checkers
# Visit online tools:
# - https://www.whatsmydns.net/
# - https://dnschecker.org/
# - https://mxtoolbox.com/

# Or use command line
for ns in 8.8.8.8 1.1.1.1 208.67.222.222; do
  echo "Checking $ns:"
  dig @$ns example.com +short
done

# Get authoritative nameservers for the domain
dig example.com NS

# Query the authoritative nameserver directly
dig @ns1.example.com example.com

# List all records for the domain
dig example.com ANY

const dns = require('dns').promises;

async function testAllRecordTypes(hostname) {
  const types = ['A', 'AAAA', 'MX', 'TXT', 'NS', 'SOA'];

  for (const type of types) {
    try {
      const records = await dns.resolveAny(hostname);
      console.log(`✓ ${type}: Found records`);
    } catch (err) {
      console.log(`✗ ${type}: ${err.code}`);
    }
  }
}

testAllRecordTypes('example.com');

const dns = require('dns');

async function resolveWithDifferentServers(hostname) {
  const servers = [
    '8.8.8.8',      // Google
    '1.1.1.1',      // Cloudflare
    '208.67.222.222' // OpenDNS
  ];

  for (const server of servers) {
    dns.setServers([server]);
    try {
      const addresses = await require('dns').promises.resolve4(hostname);
      console.log(`✓ ${server}: ${addresses[0]}`);
      return addresses[0];
    } catch (err) {
      console.log(`✗ ${server}: ${err.code}`);
    }
  }
}

resolveWithDifferentServers('example.com');

# Trace CNAME chain
dig example.com

# If it shows CNAME, trace to the target
dig target.example.com

# Repeat until you reach an A record

// Trace CNAME resolution
const dns = require('dns').promises;

async function traceCNAME(hostname) {
  try {
    const records = await dns.resolveCname(hostname);
    console.log(`CNAME: ${hostname} -> ${records[0]}`);
    return await traceCNAME(records[0]);
  } catch (err) {
    if (err.code === 'ENOTFOUND') {
      console.log(`Final target not found: ${hostname}`);
    } else {
      const addresses = await dns.resolve4(hostname);
      console.log(`A Record: ${hostname} -> ${addresses[0]}`);
    }
  }
}

traceCNAME('example.com');

const https = require('https');

function fetchWithFallback(primaryDomain, fallbackDomain) {
  return new Promise((resolve, reject) => {
    https.get(`https://${primaryDomain}`, (res) => {
      resolve(res);
    }).on('error', (err) => {
      if (err.code === 'NOTFOUND') {
        console.warn(`DNS NOTFOUND for ${primaryDomain}, trying fallback...`);
        https.get(`https://${fallbackDomain}`, (res) => {
          resolve(res);
        }).on('error', reject);
      } else {
        reject(err);
      }
    });
  });
}

fetchWithFallback('old-domain.com', 'new-domain.com')
  .catch(err => console.error('All domains failed:', err.message));