如何用脚本批量检查域名是否可用？

本文目录导读：

1. 方法一：使用Shell脚本（Linux/macOS）
2. 方法二：使用Python脚本（推荐）
3. 方法三：使用Node.js脚本
4. 使用方法
5. 注意事项

要用脚本批量检查域名是否可用，常见的方法是通过DNS解析或WHOIS查询来判断,下面我给你几个不同场景和语言的实现方案。

使用Shell脚本（Linux/macOS）

这是最简单的方法，利用系统自带的 dig 或 nslookup 命令。

#!/bin/bash
# 域名列表文件 (每行一个域名)
DOMAIN_FILE="domains.txt"
# 输出结果文件
AVAILABLE_FILE="available_domains.txt"
UNAVAILABLE_FILE="unavailable_domains.txt"
# 清空结果文件
> "$AVAILABLE_FILE"
> "$UNAVAILABLE_FILE"
# 遍历域名
while read -r domain; do
    # 跳过空行
    [ -z "$domain" ] && continue
    echo "正在检查: $domain"
    # 使用dig查询DNS记录，如果返回状态为NOERROR则表示已注册
    if dig +short "$domain" @8.8.8.8 | grep -q .; then
        echo "$domain" >> "$UNAVAILABLE_FILE"
        echo "  ✗ 不可用 (已注册)"
    else
        # 进一步检查WHOIS确认
        if whois "$domain" 2>/dev/null | grep -qiE "No match|NOT FOUND|Status: free"; then
            echo "$domain" >> "$AVAILABLE_FILE"
            echo "  ✓ 可用"
        else
            echo "$domain" >> "$UNAVAILABLE_FILE"
            echo "  ✗ 不可用 (可能被保留)"
        fi
    fi
    # 避免请求过快被限流
    sleep 0.5
done < "$DOMAIN_FILE"
echo "检查完成！"
echo "可用域名: $(wc -l < "$AVAILABLE_FILE")"
echo "不可用域名: $(wc -l < "$UNAVAILABLE_FILE")"

使用Python脚本（推荐）

Python更灵活，可以并发检查提高速度,且跨平台兼容。

#!/usr/bin/env python3
import socket
import whois
import time
from concurrent.futures import ThreadPoolExecutor, as_completed
import sys
def check_domain_available(domain, timeout=5):
    """
    检查域名是否可用
    返回: (domain, is_available, reason)
    """
    try:
        # 方法1: 检查DNS解析
        socket.setdefaulttimeout(timeout)
        socket.gethostbyname(domain)
        # DNS有解析，说明域名已被注册
        return (domain, False, "DNS已解析")
    except socket.gaierror:
        # DNS无解析，可能是未注册，需要进一步确认
        pass
    except Exception as e:
        return (domain, None, f"DNS查询错误: {str(e)}")
    # 方法2: WHOIS查询 (更准确)
    try:
        w = whois.whois(domain)
        if w.status is None and w.domain_name is None:
            # 无状态且无域名信息，很可能可用
            # 进一步判断
            if "No match for" in str(w.text).upper() or "NOT FOUND" in str(w.text).upper():
                return (domain, True, "WHOIS确认可用")
            return (domain, True, "疑似可用")
        else:
            return (domain, False, f"WHOIS状态: {w.status}")
    except whois.parser.PywhoisError as e:
        # whois查询失败，但通常也是未注册的迹象
        if "No match" in str(e):
            return (domain, True, "WHOIS无匹配")
        return (domain, None, f"WHOIS错误: {str(e)}")
    except Exception as e:
        return (domain, None, f"其他错误: {str(e)}")
def batch_check_domains(domain_list, max_workers=10):
    """批量检查域名，使用线程池提高效率"""
    available = []
    unavailable = []
    uncertain = []
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        # 提交所有任务
        future_to_domain = {
            executor.submit(check_domain_available, domain.strip()): domain.strip()
            for domain in domain_list if domain.strip()
        }
        # 收集结果
        for future in as_completed(future_to_domain):
            domain = future_to_domain[future]
            try:
                domain, is_available, reason = future.result()
                if is_available is True:
                    available.append(domain)
                    print(f"✓ {domain} - 可用 ({reason})")
                elif is_available is False:
                    unavailable.append(domain)
                    print(f"✗ {domain} - 不可用 ({reason})")
                else:
                    uncertain.append(domain)
                    print(f"? {domain} - 不确定 ({reason})")
            except Exception as e:
                uncertain.append(domain)
                print(f"! {domain} - 检查失败: {e}")
            # 加小延迟，避免触发反爬
            time.sleep(0.1)
    return available, unavailable, uncertain
def main():
    # 从文件读取域名列表
    input_file = "domains.txt"
    if len(sys.argv) > 1:
        input_file = sys.argv[1]
    try:
        with open(input_file, 'r') as f:
            domains = [line.strip() for line in f if line.strip()]
    except FileNotFoundError:
        print(f"错误: 文件 '{input_file}' 未找到")
        print("用法: python check_domains.py [域名列表文件]")
        print("     默认读取 domains.txt")
        sys.exit(1)
    print(f"开始检查 {len(domains)} 个域名...")
    print("=" * 50)
    available, unavailable, uncertain = batch_check_domains(domains, max_workers=20)
    print("=" * 50)
    print(f"检查完成!")
    print(f"可用域名: {len(available)}")
    print(f"不可用域名: {len(unavailable)}")
    print(f"不确定: {len(uncertain)}")
    # 保存结果
    with open("available_domains.txt", "w") as f:
        f.write("\n".join(available))
    with open("unavailable_domains.txt", "w") as f:
        f.write("\n".join(unavailable))
    if uncertain:
        with open("uncertain_domains.txt", "w") as f:
            f.write("\n".join(uncertain))
    print(f"\n结果已保存到:")
    print(f"  - available_domains.txt ({len(available)}个)")
    print(f"  - unavailable_domains.txt ({len(unavailable)}个)")
    if uncertain:
        print(f"  - uncertain_domains.txt ({len(uncertain)}个)")
if __name__ == "__main__":
    main()

安装依赖：

pip install python-whois

使用Node.js脚本

const dns = require('dns');
const whois = require('whois-json');
const fs = require('fs');
const { promisify } = require('util');
const readline = require('readline');
const dnsLookup = promisify(dns.lookup);
async function checkDomain(domain) {
    // 先检查DNS
    try {
        await dnsLookup(domain);
        return { domain, available: false, reason: 'DNS已解析' };
    } catch (e) {
        if (e.code !== 'ENOTFOUND') {
            return { domain, available: null, reason: `DNS错误: ${e.code}` };
        }
    }
    // WHOIS查询
    try {
        const result = await whois(domain);
        if (!result.domainName && !result.creationDate) {
            return { domain, available: true, reason: 'WHOIS无记录' };
        }
        return { domain, available: false, reason: '已有WHOIS记录' };
    } catch (e) {
        return { domain, available: null, reason: `WHOIS错误: ${e.message}` };
    }
}
async function main() {
    const args = process.argv.slice(2);
    const inputFile = args[0] || 'domains.txt';
    const domains = fs.readFileSync(inputFile, 'utf8')
        .split('\n')
        .map(d => d.trim())
        .filter(Boolean);
    console.log(`开始检查 ${domains.length} 个域名...`);
    const results = [];
    const concurrency = 10;
    // 分批处理
    for (let i = 0; i < domains.length; i += concurrency) {
        const batch = domains.slice(i, i + concurrency);
        const promises = batch.map(d => checkDomain(d));
        const batchResults = await Promise.all(promises);
        results.push(...batchResults);
        // 输出进度
        batchResults.forEach(r => {
            const icon = r.available ? '✓' : r.available === false ? '✗' : '?';
            console.log(`${icon} ${r.domain} - ${r.reason}`);
        });
    }
    // 分类并保存结果
    const available = results.filter(r => r.available === true).map(r => r.domain);
    const unavailable = results.filter(r => r.available === false).map(r => r.domain);
    const uncertain = results.filter(r => r.available === null).map(r => r.domain);
    fs.writeFileSync('available_domains.txt', available.join('\n'));
    fs.writeFileSync('unavailable_domains.txt', unavailable.join('\n'));
    console.log('\n检查完成!');
    console.log(`可用: ${available.length}`);
    console.log(`不可用: ${unavailable.length}`);
    console.log(`不确定: ${uncertain.length}`);
}
main().catch(console.error);

安装依赖：

npm install whois-json

使用方法

1. 准备域名列表文件 (domains.txt):

   google.com
   myuniquedomain123456.com
   example.org
   yourdomainxyz.net

2. 运行脚本:

   • Shell脚本: chmod +x check_domains.sh && ./check_domains.sh
   • Python脚本: python3 check_domains.py
   • Node.js脚本: node check_domains.js

3. 查看结果:

   • available_domains.txt - 可用的域名
   • unavailable_domains.txt - 不可用的域名

注意事项

1. WHOIS查询限制：WHOIS服务器通常有速率限制，不要并发太高
2. DNS缓存：DNS结果可能有缓存，建议使用公共DNS（如8.8.8.8）
3. 域名状态：有些域名虽然没被注册但被保留或限制注册
4. 隐私保护：很多域名开启了隐私保护，可能影响判断
5. 特殊TLD：某些顶级域（如.cn, .de）有特殊的WHOIS查询方式

如果你只需要检查顶级域名（如.com, .net），可以选择这些脚本中的任意一个，如果需要检查更多特殊域名，建议使用专业的域名注册API（如Namecheap, GoDaddy的API）,这些API更准确且没有速率限制。