My ane

2.1 AniList and its content delivery network#

AniList is an online community and database service for anime and manga. Its public GraphQL API returns, among other fields, coverImage URLs that reference its own image CDN. Observed asset URLs take the form:

1
https://s4.anilist.co/file/anilistcdn/media/anime/cover/medium/bx199547-LAaG3cmKCGhr.jpg

2.2 Image proxy services#

Image proxies fetch an image on behalf of a client and return the transformed or cached result. A typical request is constructed as:

1
https://proxy.example/?url=<encoded origin URL>

Because the proxy fetches the origin from its own servers, the origin sees a request that originates from a datacenter rather than from the end user’s browser. The two request paths are contrasted in Figure 1.

Figure 1: Request paths between a browser, a datacenter image proxy, and the AniList CDN.

4.1 Key observations#

• Every direct request to s4.anilist.co from a residential client succeeded with HTTP 200, irrespective of the user-agent string.
• wsrv.nl served a control GitHub avatar with HTTP 200, which demonstrates that the proxy service itself was operational at the time of testing.
• The same proxy returned HTTP 400 for AniList assets, with the body {"status":"error","code":400,"message":"Domain or TLD blocked by policy"}. This message indicates an allowlist or denylist on the proxy side.
• A self-hosted Cloudflare Worker, which has no policy of its own and performs a plain server-side fetch(), also failed with HTTP 502. This confirms that the origin itself rejects requests originating from datacenter IP ranges, independent of any proxy service policy.
• Statically.io returned HTTP 403 even for the GitHub control image, which suggests a service-level fault or broad blocking at the time of testing, and excludes it as a candidate regardless of origin.

5.1 Root cause#

The combination of results supports an IP-address-based access control policy at the origin CDN. The origin serves residential clients without regard to user agent, but refuses requests from datacenter IP ranges. Two independent datacenter paths were tested, one a commercial proxy (wsrv.nl, whose block message is explicit) and one a proxy the author fully controls (the Cloudflare Worker, which returned a generic upstream failure). Both failed, which rules out any single proxy’s policy as the sole explanation and implicates the origin. The three paths and their measured outcomes are shown in Figure 2.

Figure 2: Measured outcomes for residential and datacenter request paths.

5.2 Implications for image proxying#

The practical consequence is that no server-side proxy hosted in a conventional cloud or content delivery network can fetch AniList imagery. This renders the common image-proxy pattern unusable for this particular origin. Workarounds such as sending a browser-like user-agent string are ineffective, because the decision is made at the network layer rather than the application layer. Appendix A documents the construction of the self-hosted proxy used in this investigation, including its complete source code, so that the experiment can be reproduced.

5.3 Mitigations#

Three viable alternatives remain for a page that must display AniList imagery:

1. Direct CDN links. The browser fetches the origin image directly. This is the simplest approach and is guaranteed to work, because the end user’s client is the client that the origin agrees to serve. The trade-off is that third-party URLs appear in the page source and network inspection.
2. Self-hosted static assets. Images are downloaded once from a client machine (which the origin serves) and committed or deployed as first-party static assets. The page then references same-origin URLs, which hides the third-party origin entirely. The trade-off is that the asset set is a snapshot and must be refreshed when the source list changes.
3. Runtime fallback. A proxy URL is used as the primary src and a raw origin URL is applied by the client only when the proxy fails. This preserves a clean page source in the best case but incurs a wasted failed request per image and still exposes origin URLs in the network trace after the fallback fires.

5.4 Limitations#

The block was not characterized beyond HTTP status codes; the origin did not reveal whether the rejection is based on IP reputation, geographic region, or ASN membership. Only a small set of proxy providers was tested, and the behavior of services such as Statically.io may change over time. Replication of the measurements at a later date may yield different results.

A.1 Design#

The worker was intended to behave like wsrv.nl. It accepts the following query parameters:

• url: the encoded origin image URL (required).
• w, h: target dimensions in pixels.
• fit: one of cover, contain, crop, or pad.
• format: webp or avif; any other value is served untransformed.
• q: image quality.

The request handler proceeds in two stages:

1. Transform path. If an Images binding named IMAGES is present, the worker calls env.IMAGES.fetch(src, options), which resizes and re-encodes the origin image. This path relies on the Cloudflare Images transformations feature, which is included in the free plan up to 5,000 unique transformations per month.
2. Passthrough path. If the binding is missing, or the binding call fails (for example the free-tier 9422 over-quota error), the worker falls back to a plain fetch(src) and returns the origin image unchanged.

A server-side request forgery (SSRF) guard rejects non-HTTP URLs and hosts in the private, loopback, and link-local ranges, including the cloud metadata endpoint 169.254.169.254. Every response carries CORS headers and a one-day cache policy for both the client and the Cloudflare edge. The full request handling flow is shown in Figure 3.

Figure 3: Request handling flow inside the img-proxy worker.

A.2 Deployment#

Two deployment routes were evaluated.

Route 1: Wrangler (command line). The project is declared in wrangler.toml, which also attaches the Images binding:

1
name = "img-proxy"
2
main = "src/index.ts"
3
compatibility_date = "2026-07-08"
4

5
[[images]]
6
binding = "IMAGES"

The worker is then deployed with:

1
npx wrangler@latest login
2
npx wrangler@latest deploy

Route 2: Cloudflare dashboard. The dashboard drag-and-drop uploader routes files through the Workers Builds pipeline, which is intended for projects that require a build step. Uploading a single plain-JavaScript worker was rejected with the following message:

This uploader does not yet support projects that require a build process. At least one JavaScript file was found. Please use wrangler deploy instead for full feature support.

The practical workaround was to create a worker from a template and paste the code into the inline editor (Workers & Pages, open the worker, Edit code, replace the template, then Deploy). The Images binding, if desired, is added under Settings, Bindings.

After deployment the worker was reachable at https://img-proxy.asagirireika98.workers.dev. In the portfolio application, that URL was assigned to config.imgProxy.baseUrl and the AniList image fields were routed through it. This integration was later removed, because the proxy cannot serve AniList imagery, and the images are now loaded directly from the AniList CDN.

A.3 Source code#

The complete worker source follows. The listing is self-contained: it can be pasted into the dashboard editor or written to worker.js and uploaded.

1
// img-proxy: a self-hosted image proxy for Cloudflare Workers.
2
// The whole worker is a single ES module, which is all Cloudflare needs; it
3
// can be pasted into the dashboard editor or kept as a worker.js file. Its
4
// query surface mirrors wsrv.nl so clients do not have to know where an image
5
// actually lives:
6
//
7
//   GET /?url=<encoded>&w=&h=&fit=cover&format=webp&q=
8
//
9
// Two serving paths are chained. The preferred one resizes and re-encodes the
10
// image through the Cloudflare Images binding (free for up to 5,000 unique
11
// transformations a month); when the binding is absent or the transformation
12
// fails, the worker returns the origin image untouched instead.
13

14
const CORS_HEADERS = {
15
  "Access-Control-Allow-Origin": "*",
16
  "Access-Control-Allow-Methods": "GET, OPTIONS",
17
  "Access-Control-Allow-Headers": "*",
18
};
19

20
// Cache-Control governs the visitor's browser, while CDN-Cache-Control tells
21
// the Cloudflare edge to hold the result for a day. Together they give the
22
// proxy its caching behaviour and spare the origin repeated fetches.
23
const CACHE_HEADERS = {
24
  "Cache-Control": "public, max-age=86400, s-maxage=86400",
25
  "CDN-Cache-Control": "public, s-maxage=86400",
26
};
27

28
// A desktop browser user agent and an image-aware Accept header keep the
29
// origin from treating the worker as a generic bot when it follows a URL.
30
const BROWSER_UA =
31
  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0 Safari/537.36";
32

33
const ALLOWED_FITS = ["cover", "contain", "crop", "pad"];
34
const BINDING_FORMATS = ["webp", "avif"];
35

36
function err(status, message) {
37
  // Every failure is reported the same way: a JSON body describing the error,
38
  // with the CORS header added so a browser can still read it cross-origin.
39
  return new Response(JSON.stringify({ error: message }), {
40
    status,
41
    headers: CORS_HEADERS,
42
  });
43
}
44

45
// A proxy that accepts arbitrary URLs is an open door to internal services,
46
// so this guard rejects anything that is not an ordinary HTTP(S) request and
47
// anything that points at a private, loopback, or cloud-metadata host. DNS
48
// name rebinding is a residual risk, though it is acceptable for a
49
// personal-use proxy.
50
function isBlockedUrl(raw) {
51
  let u;
52
  try {
53
    u = new URL(raw);
54
  } catch {
55
    return true;
56
  }
57
  if (u.protocol !== "http:" && u.protocol !== "https:") return true;
58

59
  const host = u.hostname.toLowerCase();
60
  if (
61
    host === "localhost" ||
62
    host.endsWith(".local") ||
63
    host.endsWith(".internal")
64
  ) {
65
    return true;
66
  }
67
  if (host === "::1" || host === "[::1]") return true;
68
  if (host === "169.254.169.254") return true;
69

70
  const ipv4 = host.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
71
  if (ipv4) {
72
    const a = parseInt(ipv4[1], 10);
73
    const b = parseInt(ipv4[2], 10);
74
    if (
75
      a === 0 ||
76
      a === 10 ||
77
      a === 127 ||
78
      (a === 172 && b >= 16 && b <= 31) ||
79
      (a === 192 && b === 168) ||
80
      (a === 169 && b === 254)
81
    ) {
82
      return true;
83
    }
84
  }
85

86
  return false;
87
}
88

89
export default {
90
  async fetch(request, env) {
91
    // Browsers send a CORS preflight before reading the image, so OPTIONS is
92
    // answered directly rather than treated as a proxied request.
93
    if (request.method === "OPTIONS") {
94
      return new Response(null, { headers: CORS_HEADERS });
95
    }
96
    if (request.method !== "GET") {
97
      return err(405, "method not allowed");
98
    }
99

100
    const q = new URL(request.url).searchParams;
101
    const src = q.get("url") || "";
102
    if (!src) return err(400, "missing url param");
103
    if (isBlockedUrl(src)) return err(400, "blocked url");
104

105
    // The remaining parameters are the wsrv-compatible transformation set;
106
    // only `fit` has to be validated up front.
107
    const w = parseInt(q.get("w") || "", 10);
108
    const h = parseInt(q.get("h") || "", 10);
109
    const fit = q.get("fit") || "cover";
110
    const quality = parseInt(q.get("q") || "", 10);
111
    const format = (q.get("format") || q.get("output") || "").toLowerCase();
112

113
    if (!ALLOWED_FITS.includes(fit)) return err(400, "invalid fit");
114

115
    // Preferred path: the origin URL is handed to the Images binding, which
116
    // performs the resizing and format conversion itself, so the response can
117
    // be streamed straight back. Any failure here, whether the binding is
118
    // missing, the free tier is over-quota, or the origin refuses the
119
    // datacenter fetch, falls through to the plain passthrough below.
120
    if (env && env.IMAGES) {
121
      const options = { fit };
122
      if (Number.isFinite(w) && w > 0) options.width = w;
123
      if (Number.isFinite(h) && h > 0) options.height = h;
124
      if (Number.isFinite(quality) && quality > 0) options.quality = quality;
125
      if (BINDING_FORMATS.includes(format)) options.format = format;
126

127
      try {
128
        const res = await env.IMAGES.fetch(src, options);
129
        if (res.ok) {
130
          return new Response(res.body, {
131
            headers: {
132
              ...CORS_HEADERS,
133
              ...CACHE_HEADERS,
134
              "Content-Type": res.headers.get("Content-Type") || "image/webp",
135
            },
136
          });
137
        }
138
      } catch {
139
        // the binding failed, so the request continues to the fallback path
140
      }
141
    }
142

143
    // Fallback path: the worker fetches the image itself and relays the bytes
144
    // unchanged, preserving the origin content type. If even this fails, the
145
    // origin is genuinely unreachable and a 502 is returned.
146
    try {
147
      const res = await fetch(src, {
148
        headers: {
149
          "User-Agent": BROWSER_UA,
150
          Accept: "image/avif,image/webp,image/*,*/*;q=0.8",
151
        },
152
      });
153
      if (!res.ok) {
154
        return err(502, `origin returned ${res.status}`);
155
      }
156
      return new Response(res.body, {
157
        headers: {
158
          ...CORS_HEADERS,
159
          ...CACHE_HEADERS,
160
          "Content-Type":
161
            res.headers.get("Content-Type") || "application/octet-stream",
162
        },
163
      });
164
    } catch {
165
      return err(502, "origin fetch failed");
166
    }
167
  },
168
};

A.4 Verification#

The deployed worker was probed with a control image and with an AniList image:

1
$src = 'https://s4.anilist.co/file/anilistcdn/media/anime/cover/medium/bx199547-LAaG3cmKCGhr.jpg'
2
$worker = 'https://img-proxy.asagirireika98.workers.dev/?url=' + [uri]::EscapeDataString($src)
3
Invoke-WebRequest -Uri $worker -UseBasicParsing
4
# Expected: 502 Bad Gateway (AniList refuses datacenter fetches)
5

6
$control = 'https://avatars.githubusercontent.com/u/180294769'
7
Invoke-WebRequest -Uri ('https://img-proxy.asagirireika98.workers.dev/?url=' + [uri]::EscapeDataString($control)) -UseBasicParsing
8
# Expected: 200 OK (worker functions normally for unblocked origins)

The worker therefore behaves correctly as a general-purpose image proxy but cannot serve AniList imagery, which corroborates the analysis in Section 5.