---
title: "Error 1015: You are being rate limited (Cloudflare)"
url: https://proxy.wiki/guides/cloudflare-error-1015/
type: Guide
author: "proxy.wiki editorial"
published: 2026-10-21
updated: 2026-10-21
site: proxy.wiki
topics: ["Anti-bot systems"]
license: CC BY 4.0; quote freely with attribution to https://proxy.wiki/
---

# 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.

## Key takeaways

- Error 1015 means a rate limiting rule the site owner set in Cloudflare counted too many requests from you; Cloudflare sends it with HTTP 429.
- The block lasts for the rule's duration, which the owner picks from 10 seconds to one day. Retrying early may extend it.
- In our captures Cloudflare sent Retry-After: 30 only when the request carried an Accept-Encoding header. Plain curl got a 17-byte "error code: 1015" and no Retry-After.
- Through a proxy, a real 1015 arrives inside a working tunnel. A proxy that refuses you instead gives "CONNECT tunnel failed, response 429".
- Shared addresses (NAT, VPNs, office networks, proxy exits) share one counter, so a normal pace can still hit 1015.

```
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](/glossary/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](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1015/) 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](https://developers.cloudflare.com/changelog/post/2026-03-11-json-rfc9457-responses-for-1xxx-errors/). 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](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/) 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](https://developers.cloudflare.com/fundamentals/reference/error-responses/) 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](/research/default-request-headers/), 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](https://developers.cloudflare.com/waf/rate-limiting-rules/create-zone-dashboard/). 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](/guides/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](https://developers.cloudflare.com/waf/rate-limiting-rules/) 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](/glossary/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_

| 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](/glossary/exponential-backoff/) explains the doubling delay, and the [Python proxy guide](/guides/proxies-in-python-requests-httpx/) 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](/guides/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](/glossary/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](https://developers.cloudflare.com/support/troubleshooting/general-troubleshooting/gathering-information-for-troubleshooting-sites/) 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](https://developers.cloudflare.com/fundamentals/reference/policies-compliances/cloudflare-cookies/) 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](/glossary/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](https://developers.cloudflare.com/waf/rate-limiting-rules/troubleshooting/) 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](/glossary/http-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](https://developers.cloudflare.com/waf/rate-limiting-rules/parameters/). Everyone behind one interceptor can end up sharing a counter on both. Our [TLS ClientHello study](/research/tls-clienthello-fingerprints/) and the [TLS interception](/glossary/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](/guides/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](https://developers.cloudflare.com/fundamentals/reference/cloudflare-ray-id/). 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](https://developers.cloudflare.com/waf/rate-limiting-rules/):

| 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](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1015/)
2. [Cloudflare: 1xxx errors and the HTTP status each returns](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/)
3. [Cloudflare: Error responses and content negotiation](https://developers.cloudflare.com/fundamentals/reference/error-responses/)
4. [Cloudflare changelog: JSON and RFC 9457 responses for 1xxx errors](https://developers.cloudflare.com/changelog/post/2026-03-11-json-rfc9457-responses-for-1xxx-errors/)
5. [Cloudflare: Rate limiting rules, important remarks and availability by plan](https://developers.cloudflare.com/waf/rate-limiting-rules/)
6. [Cloudflare: Rate limiting parameters, characteristics, duration and response code](https://developers.cloudflare.com/waf/rate-limiting-rules/parameters/)
7. [Cloudflare: Request rate calculation and per-data-center counters](https://developers.cloudflare.com/waf/rate-limiting-rules/request-rate/)
8. [Cloudflare: Troubleshoot rate limiting rules, Workers subrequests and fail-open](https://developers.cloudflare.com/waf/rate-limiting-rules/troubleshooting/)
9. [Cloudflare: Create a rate limiting rule and a custom block response](https://developers.cloudflare.com/waf/rate-limiting-rules/create-zone-dashboard/)
10. [Cloudflare cookies: _cfuvid for rate limiting rules](https://developers.cloudflare.com/fundamentals/reference/policies-compliances/cloudflare-cookies/)
11. [Cloudflare: Ray ID and looking it up in Security Events](https://developers.cloudflare.com/fundamentals/reference/cloudflare-ray-id/)
12. [Cloudflare: Security Events, events by service and sampled logs](https://developers.cloudflare.com/waf/analytics/security-events/)
13. [Cloudflare HTTP headers: Cf-Ray and the data center code](https://developers.cloudflare.com/fundamentals/reference/http-headers/)
14. [Cloudflare: Gathering information for troubleshooting, /cdn-cgi/trace](https://developers.cloudflare.com/support/troubleshooting/general-troubleshooting/gathering-information-for-troubleshooting-sites/)
15. [Cloudflare: Error 1020, access denied](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1020/)
16. [Cloudflare: Errors 1006, 1007, 1008 or 1106, IP address banned](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1006/)
17. [Cloudflare: Error 1010, access banned on browser signature](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1010/)
18. [Cloudflare: Error 1025, Workers plan limits](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1025/)
19. [Cloudflare: Error 429 Too Many Requests](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/4xx-client-error/error-429/)
20. [Cloudflare Ruleset Engine: Block action returns 403 or 429](https://developers.cloudflare.com/ruleset-engine/rules-language/actions/)
21. [RFC 6585 section 4: 429 Too Many Requests](https://www.rfc-editor.org/rfc/rfc6585.html#section-4)
22. [RFC 9110 section 10.2.3: Retry-After](https://www.rfc-editor.org/rfc/rfc9110.html#section-10.2.3)
23. [curl man page: --retry, --retry-max-time and Retry-After](https://curl.se/docs/manpage.html#--retry)
24. [urllib3: Retry, RETRY_AFTER_STATUS_CODES and respect_retry_after_header](https://urllib3.readthedocs.io/en/stable/reference/urllib3.util.html)
25. [HTTPX: transports and connection retries](https://www.python-httpx.org/advanced/transports/)
