Bulk DNS Records Lookup

Resolve domain lists into normalized DNS records for infrastructure audits, migrations, vendor reviews, and scheduled monitoring.

The Actor accepts up to 5,000 domains or URLs and returns one dataset item per unique hostname. Each result can include A, AAAA, MX, NS, TXT, CNAME, and SOA records, lookup timing, per-record-type errors, and a stable status field.

It uses the DNS protocol directly, so no third-party API key or browser proxy is required.

What can Bulk DNS Records Lookup do?

• Resolve seven common DNS record types in one run.
• Normalize URLs, Unicode hostnames, casing, and trailing dots.
• Deduplicate repeated hostnames before lookup and billing.
• Return IPv4 and IPv6 TTL values.
• Join multi-part TXT responses into complete strings.
• Sort records for easier comparison between scheduled snapshots.
• Continue when one record type fails and report that error on the domain item.
• Use the runtime resolver or optional custom DNS server IPs.
• Export results as JSON, CSV, Excel, XML, or RSS through Apify datasets.
• Feed scheduled results into webhooks, integrations, or your own change-detection pipeline.

Who is this DNS records checker for?

Infrastructure and SRE teams can inventory DNS configuration before migrations or provider changes.

Security teams can review name servers, mail routing, TXT policies, and unexpected record changes across a domain portfolio.

Email operations teams can collect MX and TXT records for deliverability and configuration audits.

Agencies and managed service providers can run the same normalized check across customer domains.

Data engineers can enrich domain lists and send structured results to a warehouse or spreadsheet.

DNS record types returned

Field	DNS type	What it contains
a	A	IPv4 addresses and TTL values
aaaa	AAAA	IPv6 addresses and TTL values
mx	MX	Mail exchanges and priorities
ns	NS	Authoritative name server hostnames
txt	TXT	Complete TXT values after joining response chunks
cname	CNAME	Canonical-name targets
soa	SOA	Primary server, hostmaster, serial, refresh, retry, expiry, and minimum TTL

Missing record types are returned as empty arrays or null for SOA. They do not automatically make a domain an error.

Why use this bulk DNS lookup?

A single DNS tool often answers one question for one hostname. This Actor is designed for repeatable lists:

1. one normalized row per unique domain;
2. the same requested record types on every row;
3. bounded concurrency for predictable bulk runs;
4. partial failure details instead of discarding an otherwise useful result;
5. dataset exports and Apify scheduling without additional infrastructure.

The Actor does not claim historical DNS data. To build history, schedule recurring runs and compare their timestamped datasets downstream.

How to run a DNS records lookup

1. Open the Actor input page.
2. Add domain names or URLs to Domains or URLs.
3. Keep all record types selected, or select only those needed for your audit.
4. Optionally adjust concurrency, timeout, or custom DNS servers.
5. Click Start.
6. Open the dataset to inspect or export the normalized rows.

A useful first input is:

{
  "domains": [
    "apify.com",
    "https://github.com/features",
    "cloudflare.com"
  ]
}

The URL is normalized to github.com; input order and spelling are retained in the input field.

Input parameters

Parameter	Type	Default	Description
domains	string array	required	1–5,000 domain names or URLs
recordTypes	string array	all seven types	Any of A, AAAA, MX, NS, TXT, CNAME, SOA
concurrency	integer	20	Domains processed in parallel, from 1 to 100
timeoutMs	integer	5000	Per-query attempt timeout, from 500 to 30,000 ms
dnsServers	string array	runtime resolver	Optional recursive DNS server IP addresses

Inputs are validated before lookups begin. Invalid domains, unsupported record types, or out-of-range settings fail the run rather than silently changing scope.

Output example

The default dataset contains one object per unique normalized domain. This shortened example reflects the current output shape:

{
  "input": "https://github.com/features",
  "domain": "github.com",
  "status": "success",
  "recordTypes": ["A", "AAAA", "MX", "NS", "TXT", "CNAME", "SOA"],
  "a": [{ "address": "140.82.121.4", "ttl": 46 }],
  "aaaa": [],
  "mx": [{
    "exchange": "github-com.mail.protection.outlook.com",
    "priority": 0
  }],
  "ns": ["dns1.p08.nsone.net", "dns2.p08.nsone.net"],
  "txt": [{ "value": "v=spf1 include:spf.protection.outlook.com ~all" }],
  "cname": [],
  "soa": {
    "nsname": "dns1.p08.nsone.net",
    "hostmaster": "hostmaster.nsone.net",
    "serial": 1656468023,
    "refresh": 43200,
    "retry": 7200,
    "expire": 1209600,
    "minttl": 3600
  },
  "recordCount": 13,
  "errors": {},
  "resolvedAt": "2026-08-05T06:06:53.770Z",
  "durationMs": 13
}

DNS answers change over time. Addresses, TTLs, record counts, and timestamps in a later run may differ.

Understanding lookup status and errors

success means at least one record was found and no requested record type produced an operational DNS error.

partial means records were found, but one or more requested queries timed out or returned an operational resolver error.

not_found means no requested records were found and the resolver reported normal no-data or non-existent-name responses.

error means no records were returned and every requested record type produced an operational error.

The errors object is keyed by record type. A missing key means that query either succeeded or normally had no record.

How much does it cost to look up DNS records?

Pricing uses one start event per run plus one domain event per unique normalized domain saved.

At the FREE tier, the current rates are $0.005 per run and $0.00092 per domain. Higher usage tiers receive lower per-domain rates automatically.

Unique domains	Example FREE-tier charge
1	$0.00592
10	$0.0142
100	$0.097
1,000	$0.925

Duplicate domains are resolved and charged once. Selecting more record types does not create additional charge events.

Apify platform compute charges and your account tier may affect the final run total shown in Console. Check the live pricing tab before a large production run.

Scheduled DNS change monitoring workflow

The Actor produces snapshots, not built-in history. A recurring workflow can:

1. store the domain portfolio in an Apify Task;
2. schedule the Task hourly, daily, or weekly;
3. send the completed dataset to a webhook or integration;
4. compare each domain's sorted records with the previous snapshot;
5. notify the responsible team when an approved record changes.

SOA serials, NS changes, MX routing, and address records are common comparison targets. Treat TTL-only changes according to your own alert policy.

Email and vendor configuration audit

For a focused email audit, request only MX and TXT:

{
  "domains": [
    "stripe.com",
    "shopify.com",
    "salesforce.com",
    "hubspot.com"
  ],
  "recordTypes": ["MX", "TXT"]
}

This reduces DNS traffic while preserving the fields commonly used to inspect mail routing and published policy records. The Actor returns raw public TXT values; it does not judge SPF, DKIM, or DMARC policy correctness.

Custom DNS resolvers

Set dnsServers when a workflow must query a particular recursive resolver:

{
  "domains": ["apify.com", "github.com"],
  "dnsServers": ["1.1.1.1", "8.8.8.8"],
  "timeoutMs": 8000
}

Resolver IPs must be reachable from the Actor runtime. A private network address is not reachable unless your Apify environment provides that network path.

Different recursive resolvers may cache different TTLs or receive geo-aware answers. For comparable scheduled snapshots, keep the resolver configuration consistent.

Export and integration options

Every result is stored in the default Apify dataset. You can:

• download CSV for a spreadsheet review;
• retrieve JSON through the dataset API;
• connect Google Sheets, Make, Zapier, or another Apify integration;
• trigger a webhook when the run succeeds or fails;
• schedule a saved Task for repeat audits;
• stream dataset items into a warehouse or monitoring service.

Nested arrays and objects are preserved most accurately in JSON. CSV exports serialize nested values.

Run through the Apify API with cURL

Replace APIFY_TOKEN with your token:

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~bulk-dns-lookup/runs?token=APIFY_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{
    "domains": ["apify.com", "github.com"],
    "recordTypes": ["A", "AAAA", "MX", "NS", "TXT", "CNAME", "SOA"]
  }'

Fetch results from the defaultDatasetId returned by the run.

Run with JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/bulk-dns-lookup').call({
    domains: ['apify.com', 'github.com', 'cloudflare.com'],
    recordTypes: ['A', 'MX', 'NS', 'TXT', 'SOA'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Run with Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/bulk-dns-lookup').call(run_input={
    'domains': ['apify.com', 'github.com', 'cloudflare.com'],
    'recordTypes': ['A', 'MX', 'NS', 'TXT', 'SOA'],
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Use Bulk DNS Records Lookup through MCP

Add the Apify MCP server to Claude Code:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/bulk-dns-lookup"

Claude Desktop

Add this remote MCP server in Claude Desktop's connector settings. The same JSON format is also usable by supported editor clients:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/bulk-dns-lookup"
    }
  }
}

Cursor

Add the same https://mcp.apify.com?tools=automation-lab/bulk-dns-lookup URL as a remote MCP server in Cursor settings.

VS Code

Add the same remote URL to the MCP servers configuration used by your VS Code AI extension.

Example prompts:

• “Resolve A, MX, NS, TXT, and SOA records for these vendor domains and summarize any lookup errors.”
• “Run a DNS snapshot for my domain list and return the dataset URL.”
• “Check only MX and TXT records for these SaaS domains.”

Limits and operational tips

• A run accepts at most 5,000 input entries.
• Duplicate normalized domains produce one item.
• Record order is normalized, but DNS answers can legitimately vary by resolver, location, and time.
• CNAME records commonly exist on subdomains and are often absent at an apex domain.
• TXT responses may contain verification values intended to be public but operationally sensitive; control access to exported datasets.
• Custom resolvers can rate-limit high concurrency. Lower concurrency or increase timeoutMs when needed.
• The Actor retries each DNS query once through the configured resolver.
• When the runtime's default resolver has a transient operational failure, one bounded retry uses independent public recursive resolvers. User-selected custom resolvers do not silently switch.
• A successful Actor run can contain partial, not_found, or error items; inspect item status in downstream workflows.

Legality and responsible use

DNS records are publicly queryable infrastructure data. Use the Actor for lawful administration, research, security review, and monitoring.

Do not use results to misrepresent control of a domain, bypass access controls, or target systems without authorization. Follow applicable laws, contracts, and organizational policies. Avoid excessive repeated queries to custom resolvers you do not operate.

FAQ and troubleshooting

Why is CNAME empty?

A domain can have A or AAAA records without a CNAME. Apex domains often cannot use CNAME records because other required record types coexist there. Query the exact subdomain you want to inspect.

Why does a domain show not_found?

The resolver returned no data for all requested types. Confirm spelling, query the intended hostname rather than a path, and try a known recursive resolver if local DNS behavior is in doubt.

Why does a result show partial?

At least one type returned records while another query timed out or encountered an operational resolver error. Review errors, increase timeoutMs, reduce concurrency, or choose a different DNS server.

Why did multiple inputs produce fewer rows?

The Actor normalizes hostnames and removes duplicates. For example, APIFY.COM., apify.com, and https://apify.com/docs all resolve to one apify.com dataset item.

Does this Actor provide historical DNS records?

No. Each run captures current resolver answers. Schedule runs and retain datasets if you need your own change history.

Related automation-lab Actors

• Domain Availability Checker — combine DNS and registration signals for bulk domain checks.
• MX Record Checker — use when the workflow only needs mail exchanger records and provider identification.
• WHOIS Lookup — enrich DNS snapshots with public registration details.

Support

If a run behaves unexpectedly, open an issue on the Actor page with:

• a minimal input that reproduces the behavior;
• the run URL;
• the expected record type;
• whether custom DNS servers were configured.

Do not include API tokens or private network details in an issue.