# Redis Object Cache Has Three Options for Failure. Object Cache Pro Has Twelve, for $950 a Year.

> Both reach Redis the same ways. We counted every documented option in each: 12 of Object Cache Pro's 49 handle failure, against 3 of the free drop-in's 31.

- Published: 2026-10-10
- Author: xSpeed Cache Team
- Tags: Object Cache, Redis, Comparison, Performance, Pricing, platform:wordpress
- Canonical: https://xspeedcache.com/blog/redis-object-cache-vs-object-cache-pro/

---

Updated October 2026

Redis Object Cache runs on 500,000+ WordPress sites and costs nothing, per a direct wordpress.org Plugin API query on 10 October 2026. Object Cache Pro costs $950 a year, per [its own pricing page](https://objectcache.pro/pricing) read the same morning. The comparison people expect is a feature list: what does the paid one add. The more useful comparison is narrower and harder to find written down anywhere. When Redis stops answering, what does each plugin do? This article counts the configuration surface of both products from their own documentation, sorts every option by the job it does, and prices the difference. Our own object cache goes through the same count, and it does not come out well.

## Quick Summary: Which Object Cache, and Why

| If you want… | Do this | Why |
|:---|:---|:---|
| An object cache on one site, for free | Redis Object Cache | 31 documented options, GPLv3, and it keeps working whether or not anyone is paid |
| Your site to stay up when Redis does not | Object Cache Pro | 12 of its 49 options are retry and failover policy, against three in the free drop-in |
| To check whether you already have Pro | Ask your host first | Eight hosting companies list themselves as its partners, and several bundle it |
| A cache you can switch off at 3am | Either one | Both ship an emergency bypass that needs no dashboard |
| Object caching without buying a second plugin | A cache plugin that includes it | Five of the nine plugins on our comparison page ship no object cache at all |
| Observability into cache hits and latency | Object Cache Pro, or the free drop-in | Our own built-in object cache offers none, and that is the honest answer |

Read that fourth row before the price rows. A persistent object cache is the one piece of WordPress performance tuning that can take a working site offline, and both products know it.

## Both Plugins Come From the Same Author, and the Free One Advertises the Paid One

This is not a rivalry. Till Krüss wrote both.

The wordpress.org listing for Redis Object Cache names him as the author and `tillkruess` as the sole contributor. The plugin's own `readme.txt`, fetched from `plugins.svn.wordpress.org` on 10 October 2026, carries a section headed `= Object Cache Pro =` that describes a "business class" backend and links to objectcache.pro with a referral parameter. The free plugin is the paid plugin's funnel, stated in public, in the vendor's own words.

That matters for how you read the rest of this page. A free product that upsells a paid one usually has features held back. This one does not appear to, and the census below is how you can tell. What the readme promises Pro adds is "faster serialization and compression", "cache prefetching and analytics", and "a dedicated engineer when you most need it". Two of those three are insurance rather than features.

> **Licensing, before you compare anything else.** Redis Object Cache is GPLv3, per its own readme header. Object Cache Pro is not distributed through the plugin directory at all.

## The Master Table: What Each One Ships

| Capability | Redis Object Cache (free) | Object Cache Pro ($950/yr) | xSpeed Cache built-in |
|:---|:---:|:---:|:---:|
| Price | $0 | $950/yr or $95/mo | Included free |
| Licence | GPLv3 | Proprietary, token-activated | GPL, proprietary Pro tier |
| In the WordPress directory | ✅ | ❌ | ✅ |
| PhpRedis client | ✅ | ✅ | — |
| Predis client | ✅ | — | — |
| Relay client | ✅ | ✅ | ❌ |
| Memcached backend | ❌ | ❌ | ✅ |
| Redis Cluster | ✅ | ✅ | ❌ |
| Redis Sentinel | ✅ | ✅ | ❌ |
| Read replicas | ✅ | ✅ | ❌ |
| TLS connections | ✅ | ✅ | ❌ |
| igbinary serialization | ✅ | ✅ | ❌ |
| LZF, LZ4, Zstandard compression | ❌ | ✅ | ❌ |
| Batch key prefetching | ❌ | ✅ | ❌ |
| Asynchronous flushing | ❌ | ✅ | ❌ |
| Atomic group flushing | ❌ | ✅ | ❌ |
| Retry count and backoff policy | ❌ | ✅ | ❌ |
| Cluster failover strategy | ❌ | ✅ | ❌ |
| Latency metrics in the dashboard | ✅ | ✅ | ❌ |
| Request-level analytics | ❌ | ✅ | ❌ |
| New Relic and OpenTelemetry tracing | ❌ | ✅ | ❌ |
| WP-CLI commands | ✅ | ✅ | ✅ |
| Keeps caching after you stop paying | ✅ | ❌ | ✅ |

Every cell in that table was read from the product's own documentation on 10 October 2026: the GitHub README and plugin readme for the free drop-in, [the configuration-options documentation](https://objectcache.pro/docs/configuration-options) for Pro, and our own `/free-vs-pro/` page for the third column. Where a row is marked with a dash rather than a tick or a cross, the product does not expose the setting and the vendor does not document a position on it.

Note the Predis row. The free plugin bundles a second client library that Pro's documented client list does not include, which is the first sign that "paid means more of everything" is the wrong model here.

## The Configuration Census: Four Buckets, Three Products

Here is the framework, and it is the thing nobody publishes for this category.

Take every configuration option each product documents. Sort each one by the job it does, into four buckets plus housekeeping:

- **Connect**: reach the Redis server at all. Host, port, scheme, credentials, client library, TLS, cluster and sentinel topology.
- **Store**: decide what goes in and how. Prefix, TTLs, group exclusions, serializer, compression, prefetching.
- **Survive**: what happens when a connection is slow, refused, or lost mid-request. Timeouts, retry counts, backoff, failover strategy.
- **Observe**: see what the cache is doing. Metrics, analytics, tracing, logging.
- **Housekeeping**: licence tokens, update toggles, admin notices, capability checks.

Then count. The counts below were computed in a script against the fetched documentation rather than read off the page by eye, because counting by eye is how a comparison article gets its own numbers wrong.

| Bucket | xSpeed Cache built-in | Redis Object Cache | Object Cache Pro |
|:---|---:|---:|---:|
| Connect | 9 | 9 | 13 |
| Store | 1 | 8 | 13 |
| Survive | 1 | 3 | 12 |
| Observe | 0 | 6 | 7 |
| Housekeeping | 0 | 5 | 4 |
| **Total documented options** | **11** | **31** | **49** |

![Configuration options of three WordPress object caches sorted into connect, store, survive and observe buckets, showing 9-9-13 for connect and 1-3-12 for survive](https://xspeedcache.com/images/blog/object-cache-configuration-census.webp)

Read the Connect row first. Nine options against nine against thirteen, which is close to parity. All three products reach Redis in substantially the same ways, and the free drop-in reaches it in one way Pro's documentation does not list. **If you are comparing these products on how they connect, you are comparing the part where they agree.**

Now read the Survive row. Three against twelve. The paid product has four times as many options governing what happens when something goes wrong, and those options are 24.5% of its total surface against 9.7% of the free plugin's. That ratio, not the feature list, is what $950 a year buys.

**The limitations of this count, stated plainly.** An option is not an outcome: twelve settings do not prove resilience, and three do not prove fragility. The count treats every option as one unit, so a `backoff` algorithm with a documented jitter strategy weighs the same as a `timeout` integer. Bucket assignment is a judgement, and two of the assignments are genuinely arguable: `strict` mode performs integrity flushes, which is as much a storage decision as a survival one, and `split_alloptions` was filed under Survive because the vendor's own documentation says it exists to "help avoid race conditions". The census counts documentation, not code. Run it yourself against both documents and you may file two or three options differently. The Connect and Survive gap is large enough that it survives the reclassification either way.

## Connecting Is Where They Agree

The queued premise for this article was that the paid tier buys you Relay support and igbinary serialization. That premise is wrong, and the free plugin's own documentation is what disproves it.

Redis Object Cache's GitHub README, fetched on 10 October 2026, documents all of the following:

- `WP_REDIS_CLIENT` with three accepted values: `phpredis`, `predis` and `relay`
- `WP_REDIS_IGBINARY`, a boolean defaulting to `false`
- `WP_REDIS_SSL_CONTEXT` for TLS connection options
- `WP_REDIS_SENTINEL` with a service name, and `WP_REDIS_CLUSTER` for cluster nodes
- `WP_REDIS_SHARDS` for sharded setups, and `WP_REDIS_SERVERS` with a `role=primary` syntax for replication

[Relay](https://relay.so/) describes itself as a shared in-memory cache sitting in front of Redis, and the free plugin lists `relay` among its tags on [its wordpress.org listing](https://wordpress.org/plugins/redis-cache/).

So the free drop-in already does the fast binary serializer and already does the in-memory client. Both are opt-in and both default to off, which is the real story: **the free plugin ships the performance features switched off, and most installations never turn them on.** If you are running Redis Object Cache today and have never defined a constant beyond the host and port, you are running PHP's native `serialize()` over PhpRedis with no compression, and roughly half your Redis memory is format overhead you could remove for free.

### What Pro Genuinely Adds Here

Compression, which the free plugin documents no option for at all. Pro supports LZF, LZ4 and Zstandard, and its documentation is specific about the trade: Zstandard compresses smallest, LZ4 compresses fastest, and LZF "should only be used when the others aren't available". It also adds batch prefetching, which loads the keys a request is likely to need in one round trip instead of many.

Choosing between Redis and Memcached comes before any of this, and we measured that separately: Redis refused 4,600 of 6,000 writes at its memory cap in [our own four-failure test](https://xspeedcache.com/blog/redis-vs-memcached-wordpress/).

## The Failure Column Is the Product

A persistent object cache sits between WordPress and every query it has already answered once. When it cannot reach its backend, PHP throws, and a site that was fine ten seconds ago returns a fatal error.

Here is what each product documents for that moment.

**Object Cache Pro** documents `timeout` and `read_timeout` at 2.5 seconds each, `retry_interval` at 25 milliseconds, `retries` at 3, and a `backoff` option defaulting to `smart`, which its documentation describes as a decorrelated jitter algorithm using `retry_interval` as its base and capped at `read_timeout`. For clusters it documents `cluster_failover` with four values, and for Relay clusters a further `cluster_distribution_strategy` and `cluster_failover_strategy` with five values each, plus `cluster_az` to pin reads to an availability zone. For replicated setups it documents `replication_strategy` with three values.

**Redis Object Cache** documents `WP_REDIS_TIMEOUT` and `WP_REDIS_READ_TIMEOUT`, both defaulting to 1 second, and `WP_REDIS_RETRY_INTERVAL` in milliseconds, noted as PhpRedis only. There is no documented retry count, no backoff algorithm, and no failover strategy. That is the whole of it.

![Two failure paths when Redis stops answering, comparing the free drop-in's unsupported graceful switch against the paid product's documented retry and failover chain](https://xspeedcache.com/images/blog/object-cache-failure-paths.webp)

And then there is the switch everybody eventually searches for. Redis Object Cache does document a constant that stops the exceptions: `WP_REDIS_GRACEFUL`. It is worth quoting exactly where the vendor puts it. It sits in a collapsed table in the GitHub README headed *"Unsupported configuration options"*, introduced by this sentence:

> "Options that exist, but **should not**, **may break without notice** in future releases and **won't receive any support** whatsoever from our team"

The row's own description reads: *"Prevents exceptions from being thrown, but will cause data corruption"*.

That is the free plugin's answer to its single most consequential failure mode, written by the author of both products: a switch he classifies as unsupported and says will corrupt your data. Our own setup guide reached the same conclusion from the source and called it [the default that takes the site down](https://xspeedcache.com/blog/setup-redis-object-cache-wordpress/). The documented alternative is in the project FAQ and it is blunt. Delete `wp-content/object-cache.php`, or define `WP_REDIS_DISABLED` as true. Both products ship that bypass, and on the free one it is the only remedy the vendor stands behind.

This is also the point where our own product belongs in the table rather than in a closing pitch. xSpeed Cache ships object caching in the free tier, and in this census it offers eleven options, nine of them connection settings, one storage setting, one timeout and nothing at all for observability. That is a connection form, not an object-cache product, and on the axis this article measures the free dedicated drop-in beats it three to one. We build a full-stack cache in which the object cache is one module among many, which is a different thing from what Till Krüss builds, and the census is the fairest way to show the difference rather than argue about it.

## What $950 a Year Buys, and What Happens When You Stop

Object Cache Pro's pricing page, read on 10 October 2026, lists one self-serve tier and one sales tier.

| Term | Figure | Notes from the vendor's own page |
|:---|:---|:---|
| Pro, monthly | $95/month | Billed monthly, $1,140 across a year |
| Pro, yearly | $950/year | Saves $190 against twelve monthly payments |
| Enterprise | From $1,950/month | Billed annually, dedicated engineer, custom development |
| Trial | None | "For licensing reasons, we don't offer a trial" |
| Refund | 14 days, full | "14-day, no hassle, 100% money back guarantee" |
| Sites per licence | Unlimited | Conditional on each site being "owned and operated by the same entity" |
| Redistribution | Not permitted | Agencies and hosts are directed to custom plans |
| Redis server | Not included | "The monthly price does not include a Redis instance or cluster" |
| On lapse | Stops working | "After a 14-day grace period, the object cache will stop working" |

### Four Rows That Decide the Purchase

The **unlimited sites** condition is unusually generous and unusually specific. One licence covers every site you own and operate, which for a company running forty of its own properties makes the effective price $23.75 per site per year. For an agency running forty client sites it covers none of them, because the clients own them. The page is explicit that this is the line, and it directs agencies to a quote.

The **no trial** row is rare in this field. Nine caching licences we priced from vendor pages for [our three-year cost comparison](https://xspeedcache.com/blog/wordpress-caching-plugin-cost-comparison/) mostly offer either a trial or a refund window, and several now offer both. Object Cache Pro offers only the refund, and says why.

The **Redis not included** row is the one most likely to surprise a buyer. $950 buys a plugin. It does not buy the server the plugin talks to, and a managed Redis instance sized for a busy [WooCommerce store](https://xspeedcache.com/use-cases/woocommerce/) is a second recurring bill.

### And One Row That Decides It Twice Over

The **lapse** row is the one that should decide the purchase for a cautious buyer, and it is the sharpest difference on this page. Stop paying for Object Cache Pro and after fourteen days the object cache stops working, per the vendor's own words. Stop paying for Redis Object Cache and nothing happens, because there was never anything to stop paying. That is not a criticism of the pricing, which is honest and plainly stated. It is a planning fact, and it belongs in whatever document your finance team reads.

![Timeline comparing a lapsed Object Cache Pro subscription stopping the cache after a fourteen-day grace period against a GPLv3 drop-in that keeps caching indefinitely](https://xspeedcache.com/images/blog/object-cache-licence-lapse.webp)

One arithmetic note, because the two figures look like a contradiction and are not. Object Cache Pro's homepage says "Starting at $79/month" in three places while its pricing page card says $95/month. $950 divided by twelve is $79.17, so the homepage is quoting the effective monthly rate of the annual plan. The arithmetic is right. The homepage does not carry the words "billed annually" next to it, so compare the $950 and the $1,140 directly rather than the two monthly figures.

## You May Already Have It, and Eight Hosting Partners Are Why

Before you buy anything, check whether your host has bought it for you.

Object Cache Pro's homepage lists eight companies under the heading "WordPress Hosting Partners": Pagely, Nexcess, Pantheon, GoDaddy, Cloudways, Rocket.net, Cloudpress and Convesio. The quoted testimonials on the same page come from hosting executives describing deployment "across our customer base". Several managed hosts include it on qualifying plans at no separate charge.

### First Check the Server, Then the Licence

The prior question is whether your plan has Redis at all, and the answer is worse than most people expect. We resolved 2,139 WordPress domains to their hosts and read each host's own documentation: [five of seven hosts document no object cache on their entry plan](https://xspeedcache.com/blog/object-cache-availability-shared-hosting/), and 519 of the 539 sites in that census sit on exactly those plans. An object cache comparison is academic until the server offers a backend to cache into, and most shared plans do not. Our [server compatibility documentation](https://xspeedcache.com/docs/server-compatibility/) lists what the module needs, and the [object cache documentation](https://xspeedcache.com/docs/object-cache/) covers the settings our own free tier exposes.

If your host does not offer Redis and you are choosing a new one, hosting is the other half of this problem. We recommend xCloud, and it is ours: xCloud and WPDeveloper are both Startise companies. A cache is only ever as fast as the server behind a miss.

## Running an Object Cache Across Twenty Client Sites

Fleet work changes this comparison more than any benchmark does, and in both directions.

The licensing arithmetic inverts. Object Cache Pro's unlimited-sites term covers sites you own and operate, so an agency holding twenty client sites is outside it and needs a quote rather than the $950 card. Twenty separate free drop-ins cost nothing and are supported by a community forum. That is a real trade and it is not obvious which way it falls until you price the quote.

### The Operational Arithmetic Runs the Other Way

Twenty sites means twenty `wp-config.php` files carrying constants, and the failure mode is not a slow page. It is one client's Redis instance running out of memory at 2pm and taking their checkout with it, while nineteen other sites are fine and nobody knows which one broke. That is the scenario Pro's retry and failover options exist for, and the one the free plugin answers with a switch its own author marks unsupported.

### What We Actually Offer a Fleet

What our own tooling contributes here is narrower than either, and worth stating accurately. xSpeed Cache exposes its object cache settings over WP-CLI and the `/wp-json/xspeed/v1/` REST namespace, and [xSpeed Hub](https://xspeedcache.com/xspeed-hub/) manages those settings across a fleet from one place. That is fleet administration of a simple object cache, not a resilient one. For twenty sites that need a resilient one, the honest recommendation is a dedicated object-cache plugin on each, and Pro's quote if the client count justifies it.

Run the free xSpeed Scan on any site before and after you change an object cache setting: [xspeedcache.com/scan/](https://xspeedcache.com/scan/)

## Common Mistakes People Make Buying an Object Cache

- 🧩 **Buying an object cache before checking the server has Redis.** The plugin is the cheap half. Ask the host first.
- ⚙️ **Installing the free drop-in and never defining a constant.** igbinary and Relay are both there and both default to off, so the default install is the slowest configuration the plugin supports.
- 🔥 **Reaching for `WP_REDIS_GRACEFUL` when the site goes down.** The author files it under unsupported options and says it will corrupt data. Delete the drop-in or set `WP_REDIS_DISABLED` instead.
- 💳 **Treating $950 as the total.** Redis is a separate bill, and the licence covers sites you own rather than sites you manage.
- 📉 **Comparing the two products on connection features.** Nine options against thirteen. That bucket is close to a tie and it is where most comparisons stop.
- 🧾 **Assuming the paid cache keeps caching after the invoice stops.** It stops fourteen days later, which the vendor states plainly and most buyers never read.
- 🏠 **Paying for a licence your host already holds.** Eight hosting companies list themselves as partners. Check before you buy.
- 📊 **Expecting a cache plugin's built-in object cache to behave like a dedicated one.** Ours exposes eleven options and no metrics at all, and that is the usual shape.

## Frequently Asked Questions

### I enabled Redis Object Cache and my whole site started returning a fatal error. What do I do right now?

Delete `wp-content/object-cache.php`, or add `define( 'WP_REDIS_DISABLED', true );` to `wp-config.php`. Both are documented in the project FAQ and neither needs dashboard access. Our own [troubleshooting documentation](https://xspeedcache.com/docs/common-problems-and-troubleshooting/) covers the equivalent bypass for our module. Do that first, then find out why Redis was unreachable. Reaching for `WP_REDIS_GRACEFUL` instead will stop the errors and corrupt your cached data, per the vendor's own description of it.

### Is Object Cache Pro worth $950 a year for one site?

For one ordinary site, almost certainly not. The free drop-in reaches Redis the same ways and the census above shows the gap is concentrated in failure handling, which a single site with a healthy local Redis instance rarely exercises. The calculation changes when an outage costs real money, when the site is on a cluster, or when you own enough sites to divide $950 across them.

### My host already gives me Redis. Does that mean I have Object Cache Pro?

Not necessarily, and it is worth five minutes to check. Having Redis available is a server feature. Having Object Cache Pro is a licence your host may or may not hold. Eight hosting companies are listed as partners on its homepage, so ask support directly whether your plan includes it.

### I set the serializer to igbinary and now every page is broken. Why?

Both products warn about this specifically. Switching serializer or compression format changes how existing cached data is encoded, so the cache must be flushed as part of the switch, and the PHP extension has to be present. Pro's documentation links a dedicated data-encoding page for the procedure. Make the change and flush in the same maintenance window, never separately.

### Which is faster?

On a cache hit over a healthy local connection, your own measurement matters more than anyone's published figure. Pro's documented advantages are structural rather than per-operation: batch prefetching turns many round trips into one, igbinary roughly halves payload size by its own documentation, and compression reduces network transfer. The free plugin does the second of those three today for nothing.

### We stopped paying for Object Cache Pro and the site got slower a fortnight later. Is that related?

Yes, and it is documented. The pricing page states that an active subscription is required and that after a fourteen-day grace period the object cache stops working. A site that loses its object cache goes back to answering every query from the database, which usually shows up as slower admin pages and slower logged-in requests first.

### Does xSpeed Cache replace either of these?

No, and the census above is why. Our free tier includes object caching with eleven documented settings, which is useful if you want one plugin handling page cache, assets and object cache together. It is not a dedicated object-cache product, it offers no metrics, and it has one timeout where Pro has twelve failure-handling options. We are one option among several here, and on this specific axis we are not the strongest one.

### I run an agency with thirty client sites. Can I buy one Pro licence for all of them?

No. The licence covers sites "owned and operated by the same entity" and explicitly does not permit redistribution. The page directs agencies, SaaS providers and hosts to a custom plan with volume discounts. Get the quote before assuming either the $950 figure or the per-site figure applies.

### Can I try Object Cache Pro before paying?

There is no trial. The pricing page says so directly and gives licensing as the reason. There is a fourteen-day full refund, so the trial is effectively a purchase you can reverse.

### Why does the homepage say $79 a month and the pricing page say $95?

Because $950 divided by twelve is $79.17. The homepage quotes the annual plan's effective monthly rate without the words "billed annually" beside it. Compare $950 against $1,140 instead and the two figures stop disagreeing.

### Does the free plugin support Redis Cluster and Sentinel, or do I need Pro for that?

The free plugin documents both, with configuration examples for clusters, sentinels, sharded setups and replicated primaries. What Pro adds on top is the policy layer: which node a read goes to, what happens when that node fails, and how many times to retry before giving up.

### Our Redis is shared with another application and keys keep colliding. Which one fixes that?

Both. Redis Object Cache has `WP_REDIS_PREFIX` and Pro has `prefix`, and each places a string in front of every key. Pro additionally has a `shared` option that changes how it reports memory and key counts, and a `strict` mode that performs integrity flushes when no prefix is set.

## Conclusion: Free Drop-In or $950 Subscription?

| If you are… | Pick | Because |
|:---|:---|:---|
| Running one site on a healthy local Redis | Redis Object Cache | Free, GPLv3, and 31 documented options is more surface than most sites use |
| Running a cluster or anything revenue-critical | Object Cache Pro | Twelve documented failure-handling options against three |
| An agency with client-owned sites | Get the Pro quote | The $950 card does not cover sites you manage rather than own |
| On a managed host | Ask what you already have | Eight hosting partners, and several bundle it |
| Not sure your plan even has Redis | Check that first | Five of seven hosts document none on their entry plan |
| Already running a full-stack cache plugin | Keep it, add a drop-in if you need depth | A bundled object cache is a connection form, ours included |

**What to do this week:**

1. Find out whether your hosting plan offers Redis, and whether it already includes Object Cache Pro. One support ticket answers both.
2. If you are on the free drop-in, read your `wp-config.php` and check whether `WP_REDIS_IGBINARY` is defined. If it is not, you are leaving roughly half your Redis memory on the table for nothing.
3. Delete `WP_REDIS_GRACEFUL` from any site that has it, and write the drop-in deletion path into your own runbook instead.
4. Price the lapse, not just the licence. Decide now what happens to the cache if the invoice stops.
5. Run the free scan on the site, then read the delivery checks. If you want page caching, asset handling and object caching from one plugin, xSpeed Cache does that in its free tier, with [paid plans](https://xspeedcache.com/pricing/) from $29 a year at founding pricing and a 14-day money-back guarantee. If what you need is a resilient object cache specifically, buy the one built for that job, and Object Cache Pro is the one with the failure policy written down. Our [80-capability comparison](https://xspeedcache.com/comparison/) and [Free vs Pro](https://xspeedcache.com/free-vs-pro/) pages show exactly where our own module stops.

If you have run both of these on the same workload, the numbers we would most like to see are not hit rates. They are what happened the day Redis went away.