How to Clear Cache of a Specific Website: A Complete Step-by-Step Guide for Every Browser and Platform

Clearing the cache of a specific website is one of those small, tactical fixes that can save hours of troubleshooting. Whether a page refuses to load its latest design, a shopping cart won’t update, or a web app keeps showing stale data, targeted cache clearing is often the fastest way to resolve the issue without wiping your entire browsing history. This comprehensive guide explains what website caching is, why it causes problems, and—most importantly—how to clear cache for just one site across all major browsers and devices. You’ll also learn advanced techniques involving developer tools, service workers, storage APIs like IndexedDB and localStorage, and server-side caching layers that might be keeping your content stale. If you’re a site owner or manager, you’ll find best practices for controlling cache behavior and avoiding common pitfalls.

Before we dive into specific steps, here’s the core idea: every modern browser stores pieces of websites locally to speed up future visits. These pieces include files (HTML, CSS, JavaScript, images), as well as structured data (cookies, localStorage, sessionStorage, IndexedDB), application-level caches (Cache Storage used by service workers), and DNS results. When something goes wrong—say a CSS file updated on the server but not on your machine—your browser may keep using the old version from cache. Clearing the site-specific cache forces the browser to fetch fresh copies.

Caching Basics: What, Why, and When to Clear

What is cache? Cache is a local storage area where your browser saves resources downloaded from the web: images, stylesheets, scripts, fonts, and sometimes full HTML responses. The goal is performance—subsequent visits feel instant because your device can reuse these files instead of downloading them again.

Why can cache cause problems? Cache becomes problematic when the local copy doesn’t match the latest version on the server. Common scenarios include:

You’re seeing an outdated layout or color scheme after a redesign.
Interactive features—buttons, forms, dashboards—behave incorrectly after a code release because your browser still uses old JavaScript.
Login sessions loop or log you out due to conflicting cookies or stale session data.
A/B tests or feature flags get “stuck” because localStorage or IndexedDB holds old values.

When should you clear cache for one site? Do it when you suspect stale resources are causing visual glitches, errors, or performance issues—especially if other users report the site works fine for them. It’s also prudent after you deploy updates as a developer, or after switching environments (e.g., staging to production) where domain-level data conflicts.

Risks and Side Effects of Clearing a Single Site’s Cache

Clearing a site’s data is safe, but there are trade-offs to keep in mind:

Session and auth tokens: You may be logged out and required to sign in again.
Saved preferences: Site settings stored in cookies, localStorage, or IndexedDB may reset.
Offline access: PWAs that rely on service-worker caches may lose offline functionality until assets are re-downloaded.
Form data and carts: Basket contents, drafts, and recent items might vanish if stored locally.

Clear Cache for One Site in Google Chrome (Desktop)

Chrome offers two effective approaches: a quick one from the address bar and a deep clean via Site Settings.

Method 1: Site Settings (Comprehensive)

Open Chrome and visit the website you want to refresh (or note its domain).
Click the kebab menu (three dots) in the top-right corner and choose Settings.
Go to Privacy and security → Site settings.
Click View permissions and data stored across sites.
Use the search box to find the domain, then click the site entry.
Choose Clear data or Reset permissions as needed. Clearing data removes cookies, localStorage, cache storage, and more for that specific site.

Method 2: Padlock/Info Icon (Quick)

Go to the target website.
Click the padlock/info icon at the left of the address bar.
Select Site settings. A tab opens to the site’s settings page.
Click Clear data.
Reload the page (press Ctrl+R on Windows/Linux or Cmd+R on macOS).

Method 3: DevTools Hard Reload (Assets Only)

Open the site.
Open DevTools with F12 or Ctrl+Shift+I (Cmd+Option+I on macOS).
Right-click the reload button and choose Empty Cache and Hard Reload. This forces a clean fetch of assets without touching cookies or storage.

Tip: In DevTools, the Application panel lets you selectively clear Storage (cookies, localStorage, sessionStorage, IndexedDB, Web SQL), Cache Storage (service-worker caches), and Application Cache (legacy). Use Clear site data for a thorough reset.

Clear Cache for One Site in Google Chrome (Android)

Open Chrome and visit or search for the website.
Tap the kebab menu (three dots) → Settings.
Go to Site settings → All sites.
Use the search icon to find the domain.
Tap the site → Clear & reset or Clear storage. This removes cookies, cache, and site data for that specific domain.
Return to the site and refresh.

Alternate quick path: From the page, tap the padlock/info icon next to the URL, then choose Permissions or Site settings and clear data there.

Clear Cache for One Site in Microsoft Edge (Desktop)

Edge (Chromium-based) mirrors Chrome’s controls.

Open Edge and visit the target website.
Click the three-dot menu → Settings.
Select Cookies and site permissions.
Click Manage and delete cookies and site data → See all cookies and site data.
Search for the domain and click the trash icon to remove stored data for that site.
Reload the site.

DevTools option: Open DevTools, right-click the reload button, and select Empty cache and hard reload for a temporary asset refresh.

Clear Cache for One Site in Mozilla Firefox (Desktop)

Method 1: Page Info Dialog

Visit the website.
Click the padlock icon in the address bar, then click the arrow or Connection secure panel to open more details.
Choose More Information to open the Page Info dialog.
Go to the Security tab and click Clear Cookies and Site Data… for that domain.
Reload the page.

Method 2: Manage Data

Open the hamburger menu → Settings (or Preferences on macOS).
Navigate to Privacy & Security.
Under Cookies and Site Data, click Manage Data….
Search for the site, select it, and click Remove Selected.
Click Save Changes, then Remove when prompted.

Advanced: The Storage Inspector in Firefox DevTools lets you inspect and delete cookies, localStorage, sessionStorage, IndexedDB, and Cache Storage per site.

Clear Cache for One Site in Firefox (Android)

Open Firefox and load the target site.
Tap the three dots → Settings → Privacy and security.
Tap Delete browsing data → Manage data (if available), then select the site to remove its stored data.
Alternatively, long-press the site in History and choose options to clear specific site data.

Clear Cache for One Site in Apple Safari (macOS)

Safari doesn’t have a one-click “clear just this site” cache button in the standard menus, but you can achieve near-equivalent results through data management and the Develop menu.

Method 1: Remove Site Data

Open Safari and go to Safari → Settings… (or Preferences… on older versions).
Open the Privacy tab and click Manage Website Data….
Search for the domain, select it, and click Remove.
Reload the website.

Method 2: Empty Caches via Develop Menu (Assets Refresh)

Enable the Develop menu if you don’t see it: Safari → Settings… → Advanced → check Show Develop menu in menu bar.
With the site open, go to Develop → Empty Caches.
Reload the page. This clears cached assets but may not remove all site data like cookies; use Method 1 for a complete reset.

Clear Cache for One Site in Safari (iPhone & iPad)

Open Settings on iOS/iPadOS.
Scroll down to Safari → Advanced → Website Data.
Use the search bar to find the domain.
Swipe left on the site and tap Delete, or tap Edit and remove it.
Revisit the site in Safari and refresh.

Note: If a PWA is “installed” to your Home Screen, you may also need to remove and re-add it to clear its service-worker caches fully.

Clear Cache for One Site in Opera and Brave (Desktop)

Opera and Brave are Chromium-based and follow a process similar to Chrome:

Open the browser and visit the site.
Go to Settings → Privacy & security → Site settings or Cookies and other site data.
Find the site in All site data, select it, and remove data.
Refresh the site. For a quick temporary refresh, use DevTools’ Empty cache and hard reload.

Advanced: Use DevTools to Bypass or Remove a Single Site’s Cached Assets

Developer tools provide fine-grained control. Even if you’re not a developer, these features can help when the usual menus don’t work.

Disable Cache While DevTools Is Open

Open the site and launch DevTools (F12 or Ctrl+Shift+I / Cmd+Option+I).
Open the Network panel.
Check Disable cache. This forces fresh requests as long as DevTools remains open.

Application Panel (Chrome/Edge/Brave/Opera)

Go to Application → Storage and click Clear site data for a full reset.
Manually inspect and delete specific items under Cookies, Local Storage, Session Storage, IndexedDB, and Cache Storage.

Storage Inspector (Firefox)

Open DevTools and choose Storage.
Expand the storage types and delete entries for the target domain.

When to use DevTools: If you suspect a service worker or a particular IndexedDB object store is responsible for stale data, this is the most precise approach.

PWA and Service Workers: Clearing Cache Storage, IndexedDB, and LocalStorage

Progressive Web Apps (PWAs) use service workers—background scripts that intercept network requests and manage offline caches. These caches are separate from the standard HTTP cache and often live in Cache Storage. If your PWA keeps serving old assets, clearing the classic cache isn’t enough; you must also address service-worker caches.

How to Unregister a Service Worker

Open DevTools on the site.
In Chromium-based browsers, go to Application → Service Workers.
Click Unregister next to the active service worker.
Check Update on reload to force the browser to fetch the latest worker script.
Reload the site. If the PWA is installed, consider removing and reinstalling it to reset everything.

Clear Cache Storage and IndexedDB

In DevTools, under Application → Storage, expand Cache Storage and delete caches one by one.
Under IndexedDB, right-click the database(s) and delete them.
For LocalStorage and SessionStorage, select and clear keys or use the “Clear” button.

Note: If a PWA controls multiple subdomains via scope, you may need to repeat the process for each relevant origin.

DNS Cache vs. Browser Cache: When Name Resolution Is the Culprit

Sometimes a site looks “stuck” not because of stale files but because your device is resolving the domain to an outdated IP address. This is common after a hosting move or DNS update. If you can reach the old server but not the new one, clear your DNS cache.

Clear DNS Cache on Your System

Windows: Open Command Prompt as Administrator and run ipconfig /flushdns. You should see a confirmation message.
macOS: Open Terminal and run sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder (enter your password when prompted).
Linux (systemd): sudo systemd-resolve --flush-caches or restart the nscd/dnsmasq service if used.

Browser DNS Cache: Some browsers maintain their own DNS cache. In Chrome-based browsers, visit chrome://net-internals/#dns (or edge://net-internals/#dns) and click Clear host cache. Then close and reopen tabs for the affected site.

Server-Side Caching: CDNs, Reverse Proxies, and CMS Page Caches

Even when you clear your local cache, upstream caches can still serve stale content. As a site owner or developer, consider these layers:

CDNs (Content Delivery Networks): Providers like Cloudflare, Fastly, Akamai, and others store copies of your assets globally. You may need to purge cache for specific URLs or by tag.
Reverse proxies: Nginx, Apache with mod_cache, and Varnish can cache responses at the server level. Purging or reloading may be required.
Application caches: Many frameworks (Next.js, Laravel, Rails, Django) implement internal caches for templates, queries, or data snapshots.
CMS plugin caches: WordPress, Drupal, and Joomla often use page caching plugins that need manual purging after deployments.

Cloudflare Example: Purge a Single URL

Log into your Cloudflare dashboard.
Select the site → Caching → Configuration or Cache → Purge Cache.
Choose Custom Purge and paste the exact URL(s) to purge.
Confirm and wait a moment; then hard refresh the page in your browser.

Varnish / Nginx / Apache

Varnish: Use ban or purge rules depending on your setup to invalidate specific objects. Tag-based purges are efficient for batch updates.
Nginx: If using proxy_cache, purge via a dedicated location that accepts a purge method (often PURGE) or by removing cache files.
Apache: With mod_cache and mod_cache_disk, you might need to clear disk caches or adjust cache headers to make content revalidate quickly.

WordPress and Other CMSs

WordPress: In plugins like WP Super Cache, W3 Total Cache, WP Rocket, or LiteSpeed Cache, use the built-in Purge or Clear Cache for the current page or entire site. Many include a toolbar button to purge the current URL.
Drupal/Joomla: Use the respective performance or cache management panels to clear page and render caches after content updates.

Key concept: Clearing your browser cache fixes problems only on your device. If the server or CDN serves stale content, users everywhere will be affected until you purge upstream caches or set smarter caching rules.

Best Practices for Site Owners: Cache-Control, Versioning, and Cache Invalidation

If you maintain a site or web app, you can minimize cache headaches:

Use Strong Cache Headers Strategically

Immutable static assets: For JS/CSS/images with a unique hash in the filename (e.g., app.9f1c3a.js), set a very long Cache-Control: public, max-age=31536000, immutable.
HTML documents: Prefer short lifetimes or revalidation: Cache-Control: no-cache plus ETag or Last-Modified so the browser checks for updates.
APIs: Use Cache-Control and ETag carefully. Consider stale-while-revalidate and stale-if-error for resilience via CDNs that support them.

Asset Versioning (Cache Busting)

Include a unique hash or version string in asset filenames so you can deploy new versions without forcing users to clear cache. Popular build tools (Webpack, Vite, Rollup, Parcel) handle this automatically.

Service Worker Update Strategy

Implement an update flow that checks for a new service worker and prompts users to refresh.
Use distinct cache names per release (e.g., app-cache-v23) and remove old caches in the activate event.
Be mindful of cache scope; don’t accidentally capture unrelated subpaths or subdomains unless intentional.

Consistent Environments

When switching between staging and production, use different origins (e.g., staging.example.com vs www.example.com) to avoid storage conflicts. For local development, consider dedicated browser profiles to isolate state.

CDN and Edge Rules

Set page rules or edge cache rules to honor origin cache headers where appropriate.
Tag content for purging (Surrogate-Key) so you can invalidate groups of assets safely.
Test cache behavior with query parameters (?v=123) only as a last resort; true versioned filenames are more robust.

Troubleshooting Checklist: If Clearing Cache Doesn’t Fix It

Try a different browser or incognito/private window. Private mode skips or reduces cached state and extensions.
Disable extensions temporarily. Ad blockers, password managers, and privacy tools can interfere with scripts and storage.
Check DevTools → Network. Look for 304 (Not Modified) responses or cached flags that indicate what’s being reused.
Inspect service-worker status. Ensure no old worker is controlling the page. Unregister if necessary.
Purge CDN or server cache. If many users report the same issue, it’s likely upstream.
Flush DNS. Especially after migrating servers or changing DNS records.
Test on a different network. Corporate proxies and ISPs may cache aggressively.
Verify time sync. Incorrect system time can break TLS and caching revalidation logic.

Frequently Asked Questions

Will clearing a single site’s cache remove my saved passwords?

No—passwords saved by the browser’s password manager are not part of site cache or cookies. However, you may be logged out and need to sign in again, after which your password manager can autofill credentials.

What’s the difference between “hard reload” and clearing cache?

A hard reload (or Empty Cache and Hard Reload in DevTools) forces the browser to re-download assets for the current page load. Clearing site data removes the cached resources and stored data entirely, affecting future visits as well.

Do query strings like `?v=2` really bypass cache?

They usually do because the URL becomes unique. But this is a temporary workaround and can clutter analytics. Proper asset versioning and cache headers are superior.

Can I clear cache for subdomains separately?

Yes. Storage is scoped by origin (scheme + host + port). app.example.com is separate from www.example.com, so clear the one you need.

What about third-party scripts cached on a CDN like Google or jsDelivr?

Those are fetched from their own origins and managed by those CDNs. If a third-party script is stale, a hard reload or disabling cache in DevTools for the session can help, but you cannot purge another domain’s cache from your browser.

After clearing the cache, why do images still look old?

Your device or network might still be serving files from a proxy cache, CDN edge node, or even a service worker. Check the Response Headers in DevTools to identify the cache layer, then purge or bypass at that level.

Is clearing cache safe for ecommerce sessions?

It’s safe, but can log you out or empty locally stored cart data. If you’re mid-checkout, finish purchase first, then clear cache if necessary.

Will cache clearing fix 404 errors?

Sometimes. If the 404 is due to a stale reference or mismatched asset version, clearing cache helps. If the server genuinely can’t find the resource, the 404 will persist and must be fixed at the source.

What’s the role of ETags and Last-Modified headers?

They enable revalidation. Instead of re-downloading the whole file, the browser asks the server if the version it has is still valid. If yes, the server replies with 304 (Not Modified); if no, it returns the new content.

Pro Tips for Power Users and Developers

Keyboard Reload Shortcuts: Use Ctrl+F5 (Windows/Linux) or Cmd+Shift+R (macOS) for a forced reload that bypasses the HTTP cache for the moment.
Network Throttling + Disable Cache: In DevTools, combine throttling and disabled cache to mimic first-time visits from slow networks, revealing hidden race conditions.
Cache Partitioning: Modern browsers isolate caches by top-level site context to reduce tracking. If an embedded resource behaves oddly depending on the embedding page, test in a direct tab to isolate effects.
Storage Quotas: IndexedDB and Cache Storage have quotas. If a PWA fails to update, check for quota errors and free up space.
Content Hashing Everywhere: Hash all assets—CSS, JS, images, fonts—so you can set long cache lifetimes safely.
Soft Purge Before Hard Purge: Many CDNs allow a soft purge (mark stale) that keeps content available but forces revalidation next request—useful for high-traffic sites.
Automated Purge on Deploy: CI/CD pipelines can call CDN APIs to purge changed assets (by URL, tag, or surrogate key) immediately after deployment.
Service Worker Versioning: Embed a version in your worker and caches; on activate, delete old cache names to prevent “zombie” assets.
Subresource Integrity (SRI): If you rely on third-party CDNs, use SRI to ensure the fetched resource is exactly what you expect.
Observability: Add response headers showing build IDs and cache status (e.g., x-build-id, x-cache) to simplify debugging.

Step-by-Step Recipes for Common Situations

“My site just deployed, but I still see the old homepage.”

Hard reload the page: Ctrl+F5 or Cmd+Shift+R.
Open DevTools → Network → check Disable cache and reload.
Clear site data via Site settings (Chrome/Edge) or Manage Data (Firefox/Safari).
Check for service workers: unregister if one is controlling the page.
If the problem persists on multiple devices, purge your CDN for the homepage URL.

“A web app shows outdated dashboard numbers.”

Open DevTools → Application/Storage and clear Cache Storage and IndexedDB for the app.
Hard reload.
Verify API responses in the Network panel to ensure you’re hitting the right environment.

“Images won’t update even after clearing cache.”

Open the image in a new tab and check response headers in DevTools; confirm which cache (CDN/server) served it.
Purge the specific image URL at the CDN layer.
Confirm that the image filename is versioned or hashed.

“The site works on mobile but not on desktop.”

Compare service-worker status and storage between devices.
Flush DNS on the desktop machine.
Try a private window with extensions disabled to rule out conflicts.

Deep Dive: Browser-Specific Nuances

Chromium Family (Chrome, Edge, Brave, Opera)

Per-Site Data View: Comprehensive and user-friendly. You can reset permissions and clear data granularly.
DevTools Strength: Rich Application panel for precision clearing and service-worker management.
Keyboard Tricks: Right-click reload for hard/empty cache reloads.

Firefox

Storage Inspector: Excellent transparency into per-origin storage and caches.
Privacy Defaults: Tracking protection may affect third-party resource caching, which can be helpful for debugging embedded content.

Safari

Develop Menu: Essential for cache-emptying and service-worker insights.
iOS Constraints: PWAs and Safari share IndexedDB/Cache Storage per origin, but app-like experiences can hold on to state until fully removed.

Security and Privacy Considerations

Auth tokens: Clearing site data invalidates cookies; have 2FA devices ready if you’ll need to sign in again.
Shared computers: Clearing site data on public machines protects your privacy by removing session cookies and persistent identifiers.
Corporate networks: Proxy caches and SSL inspection can complicate cache behavior. If a page behaves differently in the office versus at home, that’s a clue.

Automation: Make Cache Clearing Part of Your Workflow

For developers and QA teams, automating cache invalidation keeps deployments predictable.

CI/CD Hooks: Trigger CDN purges as a post-deploy step. Use granular purges to avoid traffic spikes from cache misses.
Versioned Filenames: Ensure every deploy updates asset hashes so clients naturally fetch new files.
Feature Flags: Store flags server-side where possible, or implement robust cache-busting strategies for client-side flags.
Release Toggles: If you gate new bundles behind toggles, ensure toggles and assets update atomically to prevent mixed-version states.

Quick Reference: Clear Cache for a Specific Website

Chrome/Edge/Brave/Opera (Desktop): Settings → Privacy/Site settings → View data across sites → Search domain → Clear data. Or padlock → Site settings → Clear data.
Firefox (Desktop): Settings → Privacy & Security → Manage Data → Search domain → Remove Selected.
Safari (macOS): Settings → Privacy → Manage Website Data → Search domain → Remove. Or Develop → Empty Caches.
Android Chrome: Settings → Site settings → All sites → Search domain → Clear & reset.
iPhone/iPad Safari: iOS Settings → Safari → Advanced → Website Data → Search domain → Delete.

Case Studies: What Actually Went Wrong?

Case 1: The Disappearing Button After a Front-End Release

A retail client rolled out a redesign. A subset of users reported a key “Add to Cart” button missing. Investigation showed an old CSS bundle was still cached for some users while the HTML referenced a new class name. Clearing the site cache (or forcing a hard reload) fixed it immediately. Long-term, the team moved to hashed asset filenames and set Cache-Control: immutable on versioned assets with short caching for HTML.

Case 2: A PWA That Wouldn’t Update

A news app used a service worker to cache articles for offline reading. After deploying a new layout, users continued to see the old interface. The culprit was an outdated service worker that never activated due to a logic bug. Unregistering the worker and deleting Cache Storage resolved it; the permanent fix was to increment cache names per release and simplify the activation logic to delete old caches reliably.

Case 3: DNS Migration Shock

A startup moved hosting providers. Some users hit the new site, others the old one. Clearing browser and system DNS caches forced fresh name resolution, aligning traffic. A temporary Cache-Control: no-store on HTML responses reduced confusion during the transition window.

Glossary of Key Terms

Cache: Locally stored web resources that speed up subsequent visits.
Cookies: Small key-value pairs sent by servers and stored by the browser, often used for sessions and preferences.
localStorage/sessionStorage: Client-side storage APIs for persisting simple key-value data.
IndexedDB: A powerful client-side database used by complex web apps and PWAs.
Service Worker: A background script that intercepts network requests and manages offline caches.
Cache-Control: HTTP header that tells browsers/CDNs how to cache responses.
ETag/Last-Modified: Validators used for conditional requests to check whether a cached resource is still current.
CDN: Global network of edge servers that caches content closer to users.

Owner’s Checklist: Prevent Cache Headaches

Serve versioned (hashed) static assets.
Use short caching or revalidation for HTML.
Purge CDN on deploy—automate it.
Version service-worker caches; remove old caches on activate.
Isolate staging vs. production origins.
Instrument responses with build IDs and cache status headers.
Document a support playbook that includes per-site cache clearing steps for end users.

Summary

Clearing the cache of a specific website is a targeted, low-risk fix for many everyday web problems. On desktop browsers like Chrome, Edge, Firefox, Brave, and Opera, you can remove site data through Settings or DevTools to force a clean fetch of assets. Safari offers equivalent functionality via Manage Website Data on macOS and via Website Data settings on iOS/iPadOS. For stubborn issues—especially with PWAs—clear service-worker caches and IndexedDB. If problems persist across many users, purge upstream caches at your CDN or reverse proxy and ensure proper cache headers and asset versioning. With the techniques in this guide, you can quickly get any site back into a fresh, consistent state without sacrificing your entire browsing history.

Need Expert Help?

If you want caching that’s fast and reliable—plus a deployment pipeline that invalidates caches automatically—consider partnering with a seasoned team. You can hire WEBPEAK for end-to-end support. WEBPEAK is a full service digital marketing company offering Web Development, Digital Marketing, and SEO Services, and can help you architect resilient caching, performance budgets, and monitoring so your users always see the latest version of your site or app.