Single plan

You can use Swift Performance with Single plan for 1 WordPress site. It can be the right choice if you have only 1 site, or if you would like to test what can Swift Performance do (you can upgrade your subscription later).

Multi plan

You can use Swift Performance with Multi plan for up to 5 WordPress sites. Regarding that the Multi plan price is very reasonable, if you have at least 2 sites you should choose Multi plan.

Developer plan

As the plan name suggest this plan is the best for developers, who manage many sites. You can use Developer Plan for up to 30 WordPress sites. If you are an agency, or freelancer, who has few clients you should choose Developer plan.

Business plan

We created Business plan for professional speed up experts, who doesn't manage the site, but speed up WordPress sites as a service. Business plan can be used on unlimited sites. For this plan monthly subscription is also available, so you can choose the monthly plan with a reasonable monthly fee as well.

Micro plan

Micro license is a special Single license for bloggers and personal sites. Even if your project generates some income you can use Micro license if your project meets the following requirements: Your site may can generate income from ads, but you can't sell any service/product (including PR articles) on the site. Using Micro license is not allowed for politically active sites.

1. Login to My account on musthaveplugins.com
2. On the next screen you will see your subscriptions. Choose any active subscription and click to Manage Subscription
3. On the next screen click to Download in Swift Performance section
4. Login to WordPress admin where you would like to install Swift Performance
5. Go to Plugins > Add new and click to upload plugin
6. Select the previously downloaded ZIP file and click to install
7. Now let Swift Performance to configurate itself

What is Caching?

Caching is the core performance optimization in Swift Performance. Instead of executing PHP code and database queries on every page request (which takes 200-800ms), Swift Performance creates static HTML files that can be served in just 5-15ms – a 40-160x speed improvement.

How the Cache Engine Works

The caching process follows this lifecycle:

1. Request Arrives – Swift Performance checks if caching is enabled and if the request is cacheable (not POST, not admin, not logged-in unless Logged-in Cache is enabled)
2. Cache Load Attempt – Checks /wp-content/swift-ai/cache/{domain}/{path}/__index/ for existing cache file
3. Cache Hit – If found, serves static file immediately with Swift3: HIT header
4. Cache Miss – If not found, WordPress generates the page normally while Swift Performance captures the output
5. Output Buffering – Uses ob_start() to capture the generated HTML
6. Cacheability Check – Validates the content is cacheable (not password-protected, not 404, not excluded)
7. Cache Save – Writes HTML to __index/index.html and metadata to __data/data.json
8. Warmup Queue – Adds URL to optimization queue for image/CSS/JS optimization

Page Priority System

Swift Performance uses a smart priority system that automatically optimizes your most important pages first.

How It Works:

• Initial priorities are assigned based on page type (homepage = highest, blog posts = lower)
• Real visitor data automatically adjusts priorities – most visited pages become more important
• Adapts to changes – priorities reset weekly to reflect current traffic patterns

Real-World Examples:

• Marketing campaign: A new landing page with high traffic automatically becomes high priority for optimization
• Low traffic: A Terms & Conditions page with few visits automatically becomes lower priority
• Main Thread: Swift Performance focuses optimization resources on your most popular pages (typically top 10%)

Result: You don't need to manually configure priorities – Swift Performance automatically optimizes what matters most to your visitors.

Cache Invalidate vs Purge

Key Difference: Invalidate keeps visitors happy with cached content while rebuilding in the background. Purge forces immediate fresh content at the cost of temporary performance.

Automatic Cache Management Triggers

Swift Performance automatically manages cache based on WordPress actions:

Invalidate (Zero Downtime - Cache Remains):

• save_post – Post or page updated (also invalidates homepage and related archives)
• pre_post_update – Before post update
• wp_set_comment_status – Comment approved/unapproved
• after_switch_theme – Theme changed (invalidates all pages)
• customize_save_after – Customizer settings saved (invalidates all pages)
• wp_update_nav_menu – Navigation menu updated (invalidates all pages)
• update_option_sidebars_widgets – Widgets changed (invalidates all pages)
• activated_plugin / deactivated_plugin – Plugin status changed (invalidates all pages)
• upgrader_process_complete – WordPress/plugin/theme updated (invalidates all pages)

Purge (Immediate Deletion - Cache Removed):

• delete_post – Post or page deleted (purges that page, invalidates homepage and archives)
• wp_trash_post – Post moved to trash (purges that page, invalidates homepage and archives)
• delete_attachment – Media file deleted (purges that page, invalidates homepage and archives)
• save_post – For the specific updated post (purges old version, invalidates related pages)

Smart Invalidation: When a post is updated, Swift Performance also invalidates:

• Homepage (if post appears in recent posts)
• All pages containing loops with that post type
• Category/tag archives where the post appears
• Author archives
• Date-based archives
• swift3_purge_cache action hook – Custom purge triggers

Nonce Handling in Cached Pages

WordPress nonces expire after 12-24 hours, which can cause "expired nonce" errors on cached pages. Swift Performance handles this in several ways:

• Checksum Filtering – The swift3_checksum_source filter strips nonce values before calculating page checksums, preventing re-optimization when only nonces change
• Fragment Strategy – Wrap forms containing nonces in fragments so they load fresh via AJAX on every page view
• Collage for Logged-in Users – Enable Collage to load user-specific content (including nonces) dynamically while serving cached pages
• Exclude Sensitive Pages – Use swift3_is_url_excluded filter or Exclude URLs setting to bypass caching for pages with critical forms
• Nonces in cached pages remain valid for their full lifespan (24 hours by default)

When to Use Caching

Available Hooks & Constants

Filters: swift3_is_request_cacheable, swift3_is_page_cacheable, swift3_cache_buffer, swift3_cache_basedir, swift3_checksum_source

Actions: swift3_cache_done, swift3_page_discovered, swift3_invalidate_cache, swift3_purge_cache

Constants: SWIFT3_CACHE_LIFESPAN, SWIFT3_SEPARATE_DEVICES, INVALIDATE_CACHE_ON_COMMENT

See Developers section for detailed hook documentation and examples.

What is Critical CSS?

Critical CSS is the minimum CSS needed to render the above-the-fold content (what users see without scrolling). By inlining this CSS in the <head> and deferring the rest, pages render instantly without waiting for external stylesheets to download.

Impact: Improves First Contentful Paint (FCP) by 0.5-2 seconds and Largest Contentful Paint (LCP) by 0.3-1.5 seconds.

Optimization Levels

How CSS Optimization Works

Step 1: CSS Collection (During cache prebuild)

• Swift Performance visits the page with a headless browser
• Collects all <link rel="stylesheet"> and <style> tags
• Sends CSS URLs and inline styles to the API

Step 2: API Processing

• API renders page in Chrome (viewport: desktop 1441x721px, mobile 541x721px)
• Uses CSS coverage analysis to identify above-the-fold styles
• Generates device-specific critical CSS files
• Level 2 only: Analyzes used characters and creates subset fonts

Step 3: Delivery

• Critical CSS inlined in <head> with media queries:
  • @media (min-width: 768px) for desktop
  • @media (max-width: 767px) for mobile
• Original stylesheets changed to rel="swift/stylesheet"
• Full stylesheets load after page renders (via JavaScript)
• Level 2: Fonts preloaded with <link rel="preload" as="font">

Font Optimization (Level 2)

Character Detection:

The API scans your page HTML and extracts all used characters. For example, if your page only uses "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,!? ", only these characters are included in the subset font.

Before Optimization:

@font-face {
    font-family: 'MyFont';
    src: url('/fonts/myfont.woff2');
    /* File size: 150KB, contains 5000+ characters */
}

After Optimization (Level 2):

@font-face {
    font-family: 'MyFont';
    src: url('/wp-content/swift-ai/cache/.../abc123.woff');
    /* File size: 8KB, contains only 80 used characters */
    font-display: swap;
}

File Size Reduction: Typically 85-95% smaller (150KB → 8KB)

Troubleshooting

Available Hooks & Constants

Filters: swift3_skip_optimizer, swift3_before_assets_optimizer, swift3_after_assets_optimizer, swift3_css_layer

Constants: LEGACY_CCSS (force old critical CSS version)

See Developers section for code examples.

What Does "Offload the Main Thread" Mean?

The main thread is the browser's UI thread that handles rendering, user interactions, and JavaScript execution. When the main thread is busy executing JavaScript, the page becomes unresponsive – users can't click, scroll, or interact.

"Offloading the main thread" means deferring non-critical JavaScript execution until:

• The page has finished rendering (DOMContentLoaded)
• The browser is idle (requestIdleCallback)
• The user interacts with the page (scroll, click, touch)

Impact: Reduces Time to Interactive (TTI) by 30-60% and Total Blocking Time (TBT) by 40-70%.

What is "Delay JS"?

Delay JS means converting <script> tags to <script type="swift/javascript"> so they don't execute immediately. Swift Performance's custom loader then executes them at the optimal time based on:

• Priority – Critical scripts load first, analytics/tracking scripts load last
• Dependencies – jQuery loads before jQuery plugins
• User interaction – Some scripts wait for user activity
• Browser idle time – Low-priority scripts use requestIdleCallback

Optimization Levels

How It Works

Step 1: Script Detection

Swift Performance converts all <script> tags to <script type="swift/javascript"> and moves src to data-src:

<script src="/path/to/script.js"></script>


<script type="swift/javascript" data-src="/path/to/script.js"></script>

Step 2: User Interaction Detection (Level 1)

// Wait for user interaction
['touchstart', 'mousemove', 'scroll', 'keydown', 'click'].forEach(function(event) {
    document.addEventListener(event, function() {
        loadDeferredScripts(); // Execute all delayed scripts
    }, {once: true, passive: true});
});

// Fallback after 3 seconds if no interaction
setTimeout(loadDeferredScripts, 3000);

Step 3: Idle Time Loading (Level 2)

// Use browser idle time
if ('requestIdleCallback' in window) {
    requestIdleCallback(function() {
        loadDeferredScripts();
    }, {timeout: 2000});
} else {
    setTimeout(loadDeferredScripts, 1);
}

Step 4: Dependency Management

Swift Performance automatically detects jQuery dependencies and loads jQuery before inline jQuery code:

// Detects this pattern
<script>
jQuery(document).ready(function($) {
    $('.slider').slick(); // Requires jQuery
});
</script>

// Ensures jQuery loads first, then executes inline code

Performance Impact

Compatibility Testing Checklist

Before enabling Level 2, test these scenarios:

• Forms submit properly (contact forms, search forms)
• Sliders/carousels initialize correctly
• Modal popups open/close
• AJAX functionality works (add to cart, filters)
• Video players load (YouTube, Vimeo)
• Image galleries function
• Dropdown menus operate
• Social sharing buttons work
• Live chat widgets load
• Analytics tracking fires
• Cookie consent notices appear
• Payment gateways function (checkout process)

Troubleshooting

Available Hooks & Constants

Filters: swift3_skip_js_optimization, swift3_js_delivery_tag, swift3_script_type, swift3_before_assets_optimizer

See Developers section for code examples on excluding specific scripts.

Swift Performance will generate optimized WebP version for all images (including third party and background images) on the fly. Optionally you can also enable Optimize Images on Upload. Swift Performance also can use WebP which has been generated by other plugins, so you can switch instantly.

What It Does

Replaces heavy iframes (YouTube videos, Google Maps, embedded widgets) with optimized placeholders and lazy-loads the actual iframe content only when needed. This can improve LCP by 1-3 seconds and reduce initial page weight by 500KB-2MB per iframe.

Optimization Levels

HTML Transformation

Before Optimization:

<iframe src="https://www.youtube.com/embed/ABC123"></iframe>

After Level 1:

<iframe src="" 
        data-src="https://www.youtube.com/embed/ABC123?enablejsapi=1" 
        loading="lazy"></iframe>

After Level 2:

<div class="swift3-iframe-placeholder" 
     data-src="https://www.youtube.com/embed/ABC123?enablejsapi=1">
    <img src="/wp-content/swift-ai/cache/.../iframe-screenshot.webp">
    <button class="play-button">▶</button>
</div>

How to Exclude Specific Iframes

Method 1: Exclude by URL Pattern (Recommended)

add_filter('swift3_avoid_lazy_iframes', function($list) {
    // Exclude payment gateway iframes
    $list[] = 'paypal.com';
    $list[] = 'stripe.com';
    
    // Exclude booking systems
    $list[] = 'calendly.com';
    $list[] = 'booking.com';
    
    return $list;
});

Method 2: Exclude by HTML Attributes

add_filter('swift3_skip_iframe_optimization', function($skip, $tag) {
    // Exclude iframes with specific class
    if (isset($tag->attributes['class']) && 
        strpos($tag->attributes['class'], 'no-lazy') !== false) {
        return true; // Skip optimization
    }
    
    // Exclude iframes by data attribute
    if (isset($tag->attributes['data-critical'])) {
        return true;
    }
    
    return $skip;
}, 10, 2);

Method 3: Disable on Specific Pages

add_filter('swift3_skip_optimizer', function($skip) {
    // Disable all optimization (including iframes) on landing pages
    if (is_page('landing-page')) {
        return true;
    }
    return $skip;
});

Automatic Exclusions

Swift Performance automatically excludes these iframes from optimization:

• google.com/recaptcha/ – Google reCAPTCHA
• hotjar.com – Hotjar analytics
• Payment gateways on checkout pages (WooCommerce, SureCart)
• Iframes with display:none or width: 0-1px
• Iframes with src="about:blank"

Performance Impact

Real-world metrics from production sites:

• LCP improvement: 1.2s to 2.8s reduction (embedding YouTube videos)
• Page weight: 800KB to 1.5MB reduction per embedded video
• Initial requests: 15-25 fewer HTTP requests on page load
• TTI improvement: 500ms to 1s faster Time to Interactive

Troubleshooting

Available Hooks & Constants

Filters: swift3_skip_iframe_optimization, swift3_avoid_lazy_iframes, swift3_skip_optimizer

See Developers section for detailed hook documentation and examples.

What It Does

Selectively disables plugins on pages where they're not needed, reducing HTTP requests, database queries, PHP execution time, and memory usage. For example, WooCommerce can be disabled on blog posts, or Yoast SEO can be disabled on the frontend.

How It Works

1. Plugin Detection – Identifies the current context (admin, frontend, AJAX, REST API)
2. Rule Application – Applies intelligent rules to determine which plugins are needed
3. Temporary Deactivation – Removes plugins from active_plugins option temporarily
4. Restoration – Restores original plugin list after WordPress loads

Built-in Optimizations

• Admin Cache – Caches admin page HTML, saves 200-500ms per admin page load
• Heartbeat Control – Reduces WordPress heartbeat frequency to save server resources
• Emoji Script Removal – Removes emoji detection script (saves 1 HTTP request)

Implemented Plugin Optimizations

Swift Performance includes intelligent rules for these popular plugins:

add_action('swift3_code_optimizer_before_check_plugin', function($plugin) {
    if ($plugin === 'woocommerce/woocommerce.php') {
        Swift3_Code_Optimizer::add($plugin, function() {
            // Disable on single blog posts
            if (is_single() && get_post_type() === 'post') {
                return true; // Disable
            }
            return false; // Keep enabled
        });
    }
});

Swift3_Code_Optimizer::add('contact-form-7/wp-contact-form-7.php', function() {
    if (is_page('contact')) {
        return false; // Keep enabled
    }
    return true; // Disable everywhere else
});

Development Mode temporarily suspends caching and optimization features for two hours (unless disabled beforehand).

You can tweak advanced settings if you click "Under the hood" button in Configuration. In most cases you won't need to change these settings, except if you need a quick fix until permanent solution from our dev team.

Logged in cache

If you enable this option Swift Performance will serve cached pages even for logged in users. In most cases you can simply load cached pages for logged in users as well. If there are some parts which should be personalized, you can use fragments to load them AJAX, or enable Collage to automated detection.

Exclude URLs

With this option, you can exclude pages by URL (or URL part). Write one URL (part) per line, then click to update.

Swift Performance will detect non-cacheable pages automatically, however regarding that there are over 50 000 WordPress plugins and approximetly 30 000 themes, it can happen that Swift Performance can't detect a non-cacheable page. If you find that there is a plugin or theme related page which always should be excluded, please let us know.

Exclude Post Types

With this option, you can exclude post types. You can select multiple post types.

Just like pages, Swift Performance can detect non-cacheable post types automatically as well. However regarding that there are over 50 000 WordPress plugins, it can happen that Swift Performance can't detect a non-cacheable post type. If you find that there is a custom post type which always should be excluded, please let us know.

Query String

By default Swift Performance will bypass caching if query string is present in the URL. There are 2 options to overwrite this default behavior:

Ignored query parameters

You can define query parameters which should be ignored. Write one parameter per line. Swift Performance ignores some parameters by default: utm_source, utm_campaign, utm_medium, utm_expid, utm_term, utm_content, fb_action_ids, fb_action_types, fb_source, fbclid, _ga, gclid, age-verified

Allowed query parameters

You can list query parameters which shouldn't be ignored, but should be cached separately. For example if you add "s" parameter, all of your search results pages will be cached separately. Write one parameter per line.

Bypass Cookies

By default Swift Performance will bypass caching if some specific cookies are set. However you can list any cookies here.

If you find that there is a cookie, which always should be bypassed, please let us know.

Enable GZIP

Usually you won't need to enable GZIP manually, because Swift Performance can detect compression and configure it automatically. However if you have double GZIP issues, then you may need to disable this feature in Swift Performance settings.

Browser Cache

With this option you can let Swift Performance to set the expiry headers for different content types. Usually you don't need to disable this, however in some cases (for example if you are using a CDN with own expiry values), it is unnecessary.

Keep Original Headers

Send original headers for cached pages. If you are using a plugin which send custom headers you can keep them for the cached version as well.

Optimize Images on Upload

Swift Performance will optimize all images (even third party, and background images) on demand. This means, when the cache warmer cache a page, it will pick up all images and optimize them on the actual page. Therefore you don't really need to optimize images on upload, however it can be useful if you would like to serve optimized images for the first (uncached) pageview.

Lazyload Images

Swift Performance is using the native lazyload for images, but improve it. Automatically detects important images and exclude them from lazyloading. You need disable this feature only if you would like to use a different plugin for lazyloading (not recommended).

Smart Image Sizing

Swift Performance will automatically resize images for every used viewport size, and will use responsive images on every pages (even for logged in visitors). You need disable this feature only if you would like to use a different plugin for responsive images (not recommended).

Optimize Rendering

Swift Performance will automatically detect the important images on every pages during the optimization process. These images will be excluded from lazyloading and will be preloaded (using the right responsive size) to improve LCP and FCP scores.

General

Swift Performance can load some part of the page dynamically and load the rest from cache. You can enable fragment caching for Elementor Widgets or Gutenberg Blocks in the editor, and specify shortcodes which should be loaded dynamically.

Collage

Collage is a smart feature, which identify dynamic part of a page and load them via AJAX. It can be extremly helpful, if you also enable Logged in cache.

With this feature Swift Performance will use smart preload technique (based on network bandwidth and device) to speed up the onsite navigation. With preloading important pages before the user navigate the navigation can be nearly instant. It will improve the field data scores, and the user experience as well.

System

On the system tab you can see your subscription status and disconnect the current site from the subscription.

You can also enable/disable the optimization daemon, which is a background process, and responsible for the optimization process. In most cases you don't need to disable it, however if you are using a shared hosting with limited resources, you may need to disable it.

General

Swift Performance is compatible with most plugins and themes out of box, however there are a few third-party plugins, themes, server software and services which are highly integrated with Swift Performance. Most of them doesn't need any configuration (like Elementor, Slider Revolution, WP Bakery, LiteSpeed, etc.), some others can be configured - if it is necessary.

You can enable autopurge Cloudflare cache, which is recommended if you are using Cloudflare APO, or proxy caching. If you previously used any Cloudflare plugin where your API credentials were set, Swift Performance will find them so you don't need to set them again.

If Cloudflare couldn't be configured automatically you need to choose the authentication mode, and enter Cloudflare e-mail and API password, or Cloudflare API token (recommended).

Once you configured Cloudflare you can enable Proxy caching, which will provide the same performance as Cloudflare APO.

If your site is running on Nginx server you need to add the generated rules manually to Nginx config.

You can find the rewrite rules on Nginx tab under Integrations, copy the rules, add them to config and restart Nginx.

On Nginx integration tab you can also verify that rules are up-to-date and working.

If Swift Performance detects Varnish you can enable Varnish module on Varnish tab under Integrations. Once you enabled it, Swift Performance will manage Varnish cache as well.

There are some specific features which can be enabled for a WooCommerce site. You can manage them on WooCommerce tab under Integrations.

Prebuild Variations

If you have separate single pages for variations you should also prebuild them. For this you need to enable Prebuild Variations feature, so Swift Performance will automatically preload, cache and optimize available variation single pages for all products.

Checkout Booster

Swift Performance can preload the checkout page and optimize AJAX fragments to keep the checkout experience fast.

Price Fragments

If you have a multi-currency store, or use visitors' geolocation to calculate VAT on shop/product pages, you can enable Price Fragments feature, to load prices via AJAX, while the rest of the page can be served from cache.

Action hooks allow you to execute custom code at specific points in Swift Performance's execution. Here's a complete list of action hooks available in Swift Performance AI. You can use these hooks in your theme's functions.php file or in a custom plugin.

Note: Action hooks should be added using the add_action() WordPress function. The general syntax is:

add_action('hook_name', 'callback_function', priority, accepted_args);

Constants

Swift Performance AI uses various constants to control its behavior. You can define these constants in your wp-config.php file to override the default values. All constants use the SWIFT3_ prefix.

Note: To define a constant, add it to your wp-config.php file before the line that says "That's all, stop editing! Happy publishing."

// Add to wp-config.php for shared hosting environments
define('SWIFT3_LIMITED_RESOURCES', true);