diff --git a/examples/README.md b/examples/README.md
index b4678c1fa2..e47ef446ec 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -22,6 +22,7 @@ Let us know if you find any issue or if you want to contribute and add a new tut
 - [js-ipfs in electron](./run-in-electron)
 - [Using streams to add a directory of files to ipfs](./browser-add-readable-stream)
 - [Customizing the ipfs repository](./custom-ipfs-repo)
+- - [Streaming video from ipfs to the browser using `ReadableStream`s](./browser-readablestream)
 
 ## Understanding the IPFS Stack
 
diff --git a/examples/browser-readablestream/README.md b/examples/browser-readablestream/README.md
new file mode 100644
index 0000000000..6fe75111f8
--- /dev/null
+++ b/examples/browser-readablestream/README.md
@@ -0,0 +1,16 @@
+# Streaming video from IPFS using ReadableStreams
+
+We can use the execllent [`videostream`](https://www.npmjs.com/package/videostream) to stream video from IPFS to the browser.  All we need to do is return a [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream)-like object that contains the requested byte ranges.
+
+Take a look at [`index.js`](./index.js) to see a working example.
+
+## Running the demo
+
+In this directory:
+
+```
+$ npm install
+$ npm start
+```
+
+Then open [http://localhost:8888](http://localhost:8888) in your browser.
diff --git a/examples/browser-readablestream/index.html b/examples/browser-readablestream/index.html
new file mode 100644
index 0000000000..61ded58b13
--- /dev/null
+++ b/examples/browser-readablestream/index.html
@@ -0,0 +1,66 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8"/>
+    <title><%= htmlWebpackPlugin.options.title %></title>
+    <style type="text/css">
+
+body {
+  margin: 0;
+  padding: 0;
+}
+
+#container {
+  display: flex;
+  height: 100vh;
+}
+
+pre {
+  flex-grow: 2;
+  padding: 10px;
+  height: calc(100vh - 45px);
+  overflow: auto;
+}
+
+#form-wrapper {
+  padding: 20px;
+}
+
+form {
+  padding-bottom: 10px;
+  display: flex;
+}
+
+#hash {
+  display: inline-block;
+  margin: 0 10px 10px 0;
+  font-size: 16px;
+  flex-grow: 2;
+  padding: 5px;
+}
+
+button {
+  display: inline-block;
+  font-size: 16px;
+  height: 32px;
+}
+
+video {
+  max-width: 50vw;
+}
+
+    </style>
+  </head>
+  <body>
+    <div id="container" ondrop="dropHandler(event)" ondragover="dragOverHandler(event)">
+      <div id="form-wrapper">
+          <form>
+            <input type="text" id="hash" placeholder="Hash" disabled />
+            <button id="gobutton" disabled>Go!</button>
+          </form>
+          <video id="video" controls></video>
+      </div>
+      <pre id="output" style="display: inline-block"></pre>
+    </div>
+  </body>
+</html>
diff --git a/examples/browser-readablestream/index.js b/examples/browser-readablestream/index.js
new file mode 100644
index 0000000000..7a2a969fa1
--- /dev/null
+++ b/examples/browser-readablestream/index.js
@@ -0,0 +1,75 @@
+'use strict'
+
+/* eslint-env browser */
+
+const Ipfs = require('../../')
+const videoStream = require('videostream')
+const ipfs = new Ipfs({ repo: 'ipfs-' + Math.random() })
+const {
+  dragDrop,
+  statusMessages,
+  createVideoElement,
+  log
+} = require('./utils')
+
+log('IPFS: Initialising')
+
+ipfs.on('ready', () => {
+  // Set up event listeners on the <video> element from index.html
+  const videoElement = createVideoElement()
+  const hashInput = document.getElementById('hash')
+  const goButton = document.getElementById('gobutton')
+  let stream
+
+  goButton.onclick = function (event) {
+    event.preventDefault()
+
+    log(`IPFS: Playing ${hashInput.value.trim()}`)
+
+    // Set up the video stream an attach it to our <video> element
+    videoStream({
+      createReadStream: function createReadStream (opts) {
+        const start = opts.start
+
+        // The videostream library does not always pass an end byte but when
+        // it does, it wants bytes between start & end inclusive.
+        // catReadableStream returns the bytes exclusive so increment the end
+        // byte if it's been requested
+        const end = opts.end ? start + opts.end + 1 : undefined
+
+        log(`Stream: Asked for data starting at byte ${start} and ending at byte ${end}`)
+
+        // If we've streamed before, clean up the existing stream
+        if (stream && stream.destroy) {
+          stream.destroy()
+        }
+
+        // This stream will contain the requested bytes
+        stream = ipfs.files.catReadableStream(hashInput.value.trim(), {
+          offset: start,
+          length: end && end - start
+        })
+
+        // Log error messages
+        stream.on('error', (error) => log(error))
+
+        if (start === 0) {
+          // Show the user some messages while we wait for the data stream to start
+          statusMessages(stream, log)
+        }
+
+        return stream
+      }
+    }, videoElement)
+  }
+
+  // Allow adding files to IPFS via drag and drop
+  dragDrop(ipfs, log)
+
+  log('IPFS: Ready')
+  log('IPFS: Drop an .mp4 file into this window to add a file')
+  log('IPFS: Then press the "Go!" button to start playing a video')
+
+  hashInput.disabled = false
+  goButton.disabled = false
+})
diff --git a/examples/browser-readablestream/package.json b/examples/browser-readablestream/package.json
new file mode 100644
index 0000000000..85c6e61c52
--- /dev/null
+++ b/examples/browser-readablestream/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "browser-videostream",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "webpack",
+    "start": "npm run build && http-server dist -a 127.0.0.1 -p 8888"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "html-webpack-plugin": "^2.30.1",
+    "http-server": "^0.11.1",
+    "uglifyjs-webpack-plugin": "^1.2.0",
+    "webpack": "^3.11.0"
+  },
+  "dependencies": {
+    "videostream": "^2.4.2"
+  }
+}
diff --git a/examples/browser-readablestream/utils.js b/examples/browser-readablestream/utils.js
new file mode 100644
index 0000000000..f0b3e2e580
--- /dev/null
+++ b/examples/browser-readablestream/utils.js
@@ -0,0 +1,145 @@
+'use strict'
+
+const log = (line) => {
+  const output = document.getElementById('output')
+  let message
+
+  if (line.message) {
+    message = `Error: ${line.message.toString()}`
+  } else {
+    message = line
+  }
+
+  if (message) {
+    const node = document.createTextNode(`${message}\r\n`)
+    output.appendChild(node)
+
+    output.scrollTop = output.offsetHeight
+
+    return node
+  }
+}
+
+const dragDrop = (ipfs) => {
+  const container = document.querySelector('#container')
+
+  container.ondragover = (event) => {
+    event.preventDefault()
+  }
+
+  container.ondrop = (event) => {
+    event.preventDefault()
+
+    Array.prototype.slice.call(event.dataTransfer.items)
+      .filter(item => item.kind === 'file')
+      .map(item => item.getAsFile())
+      .forEach(file => {
+        const progress = log(`IPFS: Adding ${file.name} 0%`)
+
+        const reader = new window.FileReader()
+        reader.onload = (event) => {
+          ipfs.files.add({
+            path: file.name,
+            content: ipfs.types.Buffer.from(event.target.result)
+          }, {
+            progress: (addedBytes) => {
+              progress.textContent = `IPFS: Adding ${file.name} ${parseInt((addedBytes / file.size) * 100)}%\r\n`
+            }
+          }, (error, added) => {
+            if (error) {
+              return log(error)
+            }
+
+            const hash = added[0].hash
+
+            log(`IPFS: Added ${hash}`)
+
+            document.querySelector('#hash').value = hash
+          })
+        }
+
+        reader.readAsArrayBuffer(file)
+      })
+
+    if (event.dataTransfer.items && event.dataTransfer.items.clear) {
+      event.dataTransfer.items.clear()
+    }
+
+    if (event.dataTransfer.clearData) {
+      event.dataTransfer.clearData()
+    }
+  }
+}
+
+module.exports.statusMessages = (stream) => {
+  let time = 0
+  const timeouts = [
+    'Stream: Still loading data from IPFS...',
+    'Stream: This can take a while depending on content availability',
+    'Stream: Hopefully not long now',
+    'Stream: *Whistles absentmindedly*',
+    'Stream: *Taps foot*',
+    'Stream: *Looks at watch*',
+    'Stream: *Stares at floor*',
+    'Stream: *Checks phone*',
+    'Stream: *Stares at ceiling*',
+    'Stream: Got anything nice planned for the weekend?'
+  ].map(message => {
+    time += 5000
+
+    return setTimeout(() => {
+      log(message)
+    }, time)
+  })
+
+  stream.once('data', () => {
+    log('Stream: Started receiving data')
+    timeouts.forEach(clearTimeout)
+  })
+  stream.once('error', () => {
+    timeouts.forEach(clearTimeout)
+  })
+}
+
+const createVideoElement = () => {
+  const videoElement = document.getElementById('video')
+  videoElement.addEventListener('loadedmetadata', () => {
+    videoElement.play()
+      .catch(log)
+  })
+
+  const events = [
+    'playing',
+    'waiting',
+    'seeking',
+    'seeked',
+    'ended',
+    'loadedmetadata',
+    'loadeddata',
+    'canplay',
+    'canplaythrough',
+    'durationchange',
+    'play',
+    'pause',
+    'suspend',
+    'emptied',
+    'stalled',
+    'error',
+    'abort'
+  ]
+  events.forEach(event => {
+    videoElement.addEventListener(event, () => {
+      log(`Video: ${event}`)
+    })
+  })
+
+  videoElement.addEventListener('error', () => {
+    log(videoElement.error)
+  })
+
+  return videoElement
+}
+
+module.exports.log = log
+module.exports.dragDrop = dragDrop
+module.exports.createVideoElement = createVideoElement
diff --git a/examples/browser-readablestream/webpack.config.js b/examples/browser-readablestream/webpack.config.js
new file mode 100644
index 0000000000..29d6edfb64
--- /dev/null
+++ b/examples/browser-readablestream/webpack.config.js
@@ -0,0 +1,29 @@
+'use strict'
+
+const path = require('path')
+const UglifyJsPlugin = require('uglifyjs-webpack-plugin')
+const HtmlWebpackPlugin = require('html-webpack-plugin')
+
+module.exports = {
+  devtool: 'source-map',
+  entry: [
+    './index.js'
+  ],
+  plugins: [
+    new UglifyJsPlugin({
+      sourceMap: true,
+      uglifyOptions: {
+        mangle: false,
+        compress: false
+      }
+    }),
+    new HtmlWebpackPlugin({
+      title: 'IPFS Videostream example',
+      template: 'index.html'
+    })
+  ],
+  output: {
+    path: path.join(__dirname, 'dist'),
+    filename: 'bundle.js'
+  }
+}
diff --git a/package.json b/package.json
index a9e8dde17c..47d861fa06 100644
--- a/package.json
+++ b/package.json
@@ -73,7 +73,7 @@
     "expose-loader": "^0.7.5",
     "form-data": "^2.3.2",
     "hat": "0.0.3",
-    "interface-ipfs-core": "^0.64.2",
+    "interface-ipfs-core": "~0.64.2",
     "ipfsd-ctl": "^0.32.1",
     "lodash": "^4.17.10",
     "mocha": "^5.1.1",
@@ -118,6 +118,7 @@
     "ipfs-unixfs-engine": "~0.29.0",
     "ipld": "^0.17.0",
     "is-ipfs": "^0.3.2",
+    "ipld-dag-pb": "~0.14.3",
     "is-pull-stream": "0.0.0",
     "is-stream": "^1.1.0",
     "joi": "^13.2.0",
@@ -138,6 +139,7 @@
     "libp2p-websockets": "~0.12.0",
     "lodash.flatmap": "^4.5.0",
     "lodash.get": "^4.4.2",
+    "lodash.set": "^4.3.2",
     "lodash.sortby": "^4.7.0",
     "lodash.values": "^4.3.0",
     "mafmt": "^6.0.0",
diff --git a/src/cli/commands/files/cat.js b/src/cli/commands/files/cat.js
index 43c22ceb21..f68d6badfa 100644
--- a/src/cli/commands/files/cat.js
+++ b/src/cli/commands/files/cat.js
@@ -5,7 +5,18 @@ module.exports = {
 
   describe: 'Fetch and cat an IPFS path referencing a file',
 
-  builder: {},
+  builder: {
+    offset: {
+      alias: 'o',
+      type: 'integer',
+      describe: 'Byte offset to begin reading from'
+    },
+    length: {
+      alias: ['n', 'count'],
+      type: 'integer',
+      describe: 'Maximum number of bytes to read'
+    }
+  },
 
   handler (argv) {
     let path = argv['ipfsPath']
@@ -13,7 +24,12 @@ module.exports = {
       path = path.replace('/ipfs/', '')
     }
 
-    const stream = argv.ipfs.files.catReadableStream(path)
+    const options = {
+      offset: argv.offset,
+      length: argv.length
+    }
+
+    const stream = argv.ipfs.files.catReadableStream(path, options)
 
     stream.once('error', (err) => {
       throw err
diff --git a/src/core/components/files.js b/src/core/components/files.js
index 1df23848a4..e223e26d13 100644
--- a/src/core/components/files.js
+++ b/src/core/components/files.js
@@ -145,7 +145,7 @@ module.exports = function files (self) {
     )
   }
 
-  function _catPullStream (ipfsPath) {
+  function _catPullStream (ipfsPath, options) {
     if (typeof ipfsPath === 'function') {
       throw new Error('You must supply an ipfsPath')
     }
@@ -158,7 +158,7 @@ module.exports = function files (self) {
     const d = deferred.source()
 
     pull(
-      exporter(ipfsPath, self._ipld),
+      exporter(ipfsPath, self._ipld, options),
       pull.collect((err, files) => {
         if (err) { return d.abort(err) }
         if (files && files.length > 1) {
@@ -185,9 +185,12 @@ module.exports = function files (self) {
     const recursive = options && options.recursive
     const pathDepth = path.split('/').length
     const maxDepth = recursive ? global.Infinity : pathDepth
+    const opts = Object.assign({}, {
+      maxDepth: maxDepth
+    }, options)
 
     return pull(
-      exporter(ipfsPath, self._ipld, { maxDepth: maxDepth }),
+      exporter(ipfsPath, self._ipld, opts),
       pull.filter(node =>
         recursive ? node.depth >= pathDepth : node.depth === pathDepth
       ),
@@ -270,9 +273,18 @@ module.exports = function files (self) {
 
     addPullStream: _addPullStream,
 
-    cat: promisify((ipfsPath, callback) => {
+    cat: promisify((ipfsPath, options, callback) => {
+      if (typeof options === 'function') {
+        callback = options
+        options = {}
+      }
+
+      if (typeof callback !== 'function') {
+        throw new Error('Please supply a callback to ipfs.files.cat')
+      }
+
       pull(
-        _catPullStream(ipfsPath),
+        _catPullStream(ipfsPath, options),
         pull.collect((err, buffers) => {
           if (err) { return callback(err) }
           callback(null, Buffer.concat(buffers))
@@ -280,13 +292,22 @@ module.exports = function files (self) {
       )
     }),
 
-    catReadableStream: (ipfsPath) => toStream.source(_catPullStream(ipfsPath)),
+    catReadableStream: (ipfsPath, options) => toStream.source(_catPullStream(ipfsPath, options)),
+
+    catPullStream: (ipfsPath, options) => _catPullStream(ipfsPath, options),
+
+    get: promisify((ipfsPath, options, callback) => {
+      if (typeof options === 'function') {
+        callback = options
+        options = {}
+      }
 
-    catPullStream: _catPullStream,
+      if (typeof callback !== 'function') {
+        throw new Error('Please supply a callback to ipfs.files.get')
+      }
 
-    get: promisify((ipfsPath, callback) => {
       pull(
-        exporter(ipfsPath, self._ipld),
+        exporter(ipfsPath, self._ipld, options),
         pull.asyncMap((file, cb) => {
           if (file.content) {
             pull(
@@ -305,10 +326,10 @@ module.exports = function files (self) {
       )
     }),
 
-    getReadableStream: (ipfsPath) => {
+    getReadableStream: (ipfsPath, options) => {
       return toStream.source(
         pull(
-          exporter(ipfsPath, self._ipld),
+          exporter(ipfsPath, self._ipld, options),
           pull.map((file) => {
             if (file.content) {
               file.content = toStream.source(file.content)
@@ -321,8 +342,8 @@ module.exports = function files (self) {
       )
     },
 
-    getPullStream: (ipfsPath) => {
-      return exporter(ipfsPath, self._ipld)
+    getPullStream: (ipfsPath, options) => {
+      return exporter(ipfsPath, self._ipld, options)
     },
 
     lsImmutable: promisify((ipfsPath, options, callback) => {
diff --git a/src/http/api/resources/files.js b/src/http/api/resources/files.js
index 672ebd2aa4..b62fb67aa1 100644
--- a/src/http/api/resources/files.js
+++ b/src/http/api/resources/files.js
@@ -17,6 +17,18 @@ const ndjson = require('pull-ndjson')
 
 exports = module.exports
 
+function numberFromQuery (query, key) {
+  if (query && query[key] !== undefined) {
+    const value = parseInt(query[key], 10)
+
+    if (isNaN(value)) {
+      return undefined
+    }
+
+    return value
+  }
+}
+
 // common pre request handler that parses the args and returns `key` which is assigned to `request.pre.args`
 exports.parseKey = (request, reply) => {
   if (!request.query.arg) {
@@ -47,7 +59,11 @@ exports.parseKey = (request, reply) => {
   }
 
   reply({
-    key: request.query.arg
+    key: request.query.arg,
+    options: {
+      offset: numberFromQuery(request.query, 'offset'),
+      length: numberFromQuery(request.query, 'length')
+    }
   })
 }
 
@@ -58,9 +74,10 @@ exports.cat = {
   // main route handler which is called after the above `parseArgs`, but only if the args were valid
   handler: (request, reply) => {
     const key = request.pre.args.key
+    const options = request.pre.args.options
     const ipfs = request.server.app.ipfs
 
-    ipfs.files.cat(key, (err, stream) => {
+    ipfs.files.cat(key, options, (err, stream) => {
       if (err) {
         log.error(err)
         if (err.message === 'No such file') {
diff --git a/test/cli/files.js b/test/cli/files.js
index be9a6d96a5..07b5421aa7 100644
--- a/test/cli/files.js
+++ b/test/cli/files.js
@@ -345,6 +345,24 @@ describe('files', () => runOnAndOff((thing) => {
       })
   })
 
+  it('cat part of a file using `count`', function () {
+    this.timeout(30 * 1000)
+
+    return ipfs('files cat QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB --offset 21 --count 5')
+      .then((out) => {
+        expect(out).to.eql(readme.substring(21, 26))
+      })
+  })
+
+  it('cat part of a file using `length`', function () {
+    this.timeout(30 * 1000)
+
+    return ipfs('files cat QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB --offset 21 --length 5')
+      .then((out) => {
+        expect(out).to.eql(readme.substring(21, 26))
+      })
+  })
+
   it('cat non-existent file', () => {
     return ipfs('cat QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB/dummy')
       .then(() => expect.fail(0, 1, 'Should have thrown an error'))
