In the previous article, “From EdgeOne 524 to Query String Normalization“, I documented the process of troubleshooting, adjusting, and verifying the Query String caching strategy for the WordPress Chinese site after it experienced a 524 error under EdgeOne. (Shuijingwanwq.com)
At that time, I had tested various article pages, list pages, and archive pagination, but one scenario remained genuinely uncovered:
/YYYY/MM/DD/page/N/
That is, date archive pagination.
The reason was simple: during testing, I couldn’t find a real, existing date archive that had already generated pagination, so I had to skip it temporarily.
By August 15, 2026, the site had published enough articles that day to finally generate a real, accessible Page 3:
Chinese site:
https://www.shuijingwanwq.com/2026/08/15/page/3/
English site:
https://en.shuijingwanwq.com/2026/08/15/page/3/
I therefore decided to fill in this missing test item.
I originally thought this would be a very simple retest, but an interesting phenomenon occurred again with Cloudflare on the English site:
Cloudflare was clearly hitting the cache, yet the complete HTML SHA-256 returned each time was different.
After further comparing the pages, I ultimately found that the cache itself was fine; the real cause of the hash change was Cloudflare’s dynamic obfuscation of email addresses on the page.
As a result, this retest not only completed the date archive pagination test but also corrected a crucial evaluation method for future CDN cache testing.
Date Archive Page 3 Finally Appears
The Chinese page available for actual testing this time is:
https://www.shuijingwanwq.com/2026/08/15/page/3/
In the browser, you can already see:
Home / 2026 / August / 15 / Page 3
The page title is:
Date: August 15, 2026
Below, articles published earlier that day continue to be listed.
![[Figure 1: Date archive Page 3 for August 15, 2026, proving that a real page of the /YYYY/MM/DD/page/N/ type has appeared]](https://media.shuijingwanwq.com/2026/08/1-54-1024x525.png)
/YYYY/MM/DD/page/N/ type has appeared]This is exactly the URL type missing from the previous test.
Although other archive pages and pagination had been verified before, from the perspective of CDN cache rules:
/2026/08/15/
and:
/2026/08/15/page/3/
are ultimately two different paths.
Since a real page now exists, there is no need to continue relying on speculation; I can directly perform actual request verification.
Chinese Site EdgeOne: Random Query String Directly Hits Existing Cache
The Chinese site still follows the previous testing approach.
First, request the normal page without parameters:
https://www.shuijingwanwq.com/2026/08/15/page/3/
Then generate a random Query String with the current timestamp that has not been accessed before:
?swq_qs_test=date-page-1786844745
Forming:
https://www.shuijingwanwq.com/2026/08/15/page/3/?swq_qs_test=date-page-1786844745
The test results are straightforward:
========== EdgeOne Date Archive Pagination ==========
HTTP/2 200
eo-cache-status: MISS
--- RANDOM QUERY STRING ---
HTTP/2 200
eo-cache-status: HIT
The first request for the normal URL is:
MISS
But immediately requesting the newly generated random Query String directly yields:
HIT
Further comparing the two HTML files:
b032f39e333db0afe4952b22effcf9955ed1bd4a09076c6fa6a792bf9dc40a39 clean
b032f39e333db0afe4952b22effcf9955ed1bd4a09076c6fa6a792bf9dc40a39 dirty
Ultimately:
same_body=yes
![[Figure 2: EdgeOne date archive pagination test, Clean is MISS, random Query String is HIT, both HTML SHA-256 are completely identical]](https://media.shuijingwanwq.com/2026/08/2-44.png)
This result is sufficient to show that:
EdgeOne did not create a new page cache due to this irrelevant Query String, and date archive pagination can similarly undergo Query String normalization according to the current rules.
Therefore, this item for the Chinese site can be directly judged as passed.
English Site Cloudflare: Random Parameter Also Hits on First Try
Next, testing the English site:
https://en.shuijingwanwq.com/2026/08/15/page/3/
Similarly, first access the normal page, then generate a new random parameter:
?swq_cf_qs_test=date-page-1786844818
During the first test, I got:
CLEAN:
cf-cache-status: HIT
age: 254
Subsequently, request the newly generated random Query String:
DIRTY:
cf-cache-status: HIT
age: 255
This phenomenon itself is already quite valuable.
Because this random parameter was just generated, there was no corresponding access history before.
If Cloudflare treated the full Query String as an independent cache key, then the first access to this random URL would typically be more likely to show a new cache object.
But the actual result was:
HIT
And the cache age went directly from:
254
to:
255
From this, it is clear that the random Query String is continuing to use the existing cache.
But the Complete HTML SHA-256 Is Actually Different
The problem arose during the body comparison.
The first test yielded:
a82d0be563742050ebb8e0595c6182a9a657d0f3d9da831da0081e9d74f1b7b5 clean
e595a892523e343bf52f093cdcc98951e1cc1cb9b770d64c2b4bbe18cba602f8 dirty
same_body=no
That is to say:
Clean SHA-256 != Dirty SHA-256
If following the previous, more direct evaluation method, it would be easy to conclude:
Random Query String
→ Page body has changed
→ Cache normalization might not be actually implemented
But this conclusion clearly contradicts the cache headers.
Because the first access with the random parameter was already:
HIT
And:
age
was still incrementing along the original cache age.
Therefore, I couldn’t draw a conclusion directly based on the full-page SHA-256 here.
First Check if the Same URL is Stable Itself
To rule out the influence of the Query String itself, I conducted another set of control tests:
Clean 1
Clean 2
Dirty 1
Dirty 2
That is:
- Access the same Clean URL twice consecutively;
- Access the same Dirty URL twice consecutively.
The cache results were as follows:
age: 341
cf-cache-status: HIT
age: 342
cf-cache-status: HIT
age: 344
cf-cache-status: HIT
age: 345
cf-cache-status: HIT
All four requests:
HIT
The cache age also continued to increase:
341
342
344
345
There was no sign of the Dirty requests rebuilding the cache.
But the raw SHA-256 values below were all different.
![[Figure 3: All four Cloudflare requests were HIT, age continued to increase, but all four raw HTML SHA-256 were different]](https://media.shuijingwanwq.com/2026/08/3-38.png)
This step actually demonstrated that:
The problem could not be simply attributed to the Query String.
Because even:
Clean 1
and:
Clean 2
these two completely identical URLs returned different HTML SHA-256 values.
The comparison results were:
clean1_vs_clean2=different
dirty1_vs_dirty2=different
clean_vs_dirty=different
This meant that during the process of Cloudflare returning the HTML, some dynamic content was changing.
Directly Comparing HTML, Finally Finding the Only Difference
Continuing to compare:
Clean 1
and:
Clean 2
line by line, I finally found the actual change.
In the first response, part of the Mail social link at the bottom of the page was:
href="/cdn-cgi/l/email-protection#0e7d667b6764676069796f60797f4e69636f6762206d6163"
In the second response, it became:
href="/cdn-cgi/l/email-protection#1a69726f737073747d6d7b746d6b5a7d777b737634797577"
The rest of the page content had not changed.
The difference was concentrated in:
/cdn-cgi/l/email-protection#...
here.
At this point, the problem became quite clear.
There was an email link at the bottom of the page, and after being returned through Cloudflare, the email address was rewritten into:
/cdn-cgi/l/email-protection#...
format.
This protection value changes, so even if:
- The WordPress page content hasn’t changed;
- The article list hasn’t changed;
- The pagination hasn’t changed;
- Cloudflare is still hitting the existing cache;
The HTML ultimately sent to the client could still differ by a few bytes.
And SHA-256 is sensitive to any single byte change.
So the previous:
same_body=no
did not indicate a problem with the Cloudflare cache.
Normalizing Cloudflare’s Dynamic Email Protection Value
For final confirmation, I performed one more processing step.
Before calculating the SHA-256, I only replaced:
The dynamic value after /cdn-cgi/l/email-protection#
uniformly with:
/cdn-cgi/l/email-protection#NORMALIZED
leaving the rest of the HTML untouched by even a single byte.
Then recalculated:
Clean 1
Clean 2
Dirty 1
Dirty 2
the SHA-256 for the four pages.
The final results:
clean1 7eb9c5d221cde81de8a9824f433e5fff360d70940ee01afeed97e7899ef854bf
clean2 7eb9c5d221cde81de8a9824f433e5fff360d70940ee01afeed97e7899ef854bf
dirty1 7eb9c5d221cde81de8a9824f433e5fff360d70940ee01afeed97e7899ef854bf
dirty2 7eb9c5d221cde81de8a9824f433e5fff360d70940ee01afeed97e7899ef854bf
All four were completely identical.
The final comparison:
clean1_vs_clean2 = same
dirty1_vs_dirty2 = same
clean_vs_dirty = same
![[Figure 4: After normalizing the Cloudflare email protection value, the Clean and Dirty HTML SHA-256 for all four files are completely identical]](https://media.shuijingwanwq.com/2026/08/4-32.png)
At this point, the entire issue was completely resolved.
English Site Cloudflare Also Passes
Based on all the evidence, the date archive pagination for the English site can ultimately also be judged as passed.
Test URL:
https://en.shuijingwanwq.com/2026/08/15/page/3/
First access with a random Query String:
cf-cache-status: HIT
Cache age increased continuously:
341
342
344
345
This indicates that the random Query String did not obviously create a new independent cache object.
The initially observed:
Clean SHA-256 != Dirty SHA-256
was further proven not to be caused by the Query String.
Because the completely identical:
Clean 1
Clean 2
raw HTML was also different.
Finally, after normalizing:
/cdn-cgi/l/email-protection#...
this Cloudflare dynamic field:
Clean 1 = Clean 2 = Dirty 1 = Dirty 2
Therefore, the final conclusion is:
Cloudflare’s Query String normalization for date archive pagination is also working normally.
Final Test Results for Both CDNs
This retest can be briefly summarized into the following two sets of results.
Chinese site EdgeOne:
URL:
/2026/08/15/page/3/
HTTP:
200
Clean:
MISS
Random Query String:
HIT
Raw HTML:
SHA-256 identical
same_body:
yes
Result:
Pass
English site Cloudflare:
URL:
/2026/08/15/page/3/
HTTP:
200
Clean:
HIT
Random Query String first access:
HIT
Cache age:
Continuously increasing
Raw HTML:
Dynamic differences exist
Source of difference:
/cdn-cgi/l/email-protection#...
After normalizing Cloudflare dynamic field:
Clean 1 = Clean 2 = Dirty 1 = Dirty 2
Result:
Pass
At this point, the previously uncovered:
/YYYY/MM/DD/page/N/
date archive pagination has been officially retested and completed.
The Truly Noteworthy Change This Time is the Testing Method
Initially, I just wanted to fill in the missing date archive pagination test.
But the most valuable takeaway this time was not the date pagination itself, but rather the further confirmation that:
The raw SHA-256 of the complete HTML cannot be used as an absolute criterion for page cache consistency in all CDN scenarios.
The Chinese site EdgeOne was very straightforward this time:
Clean SHA-256 = Dirty SHA-256
So I could directly determine that the content was consistent.
But for the English site through Cloudflare, the situation was different.
Cloudflare might also perform dynamic processing on certain HTML content during the process of returning the cache object to the browser.
This time, I actually encountered:
/cdn-cgi/l/email-protection#...
changing every time.
This difference does not mean that:
- WordPress generated different pages;
- The Query String caused different pages;
- Cloudflare created different caches;
- The cache rules failed.
It merely indicates that:
The HTML the client ultimately receives may also contain dynamic fields generated by the CDN itself.
How to Test Query String Caching in the Future
After this verification, I will adjust the evaluation order when testing similar issues in the future.
First, check:
HTTP status
to confirm that the page itself is accessible normally.
Then check the CDN’s cache status, for example:
eo-cache-status
or:
cf-cache-status
Next, observe whether the first request with a random Query String results in:
MISS
or:
HIT
For Cloudflare, you can also continue to combine it with:
age
to determine whether it is reusing an existing cache object.
If body-level confirmation is still needed, then compare the HTML.
However, if the raw SHA-256 does not match, I will no longer immediately conclude:
Cache failure
Instead, I will first check:
Whether consecutive requests to the same Clean URL also differ
If the same URL is not stable itself, then continue to locate the dynamic field.
Finally, after normalizing the dynamic fields that clearly belong to the CDN’s own response processing and are unrelated to the business page content, perform the real body hash comparison.
Compared to simply using:
same_body=yes/no
this method is clearly more reliable.
Summary
The date archive pagination test gap left by the previous article, “From EdgeOne 524 to Query String Normalization“, has finally been filled this time.
The actual test page was:
/2026/08/15/page/3/
For the Chinese site EdgeOne:
Clean:MISS
Dirty:HIT
same_body=yes
Date archive pagination Query String normalization is working normally.
For the English site Cloudflare, the first access with a random Query String also directly resulted in:
HIT
The cache age continued to increase.
Although the raw HTML SHA-256 were all different at first, a line-by-line comparison ultimately confirmed that the only difference came from:
/cdn-cgi/l/email-protection#...
After normalizing this Cloudflare dynamic field:
Clean 1
Clean 2
Dirty 1
Dirty 2
The SHA-256 of all four HTML files were completely identical.
Therefore, it can be finally confirmed that:
Both EdgeOne and Cloudflare’s Query String normalization for WordPress date archive pagination are working normally.
And this test also further refined the methodology for subsequent CDN verification:
First check the cache status and cache age, then determine whether the random parameter hits the existing cache; when body comparison is needed, you must also first rule out the CDN’s own dynamic response rewriting, and you cannot judge a cache anomaly solely based on a different full-page raw SHA-256.
