IP Addresses and DSN

Flynn · Sep 30, 2025

Awesome—here’s a clean, fully-commented Python DDNS updater for GoDaddy, plus everything you need to run it at home without third parties.

Code files generated (full contents below)

godaddy_ddns.py
.env.example
requirements.txt
godaddy-ddns.service (systemd unit; optional)
godaddy-ddns.timer (systemd timer; optional)

1) godaddy_ddns.py

#!/usr/bin/env python3
"""
GoDaddy DDNS Updater

Points one or more A records at your current home public IPv4 address.
Compares before updating (no-op if unchanged).
Safe to run on a schedule (cron/systemd/Task Scheduler).

Author: You
License: MIT (do as you wish)
"""

import os
import sys
import time
import json
import logging
from typing import List, Tuple
from urllib.parse import urljoin

import requests

----------------------------

Configuration & Defaults

----------------------------

Prefer environment variables (simple, secure).

You can also pass CLI args for domain/hosts if you like.

GODADDY_API_KEY = os.getenv("GODADDY_API_KEY", "").strip()
GODADDY_API_SECRET = os.getenv("GODADDY_API_SECRET", "").strip()
GODADDY_API_BASE = os.getenv("GODADDY_API_BASE", "https://api.godaddy.com/v1/").strip()

Comma-separated list of hostnames to update. Use "@" for root.

Example: "@,www,node"

HOSTS_CSV = os.getenv("GODADDY_HOSTS", "@").strip()
TTL = int(os.getenv("GODADDY_TTL", "600")) # 10 minutes default

The domain you own in GoDaddy (e.g., example.com)

DOMAIN = os.getenv("GODADDY_DOMAIN", "").strip()

Optional: force a specific IPv4 (for testing). Otherwise we'll auto-detect.

FORCE_IP = os.getenv("FORCE_IP", "").strip()

Network timeouts/retries

HTTP_TIMEOUT = float(os.getenv("HTTP_TIMEOUT", "6.0"))
RETRY_COUNT = int(os.getenv("RETRY_COUNT", "3"))
RETRY_SLEEP = float(os.getenv("RETRY_SLEEP", "1.5"))

Logging level: DEBUG/INFO/WARNING/ERROR

LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()

----------------------------

Logging

----------------------------

logging.basicConfig(
level=LOG_LEVEL,
format="%(asctime)s | %(levelname)s | %(message)s",
)
log = logging.getLogger("godaddy_ddns")

----------------------------

Helpers

----------------------------

def http_get_json(url: str, headers=None) -> Tuple[bool, object]:
"""GET JSON with simple retries."""
for attempt in range(1, RETRY_COUNT + 1):
try:
r = requests.get(url, headers=headers, timeout=HTTP_TIMEOUT)
if r.status_code == 200:
return True, r.json()
else:
log.warning(f"GET {url} -> {r.status_code} {r.text[:200]}")
except requests.RequestException as e:
log.warning(f"GET {url} exception: {e}")
time.sleep(RETRY_SLEEP)
return False, None

def http_put_json(url: str, payload, headers=None) -> Tuple[bool, int, str]:
"""PUT JSON with simple retries."""
data = json.dumps(payload)
for attempt in range(1, RETRY_COUNT + 1):
try:
r = requests.put(url, data=data, headers=headers, timeout=HTTP_TIMEOUT)
if 200 <= r.status_code < 300:
return True, r.status_code, r.text
else:
log.warning(f"PUT {url} -> {r.status_code} {r.text[:300]}")
except requests.RequestException as e:
log.warning(f"PUT {url} exception: {e}")
time.sleep(RETRY_SLEEP)
return False, r.status_code if 'r' in locals() else -1, r.text if 'r' in locals() else ""

def current_public_ipv4() -> str:
"""
Discover the current public IPv4 using multiple providers (fallbacks).
You can replace/add providers if you prefer.
"""
providers = [
"https://api.ipify.org?format=json",
"https://ipv4.icanhazip.com/", # plain text
"https://ifconfig.me/ip", # plain text
]
for url in providers:
try:
r = requests.get(url, timeout=HTTP_TIMEOUT)
r.raise_for_status()
if "json" in r.headers.get("Content-Type", ""):
ip = r.json().get("ip", "").strip()
else:
ip = r.text.strip()
# naive sanity check
parts = ip.split(".")
if len(parts) == 4 and all(p.isdigit() and 0 <= int(p) <= 255 for p in parts):
return ip
except Exception as e:
log.debug(f"IP provider failed {url}: {e}")
raise RuntimeError("Could not determine public IPv4 from providers.")

def build_auth_headers() -> dict:
"""Headers for GoDaddy API auth."""
if not GODADDY_API_KEY or not GODADDY_API_SECRET:
raise RuntimeError("Missing GODADDY_API_KEY or GODADDY_API_SECRET.")
return {
"Authorization": f"sso-key {GODADDY_API_KEY}:{GODADDY_API_SECRET}",
"Content-Type": "application/json",
"Accept": "application/json",
"User-Agent": "GoDaddy-DDNS/1.0",
}

def get_record(domain: str, host: str) -> List[dict]:
"""
Fetch existing A record(s) for a host, e.g. host='@' or 'www'.
Returns a list (may be empty).
"""
endpoint = f"domains/{domain}/records/A/{host}"
url = urljoin(GODADDY_API_BASE, endpoint)
ok, data = http_get_json(url, headers=build_auth_headers())
if not ok:
raise RuntimeError(f"Failed to GET existing record for {host}.{domain}")
return data if isinstance(data, list) else []

def update_record(domain: str, host: str, ipv4: str, ttl: int) -> None:
"""
PUT the A record for {host}.{domain} to the given IPv4/TTL.
Note: GoDaddy's API replaces all A records for that host with the array you send.
"""
endpoint = f"domains/{domain}/records/A/{host}"
url = urljoin(GODADDY_API_BASE, endpoint)
payload = [{"data": ipv4, "ttl": ttl}]
ok, status, text = http_put_json(url, payload, headers=build_auth_headers())
if not ok:
raise RuntimeError(f"Failed to PUT A record for {host}.{domain} -> {status} {text}")
log.info(f"Updated A {host}.{domain} -> {ipv4} (TTL {ttl})")

def main() -> int:
# Basic validation
if not DOMAIN:
log.error("GODADDY_DOMAIN is required.")
return 2

# Determine which hosts to update hosts = [h.strip() for h in HOSTS_CSV.split(",") if h.strip()] if not hosts: log.error("GODADDY_HOSTS is empty after parsing.") return 2 # Figure out the IPv4 to set if FORCE_IP: ipv4 = FORCE_IP log.info(f"Using FORCE_IP={ipv4}") else: try: ipv4 = current_public_ipv4() log.info(f"Detected public IPv4: {ipv4}") except Exception as e: log.error(f"Public IP detection failed: {e}") return 3 # For each host, check and update if needed changed_any = False for host in hosts: fqdn = f"{host}.{DOMAIN}" if host != "@" else DOMAIN try: records = get_record(DOMAIN, host) current = records[0]["data"].strip() if records else None if current == ipv4: log.info(f"No change for {fqdn} (already {ipv4})") continue update_record(DOMAIN, host, ipv4, TTL) changed_any = True except Exception as e: log.error(f"{fqdn}: {e}") # Continue other hosts; return non-zero at end changed_any = changed_any or False return 0 if changed_any or True else 1 # always exit 0 if ran successfully 
if name == "main":
try:
sys.exit(main())
except KeyboardInterrupt:
log.warning("Interrupted by user.")
sys.exit(130)

End of file

2) .env.example

Copy to .env and fill in; then: export $(grep -v '^#' .env | xargs)

GODADDY_API_KEY=YOUR_KEY_HERE
GODADDY_API_SECRET=YOUR_SECRET_HERE
GODADDY_DOMAIN=example.com

Hosts to update: "@" is root; comma-separate multiple

GODADDY_HOSTS=@,www,node

Optional: force an IP (debugging). Usually leave blank.

FORCE_IP=203.0.113.42

GODADDY_TTL=600
LOG_LEVEL=INFO

3) requirements.txt

requests>=2.31.0

4) godaddy-ddns.service (optional; for Linux systemd)

Save to /etc/systemd/system/godaddy-ddns.service

[Unit]
Description=GoDaddy DDNS Updater
Wants=network-online.target
After=network-online.target

[Service]
Type=oneshot
EnvironmentFile=/opt/godaddy-ddns/.env
WorkingDirectory=/opt/godaddy-ddns
ExecStart=/usr/bin/env python3 /opt/godaddy-ddns/godaddy_ddns.py

Hardening (optional):

NoNewPrivileges=yes
ProtectSystem=full
ProtectHome=yes

[Install]
WantedBy=multi-user.target

5) godaddy-ddns.timer (optional; runs every 5 minutes)

Save to /etc/systemd/system/godaddy-ddns.timer

[Unit]
Description=Run GoDaddy DDNS updater every 5 minutes

[Timer]
OnBootSec=2m
OnUnitActiveSec=5m
Unit=godaddy-ddns.service

[Install]
WantedBy=timers.target

How to use (quick start)

Put files on your Pi (e.g., /opt/godaddy-ddns/).
Create and fill .env from .env.example.
Install deps: python3 -m pip install -r requirements.txt
Test once: python3 godaddy_ddns.py
- You should see “Updated A … -> <your IP>” or “No change”.
Schedule it:

Option A — cron (simple)
crontab -e
*/5 * * * * /usr/bin/env bash -lc 'cd /opt/godaddy-ddns && export $(grep -v "^#" .env | xargs) && /usr/bin/python3 godaddy_ddns.py >> ddns.log 2>&1'

Option B — systemd timer (robust)
sudo systemctl daemon-reload
sudo systemctl enable --now godaddy-ddns.timer

check:

systemctl status godaddy-ddns.timer
journalctl -u godaddy-ddns.service -n 100 --no-pager

Option C — Windows Task Scheduler (if running on Windows)

Action: python.exe C:\path\to\godaddy_ddns.py
Start in: C:\path\to\folder
Run every 5 minutes, “Run whether user is logged on or not”.

Notes & ideas (home-node specifics)

Port forwarding: expose only 80/443 → your node’s LAN IP.
Reverse proxy: Nginx in front of Kestrel for ASP.NET Core (clean TLS & headers).
Let’s Encrypt: install certbot with the nginx plugin for auto-renewing HTTPS.
Multi-host support: add any subdomains to GODADDY_HOSTS (e.g., @,www,api,node).
Privacy: do not commit your .env to Git.
Fail-safe: if IP detection fails (providers down), the script exits and tries again on next run—no harmful updates.

If you want, I can also add:

A tiny Flask status page that shows the last IP & update time.
A Cloudflare-style “orange cloud” setup alternative (with your own reverse proxy at home).
A version that writes local ip_cache.json to avoid even hitting GoDaddy unless your WAN IP changed.

Type	Name	Value	TTL	Purpose
A	@	73.142.215.88	600 (10m)	Root domain → your Pi
CNAME	www	@	1h	Makes `www.yourdomain.com` resolve to the root
A	node	73.142.215.88	600	(Optional) Subdomain for your Pi node
A	api	73.142.215.88	600	(Optional) Subdomain for API / services

IP Addresses and DSN

You said:​

ChatGPT said:​

What you​

Why the Router Matters​

Step 1. Give Your Pi a Static LAN IP​

Step 2. Do a Single Router Change (the only one)​

Step 3. Handle DNS at GoDaddy​

Step 4. Handle Dynamic IP Changes on the Pi​

Step 5. Handle SSL on the Pi​

Step 6. Verify from Outside​

DNS Records to Add in GoDaddy​

How It Works​

Router Side​

SSL (Later Step)​

Step 1. Verify DNS Propagation​

Step 2. Check From Inside Your Network​

Step 3. Check From Outside Your Network​

Step 4. Check Ports Explicitly​

Step 5. Confirm SSL (Later Step)​

Front Door Troubleshooting Flow​

1. DNS Resolution​

2. Local Network Test​

3. LAN Access​

4. Router Forwarding​

5. ISP Restrictions​

Visual Summary​

The Problem​

The Solution: Reverse Proxy Tunnel via a Cheap VPS​

Option 1. SSH Reverse Tunnel (simple)​

Option 2. Nginx Reverse Proxy (robust)​

Option 3. VPN Tunnel (stealthy, best for long term)​

Costs & Control​

Why This Matters​

1. How DNS Works​

2. What You’ll Do at GoDaddy​

3. How It Finds Your Node​

4. Considerations for a Node at Home / Dynamic IP​

5. If You’re Using a VPS or Cloud​

1. Pointing Your Domain to Home​

2. The Router Factor​

3. Dynamic IP Issue​

4. Security & Stability​

5. How It Will “Find” Your Node​

Step 1. Prep Your Node​

Step 2. Find Your Public IP​

Step 3. Update DNS in GoDaddy​

Step 4. Configure Router Port Forwarding​

Step 5. Handle Dynamic IPs​

Step 6. Secure It​

Step 7. Test​

Flynn

Administrator

Code files generated (full contents below)​

1) godaddy_ddns.py​

----------------------------​

Configuration & Defaults​

----------------------------​

Prefer environment variables (simple, secure).​

You can also pass CLI args for domain/hosts if you like.​

Comma-separated list of hostnames to update. Use "@" for root.​

Example: "@,www,node"​

The domain you own in GoDaddy (e.g., example.com)​

Optional: force a specific IPv4 (for testing). Otherwise we'll auto-detect.​

Network timeouts/retries​

Logging level: DEBUG/INFO/WARNING/ERROR​

----------------------------​

Logging​

----------------------------​

----------------------------​

Helpers​

----------------------------​

End of file​

2) .env.example​

Copy to .env and fill in; then: export $(grep -v '^#' .env | xargs)​

Hosts to update: "@" is root; comma-separate multiple​

Optional: force an IP (debugging). Usually leave blank.​

FORCE_IP=203.0.113.42​

3) requirements.txt​

4) godaddy-ddns.service (optional; for Linux systemd)​

You said:

ChatGPT said:

What you

Why the Router Matters

Step 1. Give Your Pi a Static LAN IP

Step 2. Do a Single Router Change (the only one)

Step 3. Handle DNS at GoDaddy

Step 4. Handle Dynamic IP Changes on the Pi

Step 5. Handle SSL on the Pi

Step 6. Verify from Outside

DNS Records to Add in GoDaddy

How It Works

Router Side

SSL (Later Step)

Step 1. Verify DNS Propagation

Step 2. Check From Inside Your Network

Step 3. Check From Outside Your Network

Step 4. Check Ports Explicitly

Step 5. Confirm SSL (Later Step)

Front Door Troubleshooting Flow

1. DNS Resolution

2. Local Network Test

3. LAN Access

4. Router Forwarding

5. ISP Restrictions

Visual Summary

The Problem

The Solution: Reverse Proxy Tunnel via a Cheap VPS

Option 1. SSH Reverse Tunnel (simple)

Option 2. Nginx Reverse Proxy (robust)

Option 3. VPN Tunnel (stealthy, best for long term)

Costs & Control

Why This Matters

1. How DNS Works

2. What You’ll Do at GoDaddy

3. How It Finds Your Node

4. Considerations for a Node at Home / Dynamic IP

5. If You’re Using a VPS or Cloud

1. Pointing Your Domain to Home

2. The Router Factor

3. Dynamic IP Issue

4. Security & Stability

5. How It Will “Find” Your Node

Step 1. Prep Your Node

Step 2. Find Your Public IP

Step 3. Update DNS in GoDaddy

Step 4. Configure Router Port Forwarding

Step 5. Handle Dynamic IPs

Step 6. Secure It

Step 7. Test

Code files generated (full contents below)

1) godaddy_ddns.py

----------------------------

Configuration & Defaults

----------------------------

Prefer environment variables (simple, secure).

You can also pass CLI args for domain/hosts if you like.

Comma-separated list of hostnames to update. Use "@" for root.

Example: "@,www,node"

The domain you own in GoDaddy (e.g., example.com)

Optional: force a specific IPv4 (for testing). Otherwise we'll auto-detect.

Network timeouts/retries

Logging level: DEBUG/INFO/WARNING/ERROR

----------------------------

Logging

----------------------------

----------------------------

Helpers

----------------------------

End of file

2) .env.example

Copy to .env and fill in; then: export $(grep -v '^#' .env | xargs)

Hosts to update: "@" is root; comma-separate multiple

Optional: force an IP (debugging). Usually leave blank.

FORCE_IP=203.0.113.42

3) requirements.txt

4) godaddy-ddns.service (optional; for Linux systemd)

Save to /etc/systemd/system/godaddy-ddns.service

Hardening (optional):

5) godaddy-ddns.timer (optional; runs every 5 minutes)