Updating GoDaddy DNS Records With Your Dynamic Home Server IP

Updating your domain records when your Internet service provider changes your public address can be challenging, especially if you host services at home. Most residential broadband connections use dynamic IP addresses that shift periodically due to reboots, power outages, or lease expirations. Because GoDaddy's standard DNS management interface is designed primarily for static zones, you need an automated method to push your current address to their servers whenever it changes.

To manage this effectively, you first need to know your current external address. You can quickly check your public visibility using the What Is My IP tool on XiaTools to verify what remote networks see when your home server connects to the internet. Once you have this baseline, you can configure scripts or client utilities to monitor your address and update your GoDaddy domain settings automatically through their API.

Understanding the GoDaddy API for DNS Management

GoDaddy provides a robust REST API that allows you to read and write DNS zone files programmatically without logging into their web portal manually. To interact with this interface, you must generate a set of production or test API credentials from the GoDaddy Developer Portal. These credentials consist of an API Key and an API Secret, which act as a username and password for your automated update scripts.

When working with the API, your scripts will typically issue an HTTP PUT request to replace an existing DNS record or a PATCH request to modify specific fields. The endpoint format for managing a specific record type and name on your domain follows a predictable REST structure:

https://api.godaddy.com/v1/domains/{domain}/records/{type}/{name}

Required API Headers

Every request you send to the GoDaddy API must include specific authentication and content-type headers. Omitting these headers will result in HTTP 401 Unauthorized or HTTP 415 Unsupported Media Type errors.

• Authorization: sso-key YOUR_API_KEY:YOUR_API_SECRET
• Content-Type: application/json
• Accept: application/json

Step-by-Step: Setting Up a Dynamic DNS Update Script

Because GoDaddy does not offer a native Dynamic DNS client like some other domain registrars, you must write a lightweight script to check your IP and update GoDaddy via their API. Below is a comprehensive guide to implementing this using a standard Bash script suitable for Linux servers, Raspberry Pi devices, or macOS environments.

Step 1: Gather Your Credentials and Domain Details

Before writing your script, ensure you have the following information ready:

• Your GoDaddy API Key and API Secret.
• The root domain name (e.g., example.com).
• The hostname or subdomain you want to update (e.g., home for home.example.com).
• A reliable external IP detection service.

Step 2: Write the Bash Update Script

Create a file named update-godaddy-dns.sh on your server. This script checks your current public address against a locally cached file to avoid spamming the GoDaddy API when your address has not changed.

#!/bin/bash

# Configuration
DOMAIN="example.com"
RECORD_NAME="home"
API_KEY="your_api_key_here"
API_SECRET="your_api_secret_here"
CACHE_FILE="/tmp/current_ip.txt"

# Get current public IP using a reliable lookup service
CURRENT_IP=$(curl -s https://api.ipify.org)

# Validate IP format
if [[ ! $CURRENT_IP =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
    echo "Error: Failed to retrieve a valid public IP address."
    exit 1
fi

# Check if cache file exists and read old IP
if [ -f "$CACHE_FILE" ]; then
    OLD_IP=$(cat "$CACHE_FILE")
else
    OLD_IP=""
fi

# Compare current IP with cached IP
if [ "$CURRENT_IP" == "$OLD_IP" ]; then
    echo "IP address has not changed ($CURRENT_IP). Exiting."
    exit 0
fi

# Update GoDaddy DNS via API
RESPONSE=$(curl -s -o /dev/null -w "%{http_code}" -X PUT \
    "https://api.godaddy.com/v1/domains/$DOMAIN/records/A/$RECORD_NAME" \
    -H "Authorization: sso-key $API_KEY:$API_SECRET" \
    -H "Content-Type: application/json" \
    -d "[{"data": "$CURRENT_IP", "ttl": 600}]")

if [ "$RESPONSE" -eq 200 ]; then
    echo "Successfully updated $RECORD_NAME.$DOMAIN to $CURRENT_IP"
    echo "$CURRENT_IP" > "$CACHE_FILE"
else
    echo "Failed to update DNS. HTTP response code: $RESPONSE"
    exit 1
fi

Make the script executable by running the following command in your terminal:

chmod +x update-godaddy-dns.sh

Step 3: Automate with Cron

To ensure your home server updates its records automatically when your IP changes, schedule the script to run periodically using a cron job. Open your crontab editor:

crontab -e

Add a line to execute the script every 15 minutes:

*/15 * * * * /path/to/update-godaddy-dns.sh >> /var/log/godaddy-ddns.log 2>&1

Alternative: PowerShell Script for Windows Servers

If you run your home server on a Windows environment, you can achieve the exact same automation using a PowerShell script scheduled through the Windows Task Scheduler.

$domain = "example.com"
$recordName = "home"
$apiKey = "your_api_key_here"
$apiSecret = "your_api_secret_here"
$cachePath = "C:\Temp\current_ip.txt"

# Fetch current public IP
$currentIp = (Invoke-RestMethod -Uri "https://api.ipify.org").Trim()

# Read cached IP if exists
$oldIp = ""
if (Test-Path $cachePath) {
    $oldIp = (Get-Content $cachePath).Trim()
}

if ($currentIp -eq $oldIp) {
    Write-Output "IP address has not changed ($currentIp)."
    exit
}

# Prepare API request
$headers = @{
    "Authorization" = "sso-key $apiKey:$apiSecret"
    "Content-Type"  = "application/json"
    "Accept"        = "application/json"
}

$body = @(
    @{
        "data" = $currentIp
        "ttl"  = 600
    }
) | ConvertTo-Json

$uri = "https://api.godaddy.com/v1/domains/$domain/records/A/$recordName"

try {
    Invoke-RestMethod -Uri $uri -Method Put -Headers $headers -Body $body
    Set-Content -Path $cachePath -Value $currentIp
    Write-Output "Successfully updated $recordName.$domain to $currentIp"
} catch {
    Write-Error "Failed to update DNS: $_"
}

Comparison of Dynamic DNS Update Methods

Verifying Your DNS Propagation

After your script executes successfully, you should verify that global nameservers are returning your new home server IP address. You can query your authoritative nameservers directly using command-line diagnostic tools.

Run an nslookup command targeting GoDaddy's default nameservers to confirm the immediate record state:

nslookup home.example.com ns1.domaincontrol.com

Expected output sample:

Server:Unreported
Address: 97.74.100.1

Name:   home.example.com
Address: 192.0.2.53

You can also use dig to check the Time to Live (TTL) and record response:

dig @ns2.domaincontrol.com home.example.com A

Common Mistakes and How to Fix Them

When setting up programmatic domain updates, certain configuration oversights frequently cause failures. Review these common pitfalls to troubleshoot issues efficiently.

• Using Production Keys on Test Endpoints: GoDaddy provides distinct API keys for theirote development environment (api.ote-godaddy.com) and production environment (api.godaddy.com). Ensure your script points to the production URL if you are managing live domains.
• Setting TTL Too High: If your Time to Live is set to 86400 seconds (24 hours), caching nameservers will take a full day to reflect your new IP after an update. Lower your TTL to 600 seconds (10 minutes) before enabling dynamic updates.
• API Rate Limiting: GoDaddy enforces rate limits on their API endpoints. Running your check script every minute can trigger HTTP 429 Too Many Requests errors. Stick to an interval of 10 to 15 minutes.
• Incorrect Record Type: Attempting to update an A record with an IPv6 address will fail. Ensure you use AAAA records if you are publishing native IPv6 addresses for your home server.
• Permissions Errors: Make sure your GoDaddy API key has full production access permissions enabled in your developer dashboard. Restricted keys may lack write access to the zone file.

Dynamic DNS Setup Checklist

Review this quick checklist before deploying your automated update solution to production:

• Generated production API Key and Secret from GoDaddy.
• Verified current public IP visibility using diagnostic tools.
• Created an A record placeholder in the GoDaddy DNS management dashboard.
• Configured script with correct domain name, hostname, and credentials.
• Set record TTL to 600 seconds or lower for fast propagation.
• Tested script execution manually and verified successful HTTP 200 response.
• Installed script into Cron or Windows Task Scheduler with logging enabled.