diff --git a/tests/zoomus/test_util.py b/tests/zoomus/test_util.py
index e8628ef..031d18f 100644
--- a/tests/zoomus/test_util.py
+++ b/tests/zoomus/test_util.py
@@ -86,6 +86,20 @@ def test_url_for_ignores_trailing_slash(self):
         client = util.ApiClient(base_uri="http://www.foo.com")
         self.assertEqual(client.url_for("bar/"), "http://www.foo.com/bar")
 
+    @responses.activate
+    def test_can_multiple_request_with_session(self):
+        responses.add(responses.GET, "http://www.foo.com/endpoint")
+        responses.add(responses.POST, "http://www.foo.com/endpoint")
+        responses.add(responses.PATCH, "http://www.foo.com/endpoint")
+        responses.add(responses.DELETE, "http://www.foo.com/endpoint")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.get_request("endpoint")
+            client.post_request("endpoint")
+            client.patch_request("endpoint")
+            client.delete_request("endpoint")
+
     @responses.activate
     def test_can_get_request(self):
         responses.add(responses.GET, "http://www.foo.com/endpoint")
@@ -94,6 +108,14 @@ def test_can_get_request(self):
         )
         client.get_request("endpoint")
 
+    @responses.activate
+    def test_can_get_request_with_session(self):
+        responses.add(responses.GET, "http://www.foo.com/endpoint")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.get_request("endpoint")
+
     @responses.activate
     def test_can_get_request_v2(self):
         responses.add(
@@ -119,6 +141,14 @@ def test_can_get_request_with_params(self):
         )
         client.get_request("endpoint", params={"foo": "bar"})
 
+    @responses.activate
+    def test_can_get_request_with_params_and_session(self):
+        responses.add(responses.GET, "http://www.foo.com/endpoint?foo=bar")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.get_request("endpoint", params={"foo": "bar"})
+
     @responses.activate
     def test_can_get_request_with_params_v2(self):
         responses.add(
@@ -146,6 +176,16 @@ def test_can_get_request_with_headers(self):
         )
         client.get_request("endpoint", headers={"foo": "bar"})
 
+    @responses.activate
+    def test_can_get_request_with_headers_and_session(self):
+        responses.add(
+            responses.GET, "http://www.foo.com/endpoint", headers={"foo": "bar"}
+        )
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.get_request("endpoint", headers={"foo": "bar"})
+
     @responses.activate
     def test_can_get_request_with_headers_v2(self):
         responses.add(
@@ -167,6 +207,15 @@ def test_can_post_request(self):
         )
         client.post_request("endpoint")
 
+    @responses.activate
+    def test_can_post_request(self):
+        responses.add(responses.POST, "http://www.foo.com/endpoint")
+
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.post_request("endpoint")
+
     @responses.activate
     def test_can_post_request_v2(self):
         responses.add(
@@ -195,6 +244,14 @@ def test_can_post_request_with_params(self):
         )
         client.post_request("endpoint", params={"foo": "bar"})
 
+    @responses.activate
+    def test_can_post_request_with_params_and_session(self):
+        responses.add(responses.POST, "http://www.foo.com/endpoint?foo=bar")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.post_request("endpoint", params={"foo": "bar"})
+
     @responses.activate
     def test_can_post_request_with_params_v2(self):
         responses.add(
@@ -221,6 +278,15 @@ def test_can_post_request_with_dict_data(self):
         client.post_request("endpoint", data={"foo": "bar"})
         self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}')
 
+    @responses.activate
+    def test_can_post_request_with_dict_data_and_session(self):
+        responses.add(responses.POST, "http://www.foo.com/endpoint")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.post_request("endpoint", data={"foo": "bar"})
+            self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}')
+
     @responses.activate
     def test_can_post_request_with_dict_data_v2(self):
         responses.add(
@@ -251,6 +317,15 @@ def test_can_post_request_with_json_data(self):
         client.post_request("endpoint", data=json.dumps({"foo": "bar"}))
         self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}')
 
+    @responses.activate
+    def test_can_post_request_with_json_data_and_session(self):
+        responses.add(responses.POST, "http://www.foo.com/endpoint")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.post_request("endpoint", data=json.dumps({"foo": "bar"}))
+            self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}')
+
     @responses.activate
     def test_can_post_request_with_json_data_v2(self):
         responses.add(
@@ -285,6 +360,19 @@ def test_can_post_request_with_headers(self):
             set(expected_headers.items()).issubset(set(actual_headers.items()))
         )
 
+    @responses.activate
+    def test_can_post_request_with_headers_and_session(self):
+        responses.add(responses.POST, "http://www.foo.com/endpoint")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.post_request("endpoint", headers={"foo": "bar"})
+            expected_headers = {"foo": "bar"}
+            actual_headers = responses.calls[0].request.headers
+            self.assertTrue(
+                set(expected_headers.items()).issubset(set(actual_headers.items()))
+            )
+
     @responses.activate
     def test_can_post_request_with_headers_v2(self):
         responses.add(
@@ -315,6 +403,19 @@ def test_can_post_request_with_cookies(self):
             set(expected_headers.items()).issubset(set(actual_headers.items()))
         )
 
+    @responses.activate
+    def test_can_post_request_with_cookies_and_session(self):
+        responses.add(responses.POST, "http://www.foo.com/endpoint")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.post_request("endpoint", cookies={"foo": "bar"})
+            expected_headers = {"Cookie": "foo=bar"}
+            actual_headers = responses.calls[0].request.headers
+            self.assertTrue(
+                set(expected_headers.items()).issubset(set(actual_headers.items()))
+            )
+
     @responses.activate
     def test_can_post_request_with_cookies_v2(self):
         responses.add(responses.POST, "http://www.foo.com/endpoint")
@@ -337,6 +438,14 @@ def test_can_patch_request(self):
         )
         client.patch_request("endpoint")
 
+    @responses.activate
+    def test_can_patch_request_with_session(self):
+        responses.add(responses.PATCH, "http://www.foo.com/endpoint")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.patch_request("endpoint")
+
     @responses.activate
     def test_can_patch_request_v2(self):
         responses.add(
@@ -364,6 +473,14 @@ def test_can_patch_request_with_params(self):
         )
         client.patch_request("endpoint", params={"foo": "bar"})
 
+    @responses.activate
+    def test_can_patch_request_with_params_and_session(self):
+        responses.add(responses.PATCH, "http://www.foo.com/endpoint?foo=bar")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.patch_request("endpoint", params={"foo": "bar"})
+
     @responses.activate
     def test_can_patch_request_with_params_v2(self):
         responses.add(
@@ -392,6 +509,15 @@ def test_can_patch_request_with_dict_data(self):
         client.patch_request("endpoint", data={"foo": "bar"})
         self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}')
 
+    @responses.activate
+    def test_can_patch_request_with_dict_data_and_session(self):
+        responses.add(responses.PATCH, "http://www.foo.com/endpoint")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.patch_request("endpoint", data={"foo": "bar"})
+            self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}')
+
     @responses.activate
     def test_can_patch_request_with_dict_data_v2(self):
         responses.add(
@@ -421,6 +547,15 @@ def test_can_patch_request_with_json_data(self):
         client.patch_request("endpoint", data=json.dumps({"foo": "bar"}))
         self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}')
 
+    @responses.activate
+    def test_can_patch_request_with_json_data_and_session(self):
+        responses.add(responses.PATCH, "http://www.foo.com/endpoint")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.patch_request("endpoint", data=json.dumps({"foo": "bar"}))
+            self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}')
+
     @responses.activate
     def test_can_patch_request_with_json_data_v2(self):
         responses.add(
@@ -454,6 +589,19 @@ def test_can_patch_request_with_headers(self):
             set(expected_headers.items()).issubset(set(actual_headers.items()))
         )
 
+    @responses.activate
+    def test_can_patch_request_with_headers_and_session(self):
+        responses.add(responses.PATCH, "http://www.foo.com/endpoint")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.patch_request("endpoint", headers={"foo": "bar"})
+            expected_headers = {"foo": "bar"}
+            actual_headers = responses.calls[0].request.headers
+            self.assertTrue(
+                set(expected_headers.items()).issubset(set(actual_headers.items()))
+            )
+
     @responses.activate
     def test_can_patch_request_with_headers_v2(self):
         responses.add(responses.PATCH, "http://www.foo.com/endpoint")
@@ -481,6 +629,19 @@ def test_can_patch_request_with_cookies(self):
             set(expected_headers.items()).issubset(set(actual_headers.items()))
         )
 
+    @responses.activate
+    def test_can_patch_request_with_cookies_and_session(self):
+        responses.add(responses.PATCH, "http://www.foo.com/endpoint")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.patch_request("endpoint", cookies={"foo": "bar"})
+            expected_headers = {"Cookie": "foo=bar"}
+            actual_headers = responses.calls[0].request.headers
+            self.assertTrue(
+                set(expected_headers.items()).issubset(set(actual_headers.items()))
+            )
+
     @responses.activate
     def test_can_patch_request_with_cookies_v2(self):
         responses.add(responses.PATCH, "http://www.foo.com/endpoint")
@@ -503,6 +664,14 @@ def test_can_delete_request(self):
         )
         client.delete_request("endpoint")
 
+    @responses.activate
+    def test_can_delete_request_with_session(self):
+        responses.add(responses.DELETE, "http://www.foo.com/endpoint")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.delete_request("endpoint")
+
     @responses.activate
     def test_can_delete_request_v2(self):
         responses.add(
@@ -531,6 +700,14 @@ def test_can_delete_request_with_params(self):
 
         client.delete_request("endpoint", params={"foo": "bar"})
 
+    @responses.activate
+    def test_can_delete_request_with_params_and_session(self):
+        responses.add(responses.DELETE, "http://www.foo.com/endpoint?foo=bar")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.delete_request("endpoint", params={"foo": "bar"})
+
     @responses.activate
     def test_can_delete_request_with_params_v2(self):
         responses.add(responses.DELETE, "http://www.foo.com/endpoint?foo=bar")
@@ -556,6 +733,15 @@ def test_can_delete_request_with_dict_data(self):
         client.delete_request("endpoint", data={"foo": "bar"})
         self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}')
 
+    @responses.activate
+    def test_can_delete_request_with_dict_data_and_session(self):
+        responses.add(responses.DELETE, "http://www.foo.com/endpoint")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.delete_request("endpoint", data={"foo": "bar"})
+            self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}')
+
     @responses.activate
     def test_can_delete_request_with_dict_data_v2(self):
         responses.add(
@@ -585,6 +771,15 @@ def test_can_delete_request_with_json_data(self):
         client.delete_request("endpoint", data=json.dumps({"foo": "bar"}))
         self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}')
 
+    @responses.activate
+    def test_can_delete_request_with_json_data_and_session(self):
+        responses.add(responses.DELETE, "http://www.foo.com/endpoint")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.delete_request("endpoint", data=json.dumps({"foo": "bar"}))
+            self.assertEqual(responses.calls[0].request.body, '{"foo": "bar"}')
+
     @responses.activate
     def test_can_delete_request_with_json_data_v2(self):
         responses.add(
@@ -615,6 +810,16 @@ def test_can_delete_request_with_headers(self):
         )
         client.delete_request("endpoint", headers={"foo": "bar"})
 
+    @responses.activate
+    def test_can_delete_request_with_headers_and_session(self):
+        responses.add(
+            responses.DELETE, "http://www.foo.com/endpoint", headers={"foo": "bar"}
+        )
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.delete_request("endpoint", headers={"foo": "bar"})
+
     @responses.activate
     def test_can_delete_request_with_headers_v2(self):
         responses.add(responses.DELETE, "http://www.foo.com/endpoint")
@@ -644,6 +849,19 @@ def test_can_delete_request_with_cookies(self):
             set(expected_headers.items()).issubset(set(actual_headers.items()))
         )
 
+    @responses.activate
+    def test_can_delete_request_with_cookies_and_session(self):
+        responses.add(responses.DELETE, "http://www.foo.com/endpoint")
+        with util.ApiClient(
+            base_uri="http://www.foo.com", config={"version": util.API_VERSION_1}
+        ) as client:
+            client.delete_request("endpoint", cookies={"foo": "bar"})
+            expected_headers = {"Cookie": "foo=bar"}
+            actual_headers = responses.calls[0].request.headers
+            self.assertTrue(
+                set(expected_headers.items()).issubset(set(actual_headers.items()))
+            )
+
     @responses.activate
     def test_can_delete_request_with_cookies_v2(self):
         responses.add(responses.DELETE, "http://www.foo.com/endpoint")
diff --git a/zoomus/util.py b/zoomus/util.py
index c1265d5..7cff073 100644
--- a/zoomus/util.py
+++ b/zoomus/util.py
@@ -30,6 +30,7 @@ def __init__(self, base_uri=None, timeout=15, **kwargs):
         self.timeout = timeout
         for k, v in kwargs.items():
             setattr(self, k, v)
+        self._session = None
 
     @property
     def timeout(self):
@@ -58,6 +59,29 @@ def base_uri(self, value):
             value = value[:-1]
         self._base_uri = value
 
+    @property
+    def session(self):
+        """Provide a session if one is in use; otherwise, provide the requests module directly."""
+        if self._session is not None:
+            return self._session
+        return requests
+
+    @session.setter
+    def session(self, val):
+        self._session = val
+
+    @session.deleter
+    def session(self):
+        self._session = None
+
+    def __enter__(self):
+        self.session = requests.Session()
+        return self
+
+    def __exit__(self, *args):
+        self.session.close()
+        self.session = None
+
     def url_for(self, endpoint):
         """Get the URL for the given endpoint
 
@@ -80,7 +104,7 @@ def get_request(self, endpoint, params=None, headers=None):
         """
         if headers is None and self.config.get("version") == API_VERSION_2:
             headers = {"Authorization": "Bearer {}".format(self.config.get("token"))}
-        return requests.get(
+        return self.session.get(
             self.url_for(endpoint), params=params, headers=headers, timeout=self.timeout
         )
 
@@ -104,7 +128,7 @@ def post_request(
                 "Authorization": "Bearer {}".format(self.config.get("token")),
                 "Content-Type": "application/json",
             }
-        return requests.post(
+        return self.session.post(
             self.url_for(endpoint),
             params=params,
             data=data,
@@ -133,7 +157,7 @@ def patch_request(
                 "Authorization": "Bearer {}".format(self.config.get("token")),
                 "Content-Type": "application/json",
             }
-        return requests.patch(
+        return self.session.patch(
             self.url_for(endpoint),
             params=params,
             data=data,
@@ -158,11 +182,8 @@ def delete_request(
         if data and not is_str_type(data):
             data = json.dumps(data)
         if headers is None and self.config.get("version") == API_VERSION_2:
-            headers = {
-                "Authorization": "Bearer {}".format(self.config.get("token")),
-                "Content-Type": "application/json",
-            }
-        return requests.delete(
+            headers = {"Authorization": "Bearer {}".format(self.config.get("token"))}
+        return self.session.delete(
             self.url_for(endpoint),
             params=params,
             data=data,
@@ -185,11 +206,8 @@ def put_request(self, endpoint, params=None, data=None, headers=None, cookies=No
         if data and not is_str_type(data):
             data = json.dumps(data)
         if headers is None and self.config.get("version") == API_VERSION_2:
-            headers = {
-                "Authorization": "Bearer {}".format(self.config.get("token")),
-                "Content-Type": "application/json",
-            }
-        return requests.put(
+            headers = {"Authorization": "Bearer {}".format(self.config.get("token"))}
+        return self.session.put(
             self.url_for(endpoint),
             params=params,
             data=data,