How to Exclude Pages and Paths From Cache in VergeCloud

How to Exclude Pages and Paths From the Cache in the VergeCloud Panel

To exclude a page or path from the VergeCloud CDN cache, open your domain in the dashboard, go to Delivery → Page Rules, create a rule for the required URL pattern, and set Cache Level to Off. Matching requests bypass VergeCloud edge cache and go to the origin.

Use exclusions for pages containing authentication, transactions, session-specific information, or personalized content. Public content can continue using the content delivery network while sensitive paths are excluded.

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

Which Pages Should Never Be Served From Cache

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.

Carts, checkouts, and account areas

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.

Admin panels and login paths

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.

APIs and personalized responses

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.

What the VergeCloud CDN Caches by Default

VergeCloud caches eligible static resources, while HTML remains uncached by default unless caching is explicitly enabled.

Default cacheable file types

The following cache behavior applies to the content types covered in this guide:

Content typeCache 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.

Why HTML stays uncached until you add a Page Rule

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.

Creating a Cache Bypass Page Rule

Create a cache bypass Page Rule when specific URLs should skip VergeCloud edge caching.
Page Rules section in the VergeCloud CDN panel

Step by step: Page Rules, then Add New Rule

Cache bypass rule using a wildcard URL pattern

  1. Sign in to the VergeCloud dashboard and select the required domain.

  2. Go to Delivery → Page Rules.

  3. Click New Page Rule.

  4. Enter the Weight for the rule. Higher values are evaluated first.

  5. Under the request condition, keep:

    • URL

    • Matches Glob Pattern

  6. Enter the URL pattern, for example:
    https://example.com/checkout/*

  7. Leave Cache disabled. Disabling Cache means caching is turned off for the matched request.

  8. Save the Page Rule and make sure it is active.

Writing a URL pattern with wildcards

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.

Setting Cache Level to Off for the matched path

Set Cache Level to Off when matching requests should not use VergeCloud edge cache.

A correctly excluded request returns:

x-cache-status: BYPASS

Repeated requests should continue returning BYPASS rather than changing from MISS to HIT.

Rule Order and Why Your Exclusion Might Be Ignored

Page Rule priority order in the VergeCloud panel

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.

Excluding a Path Versus Excluding Query Strings and Cookies

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.

Paths Worth Excluding on WordPress, WooCommerce, and Custom Apps

Choose exclusions based on how the application handles authentication, sessions, and personalized data.

Common WordPress and WooCommerce paths

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.

Headless and API-first setups

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.

Testing That a Path Genuinely Bypasses the Cache

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.
Response headers showing a cache bypass on a checkout page

Troubleshooting Exclusions That Do Not Take Effect

If a path still appears to be cached, check the URL pattern, Page Rule Weight, cookie configuration, and browser cache separately.

The pattern matches something other than you expected

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-Language

can 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 cache duration hiding the real result

Browser caching and VergeCloud edge caching are separate.

A response can return:

x-cache-status: BYPASS

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

Keeping Your Exclusion List Short and Your Site Fast

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.

Common Questions About Excluding Pages and Paths From Cache in VergeCloud

Does excluding a path from the cache slow down the rest of my site?

No. The exclusion applies only to URLs matched by the Page Rule. Other eligible resources can continue using VergeCloud caching.

How many Page Rules can I use to exclude paths from the cache?

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.

Should I exclude the whole admin directory or only specific files?

Exclude URLs containing authentication, administration, or user-specific responses. If the entire admin area is dynamic, excluding the complete admin path is usually simpler.

What is the difference between Development Mode and a bypass rule?

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.

Can I bypass the cache only for logged-in visitors?

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.