diff --git a/requirements.txt b/requirements.txt
index c1381f71..a3007afb 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -16,3 +16,4 @@ scikit-learn==0.22.2.post1
 scipy==1.4.1
 threadpoolctl==2.1.0
 urllib3==1.25.9
+s3fs==2021.4.0
diff --git a/setup.py b/setup.py
index 3c4ed1a4..90f88127 100644
--- a/setup.py
+++ b/setup.py
@@ -72,7 +72,8 @@
         'scikit-learn>=0.18',
         'scipy>=0.17.0',
         'threadpoolctl>=1.0.0',
-        'urllib3>=1.22'
+        'urllib3>=1.22',
+        's3fs>=2021.4.0'
     ],
 
     # List additional groups of dependencies here (e.g. development
diff --git a/wfdb/io/_signal.py b/wfdb/io/_signal.py
index f6a95ec6..5c9b79d9 100644
--- a/wfdb/io/_signal.py
+++ b/wfdb/io/_signal.py
@@ -2091,7 +2091,7 @@ def _infer_sig_len(file_name, fmt, n_sig, dir_name, pn_dir=None):
         file_size = os.path.getsize(os.path.join(dir_name, file_name))
     else:
         file_size = download._remote_file_size(file_name=file_name,
-                                               pn_dir=pn_dir)
+                                               remote_dir=pn_dir)
 
     sig_len = int(file_size / (BYTES_PER_SAMPLE[fmt] * n_sig))
 
diff --git a/wfdb/io/annotation.py b/wfdb/io/annotation.py
index 14855f0d..b58a738c 100644
--- a/wfdb/io/annotation.py
+++ b/wfdb/io/annotation.py
@@ -1620,7 +1620,7 @@ def rdann(record_name, extension, sampfrom=0, sampto=None, shift_samps=False,
     >>> ann = wfdb.rdann('sample-data/100', 'atr', sampto=300000)
 
     """
-    if (pn_dir is not None) and ('.' not in pn_dir):
+    if (pn_dir is not None) and ('.' not in pn_dir) and (not pn_dir.startswith('s3')):
         dir_list = pn_dir.split('/')
         pn_dir = posixpath.join(dir_list[0],
                                 record.get_version(dir_list[0]),
@@ -2255,7 +2255,7 @@ def ann2rr(record_name, extension, pn_dir=None, start_time=None,
     >>> 257
 
     """
-    if (pn_dir is not None) and ('.' not in pn_dir):
+    if (pn_dir is not None) and ('.' not in pn_dir) and (not pn_dir.startswith('s3')):
         dir_list = pn_dir.split('/')
         pn_dir = posixpath.join(dir_list[0], record.get_version(dir_list[0]),
                                 *dir_list[1:])
diff --git a/wfdb/io/download.py b/wfdb/io/download.py
index 8a5a6e77..3e1bbf10 100644
--- a/wfdb/io/download.py
+++ b/wfdb/io/download.py
@@ -49,7 +49,7 @@ def set_db_index_url(db_index_url=PN_INDEX_URL):
     config.db_index_url = db_index_url
 
 
-def _remote_file_size(url=None, file_name=None, pn_dir=None):
+def _remote_file_size(url=None, file_name=None, remote_dir=None):
     """
     Get the remote file size in bytes.
 
@@ -59,11 +59,16 @@ def _remote_file_size(url=None, file_name=None, pn_dir=None):
         The full url of the file. Use this option to explicitly
         state the full url.
     file_name : str, optional
-        The base file name. Use this argument along with pn_dir if you
+        The base file name. Use this argument along with remote_dir if you
         want the full url to be constructed.
-    pn_dir : str, optional
-        The base file name. Use this argument along with file_name if
-        you want the full url to be constructed.
+    remote_dir : str, optional
+        The remote directory of either two things:
+        (1) The S3 URI form which to find the required header file. This
+            should always begin with 's3' in order to work correctly. An
+            example input would be: 's3://my-aws-bucket/'
+        (2) The PhysioNet database directory from which to find the
+            required header file. eg. For file '100.hea' in
+            'http://physionet.org/content/mitdb', remote_dir='mitdb'.
 
     Returns
     -------
@@ -72,8 +77,17 @@ def _remote_file_size(url=None, file_name=None, pn_dir=None):
 
     """
     # Option to construct the url
-    if file_name and pn_dir:
-        url = posixpath.join(config.db_index_url, pn_dir, file_name)
+    if file_name and remote_dir:
+        if remote_dir.startswith('s3'):
+            # Set up the remote AWS S3 file system
+            import s3fs
+            fs = s3fs.S3FileSystem(anon=True)
+            file_dir = posixpath.join(remote_dir, file_name)
+            # Read and decode the lines
+            with fs.open(file_dir) as f:
+                return f.size
+        else:
+            url = posixpath.join(config.db_index_url, remote_dir, file_name)
 
     response = requests.head(url, headers={'Accept-Encoding': 'identity'})
     # Raise HTTPError if invalid url
@@ -85,7 +99,7 @@ def _remote_file_size(url=None, file_name=None, pn_dir=None):
     return remote_file_size
 
 
-def _stream_header(file_name, pn_dir):
+def _stream_header(file_name, remote_dir):
     """
     Stream the lines of a remote header file.
 
@@ -93,10 +107,14 @@ def _stream_header(file_name, pn_dir):
     ----------
     file_name : str
         The name of the headerr file to be read.
-    pn_dir : str
-        The PhysioNet database directory from which to find the
-        required header file. eg. For file '100.hea' in
-        'http://physionet.org/content/mitdb', pn_dir='mitdb'.
+    remote_dir : str
+        The remote directory of either two things:
+        (1) The S3 URI form which to find the required header file. This
+            should always begin with 's3' in order to work correctly. An
+            example input would be: 's3://my-aws-bucket/'
+        (2) The PhysioNet database directory from which to find the
+            required header file. eg. For file '100.hea' in
+            'http://physionet.org/content/mitdb', remote_dir='mitdb'.
 
     Returns
     -------
@@ -106,15 +124,23 @@ def _stream_header(file_name, pn_dir):
         All of the comment header lines.
 
     """
-    # Full url of header location
-    url = posixpath.join(config.db_index_url, pn_dir, file_name)
-    response = requests.get(url)
-
-    # Raise HTTPError if invalid url
-    response.raise_for_status()
-
-    # Get each line as a string
-    filelines = response.content.decode('iso-8859-1').splitlines()
+    if remote_dir.startswith('s3'):
+        # Set up the remote AWS S3 file system
+        import s3fs
+        fs = s3fs.S3FileSystem(anon=True)
+        file_dir = posixpath.join(remote_dir, file_name)
+        # Read and decode the lines
+        with fs.open(file_dir) as f:
+            filelines = f.readlines()
+            filelines = [l.decode('iso-8859-1') for l in filelines]
+    else:
+        # Full url of header location
+        url = posixpath.join(config.db_index_url, remote_dir, file_name)
+        response = requests.get(url)
+        # Raise HTTPError if invalid url
+        response.raise_for_status()
+        # Get each line as a string
+        filelines = response.content.decode('iso-8859-1').splitlines()
 
     # Separate content into header and comment lines
     header_lines = []
@@ -139,7 +165,7 @@ def _stream_header(file_name, pn_dir):
     return (header_lines, comment_lines)
 
 
-def _stream_dat(file_name, pn_dir, byte_count, start_byte, dtype):
+def _stream_dat(file_name, remote_dir, byte_count, start_byte, dtype):
     """
     Stream data from a remote dat file into a 1d numpy array.
 
@@ -147,8 +173,14 @@ def _stream_dat(file_name, pn_dir, byte_count, start_byte, dtype):
     ----------
     file_name : str
         The name of the dat file to be read.
-    pn_dir : str
-        The PhysioNet directory where the dat file is located.
+    remote_dir : str
+        The remote directory of either two things:
+        (1) The S3 URI form which to find the required header file. This
+            should always begin with 's3' in order to work correctly. An
+            example input would be: 's3://my-aws-bucket/'
+        (2) The PhysioNet database directory from which to find the
+            required header file. eg. For file '100.hea' in
+            'http://physionet.org/content/mitdb', remote_dir='mitdb'.
     byte_count : int
         The number of bytes to be read.
     start_byte : int
@@ -162,32 +194,42 @@ def _stream_dat(file_name, pn_dir, byte_count, start_byte, dtype):
         The data read from the dat file.
 
     """
-    # Full url of dat file
-    url = posixpath.join(config.db_index_url, pn_dir, file_name)
+    if remote_dir.startswith('s3'):
+        # Set up the remote AWS S3 file system
+        import s3fs
+        fs = s3fs.S3FileSystem(anon=True)
+        file_dir = posixpath.join(remote_dir, file_name)
+        # Read and decode the lines
+        with fs.open(file_dir) as f:
+            file_content = f.read()
+    else:
+        # Full url of dat file
+        url = posixpath.join(config.db_index_url, remote_dir, file_name)
 
-    # Specify the byte range
-    end_byte = start_byte + byte_count - 1
-    headers = {"Range":"bytes=%d-%d" % (start_byte, end_byte),
-               'Accept-Encoding': '*'}
+        # Specify the byte range
+        end_byte = start_byte + byte_count - 1
+        headers = {"Range":"bytes=%d-%d" % (start_byte, end_byte),
+                'Accept-Encoding': '*'}
 
-    # Get the content
-    response = requests.get(url, headers=headers, stream=True)
+        # Get the content
+        response = requests.get(url, headers=headers, stream=True)
 
-    # Raise HTTPError if invalid url
-    response.raise_for_status()
+        # Raise HTTPError if invalid url
+        response.raise_for_status()
+        file_content = response.content
 
     # Convert to numpy array
     if type(dtype) == str:
         # Convert 24-bit to 16-bit then proceed
-        temp_data = np.frombuffer(response.content, 'b').reshape(-1,3)[:,1:].flatten().view('i2')
+        temp_data = np.frombuffer(file_content, 'b').reshape(-1,3)[:,1:].flatten().view('i2')
         sig_data = np.fromstring(temp_data, dtype='i2')
     else:
-        sig_data = np.fromstring(response.content, dtype=dtype)
+        sig_data = np.fromstring(file_content, dtype=dtype)
 
     return sig_data
 
 
-def _stream_annotation(file_name, pn_dir):
+def _stream_annotation(file_name, remote_dir):
     """
     Stream an entire remote annotation file from Physionet.
 
@@ -195,8 +237,14 @@ def _stream_annotation(file_name, pn_dir):
     ----------
     file_name : str
         The name of the annotation file to be read.
-    pn_dir : str
-        The PhysioNet directory where the annotation file is located.
+    remote_dir : str
+        The remote directory of either two things:
+        (1) The S3 URI form which to find the required header file. This
+            should always begin with 's3' in order to work correctly. An
+            example input would be: 's3://my-aws-bucket/'
+        (2) The PhysioNet database directory from which to find the
+            required header file. eg. For file '100.hea' in
+            'http://physionet.org/content/mitdb', remote_dir='mitdb'.
 
     Returns
     -------
@@ -204,16 +252,24 @@ def _stream_annotation(file_name, pn_dir):
         The resulting data stream in numpy array format.
 
     """
-    # Full url of annotation file
-    url = posixpath.join(config.db_index_url, pn_dir, file_name)
-
-    # Get the content
-    response = requests.get(url)
-    # Raise HTTPError if invalid url
-    response.raise_for_status()
-
+    if remote_dir.startswith('s3'):
+        # Set up the remote AWS S3 file system
+        import s3fs
+        fs = s3fs.S3FileSystem(anon=True)
+        file_dir = posixpath.join(remote_dir, file_name)
+        # Read and decode the lines
+        with fs.open(file_dir) as f:
+            file_content = f.read()
+    else:
+        # Full url of annotation file
+        url = posixpath.join(config.db_index_url, remote_dir, file_name)
+        # Get the content
+        response = requests.get(url)
+        # Raise HTTPError if invalid url
+        response.raise_for_status()
+        file_content = response.content
     # Convert to numpy array
-    ann_data = np.fromstring(response.content, dtype=np.dtype('<u1'))
+    ann_data = np.fromstring(file_content, dtype=np.dtype('<u1'))
 
     return ann_data
 
diff --git a/wfdb/io/record.py b/wfdb/io/record.py
index 687da3b1..c71c6742 100644
--- a/wfdb/io/record.py
+++ b/wfdb/io/record.py
@@ -1457,23 +1457,32 @@ def edf2mit(record_name, pn_dir=None, delete_file=True, record_only=True,
 
     """
     if pn_dir is not None:
+        if pn_dir.startswith('s3'):
+            # Set up the remote AWS S3 file system
+            import s3fs
+            fs = s3fs.S3FileSystem(anon=True)
+            file_dir = posixpath.join(pn_dir, record_name)
+        else:
+            if '.' not in pn_dir:
+                dir_list = pn_dir.split('/')
+                pn_dir = posixpath.join(dir_list[0], get_version(dir_list[0]),
+                                        *dir_list[1:])
 
-        if '.' not in pn_dir:
-            dir_list = pn_dir.split('/')
-            pn_dir = posixpath.join(dir_list[0], get_version(dir_list[0]), *dir_list[1:])
-
-        file_url = posixpath.join(download.PN_INDEX_URL, pn_dir, record_name)
-        # Currently must download file for MNE to read it though can give the
-        # user the option to delete it immediately afterwards
-        r = requests.get(file_url, allow_redirects=False)
-        open(record_name, 'wb').write(r.content)
-
-    # Open the desired file
-    edf_file = open(record_name, mode='rb')
+            file_url = posixpath.join(download.PN_INDEX_URL, pn_dir, record_name)
+            # Currently must download file for MNE to read it though can give the
+            # user the option to delete it immediately afterwards
+            r = requests.get(file_url, allow_redirects=False)
+            open(record_name, 'wb').write(r.content)
 
-    # Remove the file if the `delete_file` flag is set
-    if pn_dir is not None and delete_file:
-        os.remove(record_name)
+    try:
+        # Read the remote file
+        edf_file = fs.open(file_dir, 'rb')
+    except NameError:
+        # Open the desired file
+        edf_file = open(record_name, 'rb')
+        # Remove the file if the `delete_file` flag is set
+        if pn_dir is not None and delete_file:
+            os.remove(record_name)
 
     # Version of this data format (8 bytes)
     version = struct.unpack('<8s', edf_file.read(8))[0].decode()
@@ -1685,7 +1694,7 @@ def edf2mit(record_name, pn_dir=None, delete_file=True, record_only=True,
         }
 
     sig_data = np.empty((sig_len, n_sig))
-    temp_sig_data = np.fromfile(edf_file, dtype=np.int16)
+    temp_sig_data = np.frombuffer(edf_file.read(), dtype=np.int16)
     temp_sig_data = temp_sig_data.reshape((-1,sum(samps_per_block)))
     temp_all_sigs = np.hsplit(temp_sig_data, np.cumsum(samps_per_block)[:-1])
     for i in range(n_sig):
@@ -2371,25 +2380,41 @@ def wav2mit(record_name, pn_dir=None, delete_file=True, record_only=False):
         raise Exception('Name of the input file must end in .wav')
 
     if pn_dir is not None:
+        if pn_dir.startswith('s3'):
+            # Set up the remote AWS S3 file system
+            import s3fs
+            fs = s3fs.S3FileSystem(anon=True)
+            file_dir = posixpath.join(pn_dir, record_name)
+        else:
+            if '.' not in pn_dir:
+                dir_list = pn_dir.split('/')
+                pn_dir = posixpath.join(dir_list[0], get_version(dir_list[0]),
+                                        *dir_list[1:])
+
+            file_url = posixpath.join(download.PN_INDEX_URL, pn_dir,
+                                      record_name)
+            # Currently must download file for MNE to read it though can give the
+            # user the option to delete it immediately afterwards
+            r = requests.get(file_url, allow_redirects=False)
+            open(record_name, 'wb').write(r.content)
 
-        if '.' not in pn_dir:
-            dir_list = pn_dir.split('/')
-            pn_dir = posixpath.join(dir_list[0], get_version(dir_list[0]), *dir_list[1:])
-
-        file_url = posixpath.join(download.PN_INDEX_URL, pn_dir, record_name)
-        # Currently must download file to read it though can give the
-        # user the option to delete it immediately afterwards
-        r = requests.get(file_url, allow_redirects=False)
-        open(record_name, 'wb').write(r.content)
+    try:
+        # Read the remote file
+        wave_file = fs.open(file_dir, 'rb')
+    except NameError:
+        # Open the desired file
+        wave_file = open(record_name, 'rb')
 
-    wave_file = open(record_name, mode='rb')
     record_name_out = record_name.split(os.sep)[-1].replace('-','_').replace('.wav','')
 
     chunk_ID = ''.join([s.decode() for s in struct.unpack('>4s', wave_file.read(4))])
     if chunk_ID != 'RIFF':
         raise Exception('{} is not a .wav-format file'.format(record_name))
 
-    correct_chunk_size = os.path.getsize(record_name) - 8
+    try:
+        correct_chunk_size = wave_file.size - 8
+    except AttributeError:
+        correct_chunk_size = os.path.getsize(record_name) - 8
     chunk_size = struct.unpack('<I', wave_file.read(4))[0]
     if chunk_size != correct_chunk_size:
         raise Exception('Header chunk has incorrect length (is {} should be {})'.format(chunk_size,correct_chunk_size))
@@ -2444,19 +2469,23 @@ def wav2mit(record_name, pn_dir=None, delete_file=True, record_only=False):
     if subchunk2_ID != 'data':
         raise Exception('Format chunk missing or corrupt')
 
-    correct_subchunk2_size = os.path.getsize(record_name) - 44
+    try:
+        correct_subchunk2_size = wave_file.size - 44
+    except AttributeError:
+        correct_subchunk2_size = os.path.getsize(record_name) - 44
     subchunk2_size = struct.unpack('<I', wave_file.read(4))[0]
     if subchunk2_size != correct_subchunk2_size:
         raise Exception('Data chunk has incorrect length.. (is {} should be {})'.format(subchunk2_size, correct_subchunk2_size))
     sig_len = int(subchunk2_size / block_align)
 
-    sig_data = (np.fromfile(wave_file, dtype=np.int16).reshape((-1,num_channels)) / (2*adc_res)).astype(np.int16)
+    sig_data = (np.frombuffer(wave_file.read(), dtype=np.int16).reshape((-1,num_channels)) / (2*adc_res)).astype(np.int16)
 
     init_value = [int(s[0]) for s in np.transpose(sig_data)]
     checksum = [int(np.sum(v) % 65536) for v in np.transpose(sig_data)]  # not all values correct?
 
     if pn_dir is not None and delete_file:
-        os.remove(record_name)
+        if not pn_dir.startswith('s3'):
+            os.remove(record_name)
 
     record = Record(
         record_name = record_name_out,
@@ -3250,9 +3279,10 @@ def rdheader(record_name, pn_dir=None, rd_segments=False):
     dir_name, base_record_name = os.path.split(record_name)
     dir_name = os.path.abspath(dir_name)
 
-    if (pn_dir is not None) and ('.' not in pn_dir):
+    if (pn_dir is not None) and ('.' not in pn_dir) and (not pn_dir.startswith('s3')):
         dir_list = pn_dir.split('/')
-        pn_dir = posixpath.join(dir_list[0], get_version(dir_list[0]), *dir_list[1:])
+        pn_dir = posixpath.join(dir_list[0], get_version(dir_list[0]),
+                                *dir_list[1:])
 
     # Read the header file. Separate comment and non-comment lines
     header_lines, comment_lines = _header._read_header_lines(base_record_name,
@@ -3420,9 +3450,10 @@ def rdrecord(record_name, sampfrom=0, sampto=None, channels=None,
     dir_name = os.path.abspath(dir_name)
 
     # Read the header fields
-    if (pn_dir is not None) and ('.' not in pn_dir):
+    if (pn_dir is not None) and ('.' not in pn_dir) and (not pn_dir.startswith('s3')):
         dir_list = pn_dir.split('/')
-        pn_dir = posixpath.join(dir_list[0], get_version(dir_list[0]), *dir_list[1:])
+        pn_dir = posixpath.join(dir_list[0], get_version(dir_list[0]),
+                                *dir_list[1:])
 
     if record_name.endswith('.edf'):
         record = edf2mit(record_name, pn_dir=pn_dir, record_only=True)
@@ -3711,7 +3742,7 @@ def rdsamp(record_name, sampfrom=0, sampto=None, channels=None, pn_dir=None,
                                       channel =[1,3])
 
     """
-    if (pn_dir is not None) and ('.' not in pn_dir):
+    if (pn_dir is not None) and ('.' not in pn_dir) and (not pn_dir.startswith('s3')):
         dir_list = pn_dir.split('/')
         pn_dir = posixpath.join(dir_list[0], get_version(dir_list[0]), *dir_list[1:])
 
@@ -3763,7 +3794,7 @@ def sampfreq(record_name, pn_dir=None):
     >>> ECG 4    500
 
     """
-    if (pn_dir is not None) and ('.' not in pn_dir):
+    if (pn_dir is not None) and ('.' not in pn_dir) and (not pn_dir.startswith('s3')):
         dir_list = pn_dir.split('/')
         pn_dir = posixpath.join(dir_list[0], get_version(dir_list[0]),
                                 *dir_list[1:])
@@ -3815,7 +3846,7 @@ def signame(record_name, pn_dir=None, sig_nums=[]):
     >>> ECG 4
 
     """
-    if (pn_dir is not None) and ('.' not in pn_dir):
+    if (pn_dir is not None) and ('.' not in pn_dir) and (not pn_dir.startswith('s3')):
         dir_list = pn_dir.split('/')
         pn_dir = posixpath.join(dir_list[0], get_version(dir_list[0]),
                                  *dir_list[1:])
@@ -3894,7 +3925,7 @@ def wfdbdesc(record_name, pn_dir=None):
      Checksum: 20052
 
     """
-    if (pn_dir is not None) and ('.' not in pn_dir):
+    if (pn_dir is not None) and ('.' not in pn_dir) and (not pn_dir.startswith('s3')):
         dir_list = pn_dir.split('/')
         pn_dir = posixpath.join(dir_list[0], get_version(dir_list[0]),
                                 *dir_list[1:])
@@ -3922,8 +3953,13 @@ def wfdbdesc(record_name, pn_dir=None):
         start_time = 'not specified'
     print(f'Starting time: {start_time}')
 
-    record_length = str(datetime.timedelta(seconds=record.sig_len/record.fs))
-    print(f'Length: {record_length} ({record.sig_len} sample intervals)')
+    try:
+        record_length = str(datetime.timedelta(seconds=record.sig_len/record.fs))
+        sig_len = record.sig_len
+    except TypeError:
+        record_length = 'Unknown'
+        sig_len = 'Unknown'
+    print(f'Length: {record_length} ({sig_len} sample intervals)')
 
     print(f'Sampling frequency: {record.fs} Hz')
     print(f'{record.n_sig} signal{"" if record.n_sig==1 else "s"}')
@@ -4020,7 +4056,7 @@ def wfdbtime(record_name, input_times, pn_dir=None):
        s1153            00:00:09.224    [19:46:34.981000 01/01/0001]
 
     """
-    if (pn_dir is not None) and ('.' not in pn_dir):
+    if (pn_dir is not None) and ('.' not in pn_dir) and (not pn_dir.startswith('s3')):
         dir_list = pn_dir.split('/')
         pn_dir = posixpath.join(dir_list[0], get_version(dir_list[0]),
                                 *dir_list[1:])