Prime Cache Manual (Pro Edition)

Version 1.10.13 | PHP 7.4+ | WordPress 5.8+ | Requires Prime Cache (Free) 1.10.59+ installed & active
The Pro edition adds AI-assisted speed diagnosis, AVIF conversion, Critical CSS / Remove Unused CSS, Cloudflare / Sucuri / Varnish integrations, Persistent Object Cache (APCu / Redis / Memcached), database optimization, YouTube thumbnail replacement, and more on top of every Free feature.
For settings available in the Free version, please refer to the Free Manual. (WebP conversion itself moved into the Free edition in 1.10.0; Pro layers AVIF on top.)

Pro Add-on Model
Prime Cache Pro is an add-on plugin. The Free version of Prime Cache must be installed and activated before Pro features become available. All Free features remain fully functional; Pro extends them with the capabilities documented in this manual. The bundled feature list is also visible inside WordPress at Prime Cache → Pro Features (a dedicated information page introduced in Free 1.10.14).

Getting Started

License Activation

After purchasing a Pro license, you will receive a license key by email. The key format is PCPR-XXXXX-XXXXX-XXXXX-XXXXX-XXXXX. Follow the steps below to activate Pro features on your site.

How to Activate:

Make sure the free Prime Cache plugin is installed and activated.
Install the Prime Cache Pro add-on plugin via the WordPress admin panel (Plugins → Add New → Upload Plugin).
Activate Prime Cache Pro.
Go to Prime Cache → License in the WordPress admin menu.
Paste your license key into the License Key field.
Click Activate License.
The status indicator should change to Active. Pro settings will become available immediately.

Field	Description
License Key	Your `PCPR-XXXXX-XXXXX-XXXXX-XXXXX-XXXXX` key from the purchase confirmation email
License Status	Active / Inactive / Expired
Expiration Date	Displayed after successful activation
Site URL	The domain tied to this license (one license per production domain)

License verification: Activation calls the Rapls Works license API at https://raplsworks.com/wp-content/uploads/ai-chatbot/rpls-license-api.php. Your server must be able to make outbound HTTPS requests. Verify that allow_url_fopen or cURL is enabled if activation fails.

Staging / Development sites: If you need to test Pro on a local or staging environment, deactivate the license on the production site first, then activate on the staging site. Reactivate on production when done.

Server Requirements

Most Pro features work on any standard WordPress hosting environment. Some features have additional requirements:

Feature	Requirement
WebP Conversion	PHP GD extension with WebP support, or Imagick
AVIF Conversion	PHP Imagick 3.4.4+ with libavif, or GD compiled with AVIF support (PHP 8.1+)
Object Cache (APCu)	PHP APCu extension enabled (`apc.enabled=1`)
Object Cache (Redis)	PHP `phpredis` or `predis` extension; Redis server reachable
Object Cache (Memcached)	PHP Memcached extension; Memcached daemon reachable
.htaccess Optimization	Apache with `mod_rewrite`, `mod_expires`, `mod_deflate` enabled
Speculation Rules API	Chrome 109+ (non-supporting browsers silently ignore the rules)
Brotli Compression	Apache `mod_brotli` or Nginx `ngx_brotli` module

Check your environment: Go to Prime Cache → Tools → System Information for a comprehensive report of PHP extensions, GD/Imagick capabilities, server software, and which Pro features are supported on your host.

Quick Start for Pro

After activating your license, the recommended order for enabling Pro features is:

File Optimization tab — Enable Delay JavaScript, then turn on Optimize CSS Delivery and pick a method. Test your site after each step. File combining helps only on HTTP/1.1 hosts.
Critical CSS — To inline above-the-fold CSS, choose Load CSS Asynchronously and enable Auto-Generate Critical CSS on the same card. Verify the result visually.
Media tab — Enable WebP conversion, then run Bulk Optimization on existing images.
CDN tab — If you use a CDN, enter the CDN URL and optionally configure Cloudflare API credentials.
Preload tab — Enable cache preloading and link prefetching. Enable Speculation Rules for Chrome.
Object Cache tab — Select APCu, Redis, or Memcached based on your server’s available extensions.
Database tab — Review cleanup items and set an automatic schedule (weekly is a safe default).

Important: CSS/JS combining and Delay JavaScript can break poorly coded themes or plugins. Always test in a staging environment or immediately after enabling each feature. Use the admin bar’s “Clear All Cache” button after any change.

Using presets: with Pro active, the Auto and Aggressive presets on the Free plugin’s Tools tab are enhanced. They leave CSS/JS combining off (it does not help on HTTP/2 and later, and can cause breakage), use Remove Unused CSS with auto-generated Critical CSS, self-host Google Fonts, replace YouTube embeds with thumbnails, and turn on Delay JS’s Maximum Delay (with Safe Mode off). Local Analytics is left off to avoid conflicts with Google Site Kit and consent-mode setups. Since 1.9.2, Auto no longer probes the server’s HTTP protocol and always leaves combining off.

File Optimization (Pro)

Pro unlocks advanced file optimization capabilities that reduce HTTP requests, eliminate render-blocking resources, and dramatically cut page load times. These settings are found under Prime Cache → File Optimization.

Note: Of the features covered in this chapter, Defer JavaScript and Delay JavaScript are included in the Free edition. What Pro adds is CSS/JS combining, Critical CSS, Remove Unused CSS, and the other Pro-only items below.

Combine CSS

Merges all CSS files enqueued by WordPress into a single stylesheet, reducing the number of HTTP requests the browser must make before rendering the page.

New in 1.8.4: when Inline Small CSS is enabled and the combined stylesheet fits within the inline threshold, the combined result is inlined into the HTML as a single <style> block — zero render-blocking CSS requests with none of the async-CSS restyle jank (requires Prime Cache Free 1.10.38). JS combine is also skipped automatically on requests where Free’s Maximum Delay mode is active, to preserve document-order execution of delayed scripts.

Setting	Default	Description
Combine CSS Files	Disabled	Merge all CSS files into one combined file. On HTTP/2 servers the benefit is minimal
Mobile Only	Disabled	Apply CSS/JS combining only on mobile devices. Requires separate mobile cache
Exclude CSS Files	Empty	File paths or handles to exclude from combining (one per line). Use partial matches.
Inline Small CSS	Disabled	Inline CSS files smaller than the configured threshold directly into <style> tags, eliminating HTTP requests for tiny stylesheets
Inline Threshold	2 KB	CSS files below this size are inlined rather than combined

Warning: Combining CSS can cause visual breakage if stylesheets depend on load order in unusual ways. Start with exclusions for any stylesheet that breaks, then re-enable combining for the rest. Common exclusions: block editor styles, WooCommerce stylesheets on non-shop pages.

How to Configure:

Go to Prime Cache → File Optimization
Enable Combine CSS Files
Load your homepage in a private/incognito window to check for visual issues
Add any broken stylesheet paths to the Exclude list
Save settings and purge the cache

Combining advisory (1.9.2): sites still running with combining switched on by the old Auto preset see a one-time notice on the settings screen. Turn combining off switches it off and clears the cache; Keep it on leaves it as it is. Combining is never changed automatically, and on an HTTP/1.1-only site you can keep it on.

Rebuilt on update (1.10.12): combined files and Remove Unused CSS files include the plugin version in their filename, so an update regenerates them on the next visit without a manual cache clear, and the new filenames also stop server-level caches (such as X Accelerator) from serving stale bytes. Requires Prime Cache Free 1.10.59 or later.

Combine JavaScript

Merges all JavaScript files into a single bundle, reducing HTTP requests. Combined with defer, this can dramatically lower Time to Interactive (TTI).

Setting	Default	Description
Combine JavaScript Files	Disabled	Merge all JS files into one combined file. May break some scripts; on HTTP/2 the benefit is minimal
Exclude JS Files	Empty	Paths or handles to exclude from combining (one per line)

Warning: JavaScript combining is the most likely operation to break site functionality. Test thoroughly on every page template. Scripts that use document.write() cannot be combined. Always exclude inline event handlers and scripts that must remain in <head>.

Defer JavaScript

Adds the defer attribute to script tags, preventing JavaScript from blocking the HTML parser. Deferred scripts execute after the DOM is fully parsed but before DOMContentLoaded.

Setting	Default	Description
Defer JavaScript	Disabled	Add `defer` attribute to all script tags
Exclude from Defer	Empty	Script handles or paths that should NOT be deferred

jQuery & Defer: When jQuery is deferred, inline scripts that call $() or jQuery() before jQuery loads will throw errors. Prime Cache automatically wraps inline jQuery code in a DOMContentLoaded listener to handle this safely. If you notice jQuery errors after enabling defer, add the offending script to the exclude list.

Delay JavaScript

Delays the loading and execution of all JavaScript until the user interacts with the page (scroll, click, touch, or keypress). This can dramatically improve Largest Contentful Paint (LCP) and First Input Delay (FID) scores, especially on mobile.

Setting	Default	Description
Delay JavaScript	Disabled	Delay all JS execution until first user interaction
Delay JS Safe Mode	Disabled	Only delay external (third-party) scripts. Internal scripts run normally. Safer for complex themes.
Delay Timeout	5 seconds	Maximum time to wait for interaction before loading JS anyway (prevents blank screens on non-interactive sessions)
Exclude from Delay	Empty	Script handles or URL fragments that should NOT be delayed
Third-party Presets	Empty	Preset rules for common third-party scripts (Google Tag Manager, Meta Pixel, HubSpot, etc.)

Safe Mode recommendation: Enable Safe Mode first. It delays only external scripts (analytics trackers, social widgets, chat widgets) while keeping your theme’s JavaScript functional. Once you have confirmed there are no issues, you can try disabling Safe Mode to delay all scripts for maximum performance gain.

Separate mobile cache: Delay JavaScript rewrites the mobile HTML. While Mobile Cache is on in the Page Cache settings, Separate Mobile Cache is switched on automatically so the rewritten HTML is never served to desktop visitors. Since Free 1.10.41, Delay JS no longer turns Mobile Cache itself back on.

Interaction events that trigger JS loading:

scroll — page is scrolled
click / touchstart — user taps or clicks
keydown — any key is pressed
mousemove — mouse moves (desktop only)

Critical CSS

Critical CSS contains only the styles needed to render above-the-fold content. It is inlined in the <head> so the browser can paint the visible page immediately, without waiting for full stylesheets to download.

Setting	Default	Description
Auto-Generate Critical CSS	Disabled	Automatically extract above-the-fold Critical CSS for each page. Applies to the “Load CSS Asynchronously” method only
Fallback Critical CSS	Empty	Manually written critical CSS, inlined in the <head>. When filled in, it is used instead of the auto-generated CSS

Both settings are on the Optimize CSS Delivery card of the File Optimization tab. Auto-generation runs only with the Load CSS Asynchronously method. Under Remove Unused CSS the CSS still loads normally, so nothing is generated; if the toggle is on, the card shows a notice saying so instead of leaving it silently inert (1.10.0).

Auto-Generate Process:

Choose Load CSS Asynchronously and enable Auto-Generate Critical CSS
When a page is served, Prime Cache extracts the rules that match its above-the-fold elements and stores them per URL and per device (mobile / desktop)
The result is inlined on subsequent cached page serves, and the remaining CSS loads asynchronously
Preview the page visually to verify no content is unstyled during load

Tip: Auto-generated Critical CSS works best for sites with a consistent header/hero design. For highly custom themes, use Manual Critical CSS to ensure accuracy. Critical CSS reduces Largest Contentful Paint (LCP) times significantly and is one of the highest-value optimizations available.

Remove Unused CSS

Analyzes each page and strips CSS rules that do not apply to any element on that specific page. This can reduce stylesheet size by 60-90% on sites using large CSS frameworks like Bootstrap or Tailwind.

Setting	Default	Description
Optimize CSS Delivery + method “Remove Unused CSS”	Disabled	Enable per-page CSS stripping
Used CSS Safelist	Empty	CSS selectors or patterns that should never be removed (one per line), e.g. dynamically added classes or modal selectors.

Safeguards against over-stripping:

Per-device cache (1.9.8): the trimmed stylesheet is generated and cached separately for mobile and desktop, so a mobile-generated file can no longer strip desktop-only header styles. Clear the cache once after updating.
Background-image rules are kept (1.10.0): a rule carrying background-image: url() is kept even when its selector is not found, so a hero whose class is added by JavaScript (often the LCP element) does not disappear. Filter prime_cache_ucss_keep_background_images turns this off.
Layout-defining rules are kept (1.10.11): a rule that declares position, transform, display flex/grid, overflow, clip-path, contain, aspect-ratio and similar properties is kept even when its selector doesn’t match, because it can govern how its children lay out. Filterable via prime_cache_ucss_keep_layout_rules / prime_cache_ucss_protected_properties.
Per-theme default safelist (1.10.11): for Avada, Cocoon, Swell, Elementor, Divi, WooCommerce and Smart Slider 3, the class-name prefixes they add dynamically are protected automatically. Filterable via prime_cache_ucss_auto_safelist / prime_cache_ucss_default_safelist.
Empty results are never used (1.10.8): if the result is empty or the write fails, the original <link> is left untouched.

With Enable Debug Logging on (Tools tab), each generated file gets a {hash}.removed.log next to it, listing what was removed (selector, properties, line) and what a protected property kept (1.10.11) — so “Remove Unused CSS broke my layout” can be diagnosed with a single grep.

Warning: Remove Unused CSS can strip styles for elements that appear only after user interaction (dropdowns, modals, tooltips, sticky headers). Always add dynamically shown selectors to the Safelist. Test all interactive elements after enabling.

Optimize CSS Delivery: Turn on Optimize CSS Delivery on the File Optimization tab, then choose one of two methods: Remove Unused CSS (the default; aggressive, per-page stripping) or Load CSS Asynchronously (load the full stylesheet asynchronously, optionally with Critical CSS). Async loading is safer; Remove Unused CSS is more effective but requires careful safelist configuration. 1.9.1 removed a duplicate “Async CSS” checkbox from this card that did not persist; asynchronous CSS is selected with the method radio button.

Local Google Analytics Hosting

Downloads and self-hosts gtag.js (Google Analytics 4) or analytics.js (Universal Analytics) on your own server. This eliminates the Google DNS lookup and allows the script to be served from your CDN, improving PageSpeed scores and reducing third-party render-blocking time.

Setting	Default	Description
Local Analytics Enabled	Disabled	Self-host the Google Analytics script
Measurement ID	Empty	Your GA4 Measurement ID (e.g., `G-XXXXXXXXXX`) or UA-XXXXXX-X
Update Frequency	Weekly	How often to refresh the locally cached script (Daily / Weekly / Monthly)
Script Position	Header	Enqueue in <head> (recommended) or footer

How to Configure:

Go to Prime Cache → File Optimization → Local Analytics
Enable Local Analytics
Enter your GA4 Measurement ID (found in Google Analytics → Admin → Data Streams)
Save settings. Prime Cache will download the script immediately.
Verify in PageSpeed Insights that the Google Analytics script is no longer flagged as third-party

Tip: Google updates gtag.js regularly. Set the update frequency to Weekly to stay current without sacrificing the caching benefits of local hosting.

Google Fonts Optimization

Control how Google Fonts are loaded. These settings apply to fonts loaded via the Google Fonts API (fonts.googleapis.com). Configured under Prime Cache → File Optimization → Google Fonts.

Option	Description
Combine	Merge multiple `fonts.googleapis.com` API requests into a single request. Reduces DNS lookups when a theme loads many font families separately.
Self-host	Download all requested Google Fonts (all weights and subsets) to your server and serve them locally. Eliminates the Google Fonts CDN DNS lookup entirely and ensures GDPR-friendlier font loading.
Display Swap	Append `display=swap` to all Google Fonts requests so text remains visible using a fallback font while the custom font loads. Prevents invisible text flash (FOIT).
Disable	Completely dequeue all Google Fonts requests. Use this if you have already replaced all Google Fonts with locally hosted equivalents in your theme.

Self-host + Preconnect: When self-hosting is enabled, Prime Cache automatically adds a <preconnect> hint for fonts.gstatic.com during the download phase and removes it afterward. After fonts are self-hosted, the preconnect is no longer needed and is omitted from page output.

GDPR note: Self-hosting Google Fonts prevents the browser from connecting to Google’s servers on page load, which avoids transmitting your visitor’s IP address to Google. This is increasingly required by European data protection regulations.

Media Optimization (Pro)

WebP conversion itself, bulk Media Library optimization, and the three delivery methods (.htaccess rewrite, <picture> tag, URL rewrite) are part of the Free edition (since 1.10.0). The Pro add-on layers AVIF conversion, AVIF-specific quality control, and YouTube thumbnail replacement on top. (EXIF stripping and on-upload resize are also part of the Free edition.) Settings are under Prime Cache → Media.

WebP & AVIF Conversion

WebP conversion is configured in the Free plugin (see the Free Manual). When the Pro add-on is active, the same Media tab gains an AVIF toggle and AVIF-specific quality controls. At delivery time the browser receives AVIF, WebP, or the original file automatically based on its Accept header — Safari and other AVIF-less browsers cleanly fall back to the Free WebP variant.

Setting	Provided by	Default	Description
WebP Conversion	Free (since 1.10.0)	Disabled	Convert uploads to WebP format automatically on upload
AVIF Conversion	Pro add-on	Disabled	Convert uploads to AVIF format automatically on upload. Requires Imagick with libavif or GD with AVIF (PHP 8.1+).
Conversion Library	Free / Pro	Auto-detect	GD or Imagick. Auto-detect selects the best available library.

Format support: WebP is supported by all modern browsers (Chrome 32+, Firefox 96+, Safari 14+, Edge 18+). AVIF is supported by Chrome 85+, Firefox 93+, Safari 16+. For older browsers, Prime Cache falls back to the original JPG/PNG via the selected delivery method.

Quality Control & EXIF Removal

Fine-tune output quality and strip unnecessary metadata from converted images.

Free vs. Pro: WebP conversion, EXIF data removal, image resize on upload, and bulk conversion are Free-edition features. The Pro add-on adds AVIF conversion and the AVIF-specific quality control below.

Setting	Default	Description
Lossy Compression	Disabled	Apply lossy compression for smaller file sizes (recommended for photographs)
Lossless Compression	Disabled	Apply lossless compression. Larger files than lossy but no quality reduction (recommended for graphics and logos)
Custom Quality	82	WebP/AVIF quality level (1-100). 80-85 is visually lossless for most photographs.
WebP Quality	82	Quality level specifically for WebP output
AVIF Quality	60	Quality level for AVIF output. AVIF achieves good quality at lower values than WebP.
Remove EXIF Data	Disabled	Strip EXIF metadata (camera model, GPS location, timestamps) from converted images. Recommended for privacy and smaller file sizes.

Recommended settings: For photographs, use Lossy with WebP Quality 82 and AVIF Quality 60. For logos and UI graphics, use Lossless. Enable EXIF removal on any site where images may be uploaded by users, as EXIF can contain GPS coordinates and device information.

Image Resize on Upload

Automatically downscale oversized images when they are uploaded to the Media Library. This prevents unnecessarily large originals from consuming disk space and being served to visitors.

Setting	Default	Description
Resize on Upload	Disabled	Resize images exceeding the configured maximum dimensions on upload
Max Width	2560 px	Maximum image width after resize. Images narrower than this are not resized.
Max Height	2560 px	Maximum image height after resize

Tip: A maximum width of 1920px covers full-width images on the largest common monitors. If your theme never displays images wider than 1200px, set that as the maximum to save additional disk space.

Bulk Optimization

Convert and compress all existing images in your Media Library without re-uploading them. A real-time AJAX progress bar shows conversion status per image.

Feature	Description
Start Bulk Optimization	Begin converting all unoptimized images. Processes in batches to avoid server timeouts.
Progress Bar	Shows current image number, total count, and percentage complete in real time
Pause / Resume	Pause optimization at any time and resume later without losing progress
Per-image Status	Each image shows its status: Optimized, Skipped (already done), or Failed (with reason)
Restore Originals	Roll back a selected image to its pre-optimization state if backups are enabled
Statistics	Total bytes saved, average compression ratio, number of images optimized

Media Library Column: After optimization, a Compression column appears in the Media Library list view showing the file size reduction percentage for each image (e.g., “42% smaller”). This column is sortable.

How to Run Bulk Optimization:

Configure WebP and/or AVIF conversion settings first
Go to Prime Cache → Media → Bulk Optimization
Review the summary (total images, estimated time)
Click Start Bulk Optimization
Monitor progress. You can navigate away and return; the process continues in the background.
Review the completion report for any failed images and address them individually if needed

Image Delivery Methods

Choose how converted WebP/AVIF images are served to browsers that support them. Prime Cache supports three delivery methods to accommodate different server configurations.

Method	How It Works	Best For
.htaccess Rewrite	Apache rewrite rules serve the WebP/AVIF version when the browser sends a matching `Accept` header and the converted file exists. Zero JavaScript, no extra HTML markup.	Apache hosting; maximum performance
<picture> Tag	Replaces `<img>` tags with `<picture>` elements containing multiple `<source>` elements. Browser selects the best supported format automatically.	Nginx / LiteSpeed; shared hosting without .htaccess access
URL Rewrite	Rewrites image URLs directly to the WebP/AVIF file path. Simpler than picture tags but relies on all browsers accepting the URL-referenced format.	Edge cases where picture tags cause layout issues

Recommended: Use .htaccess Rewrite on Apache servers for the cleanest implementation. Use <picture> Tag on Nginx servers or any host where you cannot modify .htaccess.

When the rewrite never runs: a server-level static-file accelerator (Xserver X Accelerator, LiteSpeed, an nginx front, some CDNs) serves image files directly and never runs .htaccess, so no visitor receives the converted image. The WebP / AVIF delivery check on the Diagnostics tab tells you whether that is happening (1.10.11); if it reports Original served, not converted, switch to <picture> Tag or URL Rewrite. Since 1.10.11 the AVIF rewrite rule also serves a .avif only while the original image still exists. Deleting variants with their original, and cleaning up orphans left from before, is handled by Prime Cache Free 1.10.58.

Per-folder Include/Exclude: By default, all image uploads are converted. You can restrict conversion to specific folders or exclude certain directories:

Include folders: Only convert images in these paths (e.g., wp-content/uploads/, wp-content/themes/)
Exclude folders: Skip these paths during conversion (e.g., wp-content/uploads/2020/ for archive images you do not want to re-convert)

YouTube Thumbnail Replacement

Replaces YouTube iframe embeds with a lightweight thumbnail image and a play button overlay. The actual YouTube player iframe loads only when the visitor clicks the thumbnail, dramatically reducing page weight for pages with multiple embedded videos.

Setting	Default	Description
YouTube Thumbnail Replacement	Disabled	Replace YouTube iframes with clickable thumbnails
Thumbnail Quality	High (hqdefault)	YouTube thumbnail resolution: maxresdefault (1280px) / hqdefault (480px) / mqdefault (320px)
Play Button Style	Default	Built-in play button overlay style: Default, Large, Custom

Performance impact: Each embedded YouTube iframe loads approximately 500 KB of scripts and makes 20+ DNS requests on its own. Replacing three iframes with thumbnails can save over 1.5 MB of initial page load weight.

CDN Integration

Connect Prime Cache to your Content Delivery Network for global asset distribution. Settings are under Prime Cache → CDN.

CDN URL Rewriting & Domain Sharding

Rewrites static asset URLs to point to your CDN pull-zone, offloading bandwidth and serving assets from the closest CDN edge node to your visitors.

Setting	Default	Description
CDN URL Rewriting	Disabled	Enable CDN URL rewriting for static assets
CDN URL	Empty	Your CDN pull-zone URL (e.g., `https://cdn.example.com`)
Include File Types	js, css, png, jpg, gif, webp, avif, woff2, svg	File extensions to rewrite to CDN URLs
Exclude Paths	Empty	URL path patterns to exclude from CDN rewriting (one per line)
Domain Sharding	Disabled	Enable multiple CDN hostnames for parallel asset downloads
Shard Hostnames	Empty	Up to 4 CDN hostnames (e.g., `cdn1.example.com`, `cdn2.example.com`). Assets are distributed round-robin.

CDN Setup: Most CDN providers (BunnyCDN, KeyCDN, Cloudflare, etc.) work in pull-zone mode: you provide your origin URL and the CDN fetches and caches assets on first request. Set your CDN pull-zone URL as the CDN URL in Prime Cache settings.

How to Configure:

Create a pull-zone in your CDN provider’s dashboard pointing to your WordPress site origin URL
Copy the CDN pull-zone URL (e.g., https://yoursite.b-cdn.net)
Go to Prime Cache → CDN
Enable CDN URL Rewriting
Paste your CDN URL
Save settings and purge all cache
Open browser DevTools (Network tab) and confirm static assets are loading from the CDN hostname

Cloudflare Integration

When your site is proxied through Cloudflare, Prime Cache can automatically purge the Cloudflare edge cache whenever WordPress content is updated. This ensures visitors always see fresh content without waiting for the default Cloudflare cache TTL to expire.

Setting	Default	Description
Cloudflare Integration	Disabled	Enable Cloudflare API integration
API Token	Empty	Cloudflare API Token with Zone.Cache Purge permission
Zone ID	Empty	Your Cloudflare Zone ID (found in the Zone Overview page)
Zone Purge on Flush	Enabled	Purge the entire Cloudflare zone cache when Prime Cache’s “Purge All” is triggered
Per-URL Purge	Enabled	Purge only the specific URL(s) affected when a post is updated, rather than the entire zone

Creating a Cloudflare API Token:

Log in to your Cloudflare dashboard
Go to My Profile → API Tokens
Click Create Token
Use the Edit Cloudflare Workers template, or create a custom token
Set permissions: Zone → Cache Purge → Purge
Limit the token to your specific zone (domain)
Create the token and copy it immediately (it is only shown once)
Paste the token and your Zone ID into Prime Cache CDN settings
Click Test Connection to verify

Tip: Use per-URL purge whenever possible to minimize disruption. Zone-wide purge is appropriate only after major site-wide changes (theme switch, mass content update). Per-URL purge is called automatically via Prime Cache’s auto-purge triggers.

Sucuri Firewall Integration

If your site uses the Sucuri Website Application Firewall (WAF), Prime Cache can clear Sucuri’s cache automatically when content changes.

Setting	Default	Description
Sucuri Integration	Disabled	Enable Sucuri cache sync
API Key	Empty	Sucuri API key (found in Sucuri Dashboard → API)
API Secret	Empty	Sucuri API secret

Note: Sucuri API credentials are found in your Sucuri Dashboard under Settings → API. After enabling, Prime Cache sends a cache clear request to Sucuri on every Prime Cache purge event.

Varnish HTTP PURGE

For hosting environments with a Varnish cache in front of the web server, Prime Cache can send HTTP PURGE requests to invalidate specific cached objects.

Setting	Default	Description
Varnish Integration	Disabled	Enable Varnish PURGE requests
Varnish IP	127.0.0.1	IP address of the Varnish server (usually localhost for co-located setups)
Varnish Port	6081	Varnish listening port
Use Regex Purge	Disabled	Use BAN with regex instead of exact URL purge (requires Varnish VCL support)

Preloading (Pro)

Preloading warms the cache before visitors arrive and signals the browser to fetch resources it will need soon. Pro provides a full suite of preloading tools. Settings are under Prime Cache → Preload.

Cache Preloading

Crawls your site in the background and populates the page cache without waiting for real visitors. Ensures every page is served from cache even on the first visit after a cache purge.

Setting	Default	Description
Cache Preloading	Disabled	Enable background cache warming
Preload Desktop	Enabled	Preload desktop cache variants
Preload Mobile	Disabled	Preload separate mobile cache variants (requires Separate Mobile Cache to be enabled in Page Cache settings)
Preload Interval	900 seconds	Time between preload passes. Lower values keep cache warmer; higher values reduce server load.
Concurrent Requests	3	Number of parallel preload requests. Increase for faster preloading; decrease on low-resource servers.
Preload on Settings Save	Enabled	Automatically start a preload pass when settings are saved
Preload on Plugin Activation	Enabled	Start preloading immediately after Prime Cache is activated

Vary Cookies note: When Vary Cookies are configured (for cookie-keyed cache variants), only the default (unauthenticated) cache variant is preloaded. Cookie-specific variants (e.g., for logged-in users with personalized content) are generated on first visitor request since the preloader does not have access to visitor-specific cookies.

Sitemap Preloading

Reads your XML sitemap to discover URLs and preload them. This is particularly useful for large sites where database-based URL discovery may miss some pages.

Setting	Default	Description
Sitemap Preloading	Disabled	Discover URLs from sitemap and include them in preloading
Sitemap URL	Auto-detect	Your sitemap URL. Auto-detect finds `/sitemap.xml`, `/sitemap_index.xml`, and sitemaps declared in robots.txt automatically.
Sitemap Index Support	Enabled	Follow sitemap index files to discover child sitemaps

Tip: If you use an SEO plugin (Yoast SEO, Rank Math, All in One SEO), its sitemap is automatically detected. Sitemap preloading combined with database preloading provides the most comprehensive cache coverage.

Link Prefetching

Instructs the browser to fetch pages the visitor is likely to navigate to next, before they click. When the visitor does click, the page loads from the browser’s cache — appearing nearly instant.

Setting	Default	Description
Link Prefetching	Disabled	Enable JavaScript-based link prefetching
Hover Prefetch	Enabled	Begin fetching a page when the cursor hovers over its link (typically 200-300ms before a click)
Hover Delay	65 ms	Milliseconds to wait after hover before prefetching, to avoid prefetching on brief accidental hovers
Viewport Prefetch	Disabled	Prefetch links as soon as they scroll into the visible viewport using IntersectionObserver
Prefetch Limit	10	Maximum number of pages to prefetch per session, to avoid excessive bandwidth consumption
Exclude Patterns	wp-admin, /cart/, /checkout/	URL patterns to skip (admin pages, WooCommerce transactional pages, logout links)

Tip: Hover prefetch has an excellent signal-to-noise ratio — most hover events over links do result in a click within a few hundred milliseconds. Enable hover prefetch before viewport prefetch; the latter uses more bandwidth by prefetching everything in view.

Speculation Rules API

The Speculation Rules API is a modern browser feature (Chrome 109+) that enables prerendering — the browser fetches and renders the full page in a hidden tab before the user navigates to it. When the user clicks a link, the prerendered page is displayed instantly with zero perceptible load time.

Setting	Default	Description
Speculation Rules	Disabled	Inject Speculation Rules JSON into page output
Speculation Mode	prefetch	prefetch: fetch only (safe, low overhead). prerender: full render (maximum speed, higher resource use).
Eagerness	moderate	conservative (on pointer down), moderate (on hover), eager (immediately). Higher eagerness = more pages prerendered but higher bandwidth use.
Exclude Patterns	wp-admin, /cart/, /checkout/, /logout/	URL patterns excluded from prerendering rules

Browser support: Chrome 109+, Edge 109+ support prerender via Speculation Rules. Firefox and Safari do not support this API yet but silently ignore the injected JSON. For non-supporting browsers, link prefetching provides a graceful fallback.

Example Speculation Rules JSON (generated by Prime Cache):

{
  "prefetch": [{
    "source": "document",
    "where": {
      "and": [
        {"href_matches": "/*"},
        {"not": {"href_matches": ["/wp-admin/*", "/cart/", "/checkout/*", "/logout/"]}},
        {"not": {"selector_matches": "a[rel~='nofollow']"}}
      ]
    },
    "eagerness": "moderate"
  }]
}

LCP Optimization

Largest Contentful Paint (LCP) measures how quickly the largest visible element (typically a hero image) loads. Prime Cache can automatically identify and prioritize LCP elements using fetchpriority="high" and resource preloading.

Setting	Default	Description
LCP Optimization	Disabled	Enable automatic LCP element detection and prioritization
Add fetchpriority	Enabled	Add `fetchpriority="high"` to the detected LCP image element
Add Preload	Enabled	Add a `<link rel="preload">` hint for the LCP image in <head>
Skip First N Images	1	Apply fetchpriority=”high” to the first N images and skip lazy-loading them. The first image in the viewport is almost always the LCP element.
Manual LCP URL	Empty	Override auto-detection by specifying the LCP image URL explicitly

How it works: Prime Cache scans the page HTML for the first image tag in the main content area. It adds fetchpriority="high" and removes the loading="lazy" attribute (since the LCP element must not be lazy-loaded). A corresponding preload link is injected in the document head. This signals to the browser to download this image with top priority.

CSS background images (1.10.0): when the largest above-the-fold element is painted by a CSS background-image (common on Avada, Divi and Elementor heroes), there is no <img> to prioritize and the browser cannot discover the image until it has downloaded and parsed the stylesheet. LCP Optimization now finds that background (from an inline style attribute or the page’s own stylesheet files) and injects an early <link rel="preload" as="image" fetchpriority="high">. Only same-origin images are preloaded; the filter prime_cache_lcp_background_preload disables it.

DNS Prefetch & Preconnect

Early connection hints that reduce the overhead of connecting to external domains. These hints are injected into <head> so the browser can resolve DNS, complete the TCP handshake, and negotiate TLS before any resource from those domains is actually requested.

Setting	Default	Description
DNS Prefetch	Disabled	Inject `<link rel="dns-prefetch">` hints for external domains detected on the page
DNS Prefetch URLs	Empty	Manual list of external domains to prefetch (one per line, e.g., `//fonts.googleapis.com`)
Preconnect	Disabled	Inject `<link rel="preconnect">` hints (includes DNS + TCP + TLS, stronger than dns-prefetch)
Preconnect URLs	Empty	External origins to preconnect to (e.g., `https://fonts.gstatic.com`)
Limit Hints	4	Maximum number of preconnect/dns-prefetch hints. Cap at 4 to avoid consuming browser connection capacity.
Remove Self-Origin	Enabled	Do not emit hints for your own domain (wasted hint)

Tip: Preconnect is stronger than DNS prefetch but uses more resources. Use preconnect for domains from which you load render-blocking resources (Google Fonts, CDN) and dns-prefetch for others (analytics, social pixels).

Font Preloading

Automatically detects fonts declared in your CSS @font-face rules and injects <link rel="preload"> hints for them in the document head. This eliminates font-induced layout shift and invisible text flash.

Setting	Default	Description
Font Preloading	Disabled	Auto-detect and preload @font-face fonts
Manual Font URLs	Empty	Additional font file URLs to preload (one per line). Use for fonts not discoverable from CSS.
Preload Limit	3	Maximum fonts to preload. More than 3-4 preloads compete for bandwidth and may slow the LCP image.

Manual Resource Preloading

Specify individual resources to preload. Prime Cache auto-detects the resource type and generates the appropriate <link rel="preload"> tag with the correct as= attribute.

Setting	Default	Description
Manual Preload URLs	Empty	One resource URL per line. Type is auto-detected from file extension (script, style, font, image, fetch).

Example:

/wp-content/themes/my-theme/fonts/hero-font.woff2
/wp-content/themes/my-theme/css/critical-above-fold.css
/wp-content/uploads/hero-image.webp

Object Cache

Persistent object caching stores the results of expensive WordPress database queries and function calls in a fast in-memory store. Repeated queries are served from memory rather than hitting the database, dramatically reducing TTFB (Time to First Byte) for dynamic pages. Settings are under Prime Cache → Object Cache.

How WordPress Object Cache Works: WordPress has a built-in object cache that is discarded at the end of every page request. A persistent object cache backend (APCu, Redis, or Memcached) makes the cache survive between requests, so frequently accessed data is retrieved from memory rather than re-queried from the database on every page load.

How to enable a backend:

Go to Prime Cache → Object Cache.
Each backend card shows Active, Available or Not Found. If the PHP extension is missing, the button reads PHP Extension Required and cannot be clicked.
Click Enable on the backend you want. The add-on installs the object-cache drop-in (wp-content/object-cache.php). The Free plugin does not install this drop-in; it only removes its own on cleanup.
The banner at the top changes to Object Cache: Active via APCU (or REDIS / MEMCACHED). Click Disable to turn it off again.

Status banner:

Status	Meaning
Object Cache: Active via %s	The selected backend is running.
Object Cache: Disabled	No object cache is in use.
Object Cache: Managed by another plugin	Another plugin’s `object-cache.php` is installed.
Object Cache: Installed but not running	The drop-in is installed but its backend could not be loaded (the PHP extension is unavailable or disabled, or a site move left the path unresolved). WordPress is falling back to its internal cache. Disable and re-enable the backend to repair it (Pro 1.9.6).

In the “Installed but not running” state a notice also appears on the Dashboard, the Plugins screen and the Prime Cache screen, and clears itself once the drop-in works again (Pro 1.10.2). Since 1.9.7, when the absolute backend path written into the drop-in no longer resolves after a migration or staging copy, the drop-in falls back to wp-content/plugins/prime-cache-pro/ (re-enable the backend once for this to take effect).

APCu Backend

APCu (Alternative PHP Cache user store) stores cache data in PHP’s shared memory segment on the same server. It is the simplest backend to configure — no additional daemon and no connection settings.

Requirement: APCu must be enabled in your PHP configuration (apc.enabled=1). On shared hosting, it may be enabled by default. On VPS/dedicated servers, install via pecl install apcu and add extension=apcu.so to your php.ini. The Diagnostics tab shows APCu memory use, hit ratio and evictions.

APCu Limitation: APCu cache is local to a single server and is lost on server restart or PHP process restart. It is not suitable for multi-server environments. Use Redis or Memcached for load-balanced or cloud hosting setups.

Redis Backend

Redis is a high-performance in-memory data store with persistence options and support for multi-server deployments. It needs the PHP redis (PhpRedis) extension. The connection is configured with constants in wp-config.php, not on the settings screen; without them the defaults below are used.

Constant	Default	Description
`WP_REDIS_HOST`	127.0.0.1	Redis server hostname or IP address
`WP_REDIS_PORT`	6379	Redis server port
`WP_REDIS_PASSWORD`	Empty	Redis AUTH password (leave undefined if no password is set)
`WP_REDIS_DATABASE`	0	Redis database index
`WP_REDIS_TIMEOUT`	1 second	Connection timeout. Increase if Redis is on a remote server.
`WP_REDIS_PREFIX`	Site-unique (automatic)	Key prefix. When undefined, a value unique to this install is used so sites sharing one Redis server never collide.
`WP_REDIS_MAXTTL`	0 (no limit)	Maximum lifetime of a cache entry, in seconds

How to Configure Redis:

Ensure Redis is running on your server (redis-cli ping should return PONG)
Ensure the PHP redis (PhpRedis) extension is installed and enabled
If Redis is not at 127.0.0.1:6379, or needs a password, define the constants above in wp-config.php
Go to Prime Cache → Object Cache and click Enable on the Redis card
Confirm on the Diagnostics tab that the write/read round-trip passes

Memcached Backend

Memcached is a distributed memory caching system. It is well-suited for load-balanced environments where multiple web servers share a single cache pool. Like Redis, it is configured with constants in wp-config.php.

Constant	Default	Description
`WP_MEMCACHED_SERVERS`	array( ‘127.0.0.1:11211’ )	Memcached servers, as an array of `host:port` strings
`WP_MEMCACHED_MAXTTL`	0 (no limit)	Maximum lifetime of a cache entry, in seconds. Memcached cannot enumerate its keys, so set a cap if you want memory reclaimed deterministically (Pro 1.9.5).

Requirement: The PHP Memcached extension (libmemcached-based) is required. Note this is different from the older Memcache extension. Verify with php -m | grep memcached.

Autoloaded Options & Excluding “alloptions”

WordPress keeps every autoloaded option in a single alloptions object that is read on every request and re-stored on every option write. Once it grows large, turning on a persistent object cache can slow the whole site to a crawl (one site: about 3.9 MB of autoload, 20+ seconds per click).

Autoload advisory (Pro 1.10.2): the Object Cache tab warns when the autoload total passes 1 MB, strongly at 3 MB, and lists the largest options. It only measures; it never changes an option.
Continuous monitoring (Pro 1.10.5): the size is measured daily. Above 3 MB a notice appears on the Dashboard, Plugins and Prime Cache screens, with Review autoloaded options and Dismiss. After dismissal it returns only if the size grows by another megabyte. No scan ever runs on a page load.
Exclude “alloptions” from the object cache (Pro 1.10.4): a card shown while a backend is running. Turn on reads alloptions from the database once per request while every other key stays cached. It is off by default and recommended only when the autoload set is large. Before turning it on, check that the alloptions read-after-flush self-test on the Diagnostics tab shows Pass.

Behavior Notes

Clearing frees memory (Pro 1.9.5): earlier builds left the previous generation of entries in memory on every flush, which could fill APCu’s shared memory until every request fell through to the database. APCu and Redis now delete this site’s own keys, leaving any other site on the same store untouched.
A refused write never leaves the old value readable (Pro 1.9.4 / 1.9.9 / 1.10.10): if the backend rejects a write (memory full, an item too large, a dropped connection), the stale value is not served. 1.10.10 changed APCu’s key format — clear the cache once after updating.
Account and session data bypass APCu (Pro 1.10.7): on hosts that run several independent PHP worker processes, APCu is not shared between them, which used to send signed-in users back to the login screen at random. With APCu, the user_meta, users, userlogins, useremail and userslugs groups are now read from the database. Define PRIME_CACHE_OC_PERSIST_USER_GROUPS in wp-config.php to cache them anyway on a host where APCu is known to be shared by every process. Redis and Memcached are unaffected.
Whether APCu really is shared across processes is shown by Cross-process consistency on the Diagnostics tab.

Diagnostics

The Prime Cache → Diagnostics tab (Pro 1.10.3+) gathers the facts a support request asks for first on one read-only screen. It never changes anything.

Card	What it shows
Environment	PHP version and SAPI, WordPress version, server software
Cache drop-ins	Object cache state, Write/read round-trip, Cross-process consistency, whether `object-cache.php` / `advanced-cache.php` are present, and the `WP_CACHE` state
APCu	Only when APCu is in use: memory used, cached items, hit ratio and evictions. Over 90% memory use or any evictions means `apc.shm_size` should be raised
WebP / AVIF delivery	Only when image delivery uses the .htaccess “rewrite” method: a loopback request fetches one converted image and reports whether the server actually delivered it (Pro 1.10.11)
Autoloaded options	Total autoload size and the largest options, the state of the “alloptions” exclusion, and the alloptions read-after-flush self-test (Pro 1.10.4)

Write/read round-trip: writes a value and reads it back in the same request, catching a backend that reports active but does not actually store anything.
Cross-process consistency (Pro 1.10.7): checks whether a value written by one PHP process is visible to another, sampling in the background over a few minutes. It shows Measuring, Shared or Not shared between processes. If it is not shared, switch to Redis or Memcached, or turn the object cache off and keep the page cache.
WebP / AVIF delivery loopback test: Original served, not converted means a server-level static-file accelerator (Xserver X Accelerator, LiteSpeed, an nginx front, some CDNs) serves images directly and never runs the rewrite, so no visitor receives the converted image. Switch image delivery to “Picture” or “URL”.

Database Optimization

WordPress accumulates database bloat over time: post revisions, auto-drafts, orphaned metadata, spam comments, and expired transients. Prime Cache Pro provides a one-click cleanup interface and automatic scheduled maintenance. Settings are under Prime Cache → Database.

Cleanup Items

Each cleanup item shows the current count of affected rows so you can make an informed decision before deleting. Review the counts before running cleanup.

Cleanup Item	Description
Post Revisions	Delete all saved revision history for posts and pages. WordPress stores a new revision on every save; these accumulate rapidly on active sites.
Auto Drafts	Remove auto-save drafts that WordPress creates in the background while you edit. They are unnecessary once a post is published.
Trashed Posts	Permanently delete posts and pages that have been moved to the WordPress Trash. Equivalent to “Empty Trash.”
Spam Comments	Permanently remove all comments marked as spam. Spam accumulates quickly on unprotected sites.
Trashed Comments	Permanently remove comments in the Trash.
Expired Transients	Delete transient records whose expiry date has passed. These are temporary option values set by plugins and WordPress core; expired ones are never read but remain in the database.
All Transients	Delete all transients, including unexpired ones. Use with caution — some plugins rely on transients for caches and will regenerate them on next request. Site performance may temporarily dip after clearing all transients.
Table Optimization	Run MySQL `OPTIMIZE TABLE` on all WordPress tables. Reclaims disk space fragmented by deletions and re-indexes tables for faster queries.

Warning: Database cleanup is irreversible. Post revisions, trashed content, and spam comments cannot be recovered after deletion. Take a full database backup before running cleanup for the first time.

How to Run Cleanup:

Go to Prime Cache → Database
Review the row counts for each cleanup item
Check the boxes for items you want to clean
Click Run Cleanup Now
Wait for the completion notice showing how many rows were deleted
Click Optimize Tables after deletion to reclaim fragmented space

Automatic Cleanup Schedule

Configure automatic database maintenance on a recurring schedule via WordPress WP-Cron. Set it and forget it.

Setting	Default	Description
Automatic Cleanup	Disabled	Enable scheduled automatic cleanup
Schedule	Weekly	Cleanup frequency: Daily / Weekly / Monthly
Cleanup Items	Revisions, Expired Transients	Which items to clean on each scheduled run. Check only items safe to remove automatically.
Next Run	—	Displays the timestamp of the next scheduled cleanup

Recommended schedule: Weekly cleanup of post revisions, auto drafts, spam/trashed comments, and expired transients. Run table optimization monthly (it is more resource-intensive). Avoid scheduling “All Transients” for automated cleanup unless you have verified no critical plugins depend on long-lived transients.

WP-Cron dependency: Scheduled cleanup relies on WordPress WP-Cron. On low-traffic sites, WP-Cron may not run on time if no visitors trigger it. For reliable scheduling on low-traffic sites, set up a real system cron that calls wp-cron.php at the desired interval.

Heartbeat API Control

The WordPress Heartbeat API sends AJAX requests to the server at regular intervals to maintain session state, notify about autosaves, and provide live updates. On high-traffic sites, these requests add measurable server load. Prime Cache lets you control Heartbeat behavior per location. Settings are under Prime Cache → Performance Tweaks → Heartbeat.

Heartbeat Settings

Configure the Heartbeat API independently for three locations:

Location	Default Behavior	Impact of Disabling
Frontend	Disabled by default in WordPress core	Negligible (not normally active)
Admin Dashboard	Active every 60 seconds	Loss of real-time dashboard notifications (plugin updates, comment counts)
Post Editor	Active every 15 seconds	Autosave still works; only real-time “post lock” and simultaneous edit warnings are lost

For each location, three modes are available:

Mode	Description
Allow	Heartbeat operates normally at its default interval. No change from standard WordPress behavior.
Reduce Frequency	Heartbeat runs at a longer interval (configurable, 15-300 seconds). Reduces AJAX request frequency while preserving functionality.
Disable	Heartbeat is completely disabled for this location. No AJAX polling occurs.

Setting	Default	Description
Frontend Mode	Allow	Heartbeat behavior on the public-facing frontend
Admin Dashboard Mode	Allow	Heartbeat behavior in the WordPress admin dashboard
Post Editor Mode	Allow	Heartbeat behavior in the block editor and classic editor
Custom Interval	60 seconds	Interval in seconds when Reduce Frequency mode is active (range: 15-300)

Recommended configuration: Set Admin Dashboard to Reduce Frequency at 120 seconds (reduces load without losing notifications), and set Post Editor to Reduce Frequency at 60 seconds (still autosaves frequently). Disable Heartbeat on the Frontend entirely if it is active.

Security & Advanced Caching

Security Headers

Prime Cache can inject HTTP security headers with every response. These headers instruct the browser to enforce security policies that protect visitors against common web attacks. Settings are under Prime Cache → Tools → Security Headers.

Header	Default Value	Description
HSTS (`Strict-Transport-Security`)	Disabled	Forces browsers to connect via HTTPS only. Configure `max-age` (recommended: 31536000 = 1 year), and optionally `includeSubDomains` and `preload`.
X-Content-Type-Options	Disabled	Set to `nosniff` to prevent browsers from MIME-sniffing responses away from the declared content type. Mitigates drive-by download attacks.
X-Frame-Options	Disabled	Controls whether your site can be embedded in an iframe. Use `SAMEORIGIN` to allow same-domain framing only, or `DENY` to block all framing. Prevents clickjacking.
X-XSS-Protection	Disabled	Enables legacy browser XSS filter. Set to `1; mode=block`. Note: modern browsers rely on CSP instead, but this header supports older browsers.
Referrer-Policy	Disabled	Controls how much referrer information is included with requests. Recommended: `strict-origin-when-cross-origin` (sends full URL within same origin, only origin for cross-origin).
Permissions-Policy	Disabled	Restricts which browser features (camera, microphone, geolocation, etc.) pages and embedded content can use. Customize based on your site’s requirements.

HSTS Warning: Once HSTS is deployed with a long max-age, browsers will refuse HTTP connections to your site for the entire duration. Ensure your HTTPS setup is rock-solid before enabling HSTS. Do not enable preload unless you intend to submit your domain to browser HSTS preload lists (this is very difficult to reverse).

Recommended Security Header Configuration:

Strict-Transport-Security: max-age=31536000; includeSubDomains
X-Content-Type-Options: nosniff
X-Frame-Options: SAMEORIGIN
X-XSS-Protection: 1; mode=block
Referrer-Policy: strict-origin-when-cross-origin
Permissions-Policy: camera=(), microphone=(), geolocation=()

Advanced Caching Options

Fine-tune how the page cache behaves for specific scenarios. Settings are under Prime Cache → Page Cache → Advanced.

Setting	Default	Description
Cookie-Keyed Cache (Vary Cookies)	Empty	List of cookie names. When any listed cookie is present with a specific value, a separate cache variant is stored for that cookie value. Useful for sites with user-specific content variations beyond login state (e.g., currency preference, A/B test assignment).
Query-String-Keyed Cache	Disabled	Cache pages separately per query string combination. Required if your site serves different content based on URL parameters. Disabled by default to prevent cache bloat from crawler bots with arbitrary query strings.
Cache Query Strings	Empty	Specific query string parameter names to include in cache key (whitelist approach). Parameters not listed are stripped from the cache key.
404 Page Caching	Disabled	Cache 404 Not Found pages. Reduces server load from bots repeatedly requesting non-existent URLs. Cached 404s are served with the correct HTTP status code.
Always Purge URLs	Empty	Additional URLs to purge on every cache clear event. Useful for pages that aggregate content (homepage, news index) that should be invalidated whenever any post changes.

Vary Cookies and Preloading: When Vary Cookies are configured, the cache preloader generates only the default (cookie-free) variant. Visitor-specific variants are created on first request. Plan accordingly for sites where most traffic is cookie-keyed — your TTFB on first visit to a variant will be uncached.

Purging on updates: updating WordPress core, a plugin or a theme clears the whole cache (plugin and theme updates since Free 1.10.57). Each follows its own trigger on the Free plugin’s Auto Purge tab.

One-Click Drop-in Mode

Pro 1.9.0+. When page caching is on but WP_CACHE is not yet true in wp-config.php, the Prime Cache settings screen offers Enable drop-in mode (edit wp-config.php). It adds define( 'WP_CACHE', true ); for you (or flips an existing false to true), so cached pages are served before WordPress loads.

A timestamped backup of wp-config.php is saved next to it first.
Only that line is edited, and the result is verified before an atomic save. If the backup or verification fails, the file is left unchanged.
It is not offered on multisite. If wp-config.php is not writable, the notice asks you to add the line manually (see the Free manual).
A valid license is required. Without Pro, the free plugin shows only the manual instructions.

Server-Level Cache Detection

Pro 1.10.0+. Hosts such as Xserver’s X Accelerator, LiteSpeed, Kinsta, SiteGround, WP Engine, an nginx microcache or a CDN edge cache can sit in front of Prime Cache and keep serving an old, un-optimized copy of a page that Prime Cache’s purge never reaches. When the site’s own response headers reveal such a layer, the Prime Cache settings screen shows an advisory. Divide the work: either disable the server-level cache and let Prime Cache handle page caching, or turn off Prime Cache’s page cache and let the server layer serve pages. The advisory never changes anything, and Dismiss hides it. Cloudflare and Varnish are skipped when the built-in integration already manages them.

Cache Exclusions

Define rules to prevent specific pages, URL patterns, cookies, user agents, or referrers from being served or stored in the cache. Settings are under Prime Cache → Page Cache → Exclusions.

Exclusion Type	Description
Exclude URLs	URL patterns (one per line, supports wildcards with ``) that should never be cached. For example: `/account/`, `/checkout/`, `/api/`
Exclude Cookies	If any listed cookie is present in the request, the page is not cached. Default exclusions include WooCommerce cart cookies and login cookies.
Exclude User Agents	Requests from matching user agent strings bypass caching. Useful for excluding specific bots or monitoring services that should see live content.
Exclude Referrers	Requests arriving from specific referrer domains bypass caching. Rarely needed; use with care.

Default exclusions: Prime Cache automatically excludes the WordPress admin area, login pages, WooCommerce cart/checkout/account pages, and requests with active WordPress login cookies. You do not need to add these manually.

Per-Post Cache Control

Disable caching for individual posts or pages directly from the post editor, without creating a URL exclusion rule.

Edit any post or page. In the sidebar, locate the Prime Cache metabox. Check Disable cache for this page. Save the post. That specific URL will now always bypass the cache and serve a live PHP response.

Use case: Useful for membership pages that conditionally show different content based on user role, landing pages that use server-side A/B testing, and pages that embed real-time data widgets that must not be cached.

AI Advisor

Configured under the Prime Cache > AI Advisor tab (Pro 1.8.0+).

It measures your site environment and the structure of your public homepage, then has an AI explain what is slowing the site down and produce a prioritized action plan. Suggested setting changes can be applied in one click, and a follow-up chat answers environment-specific questions.

Strictly opt-in, bring-your-own-key. Nothing is sent anywhere until you enable the feature and run a diagnosis. AI usage is billed by the provider whose API key you supply, and diagnosis data never passes through Rapls Works.

AI provider & model

Choose one of the following. Your API key is stored on this site and sent only to the provider you select; keys are stored per provider, so switching providers keeps each key.

Provider	API key	Models (dropdown)
Anthropic (Claude)	Required	Claude Opus 4.8 / Sonnet 5 / Haiku 4.5
OpenAI	Required	GPT-5.2 family / o4
OpenRouter	Required	Claude / GPT / Gemini / DeepSeek / Llama, etc.
Google Gemini	Required	Gemini 2.5 Pro / 2.5 Flash / 2.0 Flash
WordPress AI Connector (experimental)	Not needed	Uses the AI configured in WordPress itself (e.g. the AI Services plugin)

Pick a model from the dropdown, or choose Custom to enter any other model name. Use the Test Connection button to verify the key, model and connection before you rely on them.

Running a diagnosis

Tick Enable AI consultation and agree to the data transmission.
Select a provider and model, enter the API key, Save, and confirm with Test Connection.
Click Run AI Diagnosis (20-60 seconds).
You get a summary, findings (with severity), recommended setting changes, and actions that need your judgement.
Apply a recommendation with one click (the cache purges automatically). After applying, view one page on mobile and re-measure with PageSpeed Insights.

Safety: every setting change the AI proposes is validated twice against a fixed allowlist (key plus value type/range). Credentials, purge rules and any non-allowlisted option cannot be changed, and known-unsafe values (e.g. the rewrite image delivery on nginx-fronted hosts) are dropped automatically. No visitor data is included in what is analyzed.

Follow-up chat

Answers environment-specific questions using the diagnosis and your site facts as context, e.g. “How do I edit wp-config.php on my host?” The AI only advises; nothing in a chat answer writes to wp-config.php. (Drop-in mode can be switched on with the separate one-click button.)

Frequently Asked Questions

FAQ

Q: Does Prime Cache Pro require the free version?

Yes. Prime Cache Pro is an add-on plugin. The free Prime Cache plugin must be installed and activated first. The Pro add-on extends it with additional settings tabs and features.

Q: Can I use the same license key on multiple sites?

No. Each Pro license is tied to one production domain. Purchase additional licenses for additional sites. Development and staging environments may be activated temporarily (deactivate before reactivating on a different domain).

Q: Why does my page look broken after enabling Combine CSS or Combine JS?

CSS/JS combining occasionally breaks sites when stylesheets depend on a specific load order or when scripts use document.write(). To resolve: add the problem script or stylesheet’s filename to the corresponding Exclude list in File Optimization settings. Purge all cache and reload.

Q: WebP images are not being served despite conversion being enabled. What should I check?

Confirm the converted .webp files exist alongside the originals in wp-content/uploads/
If using .htaccess Rewrite delivery: verify mod_rewrite is enabled and the Prime Cache .htaccess rules are present
Check your browser’s request headers — it must send Accept: image/webp (all modern browsers do)
If using a CDN or reverse proxy, ensure it passes the Accept header to the origin and does not serve a cached JPG to WebP-supporting browsers
Verify the GD or Imagick library is available via System Information

Q: Does Delay JavaScript break the contact form, sliders, or other interactive elements?

It can. Enable Delay JS Safe Mode first (delays only external scripts) to identify if the issue is from first- or third-party scripts. For first-party scripts that break with Safe Mode off, add their URL fragment or script handle to the Delay Exclusion list.

Q: What is the difference between Remove Unused CSS and Critical CSS?

These solve different problems and can be used together:

Critical CSS: Extracts the styles needed for above-the-fold content and inlines them in <head> so the first paint happens immediately. The full stylesheet is loaded asynchronously.
Remove Unused CSS: Strips CSS rules that match no elements on a given page. Reduces the full stylesheet size but does not change when it loads.

Critical CSS improves LCP and perceived load speed. Remove Unused CSS reduces total CSS payload. Together, they maximize CSS delivery performance.

Q: The Speculation Rules API is enabled but I do not see faster navigation.

Check that you are testing in Chrome 109+ (or Edge 109+). Open Chrome DevTools → Application → Background Services → Speculation Rules to confirm rules are being parsed and which URLs are being prerendered. If no URLs are listed, check that the page contains internal links and that they are not matching the exclude patterns.

Q: Can I use Prime Cache Pro with a Nginx server?

Yes. All PHP-based features work on Nginx. The .htaccess optimization feature is Apache-specific and should be disabled on Nginx. For WebP/AVIF delivery on Nginx, use the <picture> Tag delivery method instead of .htaccess Rewrite. CDN, preloading, file optimization, and all other features function normally on Nginx.

Q: Does Prime Cache Pro support WordPress Multisite?

Page caching is not supported on multisite installations. All other Pro features (file optimization, image optimization, CDN, preloading, database cleanup, heartbeat control, security headers) work normally on multisite individual sites.

Q: My Cloudflare zone purge is not working. What should I check?

Verify the API Token has Zone.Cache Purge permission for the correct zone
Confirm the Zone ID matches the zone your domain is in (visible in the Cloudflare zone Overview page sidebar)
Ensure your server can make outbound HTTPS requests to api.cloudflare.com
Click Test Connection in the CDN settings and check the response message for error details

Q: How do I restore an image to its original quality after bulk optimization?

Prime Cache stores the original image alongside the converted versions (it does not overwrite the original). In the Media Library, select the image, click Edit, and use the Restore Original button in the Prime Cache section. Note: if you deactivated Prime Cache and the original was cleaned up by another process, restoration may not be possible — always keep WordPress Media Library backups.

Q: The database cleanup removed my revisions. Can they be recovered?

No. Database cleanup is permanent and irreversible. Always take a full database backup before running cleanup. Many hosting providers offer one-click database backup via phpMyAdmin or cPanel.