Skip to content
Anti-bot systems

Error 1015: You are being rate limited (Cloudflare)

Error 1015 "You are being rate limited" is Cloudflare enforcing a site owner's rate limit. Real captures, every cause, and the fix for each.

On this page 7 sections
  1. What the response contains
  2. How each client reports it
  3. Confirm it is Cloudflare’s 1015
  4. Causes, most common first
  5. 1. Your own request rate crossed the rule
  6. 2. A retry loop that ignores the block
  7. 3. You share an IP address with other people
  8. 4. One page view is many requests
  9. 5. Requests the owner did not expect to be counted
  10. 6. The proxy layer: real 1015s and look-alikes
  11. For site owners: finding the rule that fired
  12. Cause-to-fix table
  13. 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:

12 requests against a local limiter (5 per 10 s, 10 s block), by client strategy Drawn from the table below.
12 requests against a local limiter (5 per 10 s, 10 s block), by client strategy. Stacked bar chart of 200 responses, 429 responses by Strategy.3 rows, drawn from the table that follows this chart.Loop with no delayLoop with no delay · 200 responses: 55Loop with no delay · 429 responses: 77Paced, 2.1 s apartPaced, 2.1 s apart · 200 responses: 1212polite_get, no pacingpolite_get, no pacing · 200 responses: 1212polite_get, no pacing · 429 responses: 22051015 responses12 requests against a local limiter (5 per 10 s, 10 s block), by client strategy. Stacked bar chart of 200 responses, 429 responses by Strategy.3 rows, drawn from the table that follows this chart.Loop with no delayLoop with no delay · 200 responses: 55Loop with no delay · 429 responses: 77Paced, 2.1 s apartPaced, 2.1 s apart · 200 responses: 1212polite_get, no pacingpolite_get, no pacing · 200 responses: 1212polite_get, no pacing · 429 responses: 22051015 responses
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 --retry treats 429 as transient and urllib3’s Retry honours Retry-After on 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?
As long as the duration the site owner chose for the rule. Cloudflare's supported values run from 10 seconds to one day. A Free-plan rule is fixed at 10 seconds, Pro allows up to an hour, Business and Enterprise up to a day, and Enterprise can set a custom value through the API. Retrying during the block may extend it.
How do I fix error 1015?
Stop sending requests to that site, wait, and return at a lower rate. In code, honour Retry-After and cap your retries. If it happens at a normal pace you are probably sharing an IP address with heavier users, so try a connection only you use or send the Ray ID to the site owner. Clearing your browser cache does not reset a counter kept on Cloudflare's side.
Why am I getting error 1015 when I barely used the site?
Usually because the rule counts by IP and your address is shared, through NAT, a VPN, an office network or a proxy exit. A broad rule that counts every image and script also adds up fast: one cold page load on proxy.wiki sent 10 to 11 requests in our test.
Can Cloudflare remove a 1015 block?
Not for a visitor. Cloudflare says it does not control which visitors are rate limited, and only the website owner can contact Cloudflare support about a site. Contact the owner with the Ray ID shown on the page.
Is error 1015 the same as HTTP 429?
Cloudflare sends 1015 with status 429, but not every 429 is a 1015. An origin's own limiter also returns 429 through Cloudflare, and 1025 uses 429 for Workers plan limits. Look for the 1015 code in the body. An owner can also change the status of a rate limit response to any 4xx value.
Can a VPN or proxy cause error 1015?
Yes, when its exit address is shared and the rule counts by IP. Your requests and everyone else's land in one counter. A proxy that is itself rate limiting you looks different: curl reports "CONNECT tunnel failed, response 429" and Chrome reports ERR_TUNNEL_CONNECTION_FAILED.
Does error 1015 mean my IP address is banned?
No. It is temporary and ends when the rule's duration runs out. A ban on an address is a different code, 1006, 1007 or 1008, returned with status 403.
What is the "Unable to purge" error 1015?
A separate use of the same number in Cloudflare's cache purge, seen by site owners rather than visitors. Cloudflare's advice is to retry the purge and contact support if it keeps failing.

Sources

  1. Cloudflare: Error 1015, you are being rate limited
  2. Cloudflare: 1xxx errors and the HTTP status each returns
  3. Cloudflare: Error responses and content negotiation
  4. Cloudflare changelog: JSON and RFC 9457 responses for 1xxx errors
  5. Cloudflare: Rate limiting rules, important remarks and availability by plan
  6. Cloudflare: Rate limiting parameters, characteristics, duration and response code
  7. Cloudflare: Request rate calculation and per-data-center counters
  8. Cloudflare: Troubleshoot rate limiting rules, Workers subrequests and fail-open
  9. Cloudflare: Create a rate limiting rule and a custom block response
  10. Cloudflare cookies: _cfuvid for rate limiting rules
  11. Cloudflare: Ray ID and looking it up in Security Events
  12. Cloudflare: Security Events, events by service and sampled logs
  13. Cloudflare HTTP headers: Cf-Ray and the data center code
  14. Cloudflare: Gathering information for troubleshooting, /cdn-cgi/trace
  15. Cloudflare: Error 1020, access denied
  16. Cloudflare: Errors 1006, 1007, 1008 or 1106, IP address banned
  17. Cloudflare: Error 1010, access banned on browser signature
  18. Cloudflare: Error 1025, Workers plan limits
  19. Cloudflare: Error 429 Too Many Requests
  20. Cloudflare Ruleset Engine: Block action returns 403 or 429
  21. RFC 6585 section 4: 429 Too Many Requests
  22. RFC 9110 section 10.2.3: Retry-After
  23. curl man page: --retry, --retry-max-time and Retry-After
  24. urllib3: Retry, RETRY_AFTER_STATUS_CODES and respect_retry_after_header
  25. HTTPX: transports and connection retries

Read this page as Markdown · Quote it freely under CC BY 4.0 with a link back.