Lets an add-on store data so that it's retained across Firefox restarts. This module works similarly to DOM storage on the Web, except that it's only available for add-ons.


The simple storage module exports an object called storage that is persistent and scoped to your add-on. It's a normal JavaScript object, and you can treat it as you would any other.

To store a value, just assign it to a property on storage:

var ss = require("sdk/simple-storage"); = [1, 1, 2, 3, 5, 8, 13]; = true; = null; = 3.1337; = { a: "foo", b: { c: true }, d: null }; = "O frabjous day!";

You can store array, boolean, number, object, null, and string values. If you'd like to store other types of values, you'll first have to convert them to strings or another one of these types.

Be careful to set properties on the storage object and not the module itself, as demonstrated below:

// This is not good!
var ss = require("sdk/simple-storage"); = "I will not be saved! :(";

Simple storage and "jpm run"

The simple storage module stores its data in your profile. Because jpm run by default uses a fresh profile each time it runs, simple storage won't work with add-ons executed using jpm run - that is, stored data will not persist from one run to the next.

The easiest solution to this problem is to use the --profile option to jpm with a path to a profile - not just a profile name. You may also need to include the --no-copy option to prevent Firefox from copying the profile to a temporarry directory each time it starts.

jpm run --no-copy --profile path/to/profile/dir

If you specify a non-existent profile, the same will be created, don't worry.

Important: If you use this method, you must end your debugging session by quitting Firefox normally, not by cancelling the shell command. If you don't close Firefox normally, then simple storage will not be notified that the session is finished, and will not write your data to the backing store.

Accessing storage from the console

In the Add-on Debugger, you can access your add-on's simple-storage programmatically from the console using the following:


Constructing arrays

Be careful to construct array objects conditionally in your code, or you may zero them each time the construction code runs. For example, this add-on tries to store the URLs of pages the user visits:

var ss = require("sdk/simple-storage"); = [];

require("sdk/tabs").on("ready", function(tab) {;

  id: "read",
  label: "Read",
  icon: "./read.png",
  onClick: function() {

But this isn't going to work, because it empties the array each time the add-on runs (for example, each time Firefox is started). Line 2 needs to be made conditional, so the array is only constructed if it does not already exist:

if (! = [];

Deleting data

You can delete properties using the delete operator. Here's an add-on that adds three buttons to write, read, and delete a value:

var ss = require("sdk/simple-storage");

  id: "write",
  label: "Write",
  icon: "./write.png",
  onClick: function() { = 1;
    console.log("Setting value");

  id: "read",
  label: "Read",
  icon: "./read.png",
  onClick: function() {

  id: "delete",
  label: "Delete",
  icon: "./delete.png",
  onClick: function() {
    console.log("Deleting value");

If you run it, you'll see that after clicking "Read" after clicking "Delete" gives you the expected output:

info: undefined

Note that to run this add-on you'll have to save icon files named "write.png", "read.png", and "delete.png" to the add-on's "data" directory.


The simple storage available to your add-on is limited. Currently this limit is about five megabytes (5,242,880 bytes). You can choose to be notified when you go over quota, and you should respond by reducing the amount of data in storage. If the user quits the application while you are over quota, all data stored since the last time you were under quota will not be persisted. You should not let that happen.

To listen for quota notifications, register a listener for the "OverQuota" event. It will be called when your storage goes over quota.

function myOnOverQuotaListener() {
  console.log("Uh oh.");
ss.on("OverQuota", myOnOverQuotaListener);

Listeners can also be removed:

ss.removeListener("OverQuota", myOnOverQuotaListener);

To find out how much of your quota you're using, check the module's quotaUsage property. It indicates the percentage of quota your storage occupies. If you're within your quota, it's a number from 0 to 1 (so a value of 0.5 means that you're using 50% of your quota and 1.0 means you're using your entire quota). If your add-on is using more than its quota, this value is greater than 1.0.

Therefore, when you're notified that you're over quota, you should respond by removing data from the storage space until your quotaUsage is less than or equal to 1. Which particular data you remove is up to you. For example: = [ /* some long array */ ];
ss.on("OverQuota", function () {
  while (ss.quotaUsage > 1);

Private browsing

If your storage is related to your users' Web history, personal information, or other sensitive data, your add-on should respect private browsing.

To read about how to opt into private browsing mode and how to use the SDK to avoid storing user data associated with private windows, refer to the documentation for the private-browsing module.




A persistent object private to your add-on. Properties with array, boolean, number, object, null, and string values will be persisted.


A number in the range [0, Infinity) that indicates the percentage of quota occupied by storage. A value in the range [0, 1] indicates that the storage is within quota. A value greater than 1 indicates that the storage exceeds quota.



The module emits this event when your add-on's storage goes over its quota.

Document Tags and Contributors

 Last updated by: wbamberg,