Situation | Recommended action |
Cart, checkout, account, or user-specific page | Cache Level → Off |
Public content varies by query string | Apply Querystring |
Query strings do not affect the response | Ignore Querystring |
Public content varies by a known cookie | Custom Variable in Cookie |
Multiple Page Rules match the same URL | Give the required rule the higher Weight |
Pages containing authentication, transaction data, sessions, or user-specific responses should generally be excluded from shared CDN caching. A cache exclusion affects only URLs matched by the Page Rule.
Cart, checkout, payment, account, and order pages commonly depend on the visitor's session.
Typical examples include:
/cart/*
/checkout/*
/account/*
/orders/*
A generic session cookie is not automatically treated as a cache-bypass condition. If a session-dependent response is stored as one shared cache entry, a later request with a different session cookie can receive that cached response. Sensitive paths should be explicitly excluded.
Login and administration pages should normally be fetched from the application because they depend on authentication and changing application state.
For WordPress, common examples include:
/wp-admin/*
/wp-login.php
Use the actual paths configured by the application.
Authenticated or personalized APIs are also common candidates for cache bypass, such as:
/api/user/profile/*
/api/orders/*
/api/session/*
Not every API must bypass cache. Public responses that are identical for all users may still be suitable for caching. Cache exclusions control delivery behavior; application security policies can be configured separately with the web application firewall.
VergeCloud caches eligible static resources, while HTML remains uncached by default unless caching is explicitly enabled.
The following cache behavior applies to the content types covered in this guide:
| Content type | Cache behaviour |
HTML | BYPASS |
CSS | MISS →HIT |
JavaScript | MISS →HIT |
JPEG | MISS →HIT |
PNG | MISS →HIT |
GIF | MISS →HIT |
A MISS means the requested object is not currently available in VergeCloud edge cache. A subsequent HIT means the resource has been stored and is being served from cache.
HTML can contain frequently changing, personalized, session-based, or application-generated information. VergeCloud therefore keeps HTML uncached by default.
If an HTML page contains public content that is safe to share between users, caching can be enabled through a Page Rule.
The expected cache behavior is:
Default HTML → BYPASS
HTML with caching enabled → MISS → HIT
HTML with Cache Level Off → BYPASS
For related options, see cache level settings.
Sign in to the VergeCloud dashboard and select the required domain.
Go to Delivery → Page Rules.
Click New Page Rule.
Enter the Weight for the rule. Higher values are evaluated first.
Under the request condition, keep:
URL
Matches Glob Pattern
Enter the URL pattern, for example:https://example.com/checkout/*
Leave Cache disabled. Disabling Cache means caching is turned off for the matched request.
Save the Page Rule and make sure it is active.
Use a wildcard when the same cache policy should apply to multiple URLs below a path.
For example:
https://example.com/checkout/*
This pattern applies to URLs such as:
/checkout/test.html
/checkout/payment.html
/checkout/
/checkout/test.html?coupon=A
/checkout/payment/card/test.html
It does not cover:
/checkout
/checkout-old/test.html
The trailing slash therefore matters. Make sure the Page Rule pattern covers the exact URL structure used by the application.
Set Cache Level to Off when matching requests should not use VergeCloud edge cache.
A correctly excluded request returns:
x-cache-status: BYPASSRepeated requests should continue returning BYPASS rather than changing from MISS to HIT.
When multiple Page Rules match the same request, the rule with the higher Weight takes priority.
For example, if a broad caching rule has a higher Weight than a more specific Cache Level Off rule, the broader rule can take precedence.
If the specific bypass rule has the higher Weight, the matched request bypasses the VergeCloud cache.
If an exclusion is not working as expected, review all overlapping Page Rules and their Weight values.
Paths, query strings, and cookies control different parts of cache behavior.
A Page Rule such as /checkout/* applies a cache policy to matching URLs.
With Apply Querystring, different query-string variations can have separate cache entries.
For example:
/products?id=100
/products?id=200
With Ignore Querystring, those variations can share the same cached object.
Cookies can also be used to separate cache variants. If public content changes according to a known cookie, add that cookie under Custom Variable in Cookie.
For example, if user_type is configured as a custom cookie variable:
user_type=guest receives its own cache variant.
user_type=member receives a separate cache variant.
Each variant follows its own MISS-to-HIT cache sequence.
Use cookie-based variation only for content that is safe to cache. Sensitive authenticated content should normally be excluded from shared caching.
Choose exclusions based on how the application handles authentication, sessions, and personalized data.
Common WordPress paths include:
/wp-admin/*
/wp-login.php
Common WooCommerce user-specific areas include:
/cart/*
/checkout/*
/my-account/*
These areas can contain session, customer, payment, or order information and are normally safer with Cache Level Off.
Application routes can be customized, so always verify the actual paths used by the website.
For headless applications, separate public APIs from authenticated or personalized endpoints.
Public responses that are identical for all users may remain cacheable.
Account, cart, profile, order, authentication, and session endpoints should generally bypass shared caching unless the application uses a specifically designed cache-isolation policy.
Request the matched URL several times and check the VergeCloud cache-status header.
Use:
curl -sS -D - -o /dev/null \
"https://www.example.com/checkout/test.html" \
| grep -Ei "^(server|x-cache-status):"A working bypass should return:
server: vergecloud
x-cache-status: BYPASS
Repeat the request to confirm that the response continues returning BYPASS rather than changing to HIT.
If a path still appears to be cached, check the URL pattern, Page Rule Weight, cookie configuration, and browser cache separately.
Compare the requested URL with the configured wildcard pattern.
For a rule using:
/checkout/*
URLs below /checkout/ are covered, including nested paths and requests containing query strings.
The following are separate URL patterns and are not covered by that rule:
/checkout
/checkout-old/
If those URLs also need to bypass cache, create rules that cover their exact URL structure.
Also review Page Rule Weight when multiple rules can apply to the same request.
Cache Pages with Set-Cookie controls whether responses containing the Set-Cookie header can be stored in cache.
When the option is disabled, a response containing Set-Cookie is not stored as a normal shared cached response.
When the option is enabled, an otherwise cacheable response containing Set-Cookie can be stored and later served as a HIT.
The Vary response header is separate from Set-Cookie. It tells a cache that the response may change depending on specific request headers. For example:
Vary: Accept-Languagecan indicate that different language requests may need different cached responses.
If the origin sends a Vary header, review the Ignore Vary Header setting before caching the response. Ignoring a response-affecting Vary header can cause requests that should receive different content to share the same cached object.
Enable Cache Pages with Set-Cookie only when the response is safe to serve as shared cached content.
When Cache Level is Off, Set-Cookie and Vary-related cache behavior are no longer relevant because the matched request bypasses VergeCloud caching.
Browser caching and VergeCloud edge caching are separate.
A response can return:
x-cache-status: BYPASSwhile also returning:
Cache-Control: max-age=600
This means VergeCloud edge caching is bypassed, but the browser may keep the response for 600 seconds.
A Browser Cache value of three hours corresponds to:
Cache-Control: max-age=10800
If VergeCloud shows BYPASS but the browser still displays older content, use a hard refresh or private window and check the Browser Cache TTL.
Exclude only URLs that genuinely require fresh, authenticated, transactional, or personalized responses.
Keep public static content cached wherever possible so VergeCloud can serve eligible requests from edge locations and reduce traffic to the origin.
Use Cache Level Off for sensitive paths. Use query-string or cookie-based cache variation only when multiple shared versions are intentionally required.
No. The exclusion applies only to URLs matched by the Page Rule. Other eligible resources can continue using VergeCloud caching.
The limit depends on your VergeCloud plan. Growth includes 20 Page Rules, Professional includes 50, and Enterprise includes 150. Additional rules are available in blocks of five.
Exclude URLs containing authentication, administration, or user-specific responses. If the entire admin area is dynamic, excluding the complete admin path is usually simpler.
Development Mode temporarily sends requests to the origin and is useful during development or troubleshooting.
A Page Rule with Cache Level Off creates a persistent exclusion for a specific URL or path.
A generic session cookie is not automatically treated as a cache-bypass condition in the current Page Rule configuration.
For sensitive logged-in areas such as account, cart, checkout, admin, or profile paths, create URL-based Page Rules with Cache Level Off.
For public content that safely varies by a known cookie, Custom Variable in Cookie can create separate cached variants.