diff --git a/hosts/ureq/examples/azure_get.rs b/hosts/ureq/examples/azure_get.rs
index e1a5397..1670c7a 100644
--- a/hosts/ureq/examples/azure_get.rs
+++ b/hosts/ureq/examples/azure_get.rs
@@ -3,6 +3,7 @@
 use std::env;
 use std::io::Write;
 
+use borink_object_storage_proto::ListOptions;
 use borink_object_storage_proto::azure::Container;
 use borink_object_storage_ureq::azure;
 
@@ -12,6 +13,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let token = env::var("AZURE_STORAGE_ACCESS_TOKEN")?;
     let key = env::args().nth(1).ok_or("missing object key")?;
     let container = Container::new(&endpoint, &container)?;
-    std::io::stdout().write_all(&azure::get(&container, &token, &key)?)?;
+    let mut blobs = azure::Blobs::new(&container, &token, &ListOptions::default())?;
+    std::io::stdout().write_all(&blobs.get(&key)?)?;
     Ok(())
 }
diff --git a/hosts/ureq/examples/azure_list.rs b/hosts/ureq/examples/azure_list.rs
index e90e759..9260dc4 100644
--- a/hosts/ureq/examples/azure_list.rs
+++ b/hosts/ureq/examples/azure_list.rs
@@ -2,9 +2,8 @@
 
 use std::env;
 
-use borink_object_storage_proto::azure as proto;
-use borink_object_storage_proto::azure::{AzureNamespace, Container};
-use borink_object_storage_proto::{Error, ListEntry, ListItem, ListMarker, ListOptions};
+use borink_object_storage_proto::azure::Container;
+use borink_object_storage_proto::{ListEntry, ListItem, ListMarker, ListOptions};
 use borink_object_storage_ureq::azure;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -14,21 +13,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let prefix = env::args().nth(1).unwrap_or_default();
     let container = Container::new(&endpoint, &container)?;
 
-    // Every page shares the template: an empty buffer is refused with the
-    // size it needs.
+    // Every page shares the client's list template.
     let options = ListOptions {
         max_results: Some(1000),
         ..ListOptions::default()
     };
-    let prepare = |buf: &mut [u8]| {
-        proto::prepare_list(&container, &token, AzureNamespace::Unknown, &options, buf)
-    };
-    let size = match prepare(&mut []) {
-        Err(Error::Capacity(capacity)) => capacity.required,
-        other => return Err(format!("{other:?}").into()),
-    };
-    let mut bytes = vec![0; size];
-    let template = prepare(&mut bytes)?;
+    let mut blobs = azure::Blobs::new(&container, &token, &options)?;
 
     let mut marker: Option<String> = None;
     let mut body = Vec::new();
@@ -41,7 +31,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             marker: marker.as_deref().map(ListMarker::Text),
             ..ListItem::new(&prefix)
         };
-        let page = azure::list(&template, &bytes, &item, &mut body, &mut entries)?;
+        let page = blobs.list(&item, &mut body, &mut entries)?;
         for entry in &entries[..page.filled] {
             println!("{}", entry.key);
         }
diff --git a/hosts/ureq/examples/s3_get.rs b/hosts/ureq/examples/s3_get.rs
index 06d232f..c0e360e 100644
--- a/hosts/ureq/examples/s3_get.rs
+++ b/hosts/ureq/examples/s3_get.rs
@@ -5,6 +5,7 @@
 use std::env;
 use std::io::Write;
 
+use borink_object_storage_proto::ListOptions;
 use borink_object_storage_proto::s3::{Bucket, Service};
 use borink_object_storage_proto::sigv4::Credentials;
 use borink_object_storage_ureq::s3;
@@ -27,6 +28,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     if let Some(token) = &session_token {
         credentials = credentials.with_session_token(token)?;
     }
-    std::io::stdout().write_all(&s3::get(&bucket, &credentials, &key)?)?;
+    let mut objects = s3::Objects::new(&bucket, credentials, &ListOptions::default())?;
+    std::io::stdout().write_all(&objects.get(&key)?)?;
     Ok(())
 }
diff --git a/hosts/ureq/examples/s3_list.rs b/hosts/ureq/examples/s3_list.rs
index 39726d5..abfb576 100644
--- a/hosts/ureq/examples/s3_list.rs
+++ b/hosts/ureq/examples/s3_list.rs
@@ -4,9 +4,9 @@
 
 use std::env;
 
-use borink_object_storage_proto::s3::{self as proto, Bucket, Service};
+use borink_object_storage_proto::s3::{Bucket, Service};
 use borink_object_storage_proto::sigv4::Credentials;
-use borink_object_storage_proto::{Error, ListEntry, ListItem, ListMarker, ListOptions};
+use borink_object_storage_proto::{ListEntry, ListItem, ListMarker, ListOptions};
 use borink_object_storage_ureq::s3;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -28,19 +28,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         credentials = credentials.with_session_token(token)?;
     }
 
-    // Every page shares the template: an empty buffer is refused with the
-    // size it needs.
+    // Every page shares the client's list template.
     let options = ListOptions {
         max_results: Some(1000),
         ..ListOptions::default()
     };
-    let prepare = |buf: &mut [u8]| proto::prepare_list(&bucket, &credentials, &options, buf);
-    let size = match prepare(&mut []) {
-        Err(Error::Capacity(capacity)) => capacity.required,
-        other => return Err(format!("{other:?}").into()),
-    };
-    let mut bytes = vec![0; size];
-    let template = prepare(&mut bytes)?;
+    let mut objects = s3::Objects::new(&bucket, credentials, &options)?;
 
     let mut marker: Option<String> = None;
     let mut body = Vec::new();
@@ -52,14 +45,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             marker: marker.as_deref().map(ListMarker::Text),
             ..ListItem::new(&prefix)
         };
-        let page = s3::list(
-            &template,
-            &bytes,
-            &credentials,
-            &item,
-            &mut body,
-            &mut entries,
-        )?;
+        let page = objects.list(&item, &mut body, &mut entries)?;
         for entry in &entries[..page.filled] {
             println!("{}", entry.key);
         }
diff --git a/hosts/ureq/src/azure.rs b/hosts/ureq/src/azure.rs
index ff192c1..4bb74d9 100644
--- a/hosts/ureq/src/azure.rs
+++ b/hosts/ureq/src/azure.rs
@@ -3,43 +3,177 @@
 use borink_object_storage_proto::azure::{self, Template};
 use borink_object_storage_proto::azure::{AzureNamespace, Container};
 use borink_object_storage_proto::{
-    CapacityError, DeleteHeadOutcome, DeleteOptions, GetHeadOutcome, GetItem, GetOptions,
-    ListEntry, ListHeadOutcome, ListItem, Listing, ObjectItem, Payload, PutHeadOutcome, PutItem,
+    DeleteHeadOutcome, DeleteOptions, Error, GetHeadOutcome, GetItem, GetOptions, ListEntry,
+    ListHeadOutcome, ListItem, ListOptions, Listing, ObjectItem, Payload, PutHeadOutcome, PutItem,
     PutOptions,
 };
 
-/// Builds and executes one GET request, returning an owned response body.
+use crate::Prepared;
+
+/// A client of one Azure container, with one bearer token.
 ///
-/// The template is written for this one read. A host that reads many
-/// objects writes it once and keeps it.
-pub fn get(
-    container: &Container<'_>,
-    token: &str,
-    key: &str,
-) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
-    let now = crate::now()?;
-    let options = GetOptions::new();
-    let prepare = |buf: &mut [u8]| {
-        azure::prepare_get(container, token, AzureNamespace::Unknown, &options, buf)
-    };
-    let (template, bytes) = crate::sized_template(prepare)?;
-    let item = GetItem::new(key);
-    let encode = |buf: &mut [u8]| azure::encode_get(&template, &bytes, &item, &now, buf).map(drop);
-    let mut buf = vec![0; CapacityError::required_by(encode)?];
-    let request = azure::encode_get(&template, &bytes, &item, &now, &mut buf)?;
-
-    let (parts, mut body) = crate::send(&request, None)?;
-    let shape = item.shape(&options);
-    match azure::accept_get_head(shape, crate::response_head(&parts))? {
-        GetHeadOutcome::Body { .. } => body.read_to_vec().map_err(Into::into),
-        GetHeadOutcome::Complete { .. } => Ok(Vec::new()),
-        // Azure named no error in the head, so the body names it.
-        GetHeadOutcome::NeedErrorBody(failure) => Err(no_object(azure::accept_get_error_body(
-            shape,
-            failure,
-            &crate::error_body(&mut body),
-        ))),
-        outcome => Err(no_object(outcome)),
+/// It writes the template of each kind of request once, when it is made,
+/// and writes every request into one buffer that it keeps. Once that buffer
+/// has grown to fit the longest request, each request is written once. It
+/// sends with one `ureq` agent, which keeps its connections.
+pub struct Blobs {
+    get: Prepared<Template>,
+    put: Prepared<Template>,
+    delete: Prepared<Template>,
+    list: Prepared<Template>,
+    buf: Vec<u8>,
+    agent: ureq::Agent,
+}
+
+impl Blobs {
+    /// A client of `container` that sends `token`, and lists as `list`
+    /// says.
+    ///
+    /// # Errors
+    ///
+    /// Returns the error of a template that the crate refuses to write.
+    pub fn new(
+        container: &Container<'_>,
+        token: &str,
+        list: &ListOptions<'_>,
+    ) -> Result<Self, Error> {
+        let namespace = AzureNamespace::Unknown;
+        Ok(Self {
+            get: Prepared::new(|buf| {
+                azure::prepare_get(container, token, namespace, &GetOptions::new(), buf)
+            })?,
+            put: Prepared::new(|buf| {
+                azure::prepare_put(container, token, namespace, &PutOptions::default(), buf)
+            })?,
+            delete: Prepared::new(|buf| {
+                azure::prepare_delete(container, token, namespace, &DeleteOptions::new(), buf)
+            })?,
+            list: Prepared::new(|buf| azure::prepare_list(container, token, namespace, list, buf))?,
+            buf: Vec::new(),
+            agent: crate::new_agent(),
+        })
+    }
+
+    /// Gets the object `key`, and returns its bytes.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the request could not be sent, or if Azure
+    /// returned no object.
+    pub fn get(&mut self, key: &str) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
+        let now = crate::now()?;
+        let item = GetItem::new(key);
+        let Prepared { template, bytes } = &self.get;
+        let placed = crate::grown_to_fit(&mut self.buf, |buf| {
+            azure::encode_get(template, bytes, &item, &now, buf).map(|request| request.placement())
+        })?;
+
+        let (parts, mut body) = crate::send(&self.agent, &placed.request(&self.buf), None)?;
+        let shape = item.shape(&GetOptions::new());
+        match azure::accept_get_head(shape, crate::response_head(&parts))? {
+            GetHeadOutcome::Body { .. } => body.read_to_vec().map_err(Into::into),
+            GetHeadOutcome::Complete { .. } => Ok(Vec::new()),
+            // Azure named no error in the head, so the body names it.
+            GetHeadOutcome::NeedErrorBody(failure) => Err(no_object(azure::accept_get_error_body(
+                shape,
+                failure,
+                &crate::error_body(&mut body),
+            ))),
+            outcome => Err(no_object(outcome)),
+        }
+    }
+
+    /// Puts `content` as the whole object `key`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the request could not be sent, or if Azure
+    /// stored no object.
+    pub fn put(&mut self, key: &str, content: &[u8]) -> Result<(), Box<dyn std::error::Error>> {
+        let now = crate::now()?;
+        let item = PutItem::new(key, Payload::Slice(content));
+        let Prepared { template, bytes } = &self.put;
+        let placed = crate::grown_to_fit(&mut self.buf, |buf| {
+            azure::encode_put(template, bytes, &item, &now, buf).map(|request| request.placement())
+        })?;
+
+        let request = placed.request(&self.buf);
+        let (parts, mut body) = crate::send(&self.agent, &request, Some(content))?;
+        let shape = item.shape(&PutOptions::default());
+        match azure::accept_put_head(shape, crate::response_head(&parts))? {
+            PutHeadOutcome::Created { .. } => Ok(()),
+            PutHeadOutcome::NeedErrorBody(failure) => Err(not_stored(
+                azure::accept_put_error_body(shape, failure, &crate::error_body(&mut body)),
+            )),
+            outcome => Err(not_stored(outcome)),
+        }
+    }
+
+    /// Deletes the whole object `key`.
+    ///
+    /// Reports a missing object rather than treating it as success: only the
+    /// caller knows whether it meant to remove an object that is already
+    /// gone.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the request could not be sent, or if Azure
+    /// removed no object.
+    pub fn delete(&mut self, key: &str) -> Result<(), Box<dyn std::error::Error>> {
+        let now = crate::now()?;
+        let item = ObjectItem::new(key);
+        let Prepared { template, bytes } = &self.delete;
+        let placed = crate::grown_to_fit(&mut self.buf, |buf| {
+            azure::encode_delete(template, bytes, &item, &now, buf)
+                .map(|request| request.placement())
+        })?;
+
+        let (parts, mut body) = crate::send(&self.agent, &placed.request(&self.buf), None)?;
+        let shape = DeleteOptions::new().shape();
+        match azure::accept_delete_head(shape, crate::response_head(&parts))? {
+            DeleteHeadOutcome::Accepted => Ok(()),
+            DeleteHeadOutcome::NeedErrorBody(failure) => Err(not_removed(
+                azure::accept_delete_error_body(shape, failure, &crate::error_body(&mut body)),
+            )),
+            outcome => Err(not_removed(outcome)),
+        }
+    }
+
+    /// Lists one page, and reads it into `body`.
+    ///
+    /// The entries this writes into `into` borrow `body`. An array of the
+    /// `max_results` of the client's list options always holds a whole page.
+    /// A smaller one is refused with the number of entries the page holds.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the request could not be sent, or if Azure listed
+    /// nothing.
+    pub fn list<'b>(
+        &mut self,
+        item: &ListItem<'_>,
+        body: &'b mut Vec<u8>,
+        into: &mut [ListEntry<'b>],
+    ) -> Result<Listing<'b>, Box<dyn std::error::Error>> {
+        let now = crate::now()?;
+        let Prepared { template, bytes } = &self.list;
+        let placed = crate::grown_to_fit(&mut self.buf, |buf| {
+            azure::encode_list(template, bytes, item, &now, buf).map(|request| request.placement())
+        })?;
+
+        let (parts, mut incoming) = crate::send(&self.agent, &placed.request(&self.buf), None)?;
+        match azure::accept_list_head(crate::response_head(&parts))? {
+            ListHeadOutcome::Page { .. } => {
+                // The whole page, in one buffer. The entries point into it,
+                // and reading it decodes the text where it stands.
+                *body = crate::page_body(&mut incoming)?;
+                azure::fill_listing(body, into).map_err(Into::into)
+            }
+            ListHeadOutcome::NeedErrorBody(failure) => Err(not_listed(
+                azure::accept_list_error_body(failure, &crate::error_body(&mut incoming)),
+            )),
+            outcome => Err(not_listed(outcome)),
+        }
     }
 }
 
@@ -47,118 +181,14 @@ fn no_object(outcome: GetHeadOutcome<'_>) -> Box<dyn std::error::Error> {
     format!("Azure returned no object: {outcome}").into()
 }
 
-/// Builds and executes one PUT request, storing `content` as the whole object.
-pub fn put(
-    container: &Container<'_>,
-    token: &str,
-    key: &str,
-    content: &[u8],
-) -> Result<(), Box<dyn std::error::Error>> {
-    let now = crate::now()?;
-    let options = PutOptions::default();
-    let prepare = |buf: &mut [u8]| {
-        azure::prepare_put(container, token, AzureNamespace::Unknown, &options, buf)
-    };
-    let (template, bytes) = crate::sized_template(prepare)?;
-    let item = PutItem::new(key, Payload::Slice(content));
-    let encode = |buf: &mut [u8]| azure::encode_put(&template, &bytes, &item, &now, buf).map(drop);
-    let mut buf = vec![0; CapacityError::required_by(encode)?];
-    let request = azure::encode_put(&template, &bytes, &item, &now, &mut buf)?;
-
-    let (parts, mut body) = crate::send(&request, None)?;
-    let shape = item.shape(&options);
-    match azure::accept_put_head(shape, crate::response_head(&parts))? {
-        PutHeadOutcome::Created { .. } => Ok(()),
-        PutHeadOutcome::NeedErrorBody(failure) => Err(not_stored(azure::accept_put_error_body(
-            shape,
-            failure,
-            &crate::error_body(&mut body),
-        ))),
-        outcome => Err(not_stored(outcome)),
-    }
-}
-
 fn not_stored(outcome: PutHeadOutcome<'_>) -> Box<dyn std::error::Error> {
     format!("Azure stored no object: {outcome}").into()
 }
 
-/// Builds and executes one DELETE request, removing the whole object.
-///
-/// Reports a missing object rather than treating it as success: only the
-/// caller knows whether it meant to remove an object that is already gone.
-pub fn delete(
-    container: &Container<'_>,
-    token: &str,
-    key: &str,
-) -> Result<(), Box<dyn std::error::Error>> {
-    let now = crate::now()?;
-    let options = DeleteOptions::new();
-    let prepare = |buf: &mut [u8]| {
-        azure::prepare_delete(container, token, AzureNamespace::Unknown, &options, buf)
-    };
-    let (template, bytes) = crate::sized_template(prepare)?;
-    let item = ObjectItem::new(key);
-    let encode =
-        |buf: &mut [u8]| azure::encode_delete(&template, &bytes, &item, &now, buf).map(drop);
-    let mut buf = vec![0; CapacityError::required_by(encode)?];
-    let request = azure::encode_delete(&template, &bytes, &item, &now, &mut buf)?;
-
-    let (parts, mut body) = crate::send(&request, None)?;
-    let shape = options.shape();
-    match azure::accept_delete_head(shape, crate::response_head(&parts))? {
-        DeleteHeadOutcome::Accepted => Ok(()),
-        DeleteHeadOutcome::NeedErrorBody(failure) => Err(not_removed(
-            azure::accept_delete_error_body(shape, failure, &crate::error_body(&mut body)),
-        )),
-        outcome => Err(not_removed(outcome)),
-    }
-}
-
 fn not_removed(outcome: DeleteHeadOutcome<'_>) -> Box<dyn std::error::Error> {
     format!("Azure removed no object: {outcome}").into()
 }
 
-/// Builds and executes one listing request from `template`, and reads the
-/// page it answered.
-///
-/// Write the template once with `azure::prepare_list` and pass it, with its
-/// bytes, for every page. This function reads the page into `body`, and
-/// the entries it writes into `into` borrow those bytes. An array of
-/// `max_results` entries always holds a whole page. A smaller one is
-/// refused with the number of entries the page holds.
-///
-/// # Errors
-///
-/// Returns an error if the request could not be sent, or if Azure listed
-/// nothing.
-pub fn list<'b>(
-    template: &Template,
-    bytes: &[u8],
-    item: &ListItem<'_>,
-    body: &'b mut Vec<u8>,
-    into: &mut [ListEntry<'b>],
-) -> Result<Listing<'b>, Box<dyn std::error::Error>> {
-    let now = crate::now()?;
-    let encode = |buf: &mut [u8]| azure::encode_list(template, bytes, item, &now, buf).map(drop);
-    let mut buf = vec![0; CapacityError::required_by(encode)?];
-    let request = azure::encode_list(template, bytes, item, &now, &mut buf)?;
-
-    let (parts, mut incoming) = crate::send(&request, None)?;
-    match azure::accept_list_head(crate::response_head(&parts))? {
-        ListHeadOutcome::Page { .. } => {
-            // The whole page, in one buffer. The entries point into it, and
-            // reading it decodes the text where it stands.
-            *body = crate::page_body(&mut incoming)?;
-            azure::fill_listing(body, into).map_err(Into::into)
-        }
-        ListHeadOutcome::NeedErrorBody(failure) => Err(not_listed(azure::accept_list_error_body(
-            failure,
-            &crate::error_body(&mut incoming),
-        ))),
-        outcome => Err(not_listed(outcome)),
-    }
-}
-
 fn not_listed(outcome: ListHeadOutcome<'_>) -> Box<dyn std::error::Error> {
     format!("Azure listed no keys: {outcome}").into()
 }
diff --git a/hosts/ureq/src/lib.rs b/hosts/ureq/src/lib.rs
index 5dde1c7..5a9f716 100644
--- a/hosts/ureq/src/lib.rs
+++ b/hosts/ureq/src/lib.rs
@@ -1,8 +1,9 @@
 //! A synchronous `ureq` host for `borink-object-storage`.
 //!
-//! [`azure`] sends Azure requests, and [`s3`] sends S3 requests that it
-//! signs. Each module gets, puts, deletes and lists in the same way, from
-//! templates.
+//! [`azure::Blobs`] sends Azure requests, and [`s3::Objects`] sends S3
+//! requests that it signs. Each gets, puts, deletes and lists in the same
+//! way: it writes the template of each kind of request once, when it is
+//! made, and writes every request into one buffer that it keeps.
 
 pub mod azure;
 pub mod s3;
@@ -15,30 +16,66 @@ const MAX_PAGE: u64 = 8 * 1024 * 1024;
 
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use borink_object_storage_proto::{
-    CapacityError, Error, Payload, ResponseHead, Timestamps, WireRequest,
-};
+use borink_object_storage_proto::{Error, Payload, ResponseHead, Timestamps, WireRequest};
 
 // The current time, which the crate never reads itself.
 pub(crate) fn now() -> Result<Timestamps, Box<dyn std::error::Error>> {
-    let unix = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs();
-    Ok(Timestamps::from_unix(unix))
+    Ok(Timestamps::from_unix(unix_now()?))
 }
 
-// Writes a template with `prepare` into a buffer of exactly its size, and
-// returns both.
-pub(crate) fn sized_template<T>(
-    prepare: impl Fn(&mut [u8]) -> Result<T, Error>,
-) -> Result<(T, Vec<u8>), Error> {
-    let mut bytes = vec![0; CapacityError::required_by(&prepare)?];
-    let template = prepare(&mut bytes)?;
-    Ok((template, bytes))
+// The current time in seconds since the Unix epoch.
+pub(crate) fn unix_now() -> Result<u64, Box<dyn std::error::Error>> {
+    Ok(SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs())
 }
 
-// Sends `request`, with `content` for a write, and hands back the response
-// head and its body as two values, so that the head can be read while the
-// body is read too.
+// Writes a template or a request with `write` into `buf`, and grows the
+// buffer and writes again only when it was too small. What `write` returns
+// borrows nothing, a template or a request's placement, so a host that
+// keeps `buf` between calls writes each later one once.
+pub(crate) fn grown_to_fit<T>(
+    buf: &mut Vec<u8>,
+    write: impl Fn(&mut [u8]) -> Result<T, Error>,
+) -> Result<T, Error> {
+    match write(buf) {
+        Err(Error::Capacity(capacity)) => {
+            buf.resize(capacity.required, 0);
+            write(buf)
+        }
+        written => written,
+    }
+}
+
+// A template, and the bytes it was written into.
+pub(crate) struct Prepared<T> {
+    pub(crate) template: T,
+    pub(crate) bytes: Vec<u8>,
+}
+
+impl<T> Prepared<T> {
+    // Writes a template with `prepare`, into a buffer of its size.
+    pub(crate) fn new(prepare: impl Fn(&mut [u8]) -> Result<T, Error>) -> Result<Self, Error> {
+        let mut bytes = Vec::new();
+        let template = grown_to_fit(&mut bytes, prepare)?;
+        Ok(Self { template, bytes })
+    }
+}
+
+// The agent that a client sends every request with, which keeps its
+// connections. This host returns the stored bytes of an object and never
+// decompresses them: see the `ureq` dependency in Cargo.toml, which turns
+// the decoding off.
+pub(crate) fn new_agent() -> ureq::Agent {
+    ureq::Agent::config_builder()
+        .http_status_as_error(false)
+        .build()
+        .into()
+}
+
+// Sends `request` with `agent`, with `content` for a write, and hands back
+// the response head and its body as two values, so that the head can be
+// read while the body is read too.
 pub(crate) fn send(
+    agent: &ureq::Agent,
     request: &WireRequest<'_>,
     content: Option<&[u8]>,
 ) -> Result<(ureq::http::response::Parts, ureq::Body), ureq::Error> {
@@ -48,13 +85,6 @@ pub(crate) fn send(
     for (name, value) in request.headers() {
         builder = builder.header(name, value);
     }
-    // This host returns the stored bytes of an object and never decompresses
-    // them: see the `ureq` dependency in Cargo.toml, which turns the
-    // decoding off.
-    let agent: ureq::Agent = ureq::Agent::config_builder()
-        .http_status_as_error(false)
-        .build()
-        .into();
     let response = match (request.payload(), content) {
         (Payload::Slice(bytes), _) if !bytes.is_empty() => agent.run(builder.body(bytes)?)?,
         (_, Some(bytes)) => agent.run(builder.body(bytes)?)?,
diff --git a/hosts/ureq/src/s3.rs b/hosts/ureq/src/s3.rs
index 6ebaec1..38fb3e4 100644
--- a/hosts/ureq/src/s3.rs
+++ b/hosts/ureq/src/s3.rs
@@ -8,57 +8,230 @@ use borink_object_storage_crypto::{Sha256RustCrypto, sigv4};
 use borink_object_storage_proto::s3::{self, Bucket, PayloadSigning, Template};
 use borink_object_storage_proto::sigv4::Credentials;
 use borink_object_storage_proto::{
-    CapacityError, DeleteHeadOutcome, DeleteOptions, Error, GetHeadOutcome, GetItem, GetOptions,
-    ListEntry, ListHeadOutcome, ListItem, Listing, ObjectItem, Payload, PutHeadOutcome, PutItem,
+    DeleteHeadOutcome, DeleteOptions, Error, GetHeadOutcome, GetItem, GetOptions, ListEntry,
+    ListHeadOutcome, ListItem, ListOptions, Listing, ObjectItem, Payload, PutHeadOutcome, PutItem,
     PutOptions, Timestamps,
 };
 
-// The day's signing key and the start of the string to sign at `now`,
-// for the requests of `template`. A host that sends many requests derives
-// the key once a day.
-fn stamp(
-    template: &Template,
-    bytes: &[u8],
-    credentials: &Credentials<'_>,
-    now: &Timestamps,
-) -> Result<sigv4::Stamp<Sha256RustCrypto>, Error> {
-    let signing_key = sigv4::signing_key::<Sha256RustCrypto>(template, bytes, credentials, now)?;
-    sigv4::stamp(&signing_key, template, bytes, now)
-}
+use crate::Prepared;
+
+// SigV4 signs with the key of the UTC day, and a Unix day is exactly this
+// long.
+const SECONDS_PER_DAY: u64 = 86_400;
 
-/// Builds and executes one GET request, returning an owned response body.
+/// A client of one S3 bucket, which signs its requests with one set of
+/// credentials.
 ///
-/// The template and the signing key are made for this one read. A host
-/// that reads many objects makes the template once and the key once a day.
-pub fn get(
-    bucket: &Bucket<'_>,
-    credentials: &Credentials<'_>,
-    key: &str,
-) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
-    let now = crate::now()?;
-    let options = GetOptions::new();
-    let prepare = |buf: &mut [u8]| s3::prepare_get(bucket, credentials, &options, buf);
-    let (template, bytes) = crate::sized_template(prepare)?;
-    let stamp = stamp(&template, &bytes, credentials, &now)?;
-    let item = GetItem::new(key);
-    let encode = |buf: &mut [u8]| s3::encode_get(&template, &bytes, &item, &now, buf).map(drop);
-    let mut buf = vec![0; CapacityError::required_by(encode)?];
-    let unsigned = s3::encode_get(&template, &bytes, &item, &now, &mut buf)?;
-    let request = sigv4::sign(&stamp, &unsigned, &mut buf);
-
-    let (parts, mut body) = crate::send(&request, None)?;
-    let service = template.service();
-    let shape = item.shape(&options);
-    match s3::accept_get_head(service, shape, crate::response_head(&parts))? {
-        GetHeadOutcome::Body { .. } => body.read_to_vec().map_err(Into::into),
-        GetHeadOutcome::Complete { .. } => Ok(Vec::new()),
-        // S3 names every error in the body.
-        GetHeadOutcome::NeedErrorBody(failure) => Err(no_object(s3::accept_get_error_body(
-            shape,
-            failure,
-            &crate::error_body(&mut body),
-        ))),
-        outcome => Err(no_object(outcome)),
+/// It writes the template of each kind of request once, when it is made,
+/// and writes every request into one buffer that it keeps. Once that buffer
+/// has grown to fit the longest request, each request is written once. It
+/// derives the signing key once a day, and sends with one `ureq` agent,
+/// which keeps its connections.
+pub struct Objects<'a> {
+    credentials: Credentials<'a>,
+    // The day's signing key, with the day it signs on, counted in days
+    // since the Unix epoch.
+    signing_key: Option<(u64, sigv4::SigningKey<Sha256RustCrypto>)>,
+    get: Prepared<Template>,
+    put: Prepared<Template>,
+    delete: Prepared<Template>,
+    list: Prepared<Template>,
+    buf: Vec<u8>,
+    agent: ureq::Agent,
+}
+
+impl<'a> Objects<'a> {
+    /// A client of `bucket` that signs with `credentials`, and lists as
+    /// `list` says. A put signs the SHA-256 of its content.
+    ///
+    /// # Errors
+    ///
+    /// Returns the error of a template that the crate refuses to write.
+    pub fn new(
+        bucket: &Bucket<'_>,
+        credentials: Credentials<'a>,
+        list: &ListOptions<'_>,
+    ) -> Result<Self, Error> {
+        let signing = PayloadSigning::Signed;
+        Ok(Self {
+            get: Prepared::new(|buf| {
+                s3::prepare_get(bucket, &credentials, &GetOptions::new(), buf)
+            })?,
+            put: Prepared::new(|buf| {
+                s3::prepare_put(bucket, &credentials, &PutOptions::default(), signing, buf)
+            })?,
+            delete: Prepared::new(|buf| {
+                s3::prepare_delete(bucket, &credentials, &DeleteOptions::new(), buf)
+            })?,
+            list: Prepared::new(|buf| s3::prepare_list(bucket, &credentials, list, buf))?,
+            credentials,
+            signing_key: None,
+            buf: Vec::new(),
+            agent: crate::new_agent(),
+        })
+    }
+
+    // The stamp for signing at `now`, `unix` seconds after the epoch, from
+    // the day's signing key, which this derives on the first request of each
+    // day. Every template of the bucket has the same scope, so the get
+    // template serves them all.
+    fn stamp(
+        &mut self,
+        unix: u64,
+        now: &Timestamps,
+    ) -> Result<sigv4::Stamp<Sha256RustCrypto>, Error> {
+        let day = unix / SECONDS_PER_DAY;
+        let Prepared { template, bytes } = &self.get;
+        let key = match self.signing_key {
+            Some((signs_on, key)) if signs_on == day => key,
+            _ => {
+                let key = sigv4::signing_key(template, bytes, &self.credentials, now)?;
+                self.signing_key = Some((day, key));
+                key
+            }
+        };
+        sigv4::stamp(&key, template, bytes, now)
+    }
+
+    /// Gets the object `key`, and returns its bytes.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the request could not be sent, or if S3 returned
+    /// no object.
+    pub fn get(&mut self, key: &str) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
+        let unix = crate::unix_now()?;
+        let now = Timestamps::from_unix(unix);
+        let stamp = self.stamp(unix, &now)?;
+        let item = GetItem::new(key);
+        let Prepared { template, bytes } = &self.get;
+        let placed = crate::grown_to_fit(&mut self.buf, |buf| {
+            let unsigned = s3::encode_get(template, bytes, &item, &now, buf)?;
+            Ok(sigv4::sign(&stamp, &unsigned, buf).placement())
+        })?;
+
+        let (parts, mut body) = crate::send(&self.agent, &placed.request(&self.buf), None)?;
+        let shape = item.shape(&GetOptions::new());
+        match s3::accept_get_head(template.service(), shape, crate::response_head(&parts))? {
+            GetHeadOutcome::Body { .. } => body.read_to_vec().map_err(Into::into),
+            GetHeadOutcome::Complete { .. } => Ok(Vec::new()),
+            // S3 names every error in the body.
+            GetHeadOutcome::NeedErrorBody(failure) => Err(no_object(s3::accept_get_error_body(
+                shape,
+                failure,
+                &crate::error_body(&mut body),
+            ))),
+            outcome => Err(no_object(outcome)),
+        }
+    }
+
+    /// Puts `content` as the whole object `key`.
+    ///
+    /// The request signs the SHA-256 of `content`, which this method
+    /// computes.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the request could not be sent, or if S3 stored no
+    /// object.
+    pub fn put(&mut self, key: &str, content: &[u8]) -> Result<(), Box<dyn std::error::Error>> {
+        let unix = crate::unix_now()?;
+        let now = Timestamps::from_unix(unix);
+        let stamp = self.stamp(unix, &now)?;
+        let item = PutItem::new(key, Payload::Slice(content));
+        let digest = sigv4::sha256::<Sha256RustCrypto>(content);
+        let Prepared { template, bytes } = &self.put;
+        let placed = crate::grown_to_fit(&mut self.buf, |buf| {
+            let unsigned = s3::encode_put(template, bytes, &item, Some(&digest), &now, buf)?;
+            Ok(sigv4::sign(&stamp, &unsigned, buf).placement())
+        })?;
+
+        let request = placed.request(&self.buf);
+        let (parts, mut body) = crate::send(&self.agent, &request, Some(content))?;
+        let shape = item.shape(&PutOptions::default());
+        match s3::accept_put_head(shape, crate::response_head(&parts))? {
+            PutHeadOutcome::Created { .. } => Ok(()),
+            PutHeadOutcome::NeedErrorBody(failure) => Err(not_stored(s3::accept_put_error_body(
+                shape,
+                failure,
+                &crate::error_body(&mut body),
+            ))),
+            outcome => Err(not_stored(outcome)),
+        }
+    }
+
+    /// Deletes the whole object `key`.
+    ///
+    /// S3 answers the removal of a missing object as it answers any other
+    /// removal, so this method cannot report one.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the request could not be sent, or if S3 removed
+    /// no object.
+    pub fn delete(&mut self, key: &str) -> Result<(), Box<dyn std::error::Error>> {
+        let unix = crate::unix_now()?;
+        let now = Timestamps::from_unix(unix);
+        let stamp = self.stamp(unix, &now)?;
+        let item = ObjectItem::new(key);
+        let Prepared { template, bytes } = &self.delete;
+        let placed = crate::grown_to_fit(&mut self.buf, |buf| {
+            let unsigned = s3::encode_delete(template, bytes, &item, &now, buf)?;
+            Ok(sigv4::sign(&stamp, &unsigned, buf).placement())
+        })?;
+
+        let (parts, mut body) = crate::send(&self.agent, &placed.request(&self.buf), None)?;
+        let shape = DeleteOptions::new().shape();
+        let head = crate::response_head(&parts);
+        match s3::accept_delete_head(template.service(), shape, head)? {
+            DeleteHeadOutcome::Accepted => Ok(()),
+            DeleteHeadOutcome::NeedErrorBody(failure) => Err(not_removed(
+                s3::accept_delete_error_body(shape, failure, &crate::error_body(&mut body)),
+            )),
+            outcome => Err(not_removed(outcome)),
+        }
+    }
+
+    /// Lists one page, and reads it into `body`.
+    ///
+    /// The entries this writes into `into` borrow `body`. An array of the
+    /// `max_results` of the client's list options always holds a whole page,
+    /// and so does one of 1,000 entries for AWS. A smaller one is refused
+    /// with the number of entries the page holds.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the request could not be sent, or if S3 listed
+    /// nothing.
+    pub fn list<'b>(
+        &mut self,
+        item: &ListItem<'_>,
+        body: &'b mut Vec<u8>,
+        into: &mut [ListEntry<'b>],
+    ) -> Result<Listing<'b>, Box<dyn std::error::Error>> {
+        let unix = crate::unix_now()?;
+        let now = Timestamps::from_unix(unix);
+        let stamp = self.stamp(unix, &now)?;
+        let Prepared { template, bytes } = &self.list;
+        let placed = crate::grown_to_fit(&mut self.buf, |buf| {
+            let unsigned = s3::encode_list(template, bytes, item, &now, buf)?;
+            Ok(sigv4::sign(&stamp, &unsigned, buf).placement())
+        })?;
+
+        let (parts, mut incoming) = crate::send(&self.agent, &placed.request(&self.buf), None)?;
+        match s3::accept_list_head(crate::response_head(&parts))? {
+            ListHeadOutcome::Page { .. } => {
+                // S3 often sends a page without its length, so the read is
+                // capped whatever the head says.
+                *body = crate::page_body(&mut incoming)?;
+                s3::fill_listing(body, into).map_err(Into::into)
+            }
+            ListHeadOutcome::NeedErrorBody(failure) => Err(not_listed(s3::accept_list_error_body(
+                failure,
+                &crate::error_body(&mut incoming),
+            ))),
+            outcome => Err(not_listed(outcome)),
+        }
     }
 }
 
@@ -66,128 +239,72 @@ fn no_object(outcome: GetHeadOutcome<'_>) -> Box<dyn std::error::Error> {
     format!("S3 returned no object: {outcome}").into()
 }
 
-/// Builds and executes one PUT request, storing `content` as the whole object.
-///
-/// The request signs the SHA-256 of `content`, which this function
-/// computes.
-pub fn put(
-    bucket: &Bucket<'_>,
-    credentials: &Credentials<'_>,
-    key: &str,
-    content: &[u8],
-) -> Result<(), Box<dyn std::error::Error>> {
-    let now = crate::now()?;
-    let options = PutOptions::default();
-    let signing = PayloadSigning::Signed;
-    let prepare = |buf: &mut [u8]| s3::prepare_put(bucket, credentials, &options, signing, buf);
-    let (template, bytes) = crate::sized_template(prepare)?;
-    let stamp = stamp(&template, &bytes, credentials, &now)?;
-    let item = PutItem::new(key, Payload::Slice(content));
-    let digest = sigv4::sha256::<Sha256RustCrypto>(content);
-    let encode = |buf: &mut [u8]| {
-        s3::encode_put(&template, &bytes, &item, Some(&digest), &now, buf).map(drop)
-    };
-    let mut buf = vec![0; CapacityError::required_by(encode)?];
-    let unsigned = s3::encode_put(&template, &bytes, &item, Some(&digest), &now, &mut buf)?;
-    let request = sigv4::sign(&stamp, &unsigned, &mut buf);
-
-    let (parts, mut body) = crate::send(&request, None)?;
-    let shape = item.shape(&options);
-    match s3::accept_put_head(shape, crate::response_head(&parts))? {
-        PutHeadOutcome::Created { .. } => Ok(()),
-        PutHeadOutcome::NeedErrorBody(failure) => Err(not_stored(s3::accept_put_error_body(
-            shape,
-            failure,
-            &crate::error_body(&mut body),
-        ))),
-        outcome => Err(not_stored(outcome)),
-    }
-}
-
 fn not_stored(outcome: PutHeadOutcome<'_>) -> Box<dyn std::error::Error> {
     format!("S3 stored no object: {outcome}").into()
 }
 
-/// Builds and executes one DELETE request, removing the whole object.
-///
-/// S3 answers the removal of a missing object as it answers any other
-/// removal, so this function cannot report one.
-pub fn delete(
-    bucket: &Bucket<'_>,
-    credentials: &Credentials<'_>,
-    key: &str,
-) -> Result<(), Box<dyn std::error::Error>> {
-    let now = crate::now()?;
-    let options = DeleteOptions::new();
-    let prepare = |buf: &mut [u8]| s3::prepare_delete(bucket, credentials, &options, buf);
-    let (template, bytes) = crate::sized_template(prepare)?;
-    let stamp = stamp(&template, &bytes, credentials, &now)?;
-    let item = ObjectItem::new(key);
-    let encode = |buf: &mut [u8]| s3::encode_delete(&template, &bytes, &item, &now, buf).map(drop);
-    let mut buf = vec![0; CapacityError::required_by(encode)?];
-    let unsigned = s3::encode_delete(&template, &bytes, &item, &now, &mut buf)?;
-    let request = sigv4::sign(&stamp, &unsigned, &mut buf);
-
-    let (parts, mut body) = crate::send(&request, None)?;
-    let head = crate::response_head(&parts);
-    match s3::accept_delete_head(template.service(), options.shape(), head)? {
-        DeleteHeadOutcome::Accepted => Ok(()),
-        DeleteHeadOutcome::NeedErrorBody(failure) => Err(not_removed(
-            s3::accept_delete_error_body(options.shape(), failure, &crate::error_body(&mut body)),
-        )),
-        outcome => Err(not_removed(outcome)),
-    }
-}
-
 fn not_removed(outcome: DeleteHeadOutcome<'_>) -> Box<dyn std::error::Error> {
     format!("S3 removed no object: {outcome}").into()
 }
 
-/// Builds and executes one listing request from `template`, signed with
-/// `credentials`, and reads the page it answered.
-///
-/// Write the template once with `s3::prepare_list` and pass it, with its
-/// bytes, for every page. This function reads the page into `body`, and
-/// the entries it writes into `into` borrow those bytes. An array of
-/// `max_results` entries always holds a whole page, and so does one of
-/// 1,000 entries for AWS. A smaller one is refused with the number of
-/// entries the page holds.
-///
-/// # Errors
-///
-/// Returns an error if the request could not be sent, or if S3 listed
-/// nothing.
-pub fn list<'b>(
-    template: &Template,
-    bytes: &[u8],
-    credentials: &Credentials<'_>,
-    item: &ListItem<'_>,
-    body: &'b mut Vec<u8>,
-    into: &mut [ListEntry<'b>],
-) -> Result<Listing<'b>, Box<dyn std::error::Error>> {
-    let now = crate::now()?;
-    let stamp = stamp(template, bytes, credentials, &now)?;
-    let encode = |buf: &mut [u8]| s3::encode_list(template, bytes, item, &now, buf).map(drop);
-    let mut buf = vec![0; CapacityError::required_by(encode)?];
-    let unsigned = s3::encode_list(template, bytes, item, &now, &mut buf)?;
-    let request = sigv4::sign(&stamp, &unsigned, &mut buf);
-
-    let (parts, mut incoming) = crate::send(&request, None)?;
-    match s3::accept_list_head(crate::response_head(&parts))? {
-        ListHeadOutcome::Page { .. } => {
-            // S3 often sends a page without its length, so the read is
-            // capped whatever the head says.
-            *body = crate::page_body(&mut incoming)?;
-            s3::fill_listing(body, into).map_err(Into::into)
-        }
-        ListHeadOutcome::NeedErrorBody(failure) => Err(not_listed(s3::accept_list_error_body(
-            failure,
-            &crate::error_body(&mut incoming),
-        ))),
-        outcome => Err(not_listed(outcome)),
-    }
-}
-
 fn not_listed(outcome: ListHeadOutcome<'_>) -> Box<dyn std::error::Error> {
     format!("S3 listed no keys: {outcome}").into()
 }
+
+#[cfg(test)]
+mod tests {
+    use borink_object_storage_crypto::wipe;
+    use borink_object_storage_proto::s3::Service;
+
+    use super::*;
+
+    // The signature that a stamp freshly derived at `unix` gives a request.
+    fn fresh_signature(objects: &Objects<'_>, unix: u64) -> [u8; 32] {
+        let now = Timestamps::from_unix(unix);
+        let Prepared { template, bytes } = &objects.get;
+        let key = sigv4::signing_key(template, bytes, &objects.credentials, &now).unwrap();
+        let stamp: sigv4::Stamp<Sha256RustCrypto> =
+            sigv4::stamp(&key, template, bytes, &now).unwrap();
+        stamp.sign(&[7; 32])
+    }
+
+    #[test]
+    fn the_signing_key_is_kept_for_its_day_and_derived_again_on_the_next() {
+        let bucket = Bucket::new(
+            "https://s3.example.com",
+            "bucket",
+            "us-east-1",
+            Service::Aws,
+        )
+        .unwrap();
+        let credentials = Credentials::new("AKIAIOSFODNN7EXAMPLE", "secret", wipe).unwrap();
+        let mut objects = Objects::new(&bucket, credentials, &ListOptions::default()).unwrap();
+        let morning = 1_787_400_000 / SECONDS_PER_DAY * SECONDS_PER_DAY + 3_600;
+        let day = morning / SECONDS_PER_DAY;
+        let stamp = objects
+            .stamp(morning, &Timestamps::from_unix(morning))
+            .unwrap();
+        assert_eq!(stamp.sign(&[7; 32]), fresh_signature(&objects, morning));
+
+        // A key of another secret, kept for today, signs the rest of today.
+        let other = Credentials::new("AKIAIOSFODNN7EXAMPLE", "other", wipe).unwrap();
+        let Prepared { template, bytes } = &objects.get;
+        let now = Timestamps::from_unix(morning);
+        let planted = sigv4::signing_key(template, bytes, &other, &now).unwrap();
+        objects.signing_key = Some((day, planted));
+        let later = morning + 10_000;
+        let stamp = objects.stamp(later, &Timestamps::from_unix(later)).unwrap();
+        assert_ne!(stamp.sign(&[7; 32]), fresh_signature(&objects, later));
+
+        // Tomorrow's request derives tomorrow's key from the secret again.
+        let tomorrow = morning + SECONDS_PER_DAY;
+        let stamp = objects
+            .stamp(tomorrow, &Timestamps::from_unix(tomorrow))
+            .unwrap();
+        assert_eq!(
+            objects.signing_key.map(|(signs_on, _)| signs_on),
+            Some(day + 1)
+        );
+        assert_eq!(stamp.sign(&[7; 32]), fresh_signature(&objects, tomorrow));
+    }
+}
diff --git a/hosts/ureq/tests/azure_get.rs b/hosts/ureq/tests/azure_get.rs
index 773e5d9..b5280f9 100644
--- a/hosts/ureq/tests/azure_get.rs
+++ b/hosts/ureq/tests/azure_get.rs
@@ -4,6 +4,7 @@ use std::io::{Read, Write};
 use std::net::TcpListener;
 use std::thread;
 
+use borink_object_storage_proto::ListOptions;
 use borink_object_storage_proto::azure::Container;
 use borink_object_storage_ureq::azure;
 
@@ -33,6 +34,7 @@ fn executes_the_generated_request() {
     });
 
     let container = Container::new_allowing_http(&endpoint, "container").unwrap();
-    assert_eq!(azure::get(&container, "token", "a key").unwrap(), b"body");
+    let mut blobs = azure::Blobs::new(&container, "token", &ListOptions::default()).unwrap();
+    assert_eq!(blobs.get("a key").unwrap(), b"body");
     server.join().unwrap();
 }
diff --git a/hosts/ureq/tests/azure_list.rs b/hosts/ureq/tests/azure_list.rs
index 741f71a..c45cc0f 100644
--- a/hosts/ureq/tests/azure_list.rs
+++ b/hosts/ureq/tests/azure_list.rs
@@ -5,8 +5,7 @@ use std::io::{Read, Write};
 use std::net::TcpListener;
 use std::thread;
 
-use borink_object_storage_proto::azure as proto;
-use borink_object_storage_proto::azure::{AzureNamespace, Container};
+use borink_object_storage_proto::azure::Container;
 use borink_object_storage_proto::{ListEntry, ListItem, ListMarker, ListOptions};
 use borink_object_storage_ureq::azure;
 
@@ -51,19 +50,11 @@ fn reads_the_page_that_the_generated_request_asked_for() {
         max_results: Some(1000),
         ..ListOptions::default()
     };
-    let mut bytes = vec![0; 1024];
-    let template = proto::prepare_list(
-        &container,
-        "token",
-        AzureNamespace::Unknown,
-        &options,
-        &mut bytes,
-    )
-    .unwrap();
+    let mut blobs = azure::Blobs::new(&container, "token", &options).unwrap();
     let item = ListItem::new("directory/");
     let mut body = Vec::new();
     let mut entries = [ListEntry::default(); 4];
-    let page = azure::list(&template, &bytes, &item, &mut body, &mut entries).unwrap();
+    let page = blobs.list(&item, &mut body, &mut entries).unwrap();
     assert_eq!(page.filled, 2);
     assert_eq!(entries[0].key, "directory/a.txt");
     assert_eq!(entries[0].size, Some(4));
diff --git a/hosts/ureq/tests/s3.rs b/hosts/ureq/tests/s3.rs
index 00bd8b3..216f3c7 100644
--- a/hosts/ureq/tests/s3.rs
+++ b/hosts/ureq/tests/s3.rs
@@ -7,6 +7,7 @@ use std::thread;
 
 use borink_object_storage_crypto::sigv4::sha256;
 use borink_object_storage_crypto::{Sha256RustCrypto, wipe};
+use borink_object_storage_proto::ListOptions;
 use borink_object_storage_proto::s3::{Bucket, Service};
 use borink_object_storage_proto::sigv4::Credentials;
 use borink_object_storage_ureq::s3;
@@ -86,8 +87,9 @@ fn executes_the_generated_requests() {
 
     let bucket = Bucket::new_allowing_http(&endpoint, "bucket", "us-east-1", Service::Aws).unwrap();
     let credentials = Credentials::new("AKIAIOSFODNN7EXAMPLE", "secret", wipe).unwrap();
-    assert_eq!(s3::get(&bucket, &credentials, "a key").unwrap(), b"body");
-    s3::put(&bucket, &credentials, "a key", b"content").unwrap();
-    s3::delete(&bucket, &credentials, "a key").unwrap();
+    let mut objects = s3::Objects::new(&bucket, credentials, &ListOptions::default()).unwrap();
+    assert_eq!(objects.get("a key").unwrap(), b"body");
+    objects.put("a key", b"content").unwrap();
+    objects.delete("a key").unwrap();
     server.join().unwrap();
 }