diff --git a/README.md b/README.md
index 8c918ae..660acea 100644
--- a/README.md
+++ b/README.md
@@ -39,3 +39,101 @@ class UserRootValue(GraphQLView):
         return request.user
 
 ```
+
+### File upload support
+
+File uploads are supported via [multipart requests](https://github.com/jaydenseric/graphql-multipart-request-spec).
+
+You can simply define a ``FileUpload`` field in your schema, and use
+it to receive data from uploaded files.
+
+
+Example using ``graphql-core``:
+
+```python
+from collections import NamedTuple
+from graphql.type.definition import GraphQLScalarType
+
+
+GraphQLFileUpload = GraphQLScalarType(
+    name='FileUpload',
+    description='File upload',
+    serialize=lambda x: None,
+    parse_value=lambda value: value,
+    parse_literal=lambda node: None,
+)
+
+
+FileEchoResult = namedtuple('FileEchoResult', 'data,name,type')
+
+
+FileEchoResultSchema = GraphQLObjectType(
+    name='FileEchoResult,
+    fields={
+        'data': GraphQLField(GraphQLString),
+        'name': GraphQLField(GraphQLString),
+        'type': GraphQLField(GraphQLString),
+    }
+)
+
+
+def resolve_file_echo(obj, info, file):
+    data = file.stream.read().decode()
+    return FileEchoResult(
+        data=data,
+        name=file.filename,
+        type=file.content_type)
+
+
+MutationRootType = GraphQLObjectType(
+    name='MutationRoot',
+    fields={
+        # ...
+        'fileEcho': GraphQLField(
+            type=FileUploadTestResultSchema,
+            args={'file': GraphQLArgument(GraphQLFileUpload)},
+            resolver=resolve_file_echo,
+        ),
+        # ...
+    }
+)
+```
+
+
+Example using ``graphene``:
+
+```python
+import graphene
+
+class FileUpload(graphene.Scalar):
+
+    @staticmethod
+    def serialize(value):
+        return None
+
+    @staticmethod
+    def parse_literal(node):
+        return None
+
+    @staticmethod
+    def parse_value(value):
+        return value  # IMPORTANT
+
+
+class FileEcho(graphene.Mutation):
+
+    class Arguments:
+        myfile = FileUpload(required=True)
+
+    ok = graphene.Boolean()
+    name = graphene.String()
+    data = graphene.String()
+    type = graphene.String()
+
+    def mutate(self, info, myfile):
+        return FileEcho(
+            ok=True
+            name=myfile.filename
+            data=myfile.stream.read(),
+            type=myfile.content_type)
+```
diff --git a/flask_graphql/graphqlview.py b/flask_graphql/graphqlview.py
index ff257b3..d5c2271 100644
--- a/flask_graphql/graphqlview.py
+++ b/flask_graphql/graphqlview.py
@@ -135,9 +135,22 @@ def parse_body(self):
         elif content_type == 'application/json':
             return load_json_body(request.data.decode('utf8'))
 
-        elif content_type in ('application/x-www-form-urlencoded', 'multipart/form-data'):
+        elif content_type == 'application/x-www-form-urlencoded':
             return request.form
 
+        elif content_type == 'multipart/form-data':
+            # --------------------------------------------------------
+            # See spec: https://github.com/jaydenseric/graphql-multipart-request-spec
+            #
+            # When processing multipart/form-data, we need to take
+            # files (from "parts") and place them in the "operations"
+            # data structure (list or dict) according to the "map".
+            # --------------------------------------------------------
+            operations = load_json_body(request.form['operations'])
+            files_map = load_json_body(request.form['map'])
+            return place_files_in_operations(
+                operations, files_map, request.files)
+
         return {}
 
     def should_display_graphiql(self):
@@ -152,3 +165,80 @@ def request_wants_html(self):
         return best == 'text/html' and \
             request.accept_mimetypes[best] > \
             request.accept_mimetypes['application/json']
+
+
+def place_files_in_operations(operations, files_map, files):
+    """Place files from multipart reuqests inside operations.
+
+    Args:
+
+        operations:
+            Either a dict or a list of dicts, containing GraphQL
+            operations to be run.
+
+        files_map:
+            A dictionary defining the mapping of files into "paths"
+            inside the operations data structure.
+
+            Keys are file names from the "files" dict, values are
+            lists of dotted paths describing where files should be
+            placed.
+
+        files:
+            A dictionary mapping file names to FileStorage instances.
+
+    Returns:
+
+        A structure similar to operations, but with FileStorage
+        instances placed appropriately.
+    """
+
+    # operations: dict or list
+    # files_map: {filename: [path, path, ...]}
+    # files: {filename: FileStorage}
+
+    fmap = []
+    for key, values in files_map.items():
+        for val in values:
+            path = val.split('.')
+            fmap.append((path, key))
+
+    return _place_files_in_operations(operations, fmap, files)
+
+
+def _place_files_in_operations(ops, fmap, fobjs):
+    for path, fkey in fmap:
+        ops = _place_file_in_operations(ops, path, fobjs[fkey])
+    return ops
+
+
+def _place_file_in_operations(ops, path, obj):
+
+    if len(path) == 0:
+        return obj
+
+    if isinstance(ops, list):
+        key = int(path[0])
+        sub = _place_file_in_operations(ops[key], path[1:], obj)
+        return _insert_in_list(ops, key, sub)
+
+    if isinstance(ops, dict):
+        key = path[0]
+        sub = _place_file_in_operations(ops[key], path[1:], obj)
+        return _insert_in_dict(ops, key, sub)
+
+    raise TypeError('Expected ops to be list or dict')
+
+
+def _insert_in_dict(dct, key, val):
+    new_dict = dct.copy()
+    new_dict[key] = val
+    return new_dict
+
+
+def _insert_in_list(lst, key, val):
+    new_list = []
+    new_list.extend(lst[:key])
+    new_list.append(val)
+    new_list.extend(lst[key + 1:])
+    return new_list
diff --git a/tests/schema.py b/tests/schema.py
index f841672..893b7b1 100644
--- a/tests/schema.py
+++ b/tests/schema.py
@@ -1,4 +1,6 @@
-from graphql.type.definition import GraphQLArgument, GraphQLField, GraphQLNonNull, GraphQLObjectType
+from graphql.type.definition import (
+    GraphQLArgument, GraphQLField, GraphQLNonNull, GraphQLObjectType,
+    GraphQLScalarType)
 from graphql.type.scalars import GraphQLString
 from graphql.type.schema import GraphQLSchema
 
@@ -25,13 +27,58 @@ def resolve_raises(*_):
     }
 )
 
+
+FileUploadTestResult = GraphQLObjectType(
+    name='FileUploadTestResult',
+    fields={
+        'data': GraphQLField(GraphQLString),
+        'name': GraphQLField(GraphQLString),
+        'type': GraphQLField(GraphQLString),
+    }
+)
+
+GraphQLFileUpload = GraphQLScalarType(
+    name='FileUpload',
+    description='File upload',
+    serialize=lambda x: None,
+    parse_value=lambda value: value,
+    parse_literal=lambda node: None,
+)
+
+
+def to_object(dct):
+    class MyObject(object):
+        pass
+
+    obj = MyObject()
+    for key, val in dct.items():
+        setattr(obj, key, val)
+    return obj
+
+
+def resolve_file_upload_test(obj, info, file):
+    data = file.stream.read().decode()
+
+    # Need to return an object, not a dict
+    return to_object({
+        'data': data,
+        'name': file.filename,
+        'type': file.content_type,
+    })
+
+
 MutationRootType = GraphQLObjectType(
     name='MutationRoot',
     fields={
         'writeTest': GraphQLField(
             type=QueryRootType,
             resolver=lambda *_: QueryRootType
-        )
+        ),
+        'fileUploadTest': GraphQLField(
+            type=FileUploadTestResult,
+            args={'file': GraphQLArgument(GraphQLFileUpload)},
+            resolver=resolve_file_upload_test,
+        ),
     }
 )
 
diff --git a/tests/test_graphqlview.py b/tests/test_graphqlview.py
index 77626d4..f28f1c0 100644
--- a/tests/test_graphqlview.py
+++ b/tests/test_graphqlview.py
@@ -1,18 +1,26 @@
-import pytest
 import json
+from io import BytesIO
+
+import pytest
+
+from flask import url_for
+from flask_graphql.graphqlview import place_files_in_operations
+from werkzeug.test import EnvironBuilder
+
+from .app import create_app
 
 try:
     from StringIO import StringIO
 except ImportError:
     from io import StringIO
 
+
+
 try:
     from urllib import urlencode
 except ImportError:
     from urllib.parse import urlencode
 
-from .app import create_app
-from flask import url_for
 
 
 @pytest.fixture
@@ -465,18 +473,93 @@ def test_supports_pretty_printing(client):
 
 
 def test_post_multipart_data(client):
-    query = 'mutation TestMutation { writeTest { test } }'
+    query = """
+    mutation TestMutation($file: FileUpload!) {
+        fileUploadTest(file: $file) {
+            data, name, type
+        }
+    }
+    """
+
     response = client.post(
         url_string(),
-        data= {
-            'query': query,
-            'file': (StringIO(), 'text1.txt'),
-        },
-        content_type='multipart/form-data'
-    )
+        method='POST',
+        data={
+            # Form data
+            'operations': json.dumps({
+                'query': query,
+                'variables': {'file': None},
+            }),
+            'map': json.dumps({
+                '0': ['variables.file'],
+            }),
+            '0': (BytesIO(b'FILE-DATA-HERE'), 'hello.txt', 'text/plain'),
+        })
 
     assert response.status_code == 200
-    assert response_json(response) == {'data': {u'writeTest': {u'test': u'Hello World'}}}
+    assert response_json(response) == {
+        'data': {u'fileUploadTest': {
+            'data': u'FILE-DATA-HERE',
+            'name': 'hello.txt',
+            'type': 'text/plain',
+        }},
+    }
+
+
+def test_can_place_file_in_flat_variable():
+    operations = {
+        'variables': {'myfile': None},
+        "query": "QUERY",
+    }
+    files_map = {"0": ["variables.myfile"]}
+    files = {"0": "FILE-0-HERE"}
+
+    assert place_files_in_operations(operations, files_map, files) == {
+        'variables': {'myfile': "FILE-0-HERE"},
+        "query": "QUERY",
+    }
+
+
+def test_can_place_file_in_list_variable():
+    operations = {
+        'variables': {'myfile': [None]},
+        "query": "QUERY",
+    }
+    files_map = {"0": ["variables.myfile.0"]}
+    files = {"0": "FILE-0-HERE"}
+
+    assert place_files_in_operations(operations, files_map, files) == {
+        'variables': {'myfile': ["FILE-0-HERE"]},
+        "query": "QUERY",
+    }
+
+
+def test_can_place_file_in_flat_variable_in_ops_list():
+    operations = [{
+        'variables': {'myfile': None},
+        "query": "QUERY",
+    }]
+    files_map = {"0": ["0.variables.myfile"]}
+    files = {"0": "FILE-0-HERE"}
+
+    assert place_files_in_operations(operations, files_map, files) == [{
+        'variables': {'myfile': "FILE-0-HERE"},
+        "query": "QUERY",
+    }]
+
+
+def test_can_place_file_in_list_variable_in_ops_list():
+    operations = [{
+        'variables': {'myfile': [None]},
+        "query": "QUERY",
+    }]
+    files_map = {"0": ["0.variables.myfile.0"]}
+    files = {"0": "FILE-0-HERE"}
+
+    assert place_files_in_operations(operations, files_map, files) == [{
+        'variables': {'myfile': ["FILE-0-HERE"]},
+        "query": "QUERY",
+    }]
 
 
 @pytest.mark.parametrize('app', [create_app(batch=True)])
@@ -514,8 +597,8 @@ def test_batch_supports_post_json_query_with_json_variables(client):
         # 'id': 1,
         'data': {'test': "Hello Dolly"}
     }]
- 
-          
+
+
 @pytest.mark.parametrize('app', [create_app(batch=True)])
 def test_batch_allows_post_with_operation_name(client):
     response = client.post(