diff --git a/fanficfare/browsercache/__init__.py b/fanficfare/browsercache/__init__.py
index 1d760942..08f69e23 100644
--- a/fanficfare/browsercache/__init__.py
+++ b/fanficfare/browsercache/__init__.py
@@ -31,12 +31,12 @@ class BrowserCache(object):
     Class to read web browser cache
     This wrapper class contains the actual impl object.
     """
-    def __init__(self, cache_dir, age_limit=-1):
+    def __init__(self, getConfig_fn, getConfigList_fn):
         """Constructor for BrowserCache"""
         # import of child classes have to be inside the def to avoid circular import error
         for browser_cache_class in [SimpleCache, BlockfileCache, FirefoxCache2]:
-            self.browser_cache_impl = browser_cache_class.new_browser_cache(cache_dir,
-                                                                            age_limit=age_limit)
+            self.browser_cache_impl = browser_cache_class.new_browser_cache(getConfig_fn,
+                                                                            getConfigList_fn)
             if self.browser_cache_impl is not None:
                 break
         if self.browser_cache_impl is None:
diff --git a/fanficfare/browsercache/base_browsercache.py b/fanficfare/browsercache/base_browsercache.py
index 85a9f1f3..82452a4a 100644
--- a/fanficfare/browsercache/base_browsercache.py
+++ b/fanficfare/browsercache/base_browsercache.py
@@ -44,13 +44,20 @@ from ..six import ensure_text
 
 from ..exceptions import BrowserCacheException
 
+CACHE_DIR_CONFIG="browser_cache_path"
+AGE_LIMIT_CONFIG="browser_cache_age_limit"
+
 class BaseBrowserCache(object):
     """Base class to read various formats of web browser cache file"""
 
-    def __init__(self, cache_dir, age_limit=-1):
+    def __init__(self, getConfig_fn, getConfigList_fn):
         """Constructor for BaseBrowserCache"""
         ## only ever called by class method new_browser_cache()
-        self.cache_dir = cache_dir
+        self.getConfig = getConfig_fn
+        self.getConfigList = getConfigList_fn
+
+        self.cache_dir = self.expand_cache_dir(getConfig_fn(CACHE_DIR_CONFIG))
+        age_limit=self.getConfig(AGE_LIMIT_CONFIG)
         if age_limit is None or age_limit == '' or float(age_limit) < 0.0:
             self.age_limit = None
         else:
@@ -58,17 +65,20 @@ class BaseBrowserCache(object):
             self.age_limit = float(age_limit) * 3600
 
     @classmethod
-    def new_browser_cache(cls, cache_dir, age_limit=-1):
+    def new_browser_cache(cls, getConfig_fn, getConfigList_fn):
         """Return new instance of this BrowserCache class, or None if supplied directory not the correct cache type"""
-        cache_dir = os.path.realpath(os.path.expanduser(cache_dir))
-        if cls.is_cache_dir(cache_dir):
+        if cls.is_cache_dir(cls.expand_cache_dir(getConfig_fn(CACHE_DIR_CONFIG))):
             try:
-                return cls(cache_dir,
-                           age_limit=age_limit)
+                return cls(getConfig_fn,
+                           getConfigList_fn)
             except BrowserCacheException:
                 return None
         return None
 
+    @staticmethod
+    def expand_cache_dir(cache_dir):
+        return os.path.realpath(os.path.expanduser(cache_dir))
+
     @staticmethod
     def is_cache_dir(cache_dir):
         """Check given dir is a valid cache."""
diff --git a/fanficfare/browsercache/browsercache_simple.py b/fanficfare/browsercache/browsercache_simple.py
index 67de5dd0..b5b97fb3 100644
--- a/fanficfare/browsercache/browsercache_simple.py
+++ b/fanficfare/browsercache/browsercache_simple.py
@@ -39,7 +39,6 @@ SIMPLE_EOF = struct.Struct('<QLLLL')   # magic_number, flags, crc32, stream_size
 SIMPLE_EOF_SIZE = SIMPLE_EOF.size
 FLAG_HAS_SHA256 = 2
 META_HEADER = struct.Struct('<LLLQQL')
-META_HEADER_SIZE = META_HEADER.size
 ENTRY_MAGIC_NUMBER = 0xfcfb6d1ba7725c30
 EOF_MAGIC_NUMBER = 0xf4fa6f45970d41d8
 THE_REAL_INDEX_MAGIC_NUMBER = 0x656e74657220796f
@@ -51,6 +50,12 @@ class SimpleCache(BaseChromiumCache):
         """Constructor for SimpleCache"""
         super(SimpleCache,self).__init__(*args, **kargs)
         logger.debug("Using SimpleCache")
+
+        if self.getConfig("browser_cache_simple_header_old",False):
+            logger.warning("browser_cache_simple_header_old:true - Using older META_HEADER definition.")
+            global META_HEADER
+            META_HEADER = struct.Struct('<LLQQL')
+
         # self.scan_cache_keys()
         # 1/0
 
@@ -65,10 +70,10 @@ class SimpleCache(BaseChromiumCache):
                     try:
                         file_key = _read_entry_file(entry.path,entry_file)
                         if '/s/14347189/1/' in file_key:
-                            (info_size, flags, request_time, response_time, header_size) = _read_meta_headers(entry_file)
+                            (request_time, response_time, header_size) = _read_meta_headers(entry_file)
                             logger.debug("file_key:%s"%file_key)
-                            logger.debug("response_time:%s"%response_time)
-                            logger.debug("Creation Time: %s"%datetime.datetime.fromtimestamp(int(response_time/1000000)-EPOCH_DIFFERENCE))
+                            logger.debug("request_time:  %s (%s)"%(datetime.datetime.fromtimestamp(self.make_age(request_time)),request_time))
+                            logger.debug("response_time: %s (%s)"%(datetime.datetime.fromtimestamp(self.make_age(response_time)),response_time))
                     except Exception as e:
                         raise e
                         pass
@@ -121,10 +126,10 @@ class SimpleCache(BaseChromiumCache):
                         # theoretically, there can be hash collision.
                         continue
                     logger.debug("en_fl:%s"%en_fl)
-                    (info_size, flags, request_time, response_time, header_size) = _read_meta_headers(entry_file)
+                    (request_time, response_time, header_size) = _read_meta_headers(entry_file)
                     headers = _read_headers(entry_file,header_size)
-                    logger.debug("response_time:%s"%response_time)
-                    # logger.debug("Creation Time: %s"%datetime.datetime.fromtimestamp(int(response_time/1000000)-EPOCH_DIFFERENCE))
+                    logger.debug("request_time:  %s (%s)"%(datetime.datetime.fromtimestamp(self.make_age(request_time)),request_time))
+                    logger.debug("response_time: %s (%s)"%(datetime.datetime.fromtimestamp(self.make_age(response_time)),response_time))
                     logger.debug(headers)
                     ## seen both Location and location
                     location = headers.get('location','')
@@ -153,7 +158,7 @@ def _key_hash(key):
 def _get_entry_file_created(path):
     with share_open(path, "rb") as entry_file:
         key = _read_entry_file(path,entry_file)
-        (info_size, flags, request_time, response_time, header_size) = _read_meta_headers(entry_file)
+        (request_time, response_time, header_size) = _read_meta_headers(entry_file)
         # logger.debug("\nkey:%s\n request_time:%s\nresponse_time:%s"%(key,request_time, response_time))
         return (key, response_time)
 
@@ -208,8 +213,8 @@ def _read_data_from_entry(entry_file):
 
 def _get_headers(path):
     with share_open(path, "rb") as entry_file:
-        (info_size, flags, request_time, response_time, header_size) = _read_meta_headers(entry_file)
-        logger.debug("request_time:%s, response_time:%s"%(request_time, response_time))
+        (request_time, response_time, header_size) = _read_meta_headers(entry_file)
+        # logger.debug("request_time:%s, response_time:%s"%(request_time, response_time))
         return _read_headers(entry_file,header_size)
 
 
@@ -217,14 +222,19 @@ def _read_meta_headers(entry_file):
     """ Read the HTTP header (stream 0 data) from a cache entry file """
     entry_file.seek(0, os.SEEK_END)
     _skip_to_start_of_stream(entry_file)
+
+    ## Aug 2024
+    ## There's 4 more bytes in the meta header than there used to be.
+    ## request_time, response_time, header_size are still correct, but I don't
+    ## actually know if info_size, flags, and new extra are correct.
+    ## We didn't use them before, so this shouldn't hurt anything
+
     # read stream 0 meta header:
-    #   uint32 info_size, uint32 flags, uint64 request_time, uint64 response_time, uint32 header_size
-    data = entry_file.read(META_HEADER_SIZE)
-    logger.debug(data)
-    (info_size, flags, extra, request_time, response_time, header_size) = META_HEADER.unpack(data)
-    logger.debug("\n\nextra: %s\n\n"%extra)
-    logger.debug((info_size, flags, request_time, response_time, extra, header_size))
-    return (info_size, flags, request_time, response_time, header_size)
+    #   uint32 info_size, uint32 flags, uint32 extra??, uint64 request_time, uint64 response_time, uint32 header_size
+    data = entry_file.read(META_HEADER.size)
+    # logger.debug(data)
+    (request_time, response_time, header_size) = META_HEADER.unpack(data)[-3:]
+    return (request_time, response_time, header_size)
 
 
 def _read_headers(entry_file,header_size):
@@ -234,8 +244,8 @@ def _read_headers(entry_file,header_size):
     # It is a series of null terminated strings, first is status code,e.g., "HTTP/1.1 200"
     # the rest are name:value pairs used to populate the headers dict.
     data = entry_file.read(header_size)
-    logger.debug("header_size:%s"%header_size)
-    logger.debug(data)
+    # logger.debug("header_size:%s"%header_size)
+    # logger.debug(data)
     strings = data.decode('utf-8').split('\0')
     headers = dict([ (y[0].lower(),y[1]) for y in [s.split(':', 1) for s in strings[1:] if ':' in s]])
     return headers
diff --git a/fanficfare/configurable.py b/fanficfare/configurable.py
index fda9ffe5..f51518b1 100644
--- a/fanficfare/configurable.py
+++ b/fanficfare/configurable.py
@@ -218,6 +218,7 @@ def get_valid_set_options():
                'browser_cache_path':(['defaults'],None,None),
                'use_browser_cache':(None,None,boollist),
                'use_browser_cache_only':(None,None,boollist),
+               'browser_cache_simple_header_old':(None,None,boollist),
                'open_pages_in_browser':(None,None,boollist),
 
                'continue_on_chapter_error':(None,None,boollist),
@@ -522,6 +523,7 @@ def get_valid_keywords():
                  'use_basic_cache',
                  'use_browser_cache',
                  'use_browser_cache_only',
+                 'browser_cache_simple_header_old',
                  'open_pages_in_browser',
                  'use_nsapa_proxy',
                  'nsapa_proxy_address',
@@ -1024,7 +1026,7 @@ class Configuration(ConfigParser):
             # much higher user wants a file:// than something through
             # browser cache or a proxy.
             self.filelist_fetcher = fetchers.RequestsFetcher(self.getConfig,
-                                                            self.getConfigList)
+                                                             self.getConfigList)
         ( data, redirecturl ) = self.filelist_fetcher.get_request_redirected(fn)
         retval = None
         # NOT using website encoding reduce_zalgo etc decoding because again,
@@ -1084,8 +1086,8 @@ class Configuration(ConfigParser):
                     ## make a data list of decorators to re-apply if
                     ## there are many more.
                     if self.browser_cache is None:
-                        self.browser_cache = BrowserCache(self.getConfig("browser_cache_path"),
-                                                          age_limit=self.getConfig("browser_cache_age_limit"))
+                        self.browser_cache = BrowserCache(self.getConfig,
+                                                          self.getConfigList)
                     fetchers.BrowserCacheDecorator(self.browser_cache).decorate_fetcher(self.fetcher)
                 except Exception as e:
                     logger.warning("Failed to setup BrowserCache(%s)"%e)