About this article: This article is reviewed against the cited sources. This is source research, not lab validation. Check the stated versions and your own requirements before making changes.
When a Let's Encrypt renewal fails with "Timeout during connect (likely firewall problem)", the certificate authority's validator tried to open a TCP connection to your server on port 80 and the connection never completed. No answer came back at all, not even a refusal. The message can begin with the IP address it tried; if it does, that address is the clue: it shows whether the problem is a firewall in front of your IPv4 address, an old IPv6 (AAAA) record, or a redirect to a port that is closed.
What the error means
Let's Encrypt's HTTP-01 challenge works like this: the client places a token file at http://<your domain>/.well-known/acme-challenge/<token>, and Let's Encrypt "tries retrieving it (potentially multiple times from multiple vantage points)". The challenge page adds: "The HTTP-01 challenge can only be done on port 80." Certbot's --http-01-port option changes only where Certbot listens: "A conforming ACME server will still attempt to connect on port 80".
The message text comes from the Boulder source, the software Let's Encrypt runs. In the version read, a timeout while the connection is being made ("dial") is reported as Timeout during connect (likely firewall problem). For an HTTP fetch, detailedError() in va/va.go puts Fetching <URL>: in front of that text, and in front of the whole message the address it used. The source distinguishes other failures in words:
| Message (from the Boulder source) | What it means |
|---|---|
Timeout during connect (likely firewall problem) |
The TCP connection was never established. Packets were dropped or never answered |
Timeout after connect (your server may be slow or overloaded) |
The connection worked, then the response did not arrive in time. The source builds the same pattern as Timeout during <operation> (your server may be slow or overloaded) for other operations such as read |
Connection refused |
The address answered with a refusal. Nothing listens on port 80 |
Network unreachable |
No route |
Connection reset by peer |
The connection was reset after it started |
Three behaviours from the source and the Let's Encrypt documentation matter:
- IPv6 first. Let's Encrypt's IPv6 Support page (last updated August 4, 2026) says: "Let's Encrypt will always prefer the IPv6 addresses for the initial connection." A comment in the source reads "Prefer the first IPv6 address, falling back to the first IPv4 address." If the name has an
AAAArecord, that address is tried first. The page adds: "There is not a way to request Let's Encrypt prefer IPv4, you must fix the misconfiguration." - IPv4 fallback. The same page says: "If the IPv6 connection fails at the network level (e.g. there is a timeout) and there are IPv4 addresses available then we will retry the request with one of the IPv4 addresses." It also says "The IPv6 to IPv4 retry only occurs on connection timeouts, not on other types of error." In the source the fallback applies only to errors during the connection attempt.
- Redirects. The challenge page says the implementation "follows redirects, up to 10 redirects deep", accepts only http and https redirects, and "only to ports 80 or 443". A redirect to a host or port with no answer produces the same timeout.
An IPv6 address in the message means an IPv6 attempt timed out. It does not prove that no IPv4 fallback happened. The IPv6 Support page says: "To keep our CA software simple we only perform an IPv6 to IPv4 retry on the first request when validating "http-01" challenges. If you use redirects, the redirects will not get retry treatment." Its example is a name with an AAAA record that always times out and an A record whose web server redirects HTTP to HTTPS: the first request falls back to IPv4 and receives the redirect, and "the subsequent request will again prefer the IPv6 address but will time out without falling back to IPv4". In that case the message names an IPv6 address even though a fallback worked on the first request. The page gives two ways out: "fixing the IPv6 misconfiguration or removing the HTTP to HTTPS redirect for requests to the ACME HTTP-01 challenge path".
The Boulder commit read here (va/http.go) has a loop that applies the fallback record to each request, with a comment about "IPv4 fallbacks of those redirects". The current source and the August 2026 page may therefore differ about redirects. The page is the documented behaviour; the source reading has not been tested here.
If the message shows an IPv4 address, either the name has no IPv6 address or the IPv4 attempt itself failed.
Likely causes
| Cause | What you see | How to confirm |
|---|---|---|
| Firewall, security group or router blocks inbound TCP 80 | Timeout with your IPv4 address | A test of port 80 from outside your network times out |
| HTTP is closed after moving the site to HTTPS only | Site works on 443, renewal fails | Same test: 80 closed, 443 open |
An old AAAA record points to an address that does not answer |
Message shows an IPv6 address | Name resolves to an IPv6 address that is not your server, or is not allowed in |
A record points to an old server |
Timeout with an old address | The address in the message is not your current server |
| A redirect sends the validator to a host or port that does not answer | The address in the message is a different host | curl shows the redirect chain |
An AAAA record times out and port 80 redirects to HTTPS |
An IPv6 address in the message although http://name/ answers over IPv4 |
curl -4 works and curl -6 times out |
| A rate limiter, intrusion rule or geographic block drops validation traffic | Works for some tests and not for the CA | Let's Encrypt validates from several addresses and does not publish them |
| Authorisation was cached, so a firewall change only shows up later | Renewals succeed for weeks, then fail | Cached authorisations last "up to 30 days from the time of validation, depending on the associated profile" |
Prove the cause before changing anything
1. Read the exact message and the address. The Certbot log is in /var/log/letsencrypt by default (--logs-dir changes it). Copy the full line, including the leading address.
2. Test port 80 from outside your network. The validator is on the Internet, so test from a machine that is not on your LAN, not from the server itself.
curl -sI --connect-timeout 10 http://app.example.com/.well-known/acme-challenge/test
curl -4 -sI --connect-timeout 10 http://app.example.com/
curl -6 -sI --connect-timeout 10 http://app.example.com/
-I fetches headers only, --connect-timeout limits the connection phase, and -4 and -6 restrict curl to IPv4 or IPv6 addresses. A timeout from -4 means the IPv4 path is blocked. A timeout from -6 means the IPv6 address is the problem. An HTTP status (even 404) means port 80 answers, and you should look at redirects.
3. Follow the redirect chain.
curl -sI --location --max-redirs 10 http://app.example.com/.well-known/acme-challenge/test
--location follows redirects, and the manual notes that with --head the headers from all pages are shown. Count the hops and check that none leaves ports 80 and 443.
4. Check what listens on port 80 on the server.
ss -ltnp '( sport = :80 )'
A listener must exist on the address the name resolves to. For IPv6, look for a [::]:80 or specific IPv6 listener.
5. Dry-run the renewal.
certbot renew --dry-run
The Certbot guide says --dry-run tests "renew" or "certonly" without saving any certificates and uses the Let's Encrypt staging server. A dry run reproduces the failure without issuing a certificate.
Fix
Disruptive step: every change below touches live firewall, DNS or web server settings. Record the current rule, record and configuration before changing them, so you can put them back.
Open inbound port 80
Allow inbound TCP 80 from any address to the server that answers the challenge, in every layer: host firewall, network firewall or security group, NAT or port forward. Let's Encrypt says it does not publish validator addresses and "these IP addresses may change at any time", so an address allow-list is not a fix.
Disruptive step: opening port 80 exposes the web server to the Internet on that port. Keep a redirect to HTTPS for normal traffic and serve the challenge path without authentication. To back out, close the rule again.
Remove or repair a stale AAAA record
If the name has an AAAA record that does not reach your server, either make that address reach port 80 or delete the record.
Disruptive step: a DNS change takes effect as caches expire, up to the record's TTL. Visitors and the validator may see old data until then. To back out, add the record again.
Correct the A record or the redirect
Point the name at the server that answers the challenge. If the redirect leaves the host, serve /.well-known/acme-challenge/ directly on port 80 before the redirect rule. Removing the HTTP-to-HTTPS redirect for the challenge path is also the second remedy the IPv6 Support page names.
Disruptive step: changing an A record or a redirect rule changes where all visitors for that name land, and DNS changes take effect as caches expire. To back out, restore the previous record or rule.
If port 80 cannot be allowed
Use a different challenge. The Let's Encrypt page says of one alternative: "It works if port 80 is unavailable to you." "ACME challenge types: choosing HTTP-01, DNS-01 or TLS-ALPN-01 for each certificate" compares them.
Example (illustrative): app.example.com resolves to 203.0.113.10 and has no AAAA record. After the site was moved to HTTPS only, the firewall rule for TCP 80 was removed. The renewal log shows 203.0.113.10: Fetching http://app.example.com/.well-known/acme-challenge/<token>: Timeout during connect (likely firewall problem). From a machine outside the network, curl -4 -sI --connect-timeout 10 http://app.example.com/ times out after 10 seconds, while https:// answers. The firewall rule for TCP 80 is restored, with the web server redirecting everything except the challenge path to HTTPS. certbot renew --dry-run succeeds. The failure appeared weeks after the firewall change, because an earlier authorisation was cached: the FAQ says cached authorisations last "for up to 30 days from the time of validation, depending on the associated profile", so the first validation after that window hit the closed port.
Confirm the fix
- The outside
curl -4andcurl -6tests return an HTTP status, not a timeout. certbot renew --dry-runfinishes with no errors.- A real renewal later shows the new expiry date in
certbot certificates. - Port 80 also answers for every name on the certificate, not only the first. Let's Encrypt validates that you control "the domain names in that certificate".
What to watch afterwards
- Check
certbot certificatesexpiry dates on a schedule. Since Certbot 4.0.0 a certificate is ready for renewal "when less than 1/3rd of its lifetime remains"; for a 90-day certificate that is 90 ÷ 3 = 30 days left. Alert well inside that window, not at the last day. - Find the scheduled task: the Certbot guide says to look for
certbot renewin the crontab or insystemctl list-timers, and check its exit status.certbot renewexits 1 only if a renewal attempt failed. - Keep a record of every firewall rule and DNS record that renewal depends on, so a clean-up does not remove them.
- Check IPv6 whenever an
AAAArecord is added or changed.
Read next
Related articles you may want next.
- HostingACME challenge types: choosing HTTP-01, DNS-01 or TLS-ALPN-01 for each certificateHow HTTP-01, DNS-01 and TLS-ALPN-01 validate a domain, what access each needs, and how to choose one per certificate so renewals keep working.Read article
- HostingShorter TLS certificate lifetimes: the 2026 to 2029 schedule and what to automateThe CA/Browser Forum schedule cutting TLS certificate lifetimes to 200, 100 and 47 days, and how to decide which renewals to automate first.Read article
- TroubleshootingWebsite works for some users and not others: an old AAAA (IPv6) record after a moveSite moved but some users still hit the old server or get errors? Check for a stale AAAA record with dig and curl -4 and -6, then fix or remove it.Read article
Risks and limits
- These commands have not been run or lab-tested. They are taken from the Let's Encrypt, Certbot and curl documentation and the Boulder source listed below.
- Message wording is from the Boulder source at the commit named in the version scope. The IPv6 preference and the IPv4 fallback are documented on Let's Encrypt's IPv6 Support page (last updated August 4, 2026); the redirect detail there may differ from the source commit read.
- Other certificate authorities and ACME clients word their errors differently.
- Rate limits and caching rules can change. The FAQ date is April 2025.
- Opening port 80 widens exposure. Serve only a redirect and the challenge path there.
Sources
- Let's Encrypt: Challenge Types — Let's Encrypt, last updated February 12, 2026, accessed 18 November 2026
- Let's Encrypt: IPv6 Support — Let's Encrypt, last updated August 4, 2026, accessed 18 November 2026
- Let's Encrypt: Frequently Asked Questions — Let's Encrypt, last updated April 28, 2025, accessed 18 November 2026
- Boulder source: va/va.go — Let's Encrypt, commit 88ced54e dated 2026-11-18, accessed 18 November 2026
- Boulder source: va/http.go — Let's Encrypt, commit 88ced54e dated 2026-11-18, accessed 18 November 2026
- Boulder repository: latest commit listing (GitHub API) — GitHub, returned commit 88ced54e dated 2026-11-18T00:58:49Z when read, accessed 18 November 2026
- Certbot User Guide — Certbot stable documentation, no date or version shown, accessed 18 November 2026
- curl man page — curl project, describes curl 8.23.1, accessed 18 November 2026
- ss(8) — Linux man-pages, accessed 18 November 2026
This article was originally published on .