Pricing

Pay per usage

Supernet DNS Lookup

Bulk DNS records lookup. Query MX, SPF, DMARC, DKIM, TXT, CNAME, A, AAAA, NS, SOA and reverse DNS for any domain or IP. Batch thousands or query one instantly using the Standby API. For email reputation scoring, see Supernet Domain Health. For whois, see Supernet Whois.

Pricing

Pay per usage

Rating

0.0

(0)

Developer

Superlative

Actor stats

Bookmarked

114

Total users

Monthly active users

19 days ago

Last modified

.gitignore

# This file tells Git which files shouldn't be added to source control
.DS_Store
.idea
dist
node_modules
apify_storage
storage/*
!storage/key_value_stores
storage/key_value_stores/*
!storage/key_value_stores/default
storage/key_value_stores/default/*
!storage/key_value_stores/default/INPUT.json

.apifyignore

tests/
node_modules/
.claude/
storage/
apify_storage/
.env

package.json

{
    "name": "dns-lookup",
    "version": "1.2.0",
    "type": "module",
    "description": "Utility Apify actor to retrieve DNS records (A, AAAA, MX, CNAME, TXT, NS, SOA) for domains, with optional filtering by DNS record type and support for reverse DNS lookups (IP to hostname).",
    "engines": {
        "node": ">=20.0.0"
    },
    "dependencies": {
        "apify": "^3.1.10",
        "dns2": "^2.1.0"
    },
    "scripts": {
        "start": "node ./src/main.js",
        "test": "node ./test/test.js"
    },
    "author": "Superlative",
    "license": "ISC"
}

.actorignore

tests/
test/
node_modules/
.claude/
storage/
apify_storage/
.env
scripts/

.actor/Dockerfile

FROM apify/actor-node:20

COPY package*.json ./

RUN npm --quiet set progress=false \
    && npm install --omit=dev --omit=optional \
    && echo "Installed NPM packages:" \
    && (npm list --omit=dev --all || true) \
    && echo "Node.js version:" \
    && node --version \
    && echo "NPM version:" \
    && npm --version \
    && rm -r ~/.npm

COPY . ./

CMD npm start --silent

.actor/dataset_schema.json

{
    "actorSpecification": 1,
    "title": "DNS Lookup Results",
    "description": "DNS records retrieved for each domain or reverse DNS results for IP addresses",
    "fields": {
        "domain": {
            "title": "Domain",
            "type": "string",
            "description": "The domain name or IP address that was queried"
        },
        "dnsRecords": {
            "title": "DNS Records",
            "type": "array",
            "description": "Array of DNS records found for the domain"
        },
        "status": {
            "title": "Status",
            "type": "string",
            "description": "Query status: Success or Error"
        }
    },
    "views": {
        "overview": {
            "title": "DNS Records",
            "transformation": {
                "fields": [
                    "domain",
                    "dnsRecords",
                    "status"
                ]
            },
            "display": {
                "component": "table",
                "properties": {
                    "domain": {
                        "label": "Domain",
                        "format": "text"
                    },
                    "dnsRecords": {
                        "label": "DNS Records",
                        "format": "array"
                    },
                    "status": {
                        "label": "Status",
                        "format": "text"
                    }
                }
            }
        }
    }
}

.actor/web_server_openapi.json

{
    "openapi": "3.0.3",
    "info": {
        "title": "DNS Lookup — Standby API",
        "description": "Instant DNS record lookups via HTTP GET. Supports forward lookups (A, AAAA, CNAME, MX, TXT, NS, SOA, DMARC) and reverse lookups (PTR). Returns results in the same format as batch mode.",
        "version": "1.2.0"
    },
    "paths": {
        "/": {
            "get": {
                "summary": "Look up DNS records",
                "description": "Perform a forward DNS lookup for a domain or a reverse lookup for an IP address. Provide either `domain` or `ip`, not both.",
                "operationId": "dnsLookup",
                "parameters": [
                    {
                        "name": "domain",
                        "in": "query",
                        "description": "Domain name to look up (e.g. `apify.com`). Required unless `ip` is provided.",
                        "required": false,
                        "schema": {
                            "type": "string",
                            "example": "apify.com"
                        }
                    },
                    {
                        "name": "ip",
                        "in": "query",
                        "description": "IP address for reverse (PTR) lookup (e.g. `8.8.8.8`). Required unless `domain` is provided.",
                        "required": false,
                        "schema": {
                            "type": "string",
                            "example": "8.8.8.8"
                        }
                    },
                    {
                        "name": "type",
                        "in": "query",
                        "description": "Comma-separated DNS record types to retrieve. Defaults to all types. Ignored for reverse lookups.",
                        "required": false,
                        "schema": {
                            "type": "string",
                            "enum": ["A", "AAAA", "CNAME", "MX", "TXT", "NS", "SOA", "DMARC"],
                            "example": "MX,TXT"
                        }
                    }
                ],
                "responses": {
                    "200": {
                        "description": "DNS lookup result. Status is `Success`, `No records`, or `Error`.",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/DnsResult"
                                },
                                "examples": {
                                    "forward": {
                                        "summary": "Forward lookup",
                                        "value": {
                                            "domain": "apify.com",
                                            "dnsRecords": [
                                                { "type": "A", "ttl": 60, "address": "3.170.42.68" },
                                                { "type": "MX", "ttl": 21600, "exchange": "aspmx.l.google.com", "priority": 1 }
                                            ],
                                            "status": "Success"
                                        }
                                    },
                                    "reverse": {
                                        "summary": "Reverse lookup",
                                        "value": {
                                            "domain": "8.8.8.8",
                                            "dnsRecords": [
                                                { "type": "PTR", "hostname": "dns.google" }
                                            ],
                                            "status": "Success"
                                        }
                                    }
                                }
                            }
                        }
                    },
                    "400": {
                        "description": "Invalid request — missing parameters, both domain and ip provided, invalid domain/IP, or invalid record type.",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/Error"
                                },
                                "example": {
                                    "error": "Provide either a 'domain' or 'ip' query parameter."
                                }
                            }
                        }
                    },
                    "405": {
                        "description": "Method not allowed — only GET is supported.",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/Error"
                                },
                                "example": {
                                    "error": "Method not allowed. Use GET."
                                }
                            }
                        }
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "DnsResult": {
                "type": "object",
                "required": ["domain", "dnsRecords", "status"],
                "properties": {
                    "domain": {
                        "type": "string",
                        "description": "The queried domain name or IP address."
                    },
                    "dnsRecords": {
                        "type": "array",
                        "description": "Array of DNS records found.",
                        "items": {
                            "$ref": "#/components/schemas/DnsRecord"
                        }
                    },
                    "status": {
                        "type": "string",
                        "description": "Result status.",
                        "enum": ["Success", "No records", "Error"]
                    }
                }
            },
            "DnsRecord": {
                "type": "object",
                "required": ["type"],
                "description": "A single DNS record. Fields vary by record type.",
                "properties": {
                    "type": {
                        "type": "string",
                        "description": "DNS record type.",
                        "enum": ["A", "AAAA", "CNAME", "MX", "TXT", "NS", "SOA", "DMARC", "PTR"]
                    },
                    "ttl": {
                        "type": "integer",
                        "description": "Time to live in seconds."
                    },
                    "address": {
                        "type": "string",
                        "description": "IP address (A/AAAA records)."
                    },
                    "exchange": {
                        "type": "string",
                        "description": "Mail server hostname (MX records)."
                    },
                    "priority": {
                        "type": "integer",
                        "description": "Mail server priority (MX records)."
                    },
                    "domain": {
                        "type": "string",
                        "description": "Canonical name target (CNAME records)."
                    },
                    "ns": {
                        "type": "string",
                        "description": "Name server hostname (NS records)."
                    },
                    "data": {
                        "type": "string",
                        "description": "Text content (TXT/DMARC records)."
                    },
                    "hostname": {
                        "type": "string",
                        "description": "Resolved hostname (PTR records)."
                    },
                    "primary": {
                        "type": "string",
                        "description": "Primary name server (SOA records)."
                    },
                    "admin": {
                        "type": "string",
                        "description": "Admin email (SOA records)."
                    },
                    "serial": {
                        "type": "integer",
                        "description": "Zone serial number (SOA records)."
                    },
                    "refresh": {
                        "type": "integer",
                        "description": "Refresh interval in seconds (SOA records)."
                    },
                    "retry": {
                        "type": "integer",
                        "description": "Retry interval in seconds (SOA records)."
                    },
                    "expiration": {
                        "type": "integer",
                        "description": "Expiration time in seconds (SOA records)."
                    },
                    "minimum": {
                        "type": "integer",
                        "description": "Minimum TTL in seconds (SOA records)."
                    }
                }
            },
            "Error": {
                "type": "object",
                "required": ["error"],
                "properties": {
                    "error": {
                        "type": "string",
                        "description": "Human-readable error message."
                    }
                }
            }
        }
    }
}

.actor/output_schema.json

{
    "actorOutputSchemaVersion": 1,
    "title": "DNS Lookup Output",
    "description": "Each result contains the queried domain or IP, an array of DNS records with type-specific fields (address, exchange, hostname, etc.), TTL values, and a status indicator. Forward lookups return A, AAAA, MX, CNAME, TXT, DMARC, NS, and SOA records. Reverse lookups return PTR records.",
    "type": "object",
    "properties": {
        "results": {
            "type": "string",
            "title": "DNS Records",
            "template": "{{links.apiDefaultDatasetUrl}}/items?view=overview"
        }
    }
}

.actor/input_schema.json

{
    "title": "DNS Lookup Actor Input",
    "type": "object",
    "schemaVersion": 1,
    "properties": {
        "domains": {
            "title": "Domains or IP addresses",
            "type": "array",
            "description": "Domain names (without protocol prefixes like https://) for standard DNS lookup or IP addresses for reverse DNS lookup.",
            "editor": "stringList",
            "prefill": ["apify.com"]
        },
        "dnsRecordTypes": {
            "title": "DNS Record Types",
            "type": "array",
            "description": "Specific DNS record types to retrieve (e.g., A, MX, TXT). Ignored for reverse DNS lookups.",
            "editor": "stringList",
            "prefill": ["A", "AAAA", "MX", "TXT", "NS", "SOA", "CNAME"]
        },
        "reverseLookup": {
            "title": "Reverse DNS Lookup",
            "type": "boolean",
            "description": "Set to true to perform reverse DNS lookups (IP to hostname). Domains array must contain valid IP addresses if enabled.",
            "default": false
        }
    },
    "required": ["domains"]
}

.actor/actor.json

{
    "actorSpecification": 1,
    "name": "dns-lookup",
    "title": "Supernet DNS Lookup",
    "description": "Look up DNS records for any domain. MX, SPF, DMARC, TXT, A, AAAA, CNAME, NS, SOA, PTR. Input: domain array. Output: structured records per type. Batch or instant API.",
    "version": "1.2",
    "buildTag": "latest",
    "usesStandbyMode": true,
    "webServerSchema": "./web_server_openapi.json",
    "input": "./input_schema.json",
    "dockerfile": "./Dockerfile",
    "output": "./output_schema.json",
    "storages": {
        "dataset": "./dataset_schema.json"
    },
    "defaultRunOptions": {
        "build": "latest",
        "memoryMbytes": 128,
        "timeoutSecs": 360
    },
    "minMemoryMbytes": 128,
    "maxMemoryMbytes": 512
}

src/dns-utils.js

1import dns2 from 'dns2';
2import net from 'node:net';
3import { promises as nodeDns } from 'node:dns';
4
5const { UDPClient } = dns2;
6
7// Validation helpers
8export const isValidDomain = (domain) => /^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(domain);
9export const isValidIP = (ip) => net.isIP(ip) !== 0;
10
11// Record types
12export const ALL_RECORD_TYPES = ['A', 'AAAA', 'CNAME', 'MX', 'TXT', 'NS', 'SOA'];
13export const VALID_RECORD_TYPES = [...ALL_RECORD_TYPES, 'DMARC'];
14
15// Numeric-to-string type mapping
16export const TYPE_MAP = {
17    1: 'A',
18    2: 'NS',
19    5: 'CNAME',
20    6: 'SOA',
21    15: 'MX',
22    16: 'TXT',
23    28: 'AAAA',
24    DMARC: 'DMARC',
25};
26
27// DNS query timeout (ms) — 5s is generous; most DNS responses arrive in <200ms
28const DNS_TIMEOUT_MS = 5000;
29
30function withTimeout(promise, ms = DNS_TIMEOUT_MS) {
31    let timer;
32    return Promise.race([
33        promise,
34        new Promise((_, reject) => {
35            timer = setTimeout(() => reject(new Error('DNS query timeout')), ms);
36        }),
37    ]).finally(() => clearTimeout(timer));
38}
39
40// Lazy singleton DNS client
41let dnsClient = null;
42export function getDnsClient() {
43    if (!dnsClient) {
44        dnsClient = UDPClient({ dns: '8.8.8.8' });
45    }
46    return dnsClient;
47}
48
49/**
50 * Forward DNS lookup for a single domain.
51 * Returns { domain, dnsRecords, status }.
52 */
53export async function forwardLookup(domain, recordTypes) {
54    const dns = getDnsClient();
55    const typesToQuery = Array.isArray(recordTypes) && recordTypes.length > 0
56        ? recordTypes
57        : ALL_RECORD_TYPES;
58
59    const dnsRecordsFlat = [];
60    let hadError = false;
61
62    // Query all record types in parallel with timeout protection
63    const queryResults = await Promise.allSettled(
64        typesToQuery.map(async (type) => {
65            let queryDomain = domain;
66            let queryType = type;
67
68            if (type === 'DMARC') {
69                queryDomain = `_dmarc.${domain}`;
70                queryType = 'TXT';
71            }
72
73            const response = await withTimeout(dns(queryDomain, queryType));
74            return { type, response };
75        }),
76    );
77
78    for (const result of queryResults) {
79        if (result.status === 'rejected') {
80            console.warn(`Error retrieving records for ${domain}: ${result.reason?.message}`);
81            hadError = true;
82            continue;
83        }
84
85        const { type, response } = result.value;
86        if (!response.answers?.length) continue;
87
88        dnsRecordsFlat.push(...response.answers.map((record) => {
89            const recordType = type === 'DMARC' ? 'DMARC' : (TYPE_MAP[record.type] || record.type);
90            const simplifiedRecord = { type: recordType, ttl: record.ttl };
91
92            if (type === 'DMARC' || recordType === 'TXT') {
93                if (Array.isArray(record.data)) {
94                    simplifiedRecord.data = record.data.join('');
95                } else if (typeof record.data === 'string') {
96                    simplifiedRecord.data = record.data;
97                } else {
98                    simplifiedRecord.data = JSON.stringify(record.data);
99                }
100            } else {
101                switch (recordType) {
102                    case 'A':
103                    case 'AAAA':
104                        simplifiedRecord.address = record.address;
105                        break;
106                    case 'MX':
107                        simplifiedRecord.exchange = record.exchange;
108                        simplifiedRecord.priority = record.priority;
109                        break;
110                    case 'CNAME':
111                        simplifiedRecord.domain = record.domain;
112                        break;
113                    case 'NS':
114                        simplifiedRecord.ns = record.ns;
115                        break;
116                    case 'SOA':
117                        simplifiedRecord.primary = record.primary;
118                        simplifiedRecord.admin = record.admin;
119                        simplifiedRecord.serial = record.serial;
120                        simplifiedRecord.refresh = record.refresh;
121                        simplifiedRecord.retry = record.retry;
122                        simplifiedRecord.expiration = record.expiration;
123                        simplifiedRecord.minimum = record.minimum;
124                        break;
125                    default:
126                        Object.assign(simplifiedRecord, record);
127                }
128            }
129
130            return simplifiedRecord;
131        }));
132    }
133
134    // Deduplicate records (e.g. CNAME appears in answers for every query type)
135    const seen = new Set();
136    const uniqueRecords = dnsRecordsFlat.filter((record) => {
137        const value = record.address || record.domain || record.ns || record.exchange || record.data || record.primary || '';
138        const key = `${record.type}:${value}`;
139        if (seen.has(key)) return false;
140        seen.add(key);
141        return true;
142    });
143
144    let status = 'Success';
145    if (uniqueRecords.length === 0) {
146        status = hadError ? 'Error' : 'No records';
147    }
148
149    return { domain, dnsRecords: uniqueRecords, status };
150}
151
152/**
153 * Reverse DNS lookup for a single IP address.
154 * Returns { domain, dnsRecords, status }.
155 */
156export async function reverseLookup(ip) {
157    try {
158        const hostnames = await withTimeout(nodeDns.reverse(ip));
159        return {
160            domain: ip,
161            dnsRecords: hostnames.map((hostname) => ({
162                type: 'PTR',
163                hostname,
164            })),
165            status: 'Success',
166        };
167    } catch {
168        return {
169            domain: ip,
170            dnsRecords: [],
171            status: 'No records',
172        };
173    }
174}

src/main.js

1import http from 'node:http';
2import { Actor } from 'apify';
3import {
4    isValidDomain,
5    isValidIP,
6    VALID_RECORD_TYPES,
7    forwardLookup,
8    reverseLookup,
9} from './dns-utils.js';
10
11await Actor.init();
12
13if (Actor.config.get('metaOrigin') === 'STANDBY') {
14    startStandbyServer();
15} else {
16    await runBatchMode();
17    await Actor.exit();
18}
19
20// ---------------------------------------------------------------------------
21// Standby mode — HTTP server for instant single-domain lookups
22// ---------------------------------------------------------------------------
23
24function startStandbyServer() {
25    const port = Actor.config.get('containerPort');
26
27    const server = http.createServer(async (req, res) => {
28        // Readiness probe
29        if (req.headers['x-apify-container-server-readiness-probe']) {
30            res.writeHead(200, { 'Content-Type': 'application/json' });
31            res.end(JSON.stringify({ status: 'ready' }));
32            return;
33        }
34
35        // GET only
36        if (req.method !== 'GET') {
37            res.writeHead(405, { 'Content-Type': 'application/json' });
38            res.end(JSON.stringify({ error: 'Method not allowed. Use GET.' }));
39            return;
40        }
41
42        // No query params → serve landing page
43        const reqUrl = new URL(req.url, `http://${req.headers.host}`);
44        if (!reqUrl.searchParams.get('domain') && !reqUrl.searchParams.get('ip')) {
45            res.writeHead(200, { 'Content-Type': 'text/html' });
46            res.end(getLandingPageHtml());
47            return;
48        }
49
50        try {
51            const result = await handleStandbyRequest(req);
52            await Actor.pushData(result);
53
54            res.writeHead(200, { 'Content-Type': 'application/json' });
55            res.end(JSON.stringify(result));
56        } catch (err) {
57            const statusCode = err.statusCode || 500;
58            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
59            res.end(JSON.stringify({ error: err.message }));
60        }
61    });
62
63    server.listen(port, () => {
64        console.log(`Supernet DNS Lookup Standby server listening on port ${port}`);
65    });
66}
67
68async function handleStandbyRequest(req) {
69    const url = new URL(req.url, `http://${req.headers.host}`);
70    const domain = url.searchParams.get('domain');
71    const ip = url.searchParams.get('ip');
72    const typeParam = url.searchParams.get('type');
73
74    // Must provide domain or ip, not both, not neither
75    if (!domain && !ip) {
76        const err = new Error("Provide either a 'domain' or 'ip' query parameter.");
77        err.statusCode = 400;
78        throw err;
79    }
80    if (domain && ip) {
81        const err = new Error("Provide either 'domain' or 'ip', not both.");
82        err.statusCode = 400;
83        throw err;
84    }
85
86    // Reverse lookup
87    if (ip) {
88        if (!isValidIP(ip)) {
89            const err = new Error(`Invalid IP address: ${ip}`);
90            err.statusCode = 400;
91            throw err;
92        }
93        return reverseLookup(ip);
94    }
95
96    // Forward lookup
97    if (!isValidDomain(domain)) {
98        const err = new Error(`Invalid domain: ${domain}`);
99        err.statusCode = 400;
100        throw err;
101    }
102
103    let recordTypes = null;
104    if (typeParam) {
105        recordTypes = typeParam.split(',').map((t) => t.trim().toUpperCase());
106        const invalid = recordTypes.filter((t) => !VALID_RECORD_TYPES.includes(t));
107        if (invalid.length > 0) {
108            const err = new Error(`Invalid record type(s): ${invalid.join(', ')}. Valid types: ${VALID_RECORD_TYPES.join(', ')}`);
109            err.statusCode = 400;
110            throw err;
111        }
112    }
113
114    return forwardLookup(domain, recordTypes);
115}
116
117// ---------------------------------------------------------------------------
118// Batch mode — existing pipeline for standard Actor runs
119// ---------------------------------------------------------------------------
120
121async function runBatchMode() {
122    const input = await Actor.getInput();
123    const { domains, dnsRecordTypes, reverseLookup: isReverse } = input;
124
125    if (!domains || !Array.isArray(domains) || domains.length === 0) {
126        await Actor.pushData({ error: 'missing_domains', message: 'Provide a non-empty array of domains or IP addresses.' });
127        await Actor.exit('Skipped: Provide a non-empty array of domains or IP addresses.');
128        return;
129    }
130
131    const allDomains = domains.every(isValidDomain);
132    const allIPs = domains.every(isValidIP);
133
134    if (!allDomains && !allIPs) {
135        await Actor.pushData({ error: 'mixed_input', message: 'Mixed inputs detected. Provide either all valid domain names or all valid IP addresses.' });
136        await Actor.exit('Skipped: Mixed inputs detected. Provide either all valid domain names or all valid IP addresses.');
137        return;
138    }
139
140    if (isReverse && !allIPs) {
141        await Actor.pushData({ error: 'invalid_ips', message: 'For reverse lookups, provide only valid IP addresses.' });
142        await Actor.exit('Skipped: For reverse lookups, provide only valid IP addresses.');
143        return;
144    }
145
146    if (!isReverse && !allDomains) {
147        await Actor.pushData({ error: 'invalid_domains', message: 'For standard DNS lookups, provide only valid domain names.' });
148        await Actor.exit('Skipped: For standard DNS lookups, provide only valid domain names.');
149        return;
150    }
151
152    const typesToQuery = !isReverse && Array.isArray(dnsRecordTypes) && dnsRecordTypes.length > 0
153        ? dnsRecordTypes
154        : null;
155
156    // Process domains with controlled concurrency
157    const concurrency = 10;
158    for (let i = 0; i < domains.length; i += concurrency) {
159        const batch = domains.slice(i, i + concurrency);
160        const batchResults = await Promise.allSettled(
161            batch.map((entry) =>
162                isReverse ? reverseLookup(entry) : forwardLookup(entry, typesToQuery),
163            ),
164        );
165
166        const results = [];
167        for (const r of batchResults) {
168            if (r.status === 'fulfilled') {
169                results.push(r.value);
170            } else {
171                console.error(`DNS lookup failed: ${r.reason?.message}`);
172            }
173        }
174
175        if (results.length > 0) {
176            await Actor.pushData(results);
177        }
178
179        console.log(`Processed ${Math.min(i + concurrency, domains.length)}/${domains.length} entries`);
180
181    }
182}
183
184// ---------------------------------------------------------------------------
185// Landing page HTML for Standby mode
186// ---------------------------------------------------------------------------
187
188function getLandingPageHtml() {
189    return `<!DOCTYPE html>
190<html lang="en">
191<head>
192<meta charset="utf-8">
193<meta name="viewport" content="width=device-width, initial-scale=1">
194<title>Supernet DNS Lookup — Superlative</title>
195<link rel="preconnect" href="https://fonts.googleapis.com">
196<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
197<link href="https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;700&family=Space+Mono:wght@400;700&display=swap" rel="stylesheet">
198<style>
199:root{--color-bg:#0a0e14;--color-surface:#12171f;--color-border:#1e2632;--color-text:#e8eaed;--color-text-muted:#8b95a5;--color-accent:#4ade80;--color-accent-dim:rgba(74,222,128,0.15);--font-display:'Space Mono',monospace;--font-body:'DM Sans',sans-serif}
200*{margin:0;padding:0;box-sizing:border-box}
201body{font-family:var(--font-body);background:var(--color-bg);color:var(--color-text);line-height:1.6;min-height:100vh;overflow-x:hidden}
202a{color:var(--color-accent);text-decoration:none;transition:color .2s ease}
203a:hover{color:#6ee7a0}
204.grid-bg{position:fixed;top:0;left:0;width:100%;height:100%;background-image:linear-gradient(var(--color-border) 1px,transparent 1px),linear-gradient(90deg,var(--color-border) 1px,transparent 1px);background-size:60px 60px;opacity:.3;pointer-events:none;z-index:0}
205.accent-line{position:fixed;top:0;left:0;width:100%;height:2px;background:linear-gradient(90deg,transparent 0%,var(--color-accent) 50%,transparent 100%);animation:shimmer 3s ease-in-out infinite;z-index:10}
206@keyframes shimmer{0%,100%{transform:translateX(-100%)}50%{transform:translateX(100%)}}
207@keyframes fadeUp{from{opacity:0;transform:translateY(20px)}to{opacity:1;transform:translateY(0)}}
208.container{position:relative;z-index:1;max-width:900px;margin:0 auto;padding:0 24px}
209header{padding:32px 0}
210.logo{font-family:var(--font-display);font-size:14px;font-weight:700;letter-spacing:.1em;text-transform:uppercase;color:var(--color-text);display:flex;align-items:center;gap:10px;text-decoration:none}
211.logo:hover{color:var(--color-text)}
212.logo-mark{width:28px;height:28px;background:var(--color-accent);display:flex;align-items:center;justify-content:center}
213.logo-mark svg{width:16px;height:16px}
214.hero{padding:80px 0 60px;animation:fadeUp .8s ease-out}
215.hero-label{font-family:var(--font-display);font-size:12px;font-weight:400;letter-spacing:.15em;text-transform:uppercase;color:var(--color-accent);margin-bottom:24px;display:flex;align-items:center;gap:12px}
216.hero-label::before{content:'';width:24px;height:1px;background:var(--color-accent)}
217h1{font-family:var(--font-display);font-size:clamp(28px,5vw,44px);font-weight:700;line-height:1.15;margin-bottom:20px;letter-spacing:-.02em}
218h1 .highlight{color:var(--color-accent)}
219.hero-desc{font-size:18px;color:var(--color-text-muted);max-width:540px;margin-bottom:28px;line-height:1.7}
220.hero-link{font-family:var(--font-display);font-size:13px;letter-spacing:.05em;color:var(--color-accent);display:inline-flex;align-items:center;gap:6px}
221.section{padding:60px 0;border-top:1px solid var(--color-border);animation:fadeUp .8s ease-out .2s backwards}
222.section-label{font-family:var(--font-display);font-size:11px;font-weight:400;letter-spacing:.2em;text-transform:uppercase;color:var(--color-text-muted);margin-bottom:24px}
223h2{font-family:var(--font-display);font-size:20px;font-weight:700;margin-bottom:16px;letter-spacing:-.01em}
224p,li{font-size:15px;color:var(--color-text-muted);line-height:1.7}
225li{margin-bottom:6px}
226ul{margin:.5rem 0 1rem 1.25rem}
227strong{color:var(--color-text);font-weight:600}
228pre{background:var(--color-surface);color:var(--color-text);padding:16px 20px;overflow-x:auto;margin:12px 0 16px;font-family:var(--font-display);font-size:13px;line-height:1.6;border:1px solid var(--color-border)}
229code{font-family:var(--font-display);font-size:13px}
230p code,li code,td code{background:var(--color-accent-dim);color:var(--color-accent);padding:2px 6px}
231table{width:100%;border-collapse:collapse;margin:12px 0 16px;font-size:14px}
232th,td{border:1px solid var(--color-border);padding:10px 14px;text-align:left}
233th{background:var(--color-surface);color:var(--color-text-muted);font-family:var(--font-display);font-size:12px;font-weight:400;letter-spacing:.05em;text-transform:uppercase}
234td{color:var(--color-text-muted)}
235.badge{display:inline-block;background:var(--color-accent-dim);color:var(--color-accent);padding:3px 8px;font-family:var(--font-display);font-size:11px;font-weight:400;letter-spacing:.05em}
236.note{font-size:13px;color:var(--color-text-muted);margin-top:8px}
237.product-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(240px,1fr));gap:16px;margin-top:24px}
238.product-card{background:var(--color-surface);border:1px solid var(--color-border);padding:24px;transition:all .3s ease;text-decoration:none;color:inherit;display:block}
239.product-card:hover{border-color:var(--color-accent);transform:translateY(-2px)}
240.product-name{font-family:var(--font-display);font-size:14px;font-weight:700;margin-bottom:8px;color:var(--color-text);display:flex;align-items:center;gap:8px}
241.product-name .status{font-size:9px;font-weight:400;padding:3px 6px;background:var(--color-accent-dim);color:var(--color-accent);letter-spacing:.1em}
242.product-desc{font-size:14px;color:var(--color-text-muted);line-height:1.5}
243footer{padding:48px 0;border-top:1px solid var(--color-border)}
244.footer-content{display:flex;justify-content:space-between;align-items:center;flex-wrap:wrap;gap:24px}
245.footer-text{font-size:13px;color:var(--color-text-muted)}
246.footer-links{display:flex;gap:24px}
247.footer-links a{font-family:var(--font-display);font-size:12px;color:var(--color-text-muted);letter-spacing:.05em}
248.footer-links a:hover{color:var(--color-accent)}
249@media(max-width:600px){.hero{padding:60px 0 40px}.section{padding:40px 0}.footer-content{flex-direction:column;align-items:flex-start}pre{font-size:12px;padding:12px 14px}}
250</style>
251</head>
252<body>
253<div class="grid-bg"></div>
254<div class="accent-line"></div>
255
256<div class="container">
257  <header>
258    <a href="https://apify.com/superlativetech?fpr=8e9l1" class="logo">
259      <div class="logo-mark">
260        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5">
261          <polyline points="4 17 10 11 4 5"></polyline>
262          <line x1="12" y1="19" x2="20" y2="19"></line>
263        </svg>
264      </div>
265      Superlative
266    </a>
267  </header>
268
269  <section class="hero">
270    <div class="hero-label">Network Intelligence</div>
271    <h1>Supernet DNS <span class="highlight">Lookup</span></h1>
272    <p class="hero-desc">Instant DNS record lookups and reverse DNS resolution. Sub-second responses via Standby API.</p>
273    <a href="https://apify.com/superlativetech/dns-lookup?fpr=8e9l1" class="hero-link">View on Apify Store &rarr;</a>
274  </section>
275
276  <section class="section">
277    <div class="section-label">Features</div>
278    <h2>What this does</h2>
279    <ul>
280      <li><strong>Forward lookup</strong> &mdash; query A, AAAA, MX, TXT, NS, CNAME, SOA, SRV, CAA, or PTR records</li>
281      <li><strong>Reverse lookup</strong> &mdash; resolve IP addresses back to hostnames</li>
282      <li><strong>Selective types</strong> &mdash; request specific record types or get all by default</li>
283      <li><strong>Batch mode</strong> &mdash; process hundreds of domains via the standard Actor run</li>
284    </ul>
285  </section>
286
287  <section class="section">
288    <div class="section-label">Getting Started</div>
289    <h2>Quick start</h2>
290    <p>Replace <code>YOUR_TOKEN</code> with your Apify API token.</p>
291
292    <p style="margin-top:16px"><strong>Forward lookup (all record types):</strong></p>
293    <pre>curl "https://superlativetech--dns-lookup.apify.actor?token=YOUR_TOKEN&amp;domain=apify.com"</pre>
294
295    <p><strong>Specific record types:</strong></p>
296    <pre>curl "https://superlativetech--dns-lookup.apify.actor?token=YOUR_TOKEN&amp;domain=apify.com&amp;type=MX,TXT"</pre>
297
298    <p><strong>Reverse lookup:</strong></p>
299    <pre>curl "https://superlativetech--dns-lookup.apify.actor?token=YOUR_TOKEN&amp;ip=8.8.8.8"</pre>
300  </section>
301
302  <section class="section">
303    <div class="section-label">Reference</div>
304    <h2>Query parameters</h2>
305    <table>
306      <tr><th>Parameter</th><th>Required</th><th>Description</th></tr>
307      <tr><td><code>domain</code></td><td>*</td><td>Domain name to look up (e.g. <code>apify.com</code>)</td></tr>
308      <tr><td><code>ip</code></td><td>*</td><td>IP address for reverse lookup (e.g. <code>8.8.8.8</code>)</td></tr>
309      <tr><td><code>type</code></td><td>No</td><td>Comma-separated record types: A, AAAA, MX, TXT, NS, CNAME, SOA, SRV, CAA, PTR</td></tr>
310      <tr><td><code>token</code></td><td>Yes</td><td>Your Apify API token</td></tr>
311    </table>
312    <p class="note">* Provide either <code>domain</code> or <code>ip</code>, not both.</p>
313  </section>
314
315  <section class="section">
316    <div class="section-label">Response</div>
317    <h2>Response format</h2>
318    <pre>{
319  "domain": "apify.com",
320  "status": "OK",
321  "records": {
322    "A": ["18.196.0.40"],
323    "MX": [{ "exchange": "alt1.aspmx.l.google.com", "priority": 5 }],
324    "TXT": ["v=spf1 include:_spf.google.com ..."]
325  }
326}</pre>
327  </section>
328
329  <section class="section">
330    <div class="section-label">Cost</div>
331    <h2>Pricing</h2>
332    <p>Free to use — you only pay standard Apify platform usage.</p>
333  </section>
334
335  <section class="section">
336    <div class="section-label">Auth</div>
337    <h2>Authentication</h2>
338    <p>Authenticate using either method:</p>
339    <ul>
340      <li>Query parameter: <code>?token=YOUR_APIFY_TOKEN</code></li>
341      <li>Header: <code>Authorization: Bearer YOUR_APIFY_TOKEN</code></li>
342    </ul>
343    <p style="margin-top:8px">Get your token from <a href="https://console.apify.com/settings/integrations">Apify Console &rarr; Settings &rarr; Integrations</a>.</p>
344  </section>
345
346  <section class="section">
347    <div class="section-label">Superlative</div>
348    <h2>More from Superlative</h2>
349    <div class="product-grid">
350      <a href="https://apify.com/superlativetech/superclean-company-names?fpr=8e9l1" class="product-card">
351        <div class="product-name">Company Names <span class="status">Live</span></div>
352        <p class="product-desc">Normalize company names for CRM and cold email outreach.</p>
353      </a>
354      <a href="https://apify.com/superlativetech/superclean-job-titles?fpr=8e9l1" class="product-card">
355        <div class="product-name">Job Titles <span class="status">Live</span></div>
356        <p class="product-desc">Standardize job titles for outreach sequences.</p>
357      </a>
358      <a href="https://apify.com/superlativetech/superclean-person-names?fpr=8e9l1" class="product-card">
359        <div class="product-name">Person Names <span class="status">Live</span></div>
360        <p class="product-desc">Clean and format person names for personalization.</p>
361      </a>
362      <a href="https://apify.com/superlativetech/superclean-product-names?fpr=8e9l1" class="product-card">
363        <div class="product-name">Product Names <span class="status">Live</span></div>
364        <p class="product-desc">Normalize product and brand names from exports.</p>
365      </a>
366      <a href="https://apify.com/superlativetech/superclean-places?fpr=8e9l1" class="product-card">
367        <div class="product-name">Places <span class="status">Live</span></div>
368        <p class="product-desc">Parse and standardize location strings.</p>
369      </a>
370      <a href="https://apify.com/superlativetech/superclean-urls?fpr=8e9l1" class="product-card">
371        <div class="product-name">URLs <span class="status">Live</span></div>
372        <p class="product-desc">Clean and normalize URLs from lead data.</p>
373      </a>
374      <a href="https://apify.com/superlativetech/superclean-phone-numbers?fpr=8e9l1" class="product-card">
375        <div class="product-name">Phone Numbers <span class="status">Live</span></div>
376        <p class="product-desc">Format and validate phone numbers.</p>
377      </a>
378      <a href="https://apify.com/superlativetech/http-api?fpr=8e9l1" class="product-card">
379        <div class="product-name">HTTP API <span class="status">Live</span></div>
380        <p class="product-desc">General-purpose HTTP request utility.</p>
381      </a>
382      <a href="https://apify.com/superlativetech/supernet-domain-health?fpr=8e9l1" class="product-card">
383        <div class="product-name">Domain Health <span class="status">Live</span></div>
384        <p class="product-desc">Email reputation audit: SPF, DKIM, DMARC, blacklists, SSL.</p>
385      </a>
386      <a href="https://apify.com/superlativetech/supernet-whois-lookup?fpr=8e9l1" class="product-card">
387        <div class="product-name">WHOIS Lookup <span class="status">Live</span></div>
388        <p class="product-desc">Domain registration data: registrar, dates, age, name servers.</p>
389      </a>
390    </div>
391  </section>
392
393  <footer>
394    <div class="footer-content">
395      <p class="footer-text">&copy; 2026 Superlative</p>
396      <div class="footer-links">
397        <a href="https://apify.com/superlativetech?fpr=8e9l1">Apify Store</a>
398      </div>
399    </div>
400  </footer>
401</div>
402
403</body>
404</html>`;
405}

DNS Lookup API - Bulk DNS Records Checker

pink_comic/dns-lookup-records

Bulk DNS lookup API for domain records. Check A, AAAA, MX, NS, TXT, CNAME, SOA, and SRV records across many domains for email deliverability, SPF/DKIM/DMARC checks, DNS migrations, security audits, and infrastructure monitoring.

Ava Torres

WHOIS & DNS Lookup Tool

darknezz/whois-dns-lookup

Comprehensive WHOIS and DNS lookup for any domain. Get registration data, name servers, all DNS record types (A, AAAA, MX, NS, TXT, SOA, CAA, SRV), SPF/DMARC email security, and IP resolution in one call. Perfect for domain research, security audits, and infrastructure analysis.

Oaida Adrian

Bulk DNS Records Lookup (A, MX, TXT, NS, CNAME)

fit_melon/bulk-dns-records-lookup

Look up DNS records for a list of domains in bulk — A, AAAA, MX, TXT, NS, CNAME, SOA, CAA. Fast DNS-over-HTTPS resolution, clean JSON with one item per domain. Great for SPF/DMARC audits, migrations and monitoring. Free.

D N

Bulk DNS Records Lookup - A, MX, TXT, NS, CNAME

logiover/bulk-dns-records-lookup

Look up DNS records for thousands of domains at once — A, AAAA, MX, NS, TXT, CNAME, SOA and CAA — via DNS-over-HTTPS. Ideal for email deliverability (SPF/DMARC), security audits and migrations. No API key, export to CSV or JSON.

Logiover

Bulk DNS Lookup, SPF DMARC DKIM Email Check

thoob/dns-bulk-lookup

Resolves A, AAAA, MX, NS, TXT, CNAME, and SOA records for many domains at once over DNS-over-HTTPS (Cloudflare, with Google fallback), and parses SPF, DMARC, and optional DKIM. Deterministic and fast. Billed only per domain that returns DNS data.

Pono Data

DNS Records Checker - Domain DNS Lookup Data

benthepythondev/dns-records-checker

Look up public DNS records for domains and export A, AAAA, CNAME, MX, NS, TXT, SOA and CAA records as structured data.

Ben

🌐 Bulk WHOIS & DNS Lookup - Domain Records API

renzomacar/whois-dns-lookup

Bulk WHOIS + DNS + SSL lookup for a list of domains: registrar, created/expiry dates, domain age, status, nameservers, A/AAAA/MX/TXT/NS/CNAME/SOA and the live TLS certificate. Keyless WhoisXML alternative.

Renzo Madueno

DNS Lookup — Bulk A/MX/TXT/NS Records (DoH)

bgfc97/dns-lookup-doh

Bulk DNS resolver via DNS-over-HTTPS. Get A, AAAA, MX, TXT (SPF/DMARC), NS, CNAME and SOA records for many domains at once. No key, no proxy.

Bruno

DNS Lookup | Scrape Domain Records & Security Intelligence

datascoutapi/dns-lookup

DNS lookup scrapes 22 data points including 10 DNS records (A, AAAA, MX, TXT, NS, CNAME, SOA, SRV, PTR, CAA) + email security analysis ( SPF/DKIM/DMARC), SSL certificate checker, domain monitoring. Processes 100 domains per batch with security scoring.