DNSCove API · 13 min read
DNSCove API Documentation: A Practical Map for Route 53 Users
Learn how to navigate the DNSCove API documentation so you can authenticate, manage records from the CLI, and move an existing Route 53 zone over with a single import step.
The DNSCove API documentation gives infrastructure teams a direct reference for managing authoritative DNS zones, records, and credentials through a predictable REST-style interface. If you are migrating from Amazon Route 53, this map outlines how DNSCove structures its endpoints, handles authentication, executes bulk migrations, and integrates into command-line pipelines. Route 53 uses different operational models, XML payloads, and complex request signing. Reference details and account tooling are available on DNSCove.
DNS workflows require precision. The documentation specifies exact JSON schemas so teams can automate zone provisioning, verify record updates, and transition production infrastructure without surprises.
Start here: what the DNSCove API documentation covers (and what it does not)
The documentation organizes DNS management into four primary areas: the quickstart, the record-types reference, infrastructure-as-code (IaC) guides, and the JSON API endpoint reference. Each guide targets one task:
- The quickstart guide demonstrates how to create an API token, authenticate your first request, and provision a basic test zone.
- The record-types reference defines supported resource records, field constraints, TTL minimums, and syntax formats.
- The infrastructure-as-code guides provide copy-ready configurations for Terraform and automated workflows to manage zones declaratively.
- The API reference catalogs HTTP methods, status codes, parameter schemas, and pagination mechanics for every resource.
If you are coming from AWS, note that DNSCove does not expose a Route 53 wire-compatible API in v1; you manage DNS through DNSCove's own JSON API, console, and Terraform guides, and migrate off Route 53 with a one-step zone import. DNSCove uses standard JSON payloads. Amazon Route 53 relies on XML schemas and multi-step batch calls, as detailed in the AWS ChangeResourceRecordSets API reference.
This distinction changes your automation. Route 53 requires AWS Signature Version 4 request signing, which mandates timestamp calculations and HMAC hashing across headers. The mechanics of that AWS authentication process are documented in the AWS developer guide on API authentication headers. DNSCove uses standard bearer token authorization in HTTP request headers. Standard AWS SDK clients will not communicate directly with these endpoints. Automation pipelines interact through HTTP REST calls or dedicated infrastructure-as-code tooling.
Follow this 10-minute reading order:
- Inspect the authentication section of the DNSCove JSON API integration reference to see header requirements.
- Review the zone import documentation to verify how existing zone files are parsed.
- Examine the record schemas to verify syntax compatibility for your active records.
- Read the Terraform provider documentation to confirm state-handling mechanisms for your CI/CD pipelines.
The DNSCove API documentation is strictly versioned to v1. Breaking changes increment the URI prefix. You can track additions, deprecation windows, and schema updates directly through the public changelog hosted at https://dnscove.com/docs/changelog.
Authentication and your first API call
API tokens are generated inside the DNSCove management console under Account Settings > API Access. To enforce least privilege, DNSCove allows you to scope tokens tightly. You can restrict an API key to read-only access, bind it to a single zone, or grant write permissions across an entire project.
Tokens require explicit scoping. If a deployment pipeline token intended for updating an ACME challenge record carries account-wide deletion rights, an accidental secret exposure puts every production domain at risk. Issue single-zone tokens for operational pipelines, and reserve account-wide administrative tokens for dedicated provisioning repositories.
The API uses Bearer tokens. Send your key in the Authorization header on every request. Below is an example of querying your account zone list using standard tools:
curl -s -X GET "https://api.dnscove.com/v1/zones" \
-H "Authorization: Bearer dnc_live_9f83a2c04e7b1a6d" \
-H "Accept: application/json"
The API responds with an array of zone objects:
{
"data": [
{
"id": "zone_01HXYZ789ABC",
"name": "example.com",
"status": "active",
"record_count": 14,
"dnssec_enabled": true,
"created_at": "2026-03-15T10:00:00Z"
}
],
"pagination": {
"has_more": false,
"next_cursor": null
}
}
With the id extracted, query the specific records inside that zone:
curl -s -X GET "https://api.dnscove.com/v1/zones/zone_01HXYZ789ABC/records" \
-H "Authorization: Bearer dnc_live_9f83a2c04e7b1a6d" \
-H "Accept: application/json"
When an authenticated call fails, the response includes an explicit JSON payload detailing the operational error code, which lets your automated deployment scripts identify issues immediately without parsing HTML error pages. The documentation formalizes three primary authentication and lookup errors:
- An HTTP 401
UNAUTHENTICATEDresponse indicates that the token is missing, expired, or malformed, requiring credential rotation in the console. - An HTTP 403
PERMISSION_DENIEDresponse indicates that the token is valid, but lacks the necessary scope for the target zone or operation. - An HTTP 404
ZONE_NOT_FOUNDresponse indicates that the requested zone ID does not exist in your account. To prevent domain enumeration, requests using scoped tokens that lack permission for an existing zone also return a 404 status.
Code examples simplify integration. Consult the DNSCove API quickstart guide for copy-ready snippets in Python, Go, and Node.js.
Reading the endpoint reference without getting lost
The core API documentation is divided across four primary resource groups: /v1/zones, /v1/zones/{zone_id}/records, /v1/imports, and /v1/account. Navigating this reference requires evaluating four core attributes on any given endpoint:
- Check the JSON payload specifications for required fields, because record updates missing TTL or type fields fail schema validation.
- Creating zones or records with POST fails if duplicates exist, whereas PUT replaces the record set atomically and PATCH modifies individual fields.
- Endpoints returning lists use cursor-based pagination with limit and cursor query parameters. They do not return all records in an unbounded array.
- Endpoints enforce distinct per-minute token buckets for read and write operations, documented in HTTP response headers such as X-RateLimit-Limit and X-RateLimit-Remaining.
Apex records require careful planning. In Route 53, teams use proprietary Alias records pointing to Elastic Load Balancers or CloudFront distributions. In DNSCove, you manage this using flattened ALIAS records. DNSCove supports apex ALIAS records (CNAME-at-apex flattening, like Route53 Alias) with serve-stale protection. When configured, DNSCove resolves the target hostname and serves synthesized A and AAAA records to querying resolvers, falling back to cached responses if an upstream origin stops responding.
Here is an example payload creating an apex ALIAS record via the API:
curl -s -X POST "https://api.dnscove.com/v1/zones/zone_01HXYZ789ABC/records" \
-H "Authorization: Bearer dnc_live_9f83a2c04e7b1a6d" \
-H "Content-Type: application/json" \
-d '{
"name": "@",
"type": "ALIAS",
"ttl": 300,
"data": "app-alb-123456789.us-east-1.elb.amazonaws.com"
}'
Control-plane writes are synchronous. When a POST, PUT, or DELETE call returns an HTTP 200 OK or 201 Created, the record data is committed to the control plane database and pushed out to authoritative nameserver memory. You do not need to poll an external batch status endpoint, unlike Route 53's GetChange polling cycle.
External resolution propagation depends on local resolver caching governed by your record prior TTL. For guidance on structuring record lifetimes prior to deployment, consult our analysis on DNS record TTL impact on caching behavior.
Rate limits and response pagination
Rate limits protect the control plane. Automated deployment scripts and CI workers often hit API rate thresholds when they issue individual HTTP calls for hundreds of DNS records in a rapid loop. The DNSCove documentation outlines specific sliding-window rate limits designed to protect control-plane availability while allowing high-throughput updates.
Read requests against /v1/zones and record endpoints allow up to 600 requests per minute per account. Write mutations, including POST, PUT, PATCH, and DELETE, permit 120 operations per minute per account. Every API response includes three informational headers:
X-RateLimit-Limit: The total request quota allocated for the current one-minute window.X-RateLimit-Remaining: The count of unused requests remaining in the active window.X-RateLimit-Reset: The Unix epoch timestamp indicating when the current window refreshes.
When a script exceeds these thresholds, the API issues an HTTP 429 TOO_MANY_REQUESTS response accompanied by a Retry-After header stating the number of seconds to sleep. Automation clients should implement exponential backoff with jitter. For bulk zone population, uploading a complete zone file via /v1/imports consumes a single write credit.
List endpoints return bounded collections. If an infrastructure account manages dozens of zones or thousands of records within a single domain, endpoints enforce pagination via the limit and cursor query parameters. The default page size is 50 items, with a maximum allowable limit of 250 items per request.
The response envelope includes a pagination object containing two keys: has_more (a boolean) and next_cursor (an opaque string token or null). If has_more is true, pass the token into the subsequent request using ?cursor={next_cursor}. When has_more evaluates to false, the client has ingested the full record set. This cursor model prevents the race conditions and skipped records that frequently occur in offset-based pagination schemes when records are created or removed mid-traversal.
Managing DNS via CLI: scripting against the documented endpoints
Managing DNS via CLI workflows allows platform teams to embed zone modifications inside shell scripts, automated deployment steps, and incident response tooling without introducing heavy dependencies. Shell scripts require strict hygiene. Read tokens from environment variables, and avoid passing credentials as command-line arguments that leak into shell history or process tables.
Below is a minimal POSIX-compliant shell script that fetches, filters, and formats records for a given zone using curl and jq:
#!/usr/bin/env sh
set -eu
ZONE_ID="${1:-}"
if [ -z "$ZONE_ID" ]; then
echo "Usage: $0 <zone_id>" >&2
exit 1
fi
if [ -z "${DNSCOVE_API_TOKEN:-}" ]; then
echo "Error: DNSCOVE_API_TOKEN environment variable not set." >&2
exit 1
fi
BASE_URL="https://api.dnscove.com/v1"
echo "Fetching records for zone ${ZONE_ID}..."
curl -s -f -X GET "${BASE_URL}/zones/${ZONE_ID}/records" \
-H "Authorization: Bearer ${DNSCOVE_API_TOKEN}" \
-H "Accept: application/json" | jq -r '.data[] | [.name, .type, .ttl, .data] | @tsv'
Apply updates across multiple records in three stages: calculate a diff, run a dry-run confirmation, and apply changes. Use idempotent upsert logic. Instead of executing arbitrary creates or deletes, query the current state of a specific subdomain and record type. If the record exists and matches the target payload, exit cleanly. If the value differs, issue a targeted PUT update.
Custom shell scripts handle simple tasks like updating an emergency TXT record, but they become fragile when tracking large infrastructure topologies. When scripts manage tens of subdomains across environments, transition from custom scripts to declarative configuration management via the DNSCove Terraform provider.
Migrating a Route 53 zone using the documented import path
Zone files parse quickly. DNSCove provides an RFC-compliant zone file import endpoint so teams can move records without manual entry. The migration workflow follows four steps:
- Extract your zone configuration into a standard bind-compatible zone file. According to the AWS Route 53 resource record sets documentation, records can be queried through the AWS CLI using the
list-resource-record-setscommand and formatted into standard resource strings. - Ensure proprietary AWS constructs are adapted, meaning Route 53 Alias records targeting S3, CloudFront, or ALBs must be formatted as ALIAS records within DNSCove. Standard records (A, AAAA, CNAME, MX, TXT, SRV, CAA) migrate directly.
- Upload the zone file to the import endpoint through the API or management console, then review the parsed record set returned in the preview response before executing the final commit.
- Once verified, update the NS delegation records at your domain registrar.
When planning your delegation cutover, note that Customer zones are delegated to the shared ns1.dnscove.com / ns2.dnscove.org nameservers; per-customer vanity or white-label nameservers are not supported in v1.
To post a BIND zone file directly into the import API, use a multi-part form request directed to the imports endpoint:
curl -s -X POST "https://api.dnscove.com/v1/zones/zone_01HXYZ789ABC/import" \
-H "Authorization: Bearer ${DNSCOVE_API_TOKEN}" \
-F "file=@example.com.zone"
The server validates the uploaded records against standard DNS syntax rules, identifies any duplicate entries, checks syntax on TXT string formatting, and returns a JSON summary showing records queued for creation. Inspect this payload in your script before sending the final confirmation signal to apply the zone.
Architectural scope and authoritative operational boundaries
Understanding the architectural scope of an authoritative provider prevents design errors during cloud migrations. Route 53 bundles authoritative DNS with proprietary AWS load balancing triggers, health checks, and global latency measurement systems. DNSCove focuses exclusively on fast, dependable authoritative zone publication.
Network topology is one primary differentiator. Route 53 routes queries through a distributed anycast footprint across AWS data centers. DNSCove runs two unicast authoritative nameservers (ns1 in NYC, ns2 in Frankfurt), not an anycast network. The two geographically separated nodes provide resilient authoritative answers with low operational complexity.
Traffic routing rules also differ fundamentally between platforms. AWS Route 53 includes specialized routing policies that dynamically steer DNS queries based on client IP coordinates, measured round-trip times, or weighted ratios. DNSCove serves standard authoritative records and does not offer GeoDNS, weighted, latency-based, or failover traffic steering in v1. Teams that require geo-routing or endpoint health checks place those functions inside application load balancers, CDN distributions, or ingress proxies.
Zone synchronization is another operational boundary to consider during migration planning. DNSCove does not offer AXFR zone transfer or secondary-DNS operation in v1. Instead of maintaining primary and secondary zone replication across multiple providers using BIND AXFR mechanisms, infrastructure teams manage zones via the documented JSON API, the web console, or declarative Terraform configurations.
Infrastructure security also follows a lean operational model. DNSCove does not include dedicated DDoS scrubbing in v1. For domains requiring high-volume mitigation against network volumetric attacks, organizations place an edge proxy or CDN in front of web endpoints while delegating DNS directly to authoritative nameservers.
Billing structures reflect this operational focus. DNSCove uses fixed-cost pricing rather than per-zone or per-query metering. This predictable model simplifies budget planning for engineering teams managing hundreds of active records.
Frequently asked questions
Do AWS Route 53 SDK clients work directly?
No. DNSCove does not expose a Route 53 wire-compatible API in v1; you manage DNS through DNSCove's own JSON API, console, and Terraform guides, and migrate off Route 53 with a one-step zone import. Standard AWS tools like boto3 or the AWS CLI will not authenticate or parse DNSCove endpoints.
How does DNSCove handle apex domain mapping to load balancers?
DNSCove supports apex ALIAS records (CNAME-at-apex flattening, like Route53 Alias) with serve-stale protection. The nameservers resolve the configured target hostname and serve synthetic A and AAAA records directly to querying resolvers at the domain apex.
Can I configure vanity or custom branded nameservers for my zones?
No. Customer zones are delegated to the shared ns1.dnscove.com / ns2.dnscove.org nameservers; per-customer vanity or white-label nameservers are not supported in v1. You must update your domain registrar delegation to point to those two shared hostnames.
Are secondary DNS replication and AXFR zone transfers supported?
No. DNSCove does not offer AXFR zone transfer or secondary-DNS operation in v1.
Can I implement latency-based or geo-routing policies?
No. DNSCove serves standard authoritative records and does not offer GeoDNS, weighted, latency-based, or failover traffic steering in v1. Advanced steering policies must be handled at the application, proxy, or CDN edge layers.
Does the network run on anycast?
No. DNSCove runs two unicast authoritative nameservers (ns1 in NYC, ns2 in Frankfurt), not an anycast network. The dual unicast setup provides independent European and North American authoritative points of presence.
How are API rate limits enforced across automation workflows?
The API enforces limits of 600 read requests per minute and 120 write mutations per minute per account. Rate status is returned in the X-RateLimit-Remaining and X-RateLimit-Reset HTTP response headers. If an automation script exceeds this threshold, the API responds with an HTTP 429 status code indicating the required retry backoff.
- No AWS account required
- Zero-downtime Route 53 cutover
- Apex ALIAS / ANAME to any target
- DNS as code — Terraform, CloudFormation
Straight answer: DNSSEC signing isn't available yet — it's on the roadmap. Everything else here works today. Authoritative nameservers: ns1.dnscove.com, ns2.dnscove.org.