diff --git a/sstables/sstables.cc b/sstables/sstables.cc
index 3e6cc61ed5..0ca9877d17 100644
--- a/sstables/sstables.cc
+++ b/sstables/sstables.cc
@@ -3298,8 +3298,8 @@ class sstable::s3_storage final : public sstable::storage {
     future<> ensure_remote_prefix(const sstable& sst);
 
 public:
-    s3_storage(sstring host, s3::endpoint_config_ptr cfg, sstring bucket, sstring dir)
-        : _client(s3::client::make(ipv4_addr(host)))
+    s3_storage(sstring endpoint, s3::endpoint_config_ptr cfg, sstring bucket, sstring dir)
+        : _client(s3::client::make(std::move(endpoint)))
         , _bucket(std::move(bucket))
         , _location(std::move(dir))
     {
diff --git a/test/boost/s3_test.cc b/test/boost/s3_test.cc
index 0e0819ebe7..a1ec96dd6f 100644
--- a/test/boost/s3_test.cc
+++ b/test/boost/s3_test.cc
@@ -26,11 +26,10 @@
  */
 
 SEASTAR_THREAD_TEST_CASE(test_client_put_get_object) {
-    const ipv4_addr s3_server(tests::getenv_safe("S3_SERVER_ADDRESS_FOR_TEST"), 9000);
     const sstring name(fmt::format("/{}/testobject-{}", tests::getenv_safe("S3_PUBLIC_BUCKET_FOR_TEST"), ::getpid()));
 
     testlog.info("Make client\n");
-    auto cln = s3::client::make(s3_server);
+    auto cln = s3::client::make(tests::getenv_safe("S3_SERVER_ADDRESS_FOR_TEST"));
 
     testlog.info("Put object {}\n", name);
     temporary_buffer<char> data = sstring("1234567890").release();
@@ -59,11 +58,10 @@ SEASTAR_THREAD_TEST_CASE(test_client_put_get_object) {
 }
 
 SEASTAR_THREAD_TEST_CASE(test_client_multipart_upload) {
-    const ipv4_addr s3_server(tests::getenv_safe("S3_SERVER_ADDRESS_FOR_TEST"), 9000);
     const sstring name(fmt::format("/{}/testlargeobject-{}", tests::getenv_safe("S3_PUBLIC_BUCKET_FOR_TEST"), ::getpid()));
 
     testlog.info("Make client\n");
-    auto cln = s3::client::make(s3_server);
+    auto cln = s3::client::make(tests::getenv_safe("S3_SERVER_ADDRESS_FOR_TEST"));
 
     testlog.info("Upload object\n");
     auto out = output_stream<char>(cln->make_upload_sink(name));
@@ -110,11 +108,10 @@ SEASTAR_THREAD_TEST_CASE(test_client_multipart_upload) {
 }
 
 SEASTAR_THREAD_TEST_CASE(test_client_readable_file) {
-    const ipv4_addr s3_server(tests::getenv_safe("S3_SERVER_ADDRESS_FOR_TEST"), 9000);
     const sstring name(fmt::format("/{}/testroobject-{}", tests::getenv_safe("S3_PUBLIC_BUCKET_FOR_TEST"), ::getpid()));
 
     testlog.info("Make client\n");
-    auto cln = s3::client::make(s3_server);
+    auto cln = s3::client::make(tests::getenv_safe("S3_SERVER_ADDRESS_FOR_TEST"));
 
     testlog.info("Put object {}\n", name);
     temporary_buffer<char> data = sstring("1234567890ABCDEF").release();
diff --git a/utils/s3/client.cc b/utils/s3/client.cc
index 584f55c115..aaa5a5ee45 100644
--- a/utils/s3/client.cc
+++ b/utils/s3/client.cc
@@ -8,8 +8,12 @@
 
 #include <memory>
 #include <rapidxml.h>
+#include <boost/algorithm/string/split.hpp>
+#include <boost/algorithm/string/classification.hpp>
 #include <seastar/core/coroutine.hh>
 #include <seastar/core/semaphore.hh>
+#include <seastar/core/seastar.hh>
+#include <seastar/net/dns.hh>
 #include <seastar/util/short_streams.hh>
 #include <seastar/http/request.hh>
 #include "utils/s3/client.hh"
@@ -39,15 +43,14 @@ future<> ignore_reply(const http::reply& rep, input_stream<char>&& in_) {
     co_await util::skip_entire_stream(in);
 }
 
-client::client(socket_address addr, private_tag)
-        : _addr(std::move(addr))
-        , _host(to_sstring(_addr))
-        , _http(_addr)
+client::client(std::string host, private_tag)
+        : _host(std::move(host))
+        , _http(ipv4_addr(_host, 9000 /* temporary hard-coded */))
 {
 }
 
-shared_ptr<client> client::make(socket_address addr) {
-    return seastar::make_shared<client>(std::move(addr), private_tag{});
+shared_ptr<client> client::make(std::string endpoint) {
+    return seastar::make_shared<client>(std::move(endpoint), private_tag{});
 }
 
 future<uint64_t> client::get_object_size(sstring object_name) {
@@ -417,26 +420,27 @@ public:
     virtual future<> discard(uint64_t offset, uint64_t length) override { return make_ready_future<>(); }
 
     class readable_file_handle_impl final : public file_handle_impl {
-        socket_address _addr;
+        std::string _host;
         sstring _object_name;
 
     public:
-        readable_file_handle_impl(socket_address addr, sstring object_name)
-                : _addr(std::move(addr))
+        readable_file_handle_impl(std::string host, sstring object_name)
+                : _host(std::move(host))
                 , _object_name(std::move(object_name))
         {}
 
         virtual std::unique_ptr<file_handle_impl> clone() const override {
-            return std::make_unique<readable_file_handle_impl>(_addr, _object_name);
+            return std::make_unique<readable_file_handle_impl>(_host, _object_name);
         }
 
         virtual shared_ptr<file_impl> to_file() && override {
-            return make_shared<readable_file>(client::make(std::move(_addr)), std::move(_object_name));
+            auto client = seastar::make_shared<s3::client>(std::move(_host), client::private_tag{});
+            return make_shared<readable_file>(std::move(client), std::move(_object_name));
         }
     };
 
     virtual std::unique_ptr<file_handle_impl> dup() override {
-        return std::make_unique<readable_file_handle_impl>(_client->_addr, _object_name);
+        return std::make_unique<readable_file_handle_impl>(_client->_host, _object_name);
     }
 
     virtual future<uint64_t> size(void) override {
diff --git a/utils/s3/client.hh b/utils/s3/client.hh
index 8ac527b9de..36407228f4 100644
--- a/utils/s3/client.hh
+++ b/utils/s3/client.hh
@@ -24,15 +24,14 @@ struct range {
 class client : public enable_shared_from_this<client> {
     class upload_sink;
     class readable_file;
-    socket_address _addr;
-    sstring _host;
+    std::string _host;
     http::experimental::client _http;
 
     struct private_tag {};
 
 public:
-    explicit client(socket_address addr, private_tag);
-    static shared_ptr<client> make(socket_address addr);
+    explicit client(std::string host, private_tag);
+    static shared_ptr<client> make(std::string endpoint);
 
     future<uint64_t> get_object_size(sstring object_name);
     future<temporary_buffer<char>> get_object_contiguous(sstring object_name, std::optional<range> range = {});