How to send a “multipart/form-data” with requests in python?

StackOverflow

How to send a multipart/form-data with requests in python? How to send a file, I understand, but how to send the form data by this method can not understand.

Answer rating: 248

Basically, if you specify a files parameter (a dictionary), then requests will send a multipart/form-data POST instead of a application/x-www-form-urlencoded POST. You are not limited to using actual files in that dictionary, however:

>>> import requests
>>> response = requests.post("http://httpbin.org/post", files=dict(foo="bar"))
>>> response.status_code
200

and httpbin.org lets you know what headers you posted with; in response.json() we have:

>>> from pprint import pprint
>>> pprint(response.json()["headers"])
{"Accept": "*/*",
 "Accept-Encoding": "gzip, deflate",
 "Connection": "close",
 "Content-Length": "141",
 "Content-Type": "multipart/form-data; "
                 "boundary=c7cbfdd911b4e720f1dd8f479c50bc7f",
 "Host": "httpbin.org",
 "User-Agent": "python-requests/2.21.0"}

Better still, you can further control the filename, content type and additional headers for each part by using a tuple instead of a single string or bytes object. The tuple is expected to contain between 2 and 4 elements; the filename, the content, optionally a content type, and an optional dictionary of further headers.

I"d use the tuple form with None as the filename, so that the filename="..." parameter is dropped from the request for those parts:

>>> files = {"foo": "bar"}
>>> print(requests.Request("POST", "http://httpbin.org/post", files=files).prepare().body.decode("utf8"))
--bb3f05a247b43eede27a124ef8b968c5
Content-Disposition: form-data; name="foo"; filename="foo"

bar
--bb3f05a247b43eede27a124ef8b968c5--
>>> files = {"foo": (None, "bar")}
>>> print(requests.Request("POST", "http://httpbin.org/post", files=files).prepare().body.decode("utf8"))
--d5ca8c90a869c5ae31f70fa3ddb23c76
Content-Disposition: form-data; name="foo"

bar
--d5ca8c90a869c5ae31f70fa3ddb23c76--

files can also be a list of two-value tuples, if you need ordering and/or multiple fields with the same name:

requests.post(
    "http://requestb.in/xucj9exu",
    files=(
        ("foo", (None, "bar")),
        ("foo", (None, "baz")),
        ("spam", (None, "eggs")),
    )
)

If you specify both files and data, then it depends on the value of data what will be used to create the POST body. If data is a string, only it willl be used; otherwise both data and files are used, with the elements in data listed first.

There is also the excellent requests-toolbelt project, which includes advanced Multipart support. It takes field definitions in the same format as the files parameter, but unlike requests, it defaults to not setting a filename parameter. In addition, it can stream the request from open file objects, where requests will first construct the request body in memory:

from requests_toolbelt.multipart.encoder import MultipartEncoder

mp_encoder = MultipartEncoder(
    fields={
        "foo": "bar",
        # plain file object, no filename or mime type produces a
        # Content-Disposition header with just the part name
        "spam": ("spam.txt", open("spam.txt", "rb"), "text/plain"),
    }
)
r = requests.post(
    "http://httpbin.org/post",
    data=mp_encoder,  # The MultipartEncoder is posted as data, don"t use files=...!
    # The MultipartEncoder provides the content-type header with the boundary:
    headers={"Content-Type": mp_encoder.content_type}
)

Fields follow the same conventions; use a tuple with between 2 and 4 elements to add a filename, part mime-type or extra headers. Unlike the files parameter, no attempt is made to find a default filename value if you don"t use a tuple.

Answer rating: 94

You need to use the files parameter to send a multipart form POST request even when you do not need to upload any files.

From the original requests source:

def request(method, url, **kwargs):
    """Constructs and sends a :class:'Request <Request>'.

    ...
    :param files: (optional) Dictionary of ''"name": file-like-objects''
        (or ''{"name": file-tuple}'') for multipart encoding upload.
        ''file-tuple'' can be a 2-tuple ''("filename", fileobj)'',
        3-tuple ''("filename", fileobj, "content_type")''
        or a 4-tuple ''("filename", fileobj, "content_type", custom_headers)'',
        where ''"content-type"'' is a string
        defining the content type of the given file
        and ''custom_headers'' a dict-like object 
        containing additional headers to add for the file.

The relevant part is: file-tuple can be a2-tuple, 3-tupleor a4-tuple.

Based on the above, the simplest multipart form request that includes both files to upload and form fields will look like this:

multipart_form_data = {
    "file2": ("custom_file_name.zip", open("myfile.zip", "rb")),
    "action": (None, "store"),
    "path": (None, "/path1")
}

response = requests.post("https://httpbin.org/post", files=multipart_form_data)

print(response.content)

Note the None as the first argument in the tuple for plain text fields — this is a placeholder for the filename field which is only used for file uploads, but for text fields passing None as the first parameter is required in order for the data to be submitted.

Multiple fields with the same name

If you need to post multiple fields with the same name then instead of a dictionary you can define your payload as a list (or a tuple) of tuples:

multipart_form_data = (
    ("file2", ("custom_file_name.zip", open("myfile.zip", "rb"))),
    ("action", (None, "store")),
    ("path", (None, "/path1")),
    ("path", (None, "/path2")),
    ("path", (None, "/path3")),
)

Streaming requests API

If the above API is not pythonic enough for you, then consider using requests toolbelt (pip install requests_toolbelt) which is an extension of the core requests module that provides support for file upload streaming as well as the MultipartEncoder which can be used instead of files, and which also lets you define the payload as a dictionary, tuple or list.

MultipartEncoder can be used both for multipart requests with or without actual upload fields. It must be assigned to the data parameter.

import requests
from requests_toolbelt.multipart.encoder import MultipartEncoder

multipart_data = MultipartEncoder(
    fields={
            # a file upload field
            "file": ("file.zip", open("file.zip", "rb"), "text/plain")
            # plain text fields
            "field0": "value0", 
            "field1": "value1",
           }
    )

response = requests.post("http://httpbin.org/post", data=multipart_data,
                  headers={"Content-Type": multipart_data.content_type})

If you need to send multiple fields with the same name, or if the order of form fields is important, then a tuple or a list can be used instead of a dictionary:

multipart_data = MultipartEncoder(
    fields=(
            ("action", "ingest"), 
            ("item", "spam"),
            ("item", "sausage"),
            ("item", "eggs"),
           )
    )




Tutorials