A warmup cache request is an automated request your own system sends to a page or API so the response gets stored in cache before real visitors ask for it. Instead of letting the first users after a deploy, purge or restart wait for a slow, uncached page, you “pre-visit” your most important URLs yourself.
The result: the first visitor gets the same fast page as the thousandth. This guide covers when cache warming is worth it, how to send warmup requests safely, how to prove they worked, and how the same idea now applies to AI chatbots and agents.
What a Warmup Cache Request Actually Does
A warmup cache request travels through your stack exactly like a visitor’s request, but it’s sent by a script, scheduled job or deploy hook instead of a person. Each layer that can cache the response, such as your CDN, reverse proxy or application cache, stores a copy along the way.
A typical warmup request follows this path:
- Your script requests a URL, such as
/,/pricingor/api/products. - The CDN edge checks its cache. It’s empty, so it forwards the request to your server.
- Your server runs its code and database queries, builds the page, and adds caching headers.
- The CDN stores the response based on those headers.
- The next real visitor gets that stored copy in milliseconds, without touching your server.
Warmup requests are one form of cache warming (also called cache preloading or cache warmup). They’re most useful at predictable moments: after a deployment, after clearing the cache, after a server restart, or just before a planned traffic spike like a product launch or email campaign.
Cold Cache vs Warm Cache: The First-Visitor Problem
| Term | What It Means | When You See It |
|---|---|---|
| Cold cache | Nothing useful is stored, so requests go to your server | After deploys, purges, restarts or long idle periods |
| Warm cache | Popular content is already stored and served quickly | During steady, normal traffic |
| Cache warming | Loading content into cache on purpose before users ask | Before or right after planned changes |
| Prefetching | Loading what one visitor is likely to need next | During a single user’s session |
The key difference: cache warming prepares the whole system, while prefetching guesses for one user. Fast sites often use both.
Does Your Site Need Cache Warming? A Quick Decision Guide
Cache warming pays off when cold pages are slow, important, and requested often right after changes. It’s wasted effort when your cache refills naturally within seconds or your pages are cheap to build.
| Your Situation | Do You Need Warmup Requests? |
|---|---|
| Low traffic, simple pages, rare deploys | Probably not; normal visits warm the cache |
| You deploy or purge the cache several times a day | Yes, for your top pages |
| You’re launching a campaign or sale | Yes, warm landing and product pages beforehand |
| Your pages take over a second to build uncached | Yes |
| Your CDN uses stale-while-revalidate or tiered caching | Maybe; warm only your most critical URLs |
| Pages are personalized for each logged-in user | No; don’t put these in shared caches |
A good test: load a key page right after clearing its cache, then load it again. If the first load is noticeably slower, warming will help your first visitors.
Why Cache Warming Helps Speed, SEO and Conversions
Warm caches mostly improve server response time, and that improvement feeds into user experience, crawling and sales.
- Time to First Byte (TTFB): Google’s web.dev guidance says a good TTFB is 0.8 seconds or less, and anything above 1.8 seconds is poor. Serving from a warm CDN cache skips your server entirely, which is often the fastest way to stay under that line.
- Core Web Vitals: Google’s “good” thresholds are LCP of 2.5 seconds or less, INP of 200 milliseconds or less, and CLS of 0.1 or less, measured at the 75th percentile of visits. A slow server response delays everything after it, including your largest content element (LCP).
- Search: Google says it “highly recommends” achieving good Core Web Vitals for success in Search, as part of page experience signals its ranking systems reward. Google also says it crawls less when a site’s response times get longer or it returns server errors.
- Revenue: In a Google-commissioned study by Deloitte and 55, a 0.1-second improvement in mobile site speed increased retail conversions by 8.4% and travel conversions by 10.1%.
What warming won’t do: fix slow code, bloated images or heavy JavaScript. It makes sure the speed you’ve already built shows up for every visitor, including the first ones.
Picking the Right Pages and APIs to Warm
Warm the pages that bring traffic, leads or revenue, not your entire site. Trying to warm everything wastes server time and can slow your site down.
Good candidates:
- Your homepage and top landing pages
- High-traffic category, service or product pages
- Pages linked from active ads or email campaigns
- API endpoints your app or single-page site calls on first load
- Expensive pages, such as search results or reports, that many people request
Build the list from real data. Export your top pages from analytics or server logs for the last few days, and start with your top 20 to 100 URLs. Your XML sitemap is a good backup list for important pages that don’t get daily traffic.
Get Your Headers Right First
If a page isn’t cacheable, no amount of warming will help. Before you write any warmup script, check that your key pages send the right caching headers.
The headers that matter most, as defined in MDN’s Cache-Control reference:
| Header or Directive | What It Does |
|---|---|
max-age | How many seconds a response stays fresh |
s-maxage | How long it stays fresh in shared caches like CDNs (overrides max-age there) |
public | Lets shared caches store the response |
private | Only the visitor’s own browser may store it; use for personalized content |
no-store | Nothing may store it at all |
stale-while-revalidate | Serve a stale copy for a set time while refreshing it in the background |
stale-if-error | Serve a stale copy if your server returns a 500, 502, 503 or 504 error |
Watch your cache key. CDNs store separate copies based on the URL plus certain headers, cookies or query strings (often controlled by the Vary header). If real visitors arrive with Accept-Encoding: br and your warmup script doesn’t send it, you may warm a copy almost nobody receives. Make your warmup requests look like a normal browser visit.
How to Send Warmup Cache Requests: Step by Step
A Simple Warmup Script
Here’s a minimal shell script that reads a list of URLs, requests each one with browser-like headers, and pauses between requests so it doesn’t overload your server:
#!/usr/bin/env bash
# warmup.sh: request each URL in urls.txt, one at a time
while read -r url; do
status=$(curl -s -o /dev/null -w "%{http_code}" \
-H "User-Agent: BotCircles-Cache-Warmer/1.0" \
-H "Accept-Encoding: gzip, br" \
-H "Accept: text/html" \
"$url")
echo "$status $url"
sleep 0.5 # half-second pause protects your server
done < urls.txt
Run it right after each deployment, for example as the last step in your CI/CD pipeline. The custom User-Agent makes the traffic easy to filter out of analytics and allow through your firewall.
If you serve visitors in several regions, remember that each CDN location has its own cache. Running the script from one location warms only the nearby edge, unless your CDN uses a shared upper layer (covered below).
How to Confirm the Cache Is Warm
Don’t assume it worked. Check the response headers. Run the same request twice and look for a cache status header:
curl -s -o /dev/null -D - https://example.com/ | grep -iE "cf-cache-status|x-cache|age"
What to look for:
- Cloudflare:
cf-cache-status: HITmeans the page came from cache.MISSmeans it was cacheable but not stored yet.BYPASSmeans your server’s response wasn’t cacheable, andDYNAMICmeans the request wasn’t eligible for caching at all. - Amazon CloudFront:
x-cache: Hit from cloudfrontversusMiss from cloudfront. - Most CDNs and proxies: An
Ageheader above zero means the copy has been sitting in cache that many seconds.
If you keep seeing BYPASS or DYNAMIC, fix your Cache-Control headers or CDN cache rules before warming more pages.
Cache Warming on WordPress, CDNs and Serverless
WordPress
If your host runs LiteSpeed, the LiteSpeed Cache plugin includes a built-in crawler that revisits pages from your sitemap and refreshes expired cache entries. According to LiteSpeed’s documentation, it needs to be enabled by your server admin, uses a sitemap to find URLs, and includes safety controls such as a delay between requests, a thread count (3 by default) and a server load limit that pauses crawling when your server gets busy. Many other caching plugins offer a similar “preload” setting.
CDNs With Multiple Locations
Two built-in CDN features reduce how much warming you need:
- Cloudflare Tiered Cache organizes data centers into lower and upper tiers. Only upper tiers fetch from your origin, so one warm upper tier can supply many edge locations.
- Amazon CloudFront Origin Shield adds a caching layer in front of your origin. It consolidates simultaneous requests for the same object, so your server may receive as few as one.
With these turned on, warming the shared layer first gives you the most coverage for the least server load.
Serverless Functions
On serverless platforms, the “cold start” is often the function itself, not the cache. AWS Lambda’s provisioned concurrency keeps a set number of pre-initialized environments ready, which AWS says removes cold start behavior for those environments. Pair it with cache warming for your most important endpoints.
Warming Caches for AI Chatbots and Agents
Cache warming isn’t just for web pages anymore. AI chatbots and agents often send the same long system prompt, knowledge base or tool definitions with every request. Large language model (LLM) providers can cache that repeated prefix, which cuts both cost and the time until the first word of a reply.
Anthropic’s Claude prompt caching documentation describes a literal warmup cache request: send a request with max_tokens: 0 at app startup or on a schedule to load your system prompt into the cache before a real user writes in. No output tokens are billed for the warmup itself. The default cache lifetime is 5 minutes, refreshed each time it’s used, with a 1-hour option for longer gaps between conversations.
For a customer-facing assistant, that means the first customer of the morning gets the same fast reply as everyone else. It’s one of the details we tune when building AI chatbots for businesses.
Safety Rules: Rate Limits, Firewalls and Private Data
A careless warmup job can take down your own site. Follow these rules:
- Limit the speed. Send requests one at a time or in small batches with pauses. Thousands of simultaneous requests look and act like an attack on your own server.
- Allow it through your firewall. Security tools may block a script that loads many pages quickly. Allow your warmer by its IP address or a secret header rather than turning protections off.
- Lock down the trigger. If warmup runs from a URL or webhook, protect it with authentication so strangers can’t trigger expensive jobs.
- Never warm private pages into shared caches. Account pages, carts and anything showing personal data should use
privateorno-store. Otherwise one person’s details could be served to the next visitor. - Filter it from analytics. Exclude your warmer’s User-Agent or IP so it doesn’t inflate your traffic numbers.
Measuring Whether Warmup Is Working
Track these numbers before and after you add warmup requests, focusing on the first 15 to 30 minutes after each deploy:
| Metric | What Good Looks Like |
|---|---|
| Cache hit ratio | Rises quickly after deploys instead of climbing slowly |
| TTFB on key pages | Stays near your normal level right after releases |
| LCP (field data) | Stays at or under 2.5 seconds for first visits |
| Origin CPU and database load | No sharp spike after cache purges |
| Error rate | Warmed URLs return 200 OK, not cached errors |
If the numbers don’t move, the usual causes are a cache key mismatch, uncacheable headers, or warming pages that few people visit.
Smarter Alternatives When Warming Isn’t Enough
Warmup requests work best alongside other caching patterns:
- stale-while-revalidate: Visitors get the slightly old copy instantly while the cache refreshes in the background, so most pages never go fully cold.
- Write-through caching: When data changes, your app updates the cache at the same time as the database.
- Persistent caches: Redis can save snapshots (RDB) or a log of writes (AOF) and reload them on restart, so an in-memory cache doesn’t start empty.
- Rolling deployments: Update servers a few at a time, so warm servers keep handling traffic while new ones fill their caches.
- Tiered caching and origin shields: Let one warm upper layer serve many edge locations.
For many sites, the best setup is stale-while-revalidate for the long tail of pages, plus targeted warmup requests for the 20 to 100 pages that matter most.
Frequently Asked Questions
What is a warmup cache request?
A warmup cache request is an automated request sent to a page or API before real visitors arrive, so the response is stored in cache. It prevents the first visitors after a deploy, cache purge or restart from getting a slow, uncached page.
What is the difference between a cold cache and a warm cache?
A cold cache has nothing useful stored, so every request goes to your server. A warm cache already holds popular content and serves it quickly without involving your server.
How do I know if my cache warmup worked?
Request the page and check the response headers. On Cloudflare, look for cf-cache-status: HIT. On CloudFront, look for x-cache: Hit from cloudfront. An Age header above zero also means the page came from cache.
How many pages should I warm?
Start with your top 20 to 100 URLs by traffic, leads or revenue. Expand only if you see clear gains in cache hit ratio and TTFB.
Does cache warming improve SEO?
Indirectly. Faster server responses support better Core Web Vitals, which Google recommends for success in Search, and Google crawls less when sites slow down. Warming helps keep that speed consistent after changes.
Can I warm the cache on WordPress?
Yes. LiteSpeed Cache includes a crawler that refreshes cached pages from your sitemap, and many other caching plugins offer a preload option. Keep the crawl speed low so it doesn’t overload your server.




