Bulk DNS AAAA Record Checker

Run a bulk DNS lookup focused on IPv6 AAAA records. Supply domains or website URLs and receive one normalized row per unique hostname with returned IPv6 addresses, TTL values, lookup status, DNS errors, timing, and a check timestamp.

Use the Actor for recurring IPv6-readiness reviews, domain inventory audits, migration checks, and DNS snapshot exports. It performs DNS queries directly; it does not crawl websites or require a proxy.

What does Bulk DNS AAAA Record Checker do?

The Actor:

• accepts 1 to 5,000 domains or website URLs;
• extracts and normalizes each hostname;
• converts internationalized names to ASCII DNS form;
• removes duplicate hostnames within the run;
• resolves only IPv6 AAAA records;
• preserves the TTL returned for each answer;
• exports explicit success, no-record, missing-domain, and resolver-error states;
• records when each check completed and how long it took;
• supports bounded concurrency and DNS timeouts;
• optionally uses recursive DNS servers supplied by you.

A domain without an AAAA record still produces a row. That makes negative results usable in an audit instead of silently dropping them.

Who is this bulk DNS checker for?

Infrastructure teams can review whether production hostnames publish IPv6 addresses.

Security and compliance teams can preserve timestamped DNS evidence for an inventory.

SaaS operations teams can schedule the same domain portfolio and compare exported datasets downstream.

Developers can add normalized AAAA lookup results to deployment checks or asset pipelines.

Consultants and agencies can process client domain lists without checking hostnames one by one.

Choose this Actor when the job is specifically AAAA and IPv6 readiness. Choose the related multi-record Actor when you also need A, MX, NS, TXT, CNAME, or SOA records.

Why use a focused AAAA record checker?

Generic DNS tools often return many record families when the audit only needs IPv6 readiness. This Actor keeps the input and output contract focused:

1. one charged output per unique hostname;
2. IPv6 addresses available as a simple string array;
3. address-and-TTL pairs retained for deeper analysis;
4. deterministic status values for filtering;
5. resolver errors preserved for diagnosis;
6. no browser, login, or residential proxy setup.

The result can be exported from Apify as JSON, JSONL, CSV, Excel, XML, or RSS where supported by the dataset API.

Getting started

1. Open the Actor in Apify Console.
2. Add domains in the Domains field.
3. Keep concurrency at 20 for a normal portfolio.
4. Leave custom DNS servers empty unless you need a specific recursive resolver.
5. Click Start.
6. Open the default dataset when the run finishes.
7. Filter lookupStatus or hasIpv6 to find gaps.
8. Export the dataset or connect it to the next step in your workflow.

A useful first input is:

{
  "domains": [
    "google.com",
    "cloudflare.com",
    "github.com"
  ],
  "concurrency": 10
}

Input parameters

Field	Type	Default	Description
domains	string array	required	Domains or URLs to normalize and check. Maximum 5,000 entries.
concurrency	integer	20	Number of unique hostnames checked in parallel, from 1 to 100.
timeoutMs	integer	5000	DNS resolver timeout per attempt, from 500 to 30,000 milliseconds.
dnsServers	string array	runtime resolver	Optional IPv4 or IPv6 addresses of recursive DNS servers.

URLs are accepted for convenience. For example, https://www.google.com/search?q=ipv6 is checked as www.google.com. Trailing dots and hostname case are normalized. Duplicate normalized hostnames produce only one result and one domain charge.

Inputs fail closed when a value is blank, malformed, not a public domain name, or outside a documented limit.

Custom DNS resolver behavior

When dnsServers is omitted, the Actor first uses the runtime resolver. A transient resolver failure receives one bounded attempt through the public Cloudflare and Google recursive resolvers. Definitive ENODATA and ENOTFOUND responses are not retried as transient failures.

When you provide dnsServers, those servers are authoritative for the run. The Actor does not fall back to public resolvers after a custom-resolver failure. This supports reproducible internal resolver tests and organizations with a defined DNS policy.

Example:

{
  "domains": ["cloudflare.com", "workers.dev"],
  "dnsServers": ["1.1.1.1", "2606:4700:4700::1111"],
  "timeoutMs": 4000,
  "concurrency": 5
}

Output fields

Each unique normalized hostname creates one default-dataset row.

Field	Meaning
input	Original domain or URL from the input list.
hostname	Normalized ASCII hostname queried.
ipv6Addresses	Sorted unique IPv6 address strings.
records	AAAA answer objects containing address and ttl.
addressCount	Number of unique returned IPv6 addresses.
hasIpv6	true when at least one AAAA address was returned.
lookupStatus	success, no_record, not_found, or error.
errorCode	Resolver code such as ENODATA, or null on success.
errorMessage	Resolver message, or null on success.
checkedAt	ISO 8601 completion timestamp.
durationMs	Lookup duration in milliseconds.

Example output

This representative record was produced by a local run against the final input contract:

{
  "input": "cloudflare.com",
  "hostname": "cloudflare.com",
  "ipv6Addresses": [
    "2606:4700::6810:84e5",
    "2606:4700::6810:85e5"
  ],
  "records": [
    { "address": "2606:4700::6810:84e5", "ttl": 166 },
    { "address": "2606:4700::6810:85e5", "ttl": 166 }
  ],
  "addressCount": 2,
  "hasIpv6": true,
  "lookupStatus": "success",
  "errorCode": null,
  "errorMessage": null,
  "checkedAt": "2026-08-25T20:55:00.000Z",
  "durationMs": 28
}

DNS answers and TTLs change over time, so exact values will differ between runs.

Understanding lookup status

success means at least one AAAA answer was returned.

no_record means the hostname resolved but no AAAA data was available, commonly reported as ENODATA.

not_found means the queried hostname did not exist according to the resolver, commonly ENOTFOUND.

error means the resolver could not produce a definitive answer because of a timeout, server failure, refusal, or another operational error.

Use both lookupStatus and the error fields. A missing AAAA record is a valid audit result, while a resolver timeout usually deserves a retry or investigation.

How much does it cost to check IPv6 AAAA records?

Pay-per-event pricing includes a $0.001 run-start charge and one domain checked event per unique normalized hostname. The BRONZE domain price is $0.00096 per domain, with lower per-domain prices on higher Apify tiers.

BRONZE run examples use one start event plus one domain event for every unique hostname:

Unique domains	Charge calculation
1	one start event + 1 domain event
10	one start event + 10 domain events
100	one start event + 100 domain events
1,000	one start event + 1,000 domain events

Duplicate inputs are not charged twice because they are resolved once. Compute usage is handled by Apify under the applicable pay-per-event model. Check the live pricing tab for the tier that applies to your account.

Recurring IPv6-readiness workflow

A practical scheduled workflow is:

1. keep the approved domain inventory in Actor input or a Task;
2. schedule the Task daily, weekly, or monthly;
3. retain each run's default dataset;
4. compare hostname, ipv6Addresses, and lookupStatus downstream;
5. flag a transition from success to another state;
6. review TTL changes when migration timing matters;
7. send selected exceptions to a webhook, database, spreadsheet, or alerting system.

The Actor creates current snapshots. It does not maintain history, compare prior runs, or send alerts by itself.

Export and integration ideas

• Export CSV for an infrastructure inventory review.
• Send JSON rows to a data warehouse.
• Join hostname with ownership or application metadata.
• Filter hasIpv6=false for a migration backlog.
• Track not_found separately from no_record.
• Use durationMs to identify slow recursive resolver responses.
• Trigger a webhook after a scheduled Task completes.
• Feed IPv6 addresses into the related IP geolocation and network lookup Actor.

Run through the Apify API with cURL

Replace <APIFY_TOKEN> with your Apify API token:

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~bulk-dns-aaaa-record-checker/runs?token=<APIFY_TOKEN>&waitForFinish=300" \
  -H "Content-Type: application/json" \
  -d '{
    "domains": ["google.com", "cloudflare.com", "github.com"],
    "concurrency": 10
  }'

Read dataset items using the defaultDatasetId returned by the run response. Avoid placing long-lived tokens in source control.

Run through the Apify API 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-aaaa-record-checker').call({
    domains: ['google.com', 'cloudflare.com', 'github.com'],
    concurrency: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Use environment variables or a secret manager for APIFY_TOKEN.

Run through the Apify API with Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/bulk-dns-aaaa-record-checker').call(
    run_input={
        'domains': ['google.com', 'cloudflare.com', 'github.com'],
        'concurrency': 10,
    }
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

The API output is the same typed dataset available in Console.

Use with Apify MCP

Add the Actor to Claude Code:

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

Claude Desktop, Cursor, and VS Code setup

Use this equivalent JSON configuration in Claude Desktop, Cursor, or VS Code:

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

Example prompts:

• "Check AAAA records for these domains and summarize which are not IPv6 ready."
• "Run the bulk AAAA checker for my SaaS vendor list and return hostname, status, and addresses."
• "Export current IPv6 DNS records for this domain inventory so I can compare them next week."

Performance tips

Keep the default concurrency for most internet-domain portfolios. Increase it gradually only when the selected resolver tolerates more parallel queries. Reduce concurrency when a custom resolver rate-limits requests.

Use a timeout long enough for the resolver and network path. A very short timeout can turn slow but valid answers into operational errors.

Split unusually policy-sensitive portfolios by resolver requirements rather than mixing public and private DNS expectations. The 5,000-input limit keeps runtime and accidental spend bounded.

Limitations

DNS responses depend on resolver location, cache state, delegation, DNSSEC behavior, and query time. The Actor reports the recursive answer it receives; it does not query every authoritative server independently.

TTL is the value returned by the recursive resolver and may reflect cache aging. It is not guaranteed to equal the original authoritative TTL.

Only AAAA records are queried. The Actor does not test HTTP connectivity over IPv6, TLS configuration, routing, firewall access, or application readiness. Publishing an AAAA address is one readiness signal, not proof of end-to-end IPv6 service.

The Actor does not bypass split-horizon DNS. Use your own reachable resolver when internal DNS views are required.

Legality and responsible use

DNS record data is generally public infrastructure metadata, but domain inventories and internal resolver results may be sensitive. Only submit lists you are authorized to process. Protect API tokens and private resolver addresses. Follow your organization's data retention and security policies when exporting datasets.

Do not use the Actor to misrepresent a complete security assessment. Review applicable law, contracts, and platform policies for your workflow.

Troubleshooting

The run returns no_record. The resolver found no AAAA data for that hostname. Verify the exact hostname and compare it with the intended web or service endpoint.

The run returns not_found. The hostname did not exist from the selected resolver's view. Check spelling, delegation, and whether a private resolver is required.

The run returns error. Inspect errorCode and errorMessage. Try a longer timeout, lower concurrency, or a known recursive resolver.

The Actor rejects my input. Provide public domains or URLs rather than paths without a valid hostname, IP literals, blank values, or single-label internal names. Custom DNS servers must be literal IPv4 or IPv6 addresses.

Why did several inputs produce one row? Inputs that normalize to the same hostname are deduplicated within the run.

Related Automation Lab Actors

• Bulk DNS Record Lookup resolves A, AAAA, MX, NS, TXT, CNAME, and SOA records when you need a broader DNS inventory.
• IP Geolocation & Network Lookup enriches returned public IPv4 or IPv6 addresses with network and location context.

These are separate products with separate inputs and pricing. Use Bulk DNS AAAA Record Checker for a focused per-domain IPv6 DNS audit.

FAQ

Does the Actor verify that a website works over IPv6?

No. It verifies published AAAA DNS answers only. End-to-end readiness also requires routing, firewall, TLS, and application checks.

Does it return domains that have no AAAA record?

Yes. Every valid unique hostname produces a row, including no_record, not_found, and error outcomes.

Can I use URLs instead of domains?

Yes. The Actor extracts and normalizes each URL hostname before the DNS query.

Can I choose the DNS resolver?

Yes. Provide one or more literal resolver IP addresses in dnsServers.

Does it monitor changes automatically?

The Actor creates a timestamped snapshot per run. Use an Apify schedule and compare datasets in your own automation for monitoring or alerts.

Are duplicate domains charged more than once?

No. Duplicate normalized hostnames are checked and charged once in a run.

What happens when one domain fails?

The Actor emits an error-state row and continues processing the remaining valid input portfolio. Malformed input fails the run before lookups begin.