WordPress Object Caching: The Ultimate Guide to Redis & Object Cache Pro

Key Takeaways

• Object caching speeds up WordPress sites by storing database query results for faster data retrieval.
• Cloudways enhances caching efficiency through Redis and Object Cache Pro integration at both server and app levels.
• Enabling Redis and Object Cache Pro can significantly reduce response times and server load.
• Persistent object caching is ideal for dynamic, data-driven websites that handle frequent database requests.

Speed keeps visitors on your site, we all know that. But usually, the real drag on a WordPress site isn’t unoptimized images or messy code. It’s the database.

Because WordPress is dynamic, it can’t just show a static page. It has to query the database every single time a URL loads, hunting for content, author info, and settings. When your traffic spikes, those requests pile up fast, and your site starts to crawl.

This is where Object Caching steps in to fix the backend bottleneck.

Instead of forcing your database to do the heavy lifting for every visitor, object caching saves the results of those queries right in your server’s memory. This lets your site serve data instantly, bypassing the hard drive entirely. It’s a game-changer for dynamic sites like WooCommerce stores or membership platforms where standard caching plugins often fall short.

In this guide, we’ll break down exactly how object caching works and where it fits in the caching puzzle. We’ll also compare industry standards (Redis vs. Memcached), walk through the setup, and look at real benchmarks to see just how much faster your site can go.

What is Object Caching?

Object caching is simply a way to store database query results in your server’s memory so they can be accessed instantly. Think of it as a “short-term memory” for your database.

Here is the reality: asking a database to find a specific piece of data takes time and computing power. Object caching remembers that data after the first search. The next time your application needs it, it grabs it straight from the cache instead of bothering the database again.

While this concept works for all kinds of software, it is vital for WordPress because the CMS relies so heavily on database lookups to build every page.

The Difference: Object Cache vs. Page Cache vs. Opcode Cache

In the world of web performance, people often toss around different “caching” terms interchangeably. But they do very different jobs. Here is the breakdown:

Page Caching

Page caching saves the entire finished HTML of your page. It’s like taking a photo of a document and handing that photo to the user. This is the fastest option for content that rarely changes, like blog posts, but it breaks things if you try to use it on dynamic pages like shopping carts or user dashboards.

Object Caching

Object caching saves the specific bits of data rather than the whole page. If Page Caching is the photo, Object Caching is remembering the sentences so you don’t have to look them up in a book every time. It’s the go-to solution for dynamic sites where content changes from user to user.

Opcode Caching

Opcode caching deals with the PHP code itself. Since WordPress is built on PHP, the server has to read and “compile” that code every time a page loads. Opcode caching stores the compiled version so the server can skip that step and get straight to work.

Client-Side vs. Server-Side Caching

It’s also common to mix up object caching with browser caching. The key difference is simply where the data lives:

Server-Side Caching

Object caching happens on the server side. The data is stored on your web hosting server (specifically in RAM). It speeds up the process of building the page before it ever leaves the server.

Client-Side Caching

Browser caching happens on the client side, meaning the visitor’s laptop or phone. The browser saves static files like your logo, images, and CSS styles locally. This way, the user doesn’t have to download them again the next time they visit.

Built-in Object Caching Mechanism in WordPress

Many users do not realize that WordPress actually has its own object caching system running right out of the box. It is called the WP_Object_Cache class.

This built-in mechanism is active by default on every single WordPress site. Its job is to store data in the PHP memory while a page is being built. This ensures that if a specific piece of data is needed multiple times during a single page load, the database is only queried once.

However, there is a major limitation: it is non-persistent.

In a standard WordPress setup, this cache only lives for the exact duration of the page load. As soon as the server finishes sending the page to the user, the PHP memory is wiped clean. If that same user hits “Refresh” one second later, WordPress has to build everything from scratch again.

This is why the built-in system is helpful for code efficiency, but it does not solve the server load problem for high-traffic sites. To fix that, you need a persistent solution (like Redis) that keeps the data alive between different page loads.

Key WordPress Cache Functions

To actually interact with this WP_Object_Cache system, you cannot just rely on the defaults. You often need to manually tell WordPress what to remember and for how long. This is especially critical when you are running resource-heavy queries like when you use WordPress get_posts to fetch complex custom loops, and want to prevent them from hammering the database on every page load.

To give you that control, the WordPress API provides a specific set of functions to manage exactly how data is stored and wiped.

Basic Storage & Retrieval

• wp_cache_add(): This is the safe way to save data. It adds your data to the cache, but it checks if the key is empty first. If that key is already taken, this function basically does nothing and returns false.
• wp_cache_set(): This is the command you will see most often. It forces your data into the cache and will overwrite whatever is already there with the same key.
• wp_cache_get(): This is how you pull data out. It checks memory for your specific key. If it finds it, you get the data (a cache hit). If the memory is empty, it returns false (a cache miss).
• wp_cache_delete(): Use this when you need to remove a specific item. For example, if you update a post title, you want to delete the old cached version immediately so users do not see outdated info.

Advanced Management

• wp_cache_replace(): This functions like the opposite of add. It only updates the data if the key already exists. If the key is missing, it will not save anything.
• wp_cache_flush(): Think of this as the reset button. It clears every single item from the object cache. You should use this sparingly, mostly for debugging or during major site updates, as it forces the database to rebuild everything.
• wp_cache_add_non_persistent_groups(): This is critical for complex sites. It tells WordPress to keep specific groups of data in the temporary PHP memory only, even if you have Redis installed. You use this for data that changes too fast to be worth saving permanently.
• wp_cache_switch_to_blog(): If you run a Multisite network, this function is essential. It changes the cache context to a different site ID, allowing you to grab cached data from Site A while you are technically viewing Site B.

Boost Your WordPress Performance

Log in to your Cloudways account and enable Object Cache Pro to experience faster load times instantly.

Log In to Cloudways

Types of Object Caching

Now that you understand how the WP_Object_Cache system and its key functions work effectively at the code level, we need to look at the storage architecture. Object caching is categorized into two types based on how long that data remains available.

1. Persistent Object Caching (The data survives after the page loads)
2. Non-Persistent Object Caching (The data is lost immediately after the page loads)

Type	Persistent Object Caching	Non-Persistent Object Caching
Definition	Stores database query results in external memory (RAM) so they remain available across multiple different page loads and user sessions.	Stores data temporarily in the PHP memory. The data is wiped clean the moment the page finishes loading.
Characteristics	Long Lifespan: Data survives until it expires or is flushed. Scalability: Essential for high-traffic sites. Persistence: Can often recover data even after a service restart (depending on configuration).	Short Lifespan: Only exists for milliseconds. Zero Setup: Uses standard PHP resources; no external software needed. Volatile: All data is lost when the request ends.
Examples	Redis Memcached Valkey	Standard WordPress PHP Memory WP_Object_Cache (Default)

Redis vs. Memcached: Which Should You Choose?

When setting up object caching, you will generally choose between two backend technologies: Redis or Memcached.

For a long time, Memcached was the standard because it is lightweight and simple. However, in recent years, Redis has overtaken it as the preferred choice for WordPress, especially for complex sites like WooCommerce.

The main difference lies in power and persistence. Memcached is designed purely for simple caching strings of data. Redis, on the other hand, acts more like a database—it understands complex data structures and can actually save your data to the disk so it is not lost if the server restarts.

Comparison at a Glance

Here is how the two stack up against each other for WordPress users:

Feature	Redis	Memcached
Data Types	Advanced (Strings, Lists, Sets, Hashes)	Simple (Strings only)
Persistence	Yes (Can save snapshots to disk)	No (Data is lost on restart)
Replication	Yes (Master-Replica support)	No
Max Key Size	512 MB (Huge capacity)	1 MB (Limited)
Best Used For	Modern, dynamic WordPress sites	Simple, smaller caching needs

While Memcached is still a capable engine for simple caching, Redis is the clear winner for modern WordPress performance.

The reason is specific to how WordPress works. WordPress often needs to store complex data groups (like serialized objects). Since Redis supports advanced data types, it can handle these objects natively without as much processing overhead.

Furthermore, the “Persistence” feature of Redis is a safety net. If your server reboots, a Memcached site starts with an empty cache and the database gets hammered immediately (a “cache stampede”). A Redis site can reload the previous cache from the disk, keeping your site fast and stable right away.

This is exactly why we built our platform’s caching stack around Redis architecture and partnered with Object Cache Pro to deliver enterprise-grade stability.

What Are the Benefits of Object Caching?

While all caching types aim to reduce the server load and enhance the website’s performance, object caching goes beyond this. It has some unique benefits that make it more suitable for particular scenarios.

Here are some of the benefits of object caching:

• Granularity: Since object caching focuses on individual objects, you can perform targeted caching. This means that when a single piece of data changes, you just need to perform caching on that object rather than the full page caching.
• Flexibility: Object caching is flexible enough to manage data independently.
• Reduces Database Load: Object caching can drastically reduce database load by storing frequently accessed data in memory.
• Decoupling from External System: Object caching provides a buffer layer, allowing applications to function even if the primary data source (like a database) is temporarily unavailable or slow.
• Application-wide utility: Object caching caches data from various sources, not just databases.

How Does Object Caching Work?

Object caching follows a pretty simple 3-step procedure; here’s a step-by-step breakdown of how it actually works.

Step  # 1: Request for Data

Data is usually available in the database, but with object caching enabled, whenever a user requests certain data, the bot checks for it in the temporary storage (cache), surpassing the primary storage (database).

Step # 2: Check Cache

After the request is made, the bot checks the cache to see if the requested page is available.
The check is usually performed using a key that uniquely identifies the data. This key is normally based on the database query, URL, or some other unique identifier associated with the requested data.

Step # 3: Cache Hit

If the required data is available in the cache, it is called a cache hit, and the data is directly served to the user. If it’s unavailable, the requested page is fetched from the database, where it is kept for future use, and this scenario is called a cache miss.

How to Enable Object Caching on WordPress

Now that you know which technology to use, let’s look at how to actually turn it on. The process depends on your hosting environment.

Option 1: The Generic Method (Using Free Plugins)

If you are hosting your site on a standard VPS or a shared hosting provider, enabling object caching is usually a two-step process.

Important: You cannot simply install a plugin and expect it to work. The Redis software must be installed and running on your server first. The WordPress plugin is just the “bridge” that connects your site to that server software.

Step 1: Activate Redis on the Server

The Redis software is not active by default on most hosting accounts because it consumes server memory (RAM). How you turn it on depends entirely on your hosting type:

If you are on a managed plan, the hard work is usually done for you. Redis is likely pre-installed but dormant.

• Log in to your hosting dashboard.
• Look for a section labeled Caching, Performance, or PHP Settings.
• Find the Redis or Object Cache toggle and switch it to ON.
• Note the “Port” number they give you (usually 6379), as you might need it later.

If you are running a raw DigitalOcean Droplet (or similar unmanaged VPS), you have to install the software manually via the command line.

In my case, since I’m my WordPress site is hosted on DigitalOcean, I’ll:

• Connect to my server via SSH (Terminal).
• Update my package list by running: sudo apt update.
• Install Redis by running: sudo apt install redis-server.
• Verify it is running by executing: sudo systemctl status redis. If you see “active (running),” you are ready to proceed.

Success! Now that Redis is installed on my server, we just need to install the connector plugin on WordPress and enable Redis object caching.

Step 2: Install the Connector Plugin

• Log in to your WordPress Dashboard.
• Navigate to Plugins > Add New.
• Search for Redis Object Cache. The most popular free option is developed by Till Krüss.
• Install and Activate the plugin.

Step 3: Enable the Connection

After activation, go to Settings > Redis. You will see a button labeled Enable Object Cache. Click it.

If the connection is successful, the status will turn green and show “Connected.” If it fails, it usually means the plugin cannot find the Redis server at the default address (127.0.0.1).

In my case, it works!

You can further confirm a successful connection by running this command in the SSH terminal:

redis-cli ping

You should get PONG, which means Redis is running, like this:

At this point, your WordPress site is fully set up and using Redis for caching. You can also flush the cache whenever you want by clicking on the Flush Cache button.

Option 2: The Cloudways Method (Automated Setup)

If you are hosted on Cloudways, you can skip the manual configuration. We automate the entire Redis installation process at the server level.

Even better, if you are on a server with 2GB RAM or higher, we automatically install and configure Object Cache Pro (OCP). This is an enterprise-grade plugin (normally costing $95/month) that is significantly faster and more efficient than the free alternatives.

Here is how to set it up in two steps.

Step 1: Activate Redis (Server Level)

Before the plugin can work, the Redis service must be running on your server. We have made this a simple toggle.

• Log in to your Cloudways platform.
• Navigate to Servers and select your target server.
• Click on Manage Services in the left-hand menu.
• Scroll down to Redis and click Start (or Enable).

• Once the process finishes, Redis is active and ready to store data. Keep in mind that the Object Cache Pro plugin will automatically be configured on all the supported WordPress applications available on your server. If you add any new WordPress applications to the same server, they will also have the Object Cache Pro plugin installed and activated.

Step 2: Verify Object Cache Pro (Application Level)

On Cloudways, you typically do not need to install the plugin manually. When you launch a new WordPress application on a 2GB+ server (with Redis active), Object Cache Pro is installed and activated automatically.

To verify it is working:

• Log in to your WordPress Dashboard.
• Go to Settings > Object Cache.

• Look for the “Status” indicator. It should say Connected.

You can further confirm if object cache pro is enabled for your WordPress app by going to your Application > Application Settings > WordPress:

And that is it! Way simpler and streamlined, plus you unlock the enterprise-grade performance of Object Cache Pro (worth $95/mo) entirely for free with Cloudways, saving you both money and the headache of manual configuration.

What if I don’t see Object Cache Pro?

If you are on a smaller server (under 2GB) or migrated an old site, you might not see OCP. In that case, you have two choices:

• Scale Up: Upgrade your server to 2GB+ to unlock the free OCP license automatically.
• Use the Generic Method: Follow “Option 1” above and install the free “Redis Object Cache” plugin instead.

System Requirements for Object Cache Pro To run the enterprise stack smoothly, ensure your server meets these specs:

• RAM: 2GB or higher (Required for the free OCP license).
• PHP Version: PHP 8.0 or higher (We recommend PHP 8.2 for best performance).
• Redis: Must be “Active” in Manage Services.

Advanced Management: Flushing the Object Cache

Since object caching stores data in memory to avoid database queries, there is a small catch: Persistence.

Sometimes, you might make a change to your site (like updating a menu, editing a page, or publishing a new product), but the site still shows the old version. This happens because the server is serving the “saved” copy from the cache instead of the new data.

To fix this, you need to “Flush” (clear) the object cache. Here are the two best ways to do it.

Method 1: The “Flush Cache” Button (Easiest)

For daily tasks, you don’t need any code. Most object caching plugins (including Redis Object Cache and Object Cache Pro) add a handy button directly to your WordPress dashboard.

• Log in to your WordPress Admin Dashboard.
• Look at the top Admin Toolbar (the black strip at the top of the screen).

• Hover over Object Cache and click Flush Cache.

This instantly wipes the Redis memory and forces WordPress to fetch fresh data from the database for the next visitor.

Method 2: Using WP-CLI (For Developers)

If you are a developer, or if you cannot access your WordPress dashboard (e.g., a “White Screen of Death“), the command line is your lifesaver.

WP-CLI (WordPress Command Line Interface) allows you to flush the cache directly from the server. If you are on Cloudways, this is pre-installed and ready to use.

Here’s how you can clear the object cache using WP-CLI:

• Step 1: Connect to Your Server Launch your SSH terminal. (On Cloudways, you can do this in one click by going to Server > Master Credentials > Launch SSH Terminal).

• Step 2: Navigate to Your Folder WP-CLI commands must be run from inside your website’s public folder. Run this command:

cd applications/your_db_name/public_html

(Tip: Type ls to list your folders if you don’t know your DB name).

• Step 3: Flush the Cache Type the following command and hit Enter:

wp cache flush

You should see “Success: The cache was flushed” after running the command.

That’s it! You’ve successfully cleared your WordPress cache using WP-CLI.

Testing the Impact of Object Caching on WordPress Sites

I created an e-commerce store on a Cloudways server to assess the real-world performance of Object Cache Pro (OCP). I selected a DigitalOcean Premium server for this test, primarily because Cloudways automatically pre-installs Object Cache Pro on all servers with 2GB RAM or higher.

To ensure the test results focused purely on object caching, I took the following steps to isolate the environment:

• Disabled Varnish Cache (Server-level page caching)..
• Deactivated the Breeze plugin (WordPress-level caching).
• Did not configure Cloudflare to ensure the best possible performance testing conditions.

Here are the server specifications that I used for this setup:

Name	Specification
Cloudways Server	DigitalOcean Premium
Server Location	UK – London
RAM	8 GB
Disk Space	160 GB NVMe Disk
Bandwidth	5TB Transfer
CPU	4 Core Processor
Operating System	Debian 10
Nginx	1.21.3
Memcached	1.5.6
Apache	2.4.57
Database	MariaDB 10.4.20

Preparing the Test: Disabling Object Cache Pro

To measure the “Before” and “After” performance, I first needed to deactivate the pre-installed Object Cache Pro.

Step 1: Stop Redis at the Server Level

• Navigate to the Cloudways Platform.
• Select your server and access the Manage Services section.
• Locate Redis and click the Stop button. (This halts the Redis service and automatically disconnects the Object Cache Pro plugin).

Step 2: Verify Deactivation in WordPress

• Log in to your WordPress Dashboard.
• Navigate to the Object Cache Pro widget (usually under Dashboard > Home).
• Confirm it is Disabled.

Note: Stopping Redis on the server will deactivate object caching for all WordPress applications hosted on that specific server.

Object Cache Pro Benchmarking Results

We conducted a series of benchmarking tests using Loader.io to evaluate how Object Cache Pro impacts response times and overall server performance.

Test Configuration:

• Test Type: Clients Per Test
• Number of Clients: 100
• Duration: 1 Minute

Test 1: Before (Object Cache Pro Disabled)

First, with Redis stopped and OCP disabled, I subjected the site to the 100-client load test.

• Average Response Time: 1056 ms
• Success Rate: 99%

As you can see, without object caching, the server took over 1 second to respond to requests.

Before – Object Cache Pro

Test 2: After (Object Cache Pro Enabled)

Next, I restarted Redis from the Cloudways Platform and ensured Object Cache Pro was active. I then ran the exact same test again.

• Average Response Time: 522 ms
• Success Rate: 100%

After – Object Cache Pro

The numbers speak for themselves.

• Average Response Time WITH Object Cache Pro: 522 ms
• Average Response Time WITHOUT Object Cache Pro: 1056 ms

In the first test (without OCP), the server struggled with an average response time of 1056 ms. In the second test (with OCP enabled), the response time dropped to 522 ms.

This represents a 50% improvement in speed, demonstrating just how effective Object Cache Pro is at reducing database load and speeding up response times for your users.

When Should You Consider Using Object Caching?

Now that you have seen the benchmarks, you might be wondering: Does every single site need this?

While almost any dynamic site benefits from caching, it becomes absolutely critical in specific scenarios. If your site fits any of the following descriptions, object caching is not just a “nice-to-have”—it is a necessity.

1. High-Traffic Events (Black Friday / Sales)

During major sales events, your database gets hammered by thousands of simultaneous “Add to Cart” actions and checkout requests. Standard page caching cannot help here because cart data is unique to every user. Object caching relieves this pressure by storing that transient data in memory, preventing your database from crashing when you need it most.

2. Frequent Database Queries

If your theme or plugins constantly ask the database for the same information (like retrieving the site logo, navigation menu, or top-selling products list), object caching stores these results. This stops the server from wasting resources answering the exact same question thousands of times per minute.

3. Dynamic & Personalized Content

For membership sites or logged-in users (like a “My Account” dashboard), the content changes for every visitor. Since you cannot cache the entire page (HTML), object caching is the only way to speed up these personalized areas by caching the underlying data fragments instead.

4. Complex Computations

Some sites perform heavy math on every page load—like calculating shipping rates based on weight and location, or filtering thousands of products by price. Object caching stores the answer to these calculations so the server doesn’t have to do the math again and again.

5. Using Third-Party APIs

If your site relies on external data—like fetching Instagram feeds, stock prices, or shipping carrier rates—you are often limited by how many times you can ask their API per hour. Object caching saves the response, keeping you within usage limits and ensuring your site doesn’t break if their API goes down temporarily.

6. Microservices Architecture

In modern setups where different services talk to each other (like a headless WordPress setup), object caching acts as a high-speed shared memory, allowing these independent services to exchange data instantly without slowing down the user experience

Use Cases of Object Caching

Object caching is put to work in various real-world situations, including:

1. Web Content Management Systems: Object caching helps websites that frequently update content, like news sites and blogs, deliver pages quickly to visitors.
2. E-commerce Platforms: Online stores use object caching to display product listings and handle shopping cart interactions swiftly.
3. Social Media Platforms: Social networks employ object caching to ensure that users’ feeds load rapidly with the latest posts and updates.
4. API Caching: Applications that communicate with external services through APIs benefit from object caching by storing responses for faster and more efficient data retrieval.
5. Gaming Platforms: Online games rely on object caching to enhance performance, offering players a seamless gaming experience.
6. Financial Systems: Financial applications leverage object caching to quickly retrieve real-time data, which is crucial for traders and financial analysts.
7. Streaming Platforms: Streaming services such as Netflix and Spotify utilize object caching to deliver videos and music without buffering or interruptions.
8. SaaS Applications: Software as a Service (SaaS) providers use object caching to optimize their applications, ensuring users have a smooth and responsive experience.

User Testimonials on Object Caching Flexibility:

Website owners appreciate the flexibility that object caching brings to their online presence. They’ve shared their thoughts:

• Speaking of how persistent caching can be better for WordPress and WooCommerce.

• How object caching expedites your site:

Optimize Your WordPress Site Today

Access your Cloudways dashboard to activate Redis and Object Cache Pro for maximum speed and stability.

Log In to Cloudways

Summary

So there you have it. In this blog, We covered exactly how object caching works and, more importantly, proven the impact it has on real-world performance. As our benchmarks showed, the database is often the hidden bottleneck for dynamic sites, and fixing it can cut your response times in half without requiring a server upgrade.

If you are already hosting on Cloudways, the hard work is already done for you. You have an enterprise-grade solution in Object Cache Pro waiting to be activated, which offers stability that free plugins simply cannot match.

If you have any questions about your specific setup or need help troubleshooting the connection, leave a comment below!