On this page 7 sections
- What the response contains
- How each client reports it
- Confirm it is Cloudflare’s 1015
- Causes, most common first
- 1. Your own request rate crossed the rule
- 2. A retry loop that ignores the block
- 3. You share an IP address with other people
- 4. One page view is many requests
- 5. Requests the owner did not expect to be counted
- 6. The proxy layer: real 1015s and look-alikes
- For site owners: finding the rule that fired
- Cause-to-fix table
- How this was tested
Error 1015
Ray ID: a4e2d48e981b556b • 2026-10-21 19:57:15 UTC
You are being rate limited
What happened?
The owner of this website (proxy.wiki) has banned you temporarily from accessing this website.
That is the page Chrome shows. A command-line client usually gets something much shorter:
$ curl -s https://proxy.wiki/cdn-cgi/error/1015
error code: 1015
Both mean the same thing. A rate limiting rule that the site’s owner configured in Cloudflare counted more matching requests from you than it allows in its time window, and Cloudflare is refusing your requests until the rule’s block duration runs out. The HTTP status is 429 Too Many Requests. Cloudflare does not decide who gets limited. Its error 1015 page says the website owner sets these rules, and warns that trying again within a short period may extend the block.
So, from the visitor’s side: stop, wait, and come back slower. If it happens at a normal pace, you are probably sharing a counter with other people, and the person who can change that is the site owner. Send them the Ray ID.
The two captures above are real Cloudflare output. Cloudflare serves its default 1015 response at /cdn-cgi/error/1015 on any zone it proxies, and uses that path in its own changelog example. We requested it on proxy.wiki, a zone we run, so no third-party site was loaded to produce anything on this page. The proxy tests used a local Squid and local stand-in servers. Versions are listed with each capture and in the test notes near the end.
What the response contains
The headers, from curl 8.23.0 (the nel and report-to lines are removed):
$ curl -sS --compressed -D - -o /dev/null https://proxy.wiki/cdn-cgi/error/1015
HTTP/2 429
date: Wed, 21 Oct 2026 20:05:33 GMT
content-type: text/html; charset=UTF-8
retry-after: 30
cache-control: private, max-age=0, no-store, no-cache, must-revalidate, post-check=0, pre-check=0
expires: Thu, 01 Jan 1970 00:00:01 GMT
referrer-policy: same-origin
x-frame-options: SAMEORIGIN
server: cloudflare
cf-ray: a4e2e0b61b25915c-SOF
Three lines matter. The status is 429, which is what Cloudflare’s 1xxx status table lists for 1015. A log or monitor that records only the status will file this next to every other 429. The cf-ray value is the Ray ID, and its three-letter suffix names the Cloudflare data center that answered, here SOF. That suffix is worth noting because Cloudflare keeps rate limiting counters per data center, not globally; only data centers in the same location share them. And retry-after: 30 is Cloudflare telling the client when to try again.
That last header does not always arrive. Cloudflare picks the response format from the request, and in our tests the switch that mattered most was whether the request carried an Accept-Encoding header at all:
| Request headers (curl 8.23.0) | Content-Type returned | Retry-After | Body |
|---|---|---|---|
No Accept-Encoding (plain curl) |
text/plain |
absent | error code: 1015, 17 bytes |
--compressed, default Accept: */* |
text/html |
30 | Error page, 7,168 bytes |
--compressed, Accept: application/json |
application/json |
30 | JSON, 972 bytes |
--compressed, Accept: application/problem+json |
application/problem+json |
30 | JSON, 972 bytes |
--compressed, Accept: text/markdown |
text/markdown |
30 | Markdown, 799 bytes |
Cloudflare’s error responses reference describes negotiation on the Accept header. What we saw went further: without any Accept-Encoding header, every variant we tried came back as the 17-byte plain-text body with no Retry-After, whatever the Accept or User-Agent. Sending Accept-Encoding: identity, which asks for no compression, was enough to get the full response. The four Accept-Encoding variants we compared (none, gzip, br, identity) were each requested twice with identical results. Of the clients in our default request headers study, curl, Node’s node:http module and PHP’s file_get_contents send no Accept-Encoding; requests, httpx, Node fetch and Chromium all send one.
The JSON form is the easiest to act on in code:
$ curl -s --compressed -H "Accept: application/json" https://proxy.wiki/cdn-cgi/error/1015 | jq .
{
"type": "https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1015/",
"title": "Error 1015: You are being rate limited",
"status": 429,
"detail": "You are being rate-limited by the website owner's configuration.",
"instance": "a4e2e0b7feafa121",
"error_code": 1015,
"error_name": "rate_limited",
"error_category": "rate_limit",
"ray_id": "a4e2e0b7feafa121",
"timestamp": "2026-10-21T20:05:34Z",
"zone": "proxy.wiki",
"cloudflare_error": true,
"retryable": true,
"retry_after": 30,
"owner_action_required": false,
"what_you_should_do": "**Wait and retry.** This block is transient. Wait at least 30 seconds, then retry with exponential backoff.\n\nRecommended approach:\n1. Wait 30 seconds before your next request\n2. If rate-limited again, double the wait time (60s, 120s, etc.)\n3. If rate-limiting persists after 5 retries, stop and reassess your request pattern",
"footer": "This error was generated by Cloudflare on behalf of the website owner."
}
One limit on what this proves. The preview path returns the response without any rule being triggered, so its retry_after of 30 is not tied to a real rule’s duration. We did not configure a live rule to check whether a real block reports its remaining time in that field. Treat the value as Cloudflare’s advice, not as a countdown.
How each client reports it
Same URL, one request per client:
| Client | Version | What you see |
|---|---|---|
| curl, no flags | 8.23.0 and 8.7.1 | Prints error code: 1015, exit status 0 |
curl --fail |
8.23.0 | curl: (22) The requested URL returned error: 429 |
curl --fail over HTTP/2 |
8.7.1 (macOS system build) | curl: (56) The requested URL returned error: 429; the same build exits 22 with --http1.1 |
Python requests, raise_for_status() |
2.32.3 | HTTPError: 429 Client Error: Too Many Requests for url: https://proxy.wiki/cdn-cgi/error/1015 |
httpx, raise_for_status() |
0.27.2 | HTTPStatusError: Client error '429 Too Many Requests' for url 'https://proxy.wiki/cdn-cgi/error/1015' |
| Node global fetch | Node 24.2.0 | No exception. status 429, ok false |
| Chrome, headless | 155.0.8059.85 | Renders the error page with status 429 and no net:: error. Tab title: Access denied | proxy.wiki used Cloudflare to restrict access |
Plain curl and Node fetch both treat a 1015 as a successful transfer. A script that checks only the exit status, or only catches exceptions, will save error code: 1015 as if it were the page. Check the status code on every response. If you scripted around curl’s exit codes, note that the same --fail condition gave 22 on one build and 56 on the other.
Confirm it is Cloudflare’s 1015
server: cloudflare and a cf-ray header prove only that the site sits behind Cloudflare. They are on every response Cloudflare proxies, including the origin’s own errors:
$ curl -s -D - -o /dev/null https://proxy.wiki/this-page-does-not-exist-1015/ | grep -i -E "^HTTP|^server|^cf-ray|^content-type"
HTTP/2 404
content-type: text/html; charset=UTF-8
server: cloudflare
cf-ray: a4e2dd37c9203dc0-SOF
The proof is in the body: error code: 1015, the “Error 1015” page, or "error_code": 1015 in JSON. A 429 without any of those came from somewhere else, most often the origin’s own limiter, which Cloudflare passes through. There is one more wrinkle. On Pro plans and above, an owner can replace the default block with a custom body and any status from 400 to 499, according to Cloudflare’s rule setup guide. A Cloudflare rate limit can therefore arrive with no “1015” text at all.
The codes people confuse with 1015, with the status Cloudflare documents for each:
| Code | HTTP status | Who set it | What it means |
|---|---|---|---|
| 1015 | 429 | Site owner, rate limiting rule | Too many matching requests in the rule’s window |
| 1020 | 403 | Site owner, firewall rule | The request matched a rule that blocks it |
| 1006, 1007, 1008, 1106 | 403 | Site owner | Your IP address has been banned |
| 1010 | 403 | Site owner | Access banned on your browser’s signature |
| 1025 | 429 | Plan limit, not a visitor rule | The domain has reached its Cloudflare Workers plan limits |
| Plain 429, no 10xx code | 429 | Origin server | The site’s own limiter, passed through Cloudflare |
For the general shape of 403, 407 and 429 when a proxy is in the path, see 403 vs 407 vs 429.
Causes, most common first
1. Your own request rate crossed the rule
A Cloudflare rate limiting rule has five parts, all set by the owner: an expression that picks which requests count, the characteristics that decide whose counter a request lands in (the client IP on Free and Pro plans), a period, a request limit for that period, and a duration, which Cloudflare also calls the mitigation timeout. When a counter goes over the limit, the rule blocks every further matching request from that counter for the full duration. On a Free plan the period and the duration are both fixed at 10 seconds. The availability table lists the rest.
To check whether you are the cause, count your own rate in 10-second buckets. If your client logs a Unix timestamp as the first field of each request line:
awk '{print int($1/10)*10}' requests.log | uniq -c | sort -rn | head
The fix is to send fewer requests per window, honour Retry-After when you are limited, and give up after a bounded wait instead of looping. This client does all three. It ran on Python 3.9.6 with requests 2.32.3:
import random, time
from email.utils import parsedate_to_datetime
import requests
def retry_after_seconds(resp, default):
"""Seconds from a Retry-After header (delta-seconds or HTTP-date)."""
v = resp.headers.get("Retry-After")
if not v:
return default
if v.strip().isdigit():
return int(v)
try:
return max(0.0, parsedate_to_datetime(v).timestamp() - time.time())
except (TypeError, ValueError):
return default
def is_cloudflare_1015(resp):
return (resp.status_code == 429
and resp.headers.get("server", "").lower() == "cloudflare"
and "1015" in resp.text[:20000])
def polite_get(session, url, max_attempts=4, max_wait=300, **kw):
"""GET that treats 429 as 'slow down': honour Retry-After, back off, give up."""
waited, delay = 0.0, 30.0
for attempt in range(1, max_attempts + 1):
resp = session.get(url, timeout=20, **kw)
if resp.status_code != 429:
return resp
wait = retry_after_seconds(resp, delay) + random.uniform(0, 1)
if attempt == max_attempts or waited + wait > max_wait:
resp.raise_for_status() # stop: the limit is not lifting
print(f"429 on attempt {attempt} (cloudflare_1015={is_cloudflare_1015(resp)}), sleeping {wait:.1f}s")
time.sleep(wait)
waited += wait
delay = min(delay * 2, 300)
return resp
Against the real 1015 response it recognised the page, read the 30-second header, and stopped because 30 seconds exceeded the 20-second budget it was given:
cloudflare preview: 429 is_cloudflare_1015 = True retry_after_seconds = 30
gave up: 429 Client Error: Too Many Requests for url: https://proxy.wiki/cdn-cgi/error/1015
To see the behaviour under load we pointed it at a local stand-in limiter, not Cloudflare, shaped like a Free-plan rule: 5 requests per 10 seconds per client address, then a 10-second block that answers 429 with a Retry-After header. Each strategy sent 12 requests after the counter had reset:
| Strategy | 200 responses | 429 responses | Elapsed (s) |
|---|---|---|---|
| Loop with no delay | 5 | 7 | 0.0 |
| Paced, 2.1 s apart | 12 | 0 | 25.3 |
| polite_get, no pacing | 12 | 2 | 21.3 |
The unpaced loop got 7 refusals out of 12. polite_get finished slightly sooner than pacing but collected two 429s on the way. Against Cloudflare each of those is a blocked request in the owner’s security log, and Cloudflare warns that early retries may extend a block. Pacing below the limit is the version that never trips the rule. The local server is deterministic, so these numbers show client behaviour, not anything about Cloudflare’s timing. Exponential backoff explains the doubling delay, and the Python proxy guide covers sessions and adapters.
2. A retry loop that ignores the block
Automatic retries are the usual way a short block turns into a long one. curl’s --retry treats 429 as transient, and when no Retry-After arrives it waits one second, then doubles. Because plain curl gets no Retry-After from Cloudflare, that is exactly what happens:
$ curl --no-progress-meter --retry 2 -o /dev/null https://proxy.wiki/cdn-cgi/error/1015
Warning: Problem : HTTP error. Retrying in 1 second. 2 retries left.
Warning: Problem : HTTP error. Retrying in 2 seconds. 1 retry left.
Add --compressed and the header arrives, and curl honours it:
$ curl --no-progress-meter --compressed --retry 1 -o /dev/null https://proxy.wiki/cdn-cgi/error/1015
Warning: Problem : HTTP error. Retrying in 30 seconds. 1 retry left.
Cap the total with --retry-max-time. curl then refuses to wait longer than you allowed:
$ curl --no-progress-meter --compressed --retry 2 --retry-max-time 10 -o /dev/null https://proxy.wiki/cdn-cgi/error/1015
Warning: The Retry-After: time would make this command line exceed the maximum
Warning: allowed time for retries.
All three runs still exited 0, because none used --fail. In Python, urllib3’s Retry honours Retry-After by default for 413, 429 and 503. With Retry(total=1, status_forcelist=[429], backoff_factor=1) mounted on a requests session, the call waited out the header and then raised:
requests+Retry(total=1) after 30.1s -> RetryError: HTTPSConnectionPool(host='proxy.wiki', port=443): Max retries exceeded with url: /cdn-cgi/error/1015 (Caused by ResponseError('too many 429 error responses'))
httpx has no status-code retries built in. Its transport retries only connection failures, so a 429 comes straight back to your code. More curl options are in how to use a proxy with curl.
3. You share an IP address with other people
When a rule counts by IP, everyone behind one address shares one counter. That covers an office NAT, carrier-grade NAT on mobile networks, a VPN exit, a school network and a shared proxy exit. You can send a handful of requests and still land on 1015 because someone else on the same address used up the window. This is the usual explanation behind “error 1015 for no reason”.
To see the address and data center a Cloudflare site counts you under, ask that site for its trace. The address below is replaced with a documentation address:
$ curl -s https://proxy.wiki/cdn-cgi/trace | grep -E "^(ip|colo|loc|http|tls|uag)="
ip=203.0.113.24
uag=curl/8.23.0
colo=SOF
http=http/2
loc=BG
tls=TLSv1.3
Through a proxy, ip= shows the proxy’s exit. Cloudflare’s troubleshooting guide points at the same path for finding the data center.
Owners on Business plans and above can count by “IP with NAT support” instead, which tells visitors apart with a _cfuvid cookie. Cloudflare’s cookie documentation says visitors who do not return that cookie are likely to be grouped together. A script that drops cookies between requests puts itself in that shared group, so keep a cookie jar for the session. If you reach a site through a shared proxy exit, an address only you use makes the count yours alone. It does not raise the site’s limit; it stops other people’s requests from counting against you.
4. One page view is many requests
A rule whose expression matches every path counts images, scripts, stylesheets and API calls as well as pages. Cloudflare counts cached assets by default, and the option to exclude them exists only on Business plans and above. We loaded two proxy.wiki pages in Chrome 155 with the cache disabled and counted the requests sent to proxy.wiki:
| Page | Requests to the same host | Breakdown |
|---|---|---|
| Home page | 11 | 1 document, 3 fonts, 1 stylesheet, 2 scripts, 1 manifest, 1 fetch, 2 other |
| A guide page | 10 | 1 document, 3 fonts, 1 stylesheet, 2 scripts, 1 manifest, 2 other |
That is a small site. Even so, a rule allowing 20 requests per 10 seconds on every path would block a visitor on the third page opened within ten seconds. Pages with dozens of assets, apps that poll an API, and several open tabs on the same site all trip a broad rule sooner. From the visitor’s side, close tabs that auto-refresh and turn off extensions that prefetch links. The real fix sits with the owner: scope the rule to the paths that need protecting.
5. Requests the owner did not expect to be counted
Cloudflare documents a case where Workers subrequests to the same zone are counted as separate requests, so a rule fires sooner than its numbers suggest. It happens when the rule has “Also apply rate limiting to cached assets” turned off, and the troubleshooting page gives the expression that excludes them. Cloudflare is also open about rules being imprecise. Counters can lag detection by a few seconds, so some excess requests reach the origin before the block starts, and under heavy load a data center fails open rather than blocking. A visitor sees neither.
6. The proxy layer: real 1015s and look-alikes
Through a forward proxy, a real 1015 arrives inside a working tunnel. The proxy did its job. This run went through a local Squid 6.13:
$ curl -sv --compressed -o /dev/null -x http://127.0.0.1:41501 https://proxy.wiki/cdn-cgi/error/1015
> CONNECT proxy.wiki:443 HTTP/1.1
< HTTP/1.1 200 Connection established
* CONNECT tunnel established, response 200
< HTTP/2 429
< retry-after: 30
< server: cloudflare
< cf-ray: a4e2e0dea9107141-SOF
Squid logged the same request as a successful tunnel:
21/Oct/2026:23:05:40 +0300 127.0.0.1 TCP_TUNNEL/200 CONNECT proxy.wiki:443 - 172.67.211.89 -/-
A proxy that refuses you never reaches Cloudflare, and the error looks different. We ran a local stand-in gateway that answers every CONNECT with its own 429, the way a provider enforcing a concurrency cap might, and pointed Squid’s password-protected port at clients without credentials:
| Client | Proxy answers CONNECT with 429 | Proxy answers CONNECT with 407 |
|---|---|---|
| curl 8.23.0 | curl: (7) CONNECT tunnel failed, response 429 |
curl: (7) CONNECT tunnel failed, response 407 |
| curl 8.7.1 | curl: (56) CONNECT tunnel failed, response 429 |
Not run |
| requests 2.32.3 | ProxyError('Unable to connect to proxy', OSError('Tunnel connection failed: 429 Too Many Requests')) |
OSError('Tunnel connection failed: 407 Proxy Authentication Required') |
| httpx 0.27.2 | ProxyError: 429 Too Many Requests |
ProxyError: 407 Proxy Authentication Required |
| Chrome 155 | net::ERR_TUNNEL_CONNECTION_FAILED |
Not run |
If the message says “CONNECT tunnel failed” or “Tunnel connection failed”, the 429 came from your proxy, not from the site. One detail from the Chrome runs: against the refusing gateway, a single navigation produced six or seven CONNECT attempts for proxy.wiki across three runs. If your provider counts tunnel attempts, a browser spends that allowance faster than one request per page suggests.
TLS interception. An intercepting proxy, such as a corporate inspection appliance or a debugging proxy, ends your TLS session and opens its own connection to Cloudflare. The site sees the interceptor’s address and the interceptor’s TLS client, and so does every other user behind it. Rate limiting rules can count by IP, and Enterprise zones with Advanced Rate Limiting and Bot Management can also count by JA3 or JA4 fingerprint, per Cloudflare’s parameter reference. Everyone behind one interceptor can end up sharing a counter on both. Our TLS ClientHello study and the TLS interception entry cover the mechanics. Whether that site can be excluded from inspection is the network administrator’s call.
Upstream refusal. Through a rotating or residential proxy service, a 1015 is the target site’s answer to the service’s exit address. The service passes it through unchanged and cannot lift it. Switching to a fresh exit and carrying on at the same speed is working around the owner’s limit, and this guide does not cover that. Slow down. If you need more volume than the site allows, ask the owner for an API or an allowance. Rotating vs sticky sessions explains how exits change underneath you.
For site owners: finding the rule that fired
Ask the visitor for the Ray ID from the page, or the cf-ray header from their client. In the dashboard, Security Events can be filtered by Ray ID, and the “Events by service” view lists rate limiting rules separately from other security features. Sampled logs show the IP address, user agent and ASN behind an event, per Cloudflare’s Ray ID page. Security Events may use sampled data, so a narrower time range finds a single event more reliably. Then check the rule against the causes above:
- Expression too broad. Scope it to the login, search or API paths you mean to protect, so asset requests stop counting.
- Window too short. Cloudflare’s own advice on the 1015 page is that a rule blocking over a very short period, such as one second, should try 10 seconds instead.
- Shared addresses. On Business and above, count by IP with NAT support, or add a path or header characteristic so one busy address does not lock out everyone behind it.
- Custom responses. On Pro and above you can change the body and the status. curl’s
--retrytreats 429 as transient and urllib3’sRetryhonoursRetry-Afteron a 429; by default neither retries a 403. Keeping 429 lets well-behaved clients back off on their own.
What each plan can configure, from Cloudflare’s availability table:
| Plan | Rules | Counting period | Block duration | Count by |
|---|---|---|---|---|
| Free | 1 | 10 s | 10 s | IP |
| Pro | 2 | Up to 1 min | Up to 1 h | IP |
| Business | 5 | Up to 10 min | Up to 1 day | IP, IP with NAT support |
| Enterprise with app security | 100 | Up to 65,535 s | Up to 1 day, custom via API | IP, IP with NAT support |
| Enterprise with Advanced Rate Limiting | 100 | Up to 65,535 s | Up to 1 day, custom via API | Adds headers, cookies, query, ASN, country, path, JA3/JA4 and more |
Enterprise rule counts depend on the contract. On Free, Pro and Business, rules that issue a challenge instead of a block do not take a duration; they throttle, and a visitor who passes the challenge has their counter reset.
Cause-to-fix table
| Cause | How to confirm | Fix |
|---|---|---|
| Your own rate crossed the rule | Count your requests per 10-second bucket; body says error code: 1015 |
Pace below the limit; honour Retry-After; cap total wait |
| Retry loop hammering during the block | curl shows “Retrying in 1 second”, then 2, 4 | Use --compressed so Retry-After arrives; set --retry-max-time; bound attempts |
| Shared IP (NAT, VPN, office, shared proxy exit) | /cdn-cgi/trace shows the address you are counted under; limited at a normal pace |
Use an address only you use for that site; keep cookies; owner: count by IP with NAT support |
| Page assets counted by a broad rule | One page load makes many same-host requests (10 to 11 on proxy.wiki) | Owner: scope the expression, exclude cached assets on Business and above; visitor: close auto-refreshing tabs |
| Workers subrequests counted (owner side) | Rule fires sooner than its limit; zone uses Workers | Exclude same-zone subrequests with cf.worker.upstream_zone |
| Proxy’s own 429, not Cloudflare | “CONNECT tunnel failed, response 429” or ERR_TUNNEL_CONNECTION_FAILED |
Lower concurrency on the proxy account; ask the provider about its limit |
| Proxy auth missing | “CONNECT tunnel failed, response 407” | Send proxy credentials; see the 407 guide |
| TLS-intercepting proxy shares one identity | Certificate issuer is your company’s or the tool’s CA; colleagues limited too | Ask the network administrator; owner: add characteristics beyond IP |
| Origin’s own 429 | 429 with no 10xx code in the body | Read the origin’s limits or API terms; Cloudflare settings will not change it |
How this was tested
All captures were taken on 21 October 2026 on macOS (Darwin 25.6.0, Apple silicon). Clients: curl 8.23.0 (Homebrew, OpenSSL 4.0.3), curl 8.7.1 (macOS system build, SecureTransport), Python 3.9.6 with requests 2.32.3, urllib3 2.3.0 and httpx 0.27.2, Node 24.2.0, and Google Chrome 155.0.8059.85 in headless mode driven over the DevTools protocol. The forward proxy was Squid 6.13 on 127.0.0.1 with one open port and one port requiring basic authentication.
Every 1015 on this page came from https://proxy.wiki/cdn-cgi/error/1015, Cloudflare’s preview of its default 1015 response, served by the Cloudflare data center in Sofia. It returns the response without any rule being triggered, so nothing here shows how long a real block lasts or how a live rule fills Retry-After. Client captures were one request each. The Accept-Encoding comparison was repeated twice per variant. Page-load counts were one cold load per URL. The Chrome CONNECT count came from three navigations.
The 429 gateway was a short Python asyncio server that answers every request line with 429 Too Many Requests, a Retry-After: 5 header and a short body, and never opens a tunnel. The rate-limited server was a Python http.server stand-in, not Cloudflare, configured for 5 requests per 10 seconds per client address and a 10-second block. Its numbers describe the clients, not Cloudflare.
Frequently asked questions
How long does error 1015 last?
How do I fix error 1015?
Why am I getting error 1015 when I barely used the site?
Can Cloudflare remove a 1015 block?
Is error 1015 the same as HTTP 429?
Can a VPN or proxy cause error 1015?
Does error 1015 mean my IP address is banned?
What is the "Unable to purge" error 1015?
Sources
- Cloudflare: Error 1015, you are being rate limited
- Cloudflare: 1xxx errors and the HTTP status each returns
- Cloudflare: Error responses and content negotiation
- Cloudflare changelog: JSON and RFC 9457 responses for 1xxx errors
- Cloudflare: Rate limiting rules, important remarks and availability by plan
- Cloudflare: Rate limiting parameters, characteristics, duration and response code
- Cloudflare: Request rate calculation and per-data-center counters
- Cloudflare: Troubleshoot rate limiting rules, Workers subrequests and fail-open
- Cloudflare: Create a rate limiting rule and a custom block response
- Cloudflare cookies: _cfuvid for rate limiting rules
- Cloudflare: Ray ID and looking it up in Security Events
- Cloudflare: Security Events, events by service and sampled logs
- Cloudflare HTTP headers: Cf-Ray and the data center code
- Cloudflare: Gathering information for troubleshooting, /cdn-cgi/trace
- Cloudflare: Error 1020, access denied
- Cloudflare: Errors 1006, 1007, 1008 or 1106, IP address banned
- Cloudflare: Error 1010, access banned on browser signature
- Cloudflare: Error 1025, Workers plan limits
- Cloudflare: Error 429 Too Many Requests
- Cloudflare Ruleset Engine: Block action returns 403 or 429
- RFC 6585 section 4: 429 Too Many Requests
- RFC 9110 section 10.2.3: Retry-After
- curl man page: --retry, --retry-max-time and Retry-After
- urllib3: Retry, RETRY_AFTER_STATUS_CODES and respect_retry_after_header
- HTTPX: transports and connection retries