Strata — Browser Storage Inspector

About

Strata is a developer's storage inspector for Chrome. It shows you, in one popup, every piece of data a website has stored on your device — cookies, localStorage, sessionStorage, IndexedDB, Cache Storage, Storage Buckets, and more — all scoped to the site you're currently looking at. You can read it, edit it, export it, and wipe it in one click.                                                   
                                                                                                     
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━                                                                   
  WHY YOU'D WANT THIS
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━                                                                   
                                       
  Modern websites write data to at least five different browser storage APIs. Each one is inspected    
  separately in DevTools, buried inside the Application panel — and half of them don't surface at all
  without drilling through cryptic trees.                                                              
                                       
  Strata flattens that. One popup. Seven tabs. Every byte a site has stored on your device, per-origin,
   with inline editing and bulk delete. When you need to:
                                                                                                       
  • Reproduce a login bug that only happens with a specific cookie set                                 
  • Test what your app does with a malformed JWT in localStorage                                     
  • Wipe a site completely — not the half-wipe Chrome's "Clear browsing data" gives you                
  • Debug an extension you're building (chrome.storage.local/sync/session all visible)                 
  • See what that news site is actually caching in the service worker                                  
  • Edit an IndexedDB record without writing a console script                                          
  • Diff a site's storage before vs. after a bug repro                                                 
                                                                                                       
  …you were probably opening DevTools, hunting the Application panel, clicking through 4 trees, and    
  manually deleting one record at a time. Strata replaces that with a 420-pixel popup that reads       
  everything in parallel, renders it side-by-side, and lets you mutate any of it.                      
                                                                                                     
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━                                                                   
  WHAT YOU GET
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━                                                                   
                                                                                                       
  ▸ COOKIES — full CRUD with every attribute that matters: domain, path, Secure, HttpOnly, SameSite,   
  expiry. Create new cookies with a proper form (not a flat text field), validate SameSite=None        
  requires Secure, handle subdomain and path-scoped deletion correctly — the built-in "Clear cookies   
  for this site" skips cookies set on parent domains, Strata doesn't.                                
                                                                                                     
  ▸ LOCAL STORAGE & SESSION STORAGE — inspect, edit, delete, create. Edit mode pops a textarea with a  
  "Format JSON" button so when you're staring at a minified JWT or a 3KB base64 blob, one click indents
   it. Save writes back in whichever format you left.                                                  
                                       
  ▸ EXTENSION STORAGE — chrome.storage.local, .sync, and .session. Sub-tabs for each area, live        
  byte-usage counter, auto-refresh on changes via chrome.storage.onChanged. If you're building another
  extension, this is the debug view you wished was built in.                                           
                                       
  ▸ CACHE STORAGE — every named cache the site's service worker has opened, with per-cache entry counts
   and total bytes. Drill into a cache, see every request as a row (URL · method · status · size),
  click any row to open a drawer with the response headers and a pretty-printed body preview. JSON is  
  indented automatically; text is shown as-is; binary payloads are labeled.
                                                                                                     
  ▸ INDEXEDDB — three-level navigation: databases → object stores → records. Shows keyPath,            
  auto-increment flag, and index count for each store. Click into a store and you get a list of
  records. Each record is editable: click edit, get a JSON textarea, Format JSON, Save. Scalar keys and
   object values both supported. Delete a record, a store's entire contents, or the whole database with
   a single confirm.                                                                                 

  ▸ STORAGE BUCKETS — the newer API (Chrome 112+) that lets sites group storage into buckets with      
  per-bucket quotas. Strata feature-detects and hides the tab when unavailable. Per-bucket usage,
  quota, persistence, and durability all visible.                                                      
                                       
  ▸ SHARED STORAGE — when the Privacy Sandbox API is present on the page, Strata shows what it can     
  expose (sharedStorage.length at minimum). When it isn't, you get a clear "unsupported on this page"
  state instead of a mysterious empty list.                                                            
                                       
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━                                                                 
  THE FEATURES YOU'LL USE EVERY DAY
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━                                                                   
                                                                                                       
  CLEAR SITE DATA — one header icon, one confirm sheet that shows exactly how many items of each type  
  will be deleted, one click. Cookies, localStorage, sessionStorage, Cache Storage, and IndexedDB all  
  wiped at once for the current origin. Because Chrome's built-in "Clear for this site" has surprising 
  gaps, this is the button you reach for when you actually need to start fresh.                      
                                                                                                     
  RIGHT-CLICK ON ANY PAGE — same action, from the context menu. A "Clear all storage for this site"    
  option shows up on any http/https page. A small badge on the toolbar icon confirms success. Use it
  mid-browsing without opening DevTools.                                                               
                                       
  EXPORT AS JSON — copy the current tab's entire contents to your clipboard as pretty-printed JSON,    
  with origin, timestamp, count, and metadata preserved. Paste it into a gist or a file, reproduce a
  bug, run your fix, export again, diff. State-based debugging made trivial.                           
                                       
  LIVE SEARCH — filter by key or value across any tab. 120-ms debounce, instant results. When a site   
  has 200 cookies you need one grep step to find `csrf_token`.
                                                                                                       
  BULK SELECT AND DELETE — checkboxes on every item, a select-all on the toolbar, delete N in parallel.
   Works across every storage surface.                                                               
                                                                                                       
  MEMORY CHART — tap the chart icon in the header. A color-coded stacked bar shows how much each       
  storage type is using on this origin, with a legend of clickable chips that jump you straight to the
  tab you care about. Under the hood it calls navigator.storage.estimate() plus a per-surface          
  breakdown. Use it when a site is mysteriously using 3 GB and you want to know which API is
  responsible.                                                                                       

  QUOTA INDICATOR — header badge shows your storage usage versus the quota for the current origin.     
  Green under 80%, amber 80–95%, red at 95%+. Click it to expand the chart.
                                                                                                       
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━   
  DESIGN                                                                                             
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━                                                                   
  
  Clean, developer-tool aesthetic — think Raycast or the DevTools Application panel, not a 2010        
  WordPress dashboard. Light and dark themes that follow your system. Per-storage-type accent colors
  at-a-glance scanning works. Monospace for values, proportional for keys. Keyboard-friendly (Escape to
   close sheets, focus trapping).                                                                      
                                                                                                     
  Everything fits in a 420×600 popup without feeling cramped. Tab bar scrolls horizontally with
  fade-edge affordances so you always know there's more. Cards truncate long values with a clean fade  
  and expand on click.                                                                               
                                                                                                       
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━   
  PRIVACY — YES, WE MEAN IT                                                                            
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
                                                                                                       
  Strata does not talk to the network. Ever. There is no analytics pixel, no telemetry endpoint, no
  remote config. Every byte of JavaScript and CSS is packaged inside the extension. There is not even a
   CDN for a charting library — the memory chart is hand-written on a canvas. Open DevTools → Network  
  on the popup and you'll see zero requests.                                                           
                                            
  What Strata reads:                                                                                 
  - Cookies, localStorage, sessionStorage, IndexedDB, Cache Storage, and Storage Buckets for the page  
  you're currently viewing (and only then).                                                          
  - chrome.storage.* areas you've chosen to inspect (your own extensions' data).                       
  - navigator.storage.estimate() for the active origin.                         
                                                                                                       
  What Strata does not do:             
  - Send any of that to a server.                                                                      
  - Store it beyond the popup's session.
  - Correlate anything across origins.                                                                 
  - Require an account.                                                                                
  - Use your clipboard unless you press Copy or Export.                                              
                                                                                                       
  The only reason the permission requests `<all_urls>` is because browser storage APIs (localStorage,  
  IndexedDB, Cache Storage) live in the page's own context — the extension has to inject a small       
  content script into the active tab to read them. That injection happens only when you open the popup 
  on that tab.                                                                                         
                                                                                                     
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━                                                                 
  WHO IT'S FOR                      
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
                                    
  • Web developers debugging stateful bugs                                                             
  • QA engineers repro-ing issues that depend on storage                                               
  • Extension developers who want a saner chrome.storage view                                          
  • Performance engineers tracking down "why is this site 2 GB?"                                       
  • Privacy-conscious users who want to actually see (and delete) what sites are storing             
  • Anyone tired of Chrome's "Clear browsing data" being all-or-nothing                                
                                                                                                       
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━                                                                   
  TECHNICAL NOTES                                                                                      
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━                                                                 
                                                                                                       
  • Chrome Manifest V3                                                                                 
  • Minimum Chrome 102 (Storage Buckets tab hides on older versions)                                 
  • No external dependencies                                                                           
  • Source available at the repository linked in the support URL                                       
  • Licensed MIT                                                                                     
                                                                                                       
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━   
                                                                                                       
  If Strata saves you even one debugging session, it's paid for itself. Install it, pin the toolbar
  icon, and the next time you're chasing a state-related bug you'll reach for it before DevTools.