How to find the size of localStorage

Going off of what @Shourav said above, I wrote a small function that should accurately grab all your the localStorage keys (for the current domain) and calculate the combined size so that you know exactly how much memory is taken up by your localStorage object:

var localStorageSpace = function(){ var allStrings = ''; for(var key in window.localStorage){ if(window.localStorage.hasOwnProperty(key)){ allStrings += window.localStorage[key]; } } return allStrings ? 3 + ((allStrings.length*16)/(8*1024)) + ' KB' : 'Empty (0 KB)'; }; 

Mine returned: "30.896484375 KB"

You can get the current size of the local storage data using the Blob function. This may not work in old browsers, check the support for new Blob and Object.values() at caniuse.

Example:

return new Blob(Object.values(localStorage)).size; 

Object.values() turns the localStorage object to an array. Blob turns the array into raw data.

IE has a remainingSpace property of the Storage object. The other browsers have no equivalent at this time.

I believe that the default amount of space is 5MB, although I have not tested it personally.

Here is a simple example of how to do this and should work with every browser

alert(1024 * 1024 * 5 - unescape(encodeURIComponent(JSON.stringify(localStorage))).length); 

Hope this help someone.

Because Jas- example on jsfiddle does not work for me I came up with this solution. (thanks to Serge Seletskyy and Shourav for their bits I used in the code below)

Below is the function that can be used to test how much space is available for localStorage and (if any keys are already in lS) how much space is left.

It is a little brute force but it works in almost every browser... apart from Firefox. Well in desktop FF it takes ages (4-5min) to complete, and on Android it just crashes.

Underneath the function is a short summary of tests that I have done in different browsers on different platforms. Enjoy!

function testLocalStorage() { var timeStart = Date.now(); var timeEnd, countKey, countValue, amountLeft, itemLength; var occupied = leftCount = 3; //Shurav's comment on initial overhead //create localStorage entries until localStorage is totally filled and browser issues a warning. var i = 0; while (!error) { try { //length of the 'value' was picked to be a compromise between speed and accuracy, // the longer the 'value' the quicker script and result less accurate. This one is around 2Kb localStorage.setItem('testKey' + i, '11111111112222222222333333333344444444445555555555666661111111111222222222233333333334444444444555555555566666'); } catch (e) { var error = e; } i++; } //if the warning was issued - localStorage is full. if (error) { //iterate through all keys and values to count their length for (var i = 0; i < localStorage.length; i++) { countKey = localStorage.key(i); countValue = localStorage.getItem(localStorage.key(i)); itemLength = countKey.length + countValue.length; //if the key is one of our 'test' keys count it separately if (countKey.indexOf("testKey") !== -1) { leftCount = leftCount + itemLength; } //count all keys and their values occupied = occupied + itemLength; } ; //all keys + values lenght recalculated to Mb occupied = (((occupied * 16) / (8 * 1024)) / 1024).toFixed(2); //if there are any other keys then our 'testKeys' it will show how much localStorage is left amountLeft = occupied - (((leftCount * 16) / (8 * 1024)) / 1024).toFixed(2); //iterate through all localStorage keys and remove 'testKeys' Object.keys(localStorage).forEach(function(key) { if (key.indexOf("testKey") !== -1) { localStorage.removeItem(key); } }); } //calculate execution time var timeEnd = Date.now(); var time = timeEnd - timeStart; //create message var message = 'Finished in: ' + time + 'ms \n total localStorage: ' + occupied + 'Mb \n localStorage left: ' + amountLeft + "Mb"; //put the message on the screen document.getElementById('scene').innerText = message; //this works with Chrome,Safari, Opera, IE //document.getElementById('scene').textContent = message; //Required for Firefox to show messages } 

And as promised above some test in different browsers:

GalaxyTab 10.1

• Maxthon Pad 1.7 ~1130ms 5Mb
• Firefox 20.0(Beta 20.0) crashed both
• Chrome 25.0.1364.169 ~22250ms /5Mb
• Native (identifies as Safari 4.0/Webkit534.30) ~995ms /5Mb

iPhone 4s iOS 6.1.3

• Safari ~ 520ms /5Mb
• As HomeApp ~525ms / 5Mb
• iCab ~ 710ms /5mb

MacBook Pro OSX 1.8.3 (Core 2 Duo 2.66 8Gb memory)

• Safari 6.0.3 ~105ms /5Mb
• Chrome 26.0.1410.43 ~3400ms /5Mb
• Firefox 20.0 300150ms(!) /10Mb (after complaining about script running to long)

iPad 3 iOS 6.1.3

• Safari ~430ms /5Mb
• iCab ~595ms /5mb

Windows 7 -64b (Core 2 Duo 2.93 6Gb memory)

• Safari 5.1.7 ~80ms /5Mb
• Chrome 26.0.1410.43 ~1220ms /5Mb
• Firefox 20.0 228500ms(!) /10Mb (after complaining about script running to long)
• IE9 ~17900ms /9.54Mb ( if any console.logs are in the code does not work until DevTools are opened)
• Opera 12.15 ~4212ms /3.55Mb (this is when 5Mb is selected, but Opera asks nicely if we want increase the amount of lS, unfortunately it crashes if test conducted a few times in a row)

Win 8 (Under Parallels 8)

• IE10 ~7850ms /9.54Mb

You can calculate your localstorage by following methods:

function sizeofAllStorage(){ // provide the size in bytes of the data currently stored var size = 0; for (i=0; i<=localStorage.length-1; i++) { key = localStorage.key(i); size += lengthInUtf8Bytes(localStorage.getItem(key)); } return size; } function lengthInUtf8Bytes(str) { // Matches only the 10.. bytes that are non-initial characters in a multi-byte sequence. var m = encodeURIComponent(str).match(/%[89ABab]/g); return str.length + (m ? m.length : 0); } console.log(sizeofAllStorage()); 

Finally size in bytes will be logged in browser.

The way I went about this problem is to create functions for finding out the used space and remaining space in Local Storage and then a function that calls those functions to determine the max storage space.

function getUsedSpaceOfLocalStorageInBytes() { // Returns the total number of used space (in Bytes) of the Local Storage var b = 0; for (var key in window.localStorage) { if (window.localStorage.hasOwnProperty(key)) { b += key.length + localStorage.getItem(key).length; } } return b; } function getUnusedSpaceOfLocalStorageInBytes() { var maxByteSize = 10485760; // 10MB var minByteSize = 0; var tryByteSize = 0; var testQuotaKey = 'testQuota'; var timeout = 20000; var startTime = new Date().getTime(); var unusedSpace = 0; do { runtime = new Date().getTime() - startTime; try { tryByteSize = Math.floor((maxByteSize + minByteSize) / 2); //localStorage.setItem(testQuotaKey, new Array(tryByteSize).join('1')); //Recommended by @pkExec and @jrob007 localStorage.setItem(testQuotaKey, String('1').repeat(tryByteSize)); minByteSize = tryByteSize; } catch (e) { maxByteSize = tryByteSize - 1; } } while ((maxByteSize - minByteSize > 1) && runtime < timeout); localStorage.removeItem(testQuotaKey); if (runtime >= timeout) { console.log("Unused space calculation may be off due to timeout."); } // Compensate for the byte size of the key that was used, then subtract 1 byte because the last value of the tryByteSize threw the exception unusedSpace = tryByteSize + testQuotaKey.length - 1; return unusedSpace; } function getLocalStorageQuotaInBytes() { // Returns the total Bytes of Local Storage Space that the browser supports var unused = getUnusedSpaceOfLocalStorageInBytes(); var used = getUsedSpaceOfLocalStorageInBytes(); var quota = unused + used; return quota; } 

I would use the code of @tennisgen which get all and count the content, but I count the keys themselves:

var localStorageSpace = function(){ var allStrings = ''; for(var key in window.localStorage){ allStrings += key; if(window.localStorage.hasOwnProperty(key)){ allStrings += window.localStorage[key]; } } return allStrings ? 3 + ((allStrings.length*16)/(8*1024)) + ' KB' : 'Empty (0 KB)'; }; 

In addition to @serge's answer which is most voted here, size of the keys need to be considered. Code below will add the size of the keys stored in localStorage

var t = 0; for (var x in localStorage) { t += (x.length + localStorage[x].length) * 2; } console.log((t / 1024) + " KB"); 

As the spec goes, each character of a string is 16 bit.

But inspecting with chrome (Settings>Content Settings>Cookies & Site data) shows us that initiating localStorage takes 3kB (overhead size)

And stored data size follows this relation (accurate to 1kB)
3 + ((localStorage.x.length*16)/(8*1024)) kB

where localStorage.x is your storage string.

Yes, this question was asked like 10 years ago. But for those interested (like myself, as I am building an offline text editor that saves data with local storage) and suck at programming, you could use something simple like this:

var warning = 1; var limit = 2000000; //2 million characters, not really taking in account to bytes but for tested number of characters stored setInterval(function() { localStorage["text"] = document.getElementById("editor").innerHTML; //gets text and saves it in local storage under "text" if(localStorage["text"].length > limit && warning == 1){ alert("Local Storage capacity has been filled"); warning = 2; //prevent a stream of alerts } }, 1000); //setInterval function saves and checks local storage 

The best way to get the amount of storage filled is to view the site settings (say, if you stored an image in local storage). At least in chrome, you can see the amount of bytes used (ie: 1222 bytes). However, the best ways to see filled local storage with js have already been mentioned above, so use them.

I would just use a try/catch with some test content after the page loads or at any input focus, like:

function canSetItem(){ const KEY = "check_available_space" try { localStorage.setItem(KEY, KEY); } catch(e) { console.error(e); return false; } localStorage.removeItem(KEY); return true; } 

//Memory occupy by both key and value so Updated Code.

var jsonarr=[]; var jobj=null; for(x in sessionStorage) // Iterate through each session key { jobj={}; jobj[x]=sessionStorage.getItem(x); //because key will also occupy some memory jsonarr.push(jobj); jobj=null; } //https://developer.mozilla.org/en/docs/Web/JavaScript/Data_structures //JavaScript's String type is used to represent textual data. It is a set of "elements" of 16-bit unsigned integer values. var size=JSON.stringify(jsonarr).length*2; //16-bit that's why multiply by 2 var arr=["bytes","KB","MB","GB","TB"]; // Define Units var sizeUnit=0; while(size>1024){ // To get result in Proper Unit sizeUnit++; size/=1024; } alert(size.toFixed(2)+" "+arr[sizeUnit]);