diff --git a/examples/async-ae.c b/examples/async-ae.c
index 5a85165c..cd3d2901 100644
--- a/examples/async-ae.c
+++ b/examples/async-ae.c
@@ -23,7 +23,7 @@ void getCallback(valkeyAsyncContext *c, void *r, void *privdata) {
 
 void connectCallback(valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         aeStop(loop);
         return;
     }
@@ -33,7 +33,7 @@ void connectCallback(valkeyAsyncContext *c, int status) {
 
 void disconnectCallback(const valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         aeStop(loop);
         return;
     }
@@ -46,9 +46,9 @@ int main(int argc, char **argv) {
     signal(SIGPIPE, SIG_IGN);
 
     valkeyAsyncContext *c = valkeyAsyncConnect("127.0.0.1", 6379);
-    if (c->err) {
+    if (valkeyAsyncGetError(c)) {
         /* Let *c leak for now... */
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return 1;
     }
 
diff --git a/examples/async-glib.c b/examples/async-glib.c
index ea70a784..274096df 100644
--- a/examples/async-glib.c
+++ b/examples/async-glib.c
@@ -11,7 +11,7 @@ static void
 connect_cb(valkeyAsyncContext *ac G_GNUC_UNUSED,
            int status) {
     if (status != VALKEY_OK) {
-        g_printerr("Failed to connect: %s\n", ac->errstr);
+        g_printerr("Failed to connect: %s\n", valkeyAsyncGetErrorString(ac));
         g_main_loop_quit(mainloop);
     } else {
         g_printerr("Connected...\n");
@@ -22,7 +22,7 @@ static void
 disconnect_cb(const valkeyAsyncContext *ac G_GNUC_UNUSED,
               int status) {
     if (status != VALKEY_OK) {
-        g_error("Failed to disconnect: %s", ac->errstr);
+        g_error("Failed to disconnect: %s", valkeyAsyncGetErrorString(ac));
     } else {
         g_printerr("Disconnected...\n");
         g_main_loop_quit(mainloop);
@@ -48,8 +48,8 @@ gint main(gint argc G_GNUC_UNUSED, gchar *argv[] G_GNUC_UNUSED) {
     GSource *source;
 
     ac = valkeyAsyncConnect("127.0.0.1", 6379);
-    if (ac->err) {
-        g_printerr("%s\n", ac->errstr);
+    if (valkeyAsyncGetError(ac)) {
+        g_printerr("%s\n", valkeyAsyncGetErrorString(ac));
         exit(EXIT_FAILURE);
     }
 
diff --git a/examples/async-ivykis.c b/examples/async-ivykis.c
index ead72412..b932d35b 100644
--- a/examples/async-ivykis.c
+++ b/examples/async-ivykis.c
@@ -20,7 +20,7 @@ void getCallback(valkeyAsyncContext *c, void *r, void *privdata) {
 
 void connectCallback(valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     printf("Connected...\n");
@@ -28,7 +28,7 @@ void connectCallback(valkeyAsyncContext *c, int status) {
 
 void disconnectCallback(const valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     printf("Disconnected...\n");
@@ -42,9 +42,9 @@ int main(int argc, char **argv) {
     iv_init();
 
     valkeyAsyncContext *c = valkeyAsyncConnect("127.0.0.1", 6379);
-    if (c->err) {
+    if (valkeyAsyncGetError(c)) {
         /* Let *c leak for now... */
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return 1;
     }
 
diff --git a/examples/async-libev.c b/examples/async-libev.c
index 37c85604..cd8088d8 100644
--- a/examples/async-libev.c
+++ b/examples/async-libev.c
@@ -20,7 +20,7 @@ void getCallback(valkeyAsyncContext *c, void *r, void *privdata) {
 
 void connectCallback(valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     printf("Connected...\n");
@@ -28,7 +28,7 @@ void connectCallback(valkeyAsyncContext *c, int status) {
 
 void disconnectCallback(const valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     printf("Disconnected...\n");
@@ -40,9 +40,9 @@ int main(int argc, char **argv) {
 #endif
 
     valkeyAsyncContext *c = valkeyAsyncConnect("127.0.0.1", 6379);
-    if (c->err) {
+    if (valkeyAsyncGetError(c)) {
         /* Let *c leak for now... */
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return 1;
     }
 
diff --git a/examples/async-libevent-tls.c b/examples/async-libevent-tls.c
index cf42ee3a..87f6a4b5 100644
--- a/examples/async-libevent-tls.c
+++ b/examples/async-libevent-tls.c
@@ -21,7 +21,7 @@ void getCallback(valkeyAsyncContext *c, void *r, void *privdata) {
 
 void connectCallback(valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     printf("Connected...\n");
@@ -29,7 +29,7 @@ void connectCallback(valkeyAsyncContext *c, int status) {
 
 void disconnectCallback(const valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     printf("Disconnected...\n");
@@ -70,9 +70,9 @@ int main(int argc, char **argv) {
     }
 
     valkeyAsyncContext *c = valkeyAsyncConnect(hostname, port);
-    if (c->err) {
+    if (valkeyAsyncGetError(c)) {
         /* Let *c leak for now... */
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return 1;
     }
     if (valkeyInitiateTLSWithContext(&c->c, tls) != VALKEY_OK) {
diff --git a/examples/async-libevent.c b/examples/async-libevent.c
index 943c05a0..96427cbc 100644
--- a/examples/async-libevent.c
+++ b/examples/async-libevent.c
@@ -11,8 +11,8 @@
 void getCallback(valkeyAsyncContext *c, void *r, void *privdata) {
     valkeyReply *reply = r;
     if (reply == NULL) {
-        if (c->errstr) {
-            printf("errstr: %s\n", c->errstr);
+        if (valkeyAsyncGetErrorString(c)) {
+            printf("errstr: %s\n", valkeyAsyncGetErrorString(c));
         }
         return;
     }
@@ -24,7 +24,7 @@ void getCallback(valkeyAsyncContext *c, void *r, void *privdata) {
 
 void connectCallback(valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     printf("Connected...\n");
@@ -32,7 +32,7 @@ void connectCallback(valkeyAsyncContext *c, int status) {
 
 void disconnectCallback(const valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     printf("Disconnected...\n");
@@ -51,9 +51,9 @@ int main(int argc, char **argv) {
     options.connect_timeout = &tv;
 
     valkeyAsyncContext *c = valkeyAsyncConnectWithOptions(&options);
-    if (c->err) {
+    if (valkeyAsyncGetError(c)) {
         /* Let *c leak for now... */
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return 1;
     }
 
diff --git a/examples/async-libhv.c b/examples/async-libhv.c
index 9d7ba91d..1479f623 100644
--- a/examples/async-libhv.c
+++ b/examples/async-libhv.c
@@ -23,7 +23,7 @@ void debugCallback(valkeyAsyncContext *c, void *r, void *privdata) {
     valkeyReply *reply = r;
 
     if (reply == NULL) {
-        printf("`DEBUG SLEEP` error: %s\n", c->errstr ? c->errstr : "unknown error");
+        printf("`DEBUG SLEEP` error: %s\n", valkeyAsyncGetErrorString(c) ? valkeyAsyncGetErrorString(c) : "unknown error");
         return;
     }
 
@@ -32,7 +32,7 @@ void debugCallback(valkeyAsyncContext *c, void *r, void *privdata) {
 
 void connectCallback(valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     printf("Connected...\n");
@@ -40,7 +40,7 @@ void connectCallback(valkeyAsyncContext *c, int status) {
 
 void disconnectCallback(const valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     printf("Disconnected...\n");
@@ -52,9 +52,9 @@ int main(int argc, char **argv) {
 #endif
 
     valkeyAsyncContext *c = valkeyAsyncConnect("127.0.0.1", 6379);
-    if (c->err) {
+    if (valkeyAsyncGetError(c)) {
         /* Let *c leak for now... */
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return 1;
     }
 
diff --git a/examples/async-libsdevent.c b/examples/async-libsdevent.c
index 18632542..9772fa71 100644
--- a/examples/async-libsdevent.c
+++ b/examples/async-libsdevent.c
@@ -14,7 +14,7 @@ void debugCallback(valkeyAsyncContext *c, void *r, void *privdata) {
     valkeyReply *reply = r;
     if (reply == NULL) {
         /* The DEBUG SLEEP command will almost always fail, because we have set a 1 second timeout */
-        printf("`DEBUG SLEEP` error: %s\n", c->errstr ? c->errstr : "unknown error");
+        printf("`DEBUG SLEEP` error: %s\n", valkeyAsyncGetErrorString(c) ? valkeyAsyncGetErrorString(c) : "unknown error");
         return;
     }
     /* Disconnect after receiving the reply of DEBUG SLEEP (which will not)*/
@@ -24,7 +24,7 @@ void debugCallback(valkeyAsyncContext *c, void *r, void *privdata) {
 void getCallback(valkeyAsyncContext *c, void *r, void *privdata) {
     valkeyReply *reply = r;
     if (reply == NULL) {
-        printf("`GET key` error: %s\n", c->errstr ? c->errstr : "unknown error");
+        printf("`GET key` error: %s\n", valkeyAsyncGetErrorString(c) ? valkeyAsyncGetErrorString(c) : "unknown error");
         return;
     }
     printf("`GET key` result: argv[%s]: %s\n", (char *)privdata, reply->str);
@@ -35,7 +35,7 @@ void getCallback(valkeyAsyncContext *c, void *r, void *privdata) {
 
 void connectCallback(valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("connect error: %s\n", c->errstr);
+        printf("connect error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     printf("Connected...\n");
@@ -43,7 +43,7 @@ void connectCallback(valkeyAsyncContext *c, int status) {
 
 void disconnectCallback(const valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("disconnect because of error: %s\n", c->errstr);
+        printf("disconnect because of error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     printf("Disconnected...\n");
@@ -56,8 +56,8 @@ int main(int argc, char **argv) {
     sd_event_default(&event);
 
     valkeyAsyncContext *c = valkeyAsyncConnect("127.0.0.1", 6379);
-    if (c->err) {
-        printf("Error: %s\n", c->errstr);
+    if (valkeyAsyncGetError(c)) {
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         valkeyAsyncFree(c);
         return 1;
     }
diff --git a/examples/async-libuv.c b/examples/async-libuv.c
index 7adf3204..7dfb117a 100644
--- a/examples/async-libuv.c
+++ b/examples/async-libuv.c
@@ -14,7 +14,7 @@ void debugCallback(valkeyAsyncContext *c, void *r, void *privdata) {
     valkeyReply *reply = r;
     if (reply == NULL) {
         /* The DEBUG SLEEP command will almost always fail, because we have set a 1 second timeout */
-        printf("`DEBUG SLEEP` error: %s\n", c->errstr ? c->errstr : "unknown error");
+        printf("`DEBUG SLEEP` error: %s\n", valkeyAsyncGetErrorString(c) ? valkeyAsyncGetErrorString(c) : "unknown error");
         return;
     }
     /* Disconnect after receiving the reply of DEBUG SLEEP (which will not)*/
@@ -24,7 +24,7 @@ void debugCallback(valkeyAsyncContext *c, void *r, void *privdata) {
 void getCallback(valkeyAsyncContext *c, void *r, void *privdata) {
     valkeyReply *reply = r;
     if (reply == NULL) {
-        printf("`GET key` error: %s\n", c->errstr ? c->errstr : "unknown error");
+        printf("`GET key` error: %s\n", valkeyAsyncGetErrorString(c) ? valkeyAsyncGetErrorString(c) : "unknown error");
         return;
     }
     printf("`GET key` result: argv[%s]: %s\n", (char *)privdata, reply->str);
@@ -35,7 +35,7 @@ void getCallback(valkeyAsyncContext *c, void *r, void *privdata) {
 
 void connectCallback(valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("connect error: %s\n", c->errstr);
+        printf("connect error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     printf("Connected...\n");
@@ -43,7 +43,7 @@ void connectCallback(valkeyAsyncContext *c, int status) {
 
 void disconnectCallback(const valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("disconnect because of error: %s\n", c->errstr);
+        printf("disconnect because of error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     printf("Disconnected...\n");
@@ -57,9 +57,9 @@ int main(int argc, char **argv) {
     uv_loop_t *loop = uv_default_loop();
 
     valkeyAsyncContext *c = valkeyAsyncConnect("127.0.0.1", 6379);
-    if (c->err) {
+    if (valkeyAsyncGetError(c)) {
         /* Let *c leak for now... */
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return 1;
     }
 
diff --git a/examples/async-macosx.c b/examples/async-macosx.c
index 3eecb2eb..e4821635 100644
--- a/examples/async-macosx.c
+++ b/examples/async-macosx.c
@@ -50,7 +50,7 @@ void getCallback(valkeyAsyncContext *c, void *r, void *privdata) {
 
 void connectCallback(valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     printf("Connected...\n");
@@ -58,7 +58,7 @@ void connectCallback(valkeyAsyncContext *c, int status) {
 
 void disconnectCallback(const valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     CFRunLoopStop(CFRunLoopGetCurrent());
@@ -75,9 +75,9 @@ int main(int argc, char **argv) {
     }
 
     valkeyAsyncContext *c = valkeyAsyncConnect("127.0.0.1", 6379);
-    if (c->err) {
+    if (valkeyAsyncGetError(c)) {
         /* Let *c leak for now... */
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return 1;
     }
 
diff --git a/examples/async-poll.c b/examples/async-poll.c
index 077f14a2..ada28064 100644
--- a/examples/async-poll.c
+++ b/examples/async-poll.c
@@ -23,7 +23,7 @@ void getCallback(valkeyAsyncContext *c, void *r, void *privdata) {
 
 void connectCallback(valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         exit_loop = 1;
         return;
     }
@@ -34,7 +34,7 @@ void connectCallback(valkeyAsyncContext *c, int status) {
 void disconnectCallback(const valkeyAsyncContext *c, int status) {
     exit_loop = 1;
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
 
@@ -45,9 +45,9 @@ int main(int argc, char **argv) {
     signal(SIGPIPE, SIG_IGN);
 
     valkeyAsyncContext *c = valkeyAsyncConnect("127.0.0.1", 6379);
-    if (c->err) {
+    if (valkeyAsyncGetError(c)) {
         /* Let *c leak for now... */
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return 1;
     }
 
diff --git a/examples/async-valkeymoduleapi.c b/examples/async-valkeymoduleapi.c
index 18dcbe11..0de65bd0 100644
--- a/examples/async-valkeymoduleapi.c
+++ b/examples/async-valkeymoduleapi.c
@@ -11,7 +11,7 @@ void debugCallback(valkeyAsyncContext *c, void *r, void *privdata) {
     valkeyReply *reply = r;
     if (reply == NULL) {
         /* The DEBUG SLEEP command will almost always fail, because we have set a 1 second timeout */
-        printf("`DEBUG SLEEP` error: %s\n", c->errstr ? c->errstr : "unknown error");
+        printf("`DEBUG SLEEP` error: %s\n", valkeyAsyncGetErrorString(c) ? valkeyAsyncGetErrorString(c) : "unknown error");
         return;
     }
     /* Disconnect after receiving the reply of DEBUG SLEEP (which will not)*/
@@ -21,8 +21,8 @@ void debugCallback(valkeyAsyncContext *c, void *r, void *privdata) {
 void getCallback(valkeyAsyncContext *c, void *r, void *privdata) {
     valkeyReply *reply = r;
     if (reply == NULL) {
-        if (c->errstr) {
-            printf("errstr: %s\n", c->errstr);
+        if (valkeyAsyncGetErrorString(c)) {
+            printf("errstr: %s\n", valkeyAsyncGetErrorString(c));
         }
         return;
     }
@@ -34,7 +34,7 @@ void getCallback(valkeyAsyncContext *c, void *r, void *privdata) {
 
 void connectCallback(valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     printf("Connected...\n");
@@ -42,7 +42,7 @@ void connectCallback(valkeyAsyncContext *c, int status) {
 
 void disconnectCallback(const valkeyAsyncContext *c, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return;
     }
     printf("Disconnected...\n");
@@ -64,9 +64,9 @@ int ValkeyModule_OnLoad(ValkeyModuleCtx *ctx, ValkeyModuleString **argv, int arg
     }
 
     valkeyAsyncContext *c = valkeyAsyncConnect("127.0.0.1", 6379);
-    if (c->err) {
+    if (valkeyAsyncGetError(c)) {
         /* Let *c leak for now... */
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(c));
         return 1;
     }
 
diff --git a/examples/blocking-push.c b/examples/blocking-push.c
index 71bb169c..7db24cf4 100644
--- a/examples/blocking-push.c
+++ b/examples/blocking-push.c
@@ -60,8 +60,8 @@ static void assertReplyAndFree(valkeyContext *context, valkeyReply *reply, int t
 /* Switch to the RESP3 protocol and enable client tracking */
 static void enableClientTracking(valkeyContext *c) {
     valkeyReply *reply = valkeyCommand(c, "HELLO 3");
-    if (reply == NULL || c->err) {
-        panicAbort("NULL reply or server error (error: %s)", c->errstr);
+    if (reply == NULL || valkeyGetError(c)) {
+        panicAbort("NULL reply or server error (error: %s)", valkeyGetErrorString(c));
     }
 
     if (reply->type != VALKEY_REPLY_MAP) {
@@ -130,8 +130,8 @@ int main(int argc, char **argv) {
     o.push_cb = pushReplyHandler;
 
     c = valkeyConnectWithOptions(&o);
-    if (c == NULL || c->err)
-        panicAbort("Connection error:  %s", c ? c->errstr : "OOM");
+    if (c == NULL || valkeyGetError(c))
+        panicAbort("Connection error:  %s", c ? valkeyGetErrorString(c) : "OOM");
 
     /* Enable RESP3 and turn on client tracking */
     enableClientTracking(c);
diff --git a/examples/blocking-tls.c b/examples/blocking-tls.c
index 922fc557..9b58b3e8 100644
--- a/examples/blocking-tls.c
+++ b/examples/blocking-tls.c
@@ -38,9 +38,9 @@ int main(int argc, char **argv) {
     options.connect_timeout = &tv;
     c = valkeyConnectWithOptions(&options);
 
-    if (c == NULL || c->err) {
+    if (c == NULL || valkeyGetError(c)) {
         if (c) {
-            printf("Connection error: %s\n", c->errstr);
+            printf("Connection error: %s\n", valkeyGetErrorString(c));
             valkeyFree(c);
         } else {
             printf("Connection error: can't allocate valkey context\n");
@@ -50,7 +50,7 @@ int main(int argc, char **argv) {
 
     if (valkeyInitiateTLSWithContext(c, tls) != VALKEY_OK) {
         printf("Couldn't initialize TLS!\n");
-        printf("Error: %s\n", c->errstr);
+        printf("Error: %s\n", valkeyGetErrorString(c));
         valkeyFree(c);
         exit(1);
     }
diff --git a/examples/blocking.c b/examples/blocking.c
index a8da6fa8..92d54ecf 100644
--- a/examples/blocking.c
+++ b/examples/blocking.c
@@ -38,7 +38,7 @@ static void example_argv_command(valkeyContext *c, size_t n) {
     reply = valkeyCommandArgv(
         c, n + 2, (const char **)argv, (const size_t *)argvlen);
 
-    if (reply == NULL || c->err) {
+    if (reply == NULL || valkeyGetError(c)) {
         fprintf(stderr, "Error:  Couldn't execute valkeyCommandArgv\n");
         exit(1);
     }
@@ -80,9 +80,9 @@ int main(int argc, char **argv) {
     } else {
         c = valkeyConnectWithTimeout(hostname, port, timeout);
     }
-    if (c == NULL || c->err) {
+    if (c == NULL || valkeyGetError(c)) {
         if (c) {
-            printf("Connection error: %s\n", c->errstr);
+            printf("Connection error: %s\n", valkeyGetErrorString(c));
             valkeyFree(c);
         } else {
             printf("Connection error: can't allocate valkey context\n");
diff --git a/examples/cluster-async-tls.c b/examples/cluster-async-tls.c
index 759552b5..5643530e 100644
--- a/examples/cluster-async-tls.c
+++ b/examples/cluster-async-tls.c
@@ -9,25 +9,25 @@
 
 #define CLUSTER_NODE_TLS "127.0.0.1:7300"
 
-void getCallback(valkeyClusterAsyncContext *cc, void *r, void *privdata) {
+void getCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
     valkeyReply *reply = (valkeyReply *)r;
     if (reply == NULL) {
-        if (cc->err) {
-            printf("errstr: %s\n", cc->errstr);
+        if (valkeyClusterAsyncGetError(acc)) {
+            printf("errstr: %s\n", valkeyClusterAsyncGetErrorString(acc));
         }
         return;
     }
     printf("privdata: %s reply: %s\n", (char *)privdata, reply->str);
 
     /* Disconnect after receiving the reply to GET */
-    valkeyClusterAsyncDisconnect(cc);
+    valkeyClusterAsyncDisconnect(acc);
 }
 
-void setCallback(valkeyClusterAsyncContext *cc, void *r, void *privdata) {
+void setCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
     valkeyReply *reply = (valkeyReply *)r;
     if (reply == NULL) {
-        if (cc->err) {
-            printf("errstr: %s\n", cc->errstr);
+        if (valkeyClusterAsyncGetError(acc)) {
+            printf("errstr: %s\n", valkeyClusterAsyncGetErrorString(acc));
         }
         return;
     }
@@ -36,7 +36,7 @@ void setCallback(valkeyClusterAsyncContext *cc, void *r, void *privdata) {
 
 void connectCallback(valkeyAsyncContext *ac, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", ac->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(ac));
         return;
     }
 
@@ -45,7 +45,7 @@ void connectCallback(valkeyAsyncContext *ac, int status) {
 
 void disconnectCallback(const valkeyAsyncContext *ac, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", ac->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(ac));
         return;
     }
     printf("Disconnected from %s:%d\n", ac->c.tcp.host, ac->c.tcp.port);
@@ -74,8 +74,8 @@ int main(void) {
     valkeyClusterOptionsUseLibevent(&options, base);
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
-    if (acc == NULL || acc->err != 0) {
-        printf("Error: %s\n", acc ? acc->errstr : "OOM");
+    if (acc == NULL || valkeyClusterAsyncGetError(acc) != 0) {
+        printf("Error: %s\n", acc ? valkeyClusterAsyncGetErrorString(acc) : "OOM");
         exit(-1);
     }
 
@@ -83,13 +83,13 @@ int main(void) {
     status = valkeyClusterAsyncCommand(acc, setCallback, (char *)"THE_ID",
                                        "SET %s %s", "key", "value");
     if (status != VALKEY_OK) {
-        printf("error: err=%d errstr=%s\n", acc->err, acc->errstr);
+        printf("error: err=%d errstr=%s\n", valkeyClusterAsyncGetError(acc), valkeyClusterAsyncGetErrorString(acc));
     }
 
     status = valkeyClusterAsyncCommand(acc, getCallback, (char *)"THE_ID",
                                        "GET %s", "key");
     if (status != VALKEY_OK) {
-        printf("error: err=%d errstr=%s\n", acc->err, acc->errstr);
+        printf("error: err=%d errstr=%s\n", valkeyClusterAsyncGetError(acc), valkeyClusterAsyncGetErrorString(acc));
     }
 
     printf("Dispatch..\n");
diff --git a/examples/cluster-async.c b/examples/cluster-async.c
index 3310ab50..7a2d181b 100644
--- a/examples/cluster-async.c
+++ b/examples/cluster-async.c
@@ -5,25 +5,25 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-void getCallback(valkeyClusterAsyncContext *cc, void *r, void *privdata) {
+void getCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
     valkeyReply *reply = (valkeyReply *)r;
     if (reply == NULL) {
-        if (cc->err) {
-            printf("errstr: %s\n", cc->errstr);
+        if (valkeyClusterAsyncGetError(acc)) {
+            printf("errstr: %s\n", valkeyClusterAsyncGetErrorString(acc));
         }
         return;
     }
     printf("privdata: %s reply: %s\n", (char *)privdata, reply->str);
 
     /* Disconnect after receiving the reply to GET */
-    valkeyClusterAsyncDisconnect(cc);
+    valkeyClusterAsyncDisconnect(acc);
 }
 
-void setCallback(valkeyClusterAsyncContext *cc, void *r, void *privdata) {
+void setCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
     valkeyReply *reply = (valkeyReply *)r;
     if (reply == NULL) {
-        if (cc->err) {
-            printf("errstr: %s\n", cc->errstr);
+        if (valkeyClusterAsyncGetError(acc)) {
+            printf("errstr: %s\n", valkeyClusterAsyncGetErrorString(acc));
         }
         return;
     }
@@ -32,7 +32,7 @@ void setCallback(valkeyClusterAsyncContext *cc, void *r, void *privdata) {
 
 void connectCallback(valkeyAsyncContext *ac, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", ac->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(ac));
         return;
     }
     printf("Connected to %s:%d\n", ac->c.tcp.host, ac->c.tcp.port);
@@ -40,7 +40,7 @@ void connectCallback(valkeyAsyncContext *ac, int status) {
 
 void disconnectCallback(const valkeyAsyncContext *ac, int status) {
     if (status != VALKEY_OK) {
-        printf("Error: %s\n", ac->errstr);
+        printf("Error: %s\n", valkeyAsyncGetErrorString(ac));
         return;
     }
     printf("Disconnected from %s:%d\n", ac->c.tcp.host, ac->c.tcp.port);
@@ -60,8 +60,8 @@ int main(void) {
     if (!acc) {
         printf("Error: Allocation failure\n");
         exit(-1);
-    } else if (acc->err) {
-        printf("Error: %s\n", acc->errstr);
+    } else if (valkeyClusterAsyncGetError(acc)) {
+        printf("Error: %s\n", valkeyClusterAsyncGetErrorString(acc));
         // handle error
         exit(-1);
     }
@@ -70,25 +70,25 @@ int main(void) {
     status = valkeyClusterAsyncCommand(acc, setCallback, (char *)"THE_ID",
                                        "SET %s %s", "key", "value");
     if (status != VALKEY_OK) {
-        printf("error: err=%d errstr=%s\n", acc->err, acc->errstr);
+        printf("error: err=%d errstr=%s\n", valkeyClusterAsyncGetError(acc), valkeyClusterAsyncGetErrorString(acc));
     }
 
     status = valkeyClusterAsyncCommand(acc, getCallback, (char *)"THE_ID",
                                        "GET %s", "key");
     if (status != VALKEY_OK) {
-        printf("error: err=%d errstr=%s\n", acc->err, acc->errstr);
+        printf("error: err=%d errstr=%s\n", valkeyClusterAsyncGetError(acc), valkeyClusterAsyncGetErrorString(acc));
     }
 
     status = valkeyClusterAsyncCommand(acc, setCallback, (char *)"THE_ID",
                                        "SET %s %s", "key2", "value2");
     if (status != VALKEY_OK) {
-        printf("error: err=%d errstr=%s\n", acc->err, acc->errstr);
+        printf("error: err=%d errstr=%s\n", valkeyClusterAsyncGetError(acc), valkeyClusterAsyncGetErrorString(acc));
     }
 
     status = valkeyClusterAsyncCommand(acc, getCallback, (char *)"THE_ID",
                                        "GET %s", "key2");
     if (status != VALKEY_OK) {
-        printf("error: err=%d errstr=%s\n", acc->err, acc->errstr);
+        printf("error: err=%d errstr=%s\n", valkeyClusterAsyncGetError(acc), valkeyClusterAsyncGetErrorString(acc));
     }
 
     printf("Dispatch..\n");
diff --git a/examples/cluster-clientside-caching-async.c b/examples/cluster-clientside-caching-async.c
index 385f5c66..a18c6821 100644
--- a/examples/cluster-clientside-caching-async.c
+++ b/examples/cluster-clientside-caching-async.c
@@ -150,8 +150,8 @@ int main(void) {
     valkeyClusterOptionsUseLibevent(&options, base);
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
-    if (acc == NULL || acc->err != 0) {
-        printf("Connect error: %s\n", acc ? acc->errstr : "OOM");
+    if (acc == NULL || valkeyClusterAsyncGetError(acc) != 0) {
+        printf("Connect error: %s\n", acc ? valkeyClusterAsyncGetErrorString(acc) : "OOM");
         exit(2);
     }
 
diff --git a/examples/cluster-simple.c b/examples/cluster-simple.c
index 80e69844..45966a8a 100644
--- a/examples/cluster-simple.c
+++ b/examples/cluster-simple.c
@@ -14,8 +14,8 @@ int main(void) {
     if (!cc) {
         printf("Error: Allocation failure\n");
         exit(-1);
-    } else if (cc->err) {
-        printf("Error: %s\n", cc->errstr);
+    } else if (valkeyClusterGetError(cc)) {
+        printf("Error: %s\n", valkeyClusterGetErrorString(cc));
         // handle error
         exit(-1);
     }
diff --git a/examples/cluster-tls.c b/examples/cluster-tls.c
index 975f1624..9b809ca9 100644
--- a/examples/cluster-tls.c
+++ b/examples/cluster-tls.c
@@ -30,15 +30,15 @@ int main(void) {
     if (!cc) {
         printf("Error: Allocation failure\n");
         exit(-1);
-    } else if (cc->err) {
-        printf("Error: %s\n", cc->errstr);
+    } else if (valkeyClusterGetError(cc)) {
+        printf("Error: %s\n", valkeyClusterGetErrorString(cc));
         // handle error
         exit(-1);
     }
 
     valkeyReply *reply = valkeyClusterCommand(cc, "SET %s %s", "key", "value");
     if (!reply) {
-        printf("Reply missing: %s\n", cc->errstr);
+        printf("Reply missing: %s\n", valkeyClusterGetErrorString(cc));
         exit(-1);
     }
     printf("SET: %s\n", reply->str);
@@ -46,7 +46,7 @@ int main(void) {
 
     valkeyReply *reply2 = valkeyClusterCommand(cc, "GET %s", "key");
     if (!reply2) {
-        printf("Reply missing: %s\n", cc->errstr);
+        printf("Reply missing: %s\n", valkeyClusterGetErrorString(cc));
         exit(-1);
     }
     printf("GET: %s\n", reply2->str);
diff --git a/include/valkey/async.h b/include/valkey/async.h
index ad360830..80786247 100644
--- a/include/valkey/async.h
+++ b/include/valkey/async.h
@@ -137,6 +137,9 @@ int valkeyAsyncSetTimeout(valkeyAsyncContext *ac, struct timeval tv);
 void valkeyAsyncDisconnect(valkeyAsyncContext *ac);
 void valkeyAsyncFree(valkeyAsyncContext *ac);
 
+int valkeyAsyncGetError(const valkeyAsyncContext *ac);
+const char *valkeyAsyncGetErrorString(const valkeyAsyncContext *ac);
+
 /* Handle read/write events */
 void valkeyAsyncHandleRead(valkeyAsyncContext *ac);
 void valkeyAsyncHandleWrite(valkeyAsyncContext *ac);
diff --git a/include/valkey/cluster.h b/include/valkey/cluster.h
index 3737533c..f009ca8d 100644
--- a/include/valkey/cluster.h
+++ b/include/valkey/cluster.h
@@ -217,6 +217,10 @@ valkeyClusterContext *valkeyClusterConnect(const char *addrs);
 valkeyClusterContext *valkeyClusterConnectWithTimeout(const char *addrs, const struct timeval tv);
 void valkeyClusterFree(valkeyClusterContext *cc);
 
+int valkeyClusterGetError(const valkeyClusterContext *cc);
+const char *valkeyClusterGetErrorString(const valkeyClusterContext *cc);
+void valkeyClusterClearError(valkeyClusterContext *cc);
+
 /* Options configurable in runtime. */
 int valkeyClusterSetOptionTimeout(valkeyClusterContext *cc, const struct timeval tv);
 
@@ -287,6 +291,10 @@ valkeyClusterAsyncContext *valkeyClusterAsyncConnectWithOptions(const valkeyClus
 void valkeyClusterAsyncDisconnect(valkeyClusterAsyncContext *acc);
 void valkeyClusterAsyncFree(valkeyClusterAsyncContext *acc);
 
+int valkeyClusterAsyncGetError(const valkeyClusterAsyncContext *acc);
+const char *valkeyClusterAsyncGetErrorString(const valkeyClusterAsyncContext *acc);
+void valkeyClusterAsyncClearError(valkeyClusterAsyncContext *acc);
+
 /* Commands */
 int valkeyClusterAsyncCommand(valkeyClusterAsyncContext *acc,
                               valkeyClusterCallbackFn *fn, void *privdata,
diff --git a/include/valkey/valkey.h b/include/valkey/valkey.h
index ffdfa25d..1ff93af3 100644
--- a/include/valkey/valkey.h
+++ b/include/valkey/valkey.h
@@ -348,6 +348,9 @@ int valkeyEnableKeepAlive(valkeyContext *c);
 int valkeyEnableKeepAliveWithInterval(valkeyContext *c, int interval);
 int valkeySetTcpUserTimeout(valkeyContext *c, unsigned int timeout);
 
+int valkeyGetError(const valkeyContext *c);
+const char *valkeyGetErrorString(const valkeyContext *c);
+
 void valkeyFree(valkeyContext *c);
 valkeyFD valkeyFreeKeepFd(valkeyContext *c);
 int valkeyBufferRead(valkeyContext *c);
diff --git a/src/async.c b/src/async.c
index 9d28ff36..1482d210 100644
--- a/src/async.c
+++ b/src/async.c
@@ -408,6 +408,16 @@ void valkeyAsyncFree(valkeyAsyncContext *ac) {
         valkeyAsyncFreeInternal(ac);
 }
 
+/* Get context error status (VALKEY_OK or VALKEY_ERR_x). */
+int valkeyAsyncGetError(const valkeyAsyncContext *ac) {
+    return ac->err;
+}
+
+/* Get context error description. */
+const char *valkeyAsyncGetErrorString(const valkeyAsyncContext *ac) {
+    return ac->errstr;
+}
+
 /* Helper function to make the disconnect happen and clean up. */
 void valkeyAsyncDisconnectInternal(valkeyAsyncContext *ac) {
     valkeyContext *c = &(ac->c);
diff --git a/src/cluster.c b/src/cluster.c
index f347aa0e..fd1b2816 100644
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -218,7 +218,7 @@ static void valkeyClusterSetError(valkeyClusterContext *cc, int type,
     }
 }
 
-static inline void valkeyClusterClearError(valkeyClusterContext *cc) {
+void valkeyClusterClearError(valkeyClusterContext *cc) {
     cc->err = 0;
     cc->errstr[0] = '\0';
 }
@@ -1640,6 +1640,16 @@ int valkeyClusterSetOptionTimeout(valkeyClusterContext *cc,
     return VALKEY_OK;
 }
 
+/* Get context error status (VALKEY_OK or VALKEY_ERR_x). */
+int valkeyClusterGetError(const valkeyClusterContext *cc) {
+    return cc->err;
+}
+
+/* Get context error description. */
+const char *valkeyClusterGetErrorString(const valkeyClusterContext *cc) {
+    return cc->errstr;
+}
+
 valkeyContext *valkeyClusterGetValkeyContext(valkeyClusterContext *cc,
                                              valkeyClusterNode *node) {
     valkeyContext *c = NULL;
@@ -2650,7 +2660,7 @@ static void valkeyClusterAsyncSetError(valkeyClusterAsyncContext *acc, int type,
     acc->err = acc->cc.err;
 }
 
-static inline void valkeyClusterAsyncClearError(valkeyClusterAsyncContext *acc) {
+void valkeyClusterAsyncClearError(valkeyClusterAsyncContext *acc) {
     valkeyClusterClearError(&acc->cc);
     acc->err = acc->cc.err;
 }
@@ -2835,6 +2845,16 @@ static int valkeyClusterAsyncConnect(valkeyClusterAsyncContext *acc) {
     return updateSlotMapAsync(acc, NULL /*any node*/);
 }
 
+/* Get context error status (VALKEY_OK or VALKEY_ERR_x). */
+int valkeyClusterAsyncGetError(const valkeyClusterAsyncContext *acc) {
+    return acc->err;
+}
+
+/* Get context error description. */
+const char *valkeyClusterAsyncGetErrorString(const valkeyClusterAsyncContext *acc) {
+    return acc->errstr;
+}
+
 /* Reply callback function for CLUSTER SLOTS */
 void clusterSlotsReplyCallback(valkeyAsyncContext *ac, void *r,
                                void *privdata) {
diff --git a/src/valkey.c b/src/valkey.c
index 02a4c7fc..edf250f5 100644
--- a/src/valkey.c
+++ b/src/valkey.c
@@ -996,6 +996,16 @@ valkeyPushFn *valkeySetPushCallback(valkeyContext *c, valkeyPushFn *fn) {
     return old;
 }
 
+/* Get context error status (VALKEY_OK or VALKEY_ERR_x). */
+int valkeyGetError(const valkeyContext *c) {
+    return c->err;
+}
+
+/* Get context error description. */
+const char *valkeyGetErrorString(const valkeyContext *c) {
+    return c->errstr;
+}
+
 /* Use this function to handle a read event on the descriptor. It will try
  * and read some bytes from the socket and feed them to the reply parser.
  *
diff --git a/tests/client_test.c b/tests/client_test.c
index 5ccc4907..d4161291 100644
--- a/tests/client_test.c
+++ b/tests/client_test.c
@@ -161,7 +161,7 @@ void get_server_version(valkeyContext *c, int *majorptr, int *minorptr) {
     int major, minor;
 
     reply = valkeyCommand(c, "INFO");
-    if (reply == NULL || c->err || reply->type != VALKEY_REPLY_STRING)
+    if (reply == NULL || valkeyGetError(c) || reply->type != VALKEY_REPLY_STRING)
         goto abort;
     if ((s = strstr(reply->str, VALKEY_VERSION_FIELD)) != NULL)
         s += strlen(VALKEY_VERSION_FIELD);
@@ -258,8 +258,8 @@ static int disconnect(valkeyContext *c, int keep_fd) {
 static void do_tls_handshake(valkeyContext *c) {
 #ifdef VALKEY_TEST_TLS
     valkeyInitiateTLSWithContext(c, _tls_ctx);
-    if (c->err) {
-        printf("TLS error: %s\n", c->errstr);
+    if (valkeyGetError(c)) {
+        printf("TLS error: %s\n", valkeyGetErrorString(c));
         valkeyFree(c);
         exit(1);
     }
@@ -309,8 +309,8 @@ static valkeyContext *do_connect(struct config config) {
     if (c == NULL) {
         printf("Connection error: can't allocate valkey context\n");
         exit(1);
-    } else if (c->err) {
-        printf("Connection error: %s\n", c->errstr);
+    } else if (valkeyGetError(c)) {
+        printf("Connection error: %s\n", valkeyGetErrorString(c));
         valkeyFree(c);
         exit(1);
     }
@@ -502,7 +502,7 @@ static void test_tcp_options(struct config cfg) {
     test_cond(valkeySetTcpUserTimeout(c, 100) == VALKEY_OK);
 #else
     test("Setting TCP_USER_TIMEOUT errors when unsupported: ");
-    test_cond(valkeySetTcpUserTimeout(c, 100) == VALKEY_ERR && c->err == VALKEY_ERR_IO);
+    test_cond(valkeySetTcpUserTimeout(c, 100) == VALKEY_ERR && valkeyGetError(c) == VALKEY_ERR_IO);
 #endif
 
     valkeyFree(c);
@@ -515,7 +515,7 @@ static void test_unix_keepalive(struct config cfg) {
     c = do_connect(cfg);
 
     test("Setting TCP_KEEPALIVE on a unix socket returns an error: ");
-    test_cond(valkeyEnableKeepAlive(c) == VALKEY_ERR && c->err == 0);
+    test_cond(valkeyEnableKeepAlive(c) == VALKEY_ERR && valkeyGetError(c) == 0);
 
     test("Setting TCP_KEEPALIVE on a unix socket doesn't break the connection: ");
     r = valkeyCommand(c, "PING");
@@ -1047,17 +1047,17 @@ static void test_blocking_connection_errors(void) {
         // First see if this domain name *actually* resolves to NXDOMAIN
         c = valkeyConnect(VALKEY_BAD_DOMAIN, 6379);
         test_cond(
-            c->err == VALKEY_ERR_OTHER &&
-            (strcmp(c->errstr, "Name or service not known") == 0 ||
-             strcmp(c->errstr, "Can't resolve: " VALKEY_BAD_DOMAIN) == 0 ||
-             strcmp(c->errstr, "Name does not resolve") == 0 ||
-             strcmp(c->errstr, "nodename nor servname provided, or not known") == 0 ||
-             strcmp(c->errstr, "node name or service name not known") == 0 ||
-             strcmp(c->errstr, "No address associated with hostname") == 0 ||
-             strcmp(c->errstr, "Temporary failure in name resolution") == 0 ||
-             strcmp(c->errstr, "hostname nor servname provided, or not known") == 0 ||
-             strcmp(c->errstr, "no address associated with name") == 0 ||
-             strcmp(c->errstr, "No such host is known. ") == 0));
+            valkeyGetError(c) == VALKEY_ERR_OTHER &&
+            (strcmp(valkeyGetErrorString(c), "Name or service not known") == 0 ||
+             strcmp(valkeyGetErrorString(c), "Can't resolve: " VALKEY_BAD_DOMAIN) == 0 ||
+             strcmp(valkeyGetErrorString(c), "Name does not resolve") == 0 ||
+             strcmp(valkeyGetErrorString(c), "nodename nor servname provided, or not known") == 0 ||
+             strcmp(valkeyGetErrorString(c), "node name or service name not known") == 0 ||
+             strcmp(valkeyGetErrorString(c), "No address associated with hostname") == 0 ||
+             strcmp(valkeyGetErrorString(c), "Temporary failure in name resolution") == 0 ||
+             strcmp(valkeyGetErrorString(c), "hostname nor servname provided, or not known") == 0 ||
+             strcmp(valkeyGetErrorString(c), "no address associated with name") == 0 ||
+             strcmp(valkeyGetErrorString(c), "No such host is known. ") == 0));
         valkeyFree(c);
     } else {
         printf("Skipping NXDOMAIN test. Found evil ISP!\n");
@@ -1070,8 +1070,8 @@ static void test_blocking_connection_errors(void) {
 
     test("Returns error when the port is not open: ");
     c = valkeyConnect((char *)"localhost", 1);
-    test_cond(c->err == VALKEY_ERR_IO &&
-              strcmp(c->errstr, "Connection refused") == 0);
+    test_cond(valkeyGetError(c) == VALKEY_ERR_IO &&
+              strcmp(valkeyGetErrorString(c), "Connection refused") == 0);
     valkeyFree(c);
 
     /* Verify we don't regress from the fix in PR #1180 */
@@ -1082,17 +1082,17 @@ static void test_blocking_connection_errors(void) {
     c = valkeyConnectWithOptions(&opt);
 #ifdef __CYGWIN__
     /* Cygwin's socket layer will poll until timeout. */
-    test_cond(c->err == VALKEY_ERR_IO &&
-              strcmp(c->errstr, "Connection timed out") == 0);
+    test_cond(valkeyGetError(c) == VALKEY_ERR_IO &&
+              strcmp(valkeyGetErrorString(c), "Connection timed out") == 0);
 #else
-    test_cond(c->err == VALKEY_ERR_IO &&
-              strcmp(c->errstr, "Connection refused") == 0);
+    test_cond(valkeyGetError(c) == VALKEY_ERR_IO &&
+              strcmp(valkeyGetErrorString(c), "Connection refused") == 0);
 #endif
     valkeyFree(c);
 
     test("Returns error when the unix_sock socket path doesn't accept connections: ");
     c = valkeyConnectUnix((char *)"/tmp/idontexist.sock");
-    test_cond(c->err == VALKEY_ERR_IO); /* Don't care about the message... */
+    test_cond(valkeyGetError(c) == VALKEY_ERR_IO); /* Don't care about the message... */
     valkeyFree(c);
 #endif
 }
@@ -1373,8 +1373,8 @@ static int detect_debug_sleep(valkeyContext *c) {
     int detected;
     valkeyReply *reply = valkeyCommand(c, "DEBUG SLEEP 0\r\n");
 
-    if (reply == NULL || c->err) {
-        const char *cause = c->err ? c->errstr : "(none)";
+    if (reply == NULL || valkeyGetError(c)) {
+        const char *cause = valkeyGetError(c) ? valkeyGetErrorString(c) : "(none)";
         fprintf(stderr, "Error testing for DEBUG SLEEP (server error: %s), exiting\n", cause);
         exit(-1);
     }
@@ -1416,11 +1416,11 @@ static void test_blocking_connection_timeouts(struct config config) {
         valkeySetTimeout(c, tv);
         reply = valkeyCommand(c, "GET foo");
 #ifndef _WIN32
-        test_cond(s > 0 && reply == NULL && c->err == VALKEY_ERR_IO &&
-                  strcmp(c->errstr, "Resource temporarily unavailable") == 0);
+        test_cond(s > 0 && reply == NULL && valkeyGetError(c) == VALKEY_ERR_IO &&
+                  strcmp(valkeyGetErrorString(c), "Resource temporarily unavailable") == 0);
 #else
-        test_cond(s > 0 && reply == NULL && c->err == VALKEY_ERR_TIMEOUT &&
-                  strcmp(c->errstr, "recv timeout") == 0);
+        test_cond(s > 0 && reply == NULL && valkeyGetError(c) == VALKEY_ERR_TIMEOUT &&
+                  strcmp(valkeyGetErrorString(c), "recv timeout") == 0);
 #endif
         freeReplyObject(reply);
 
@@ -1475,8 +1475,8 @@ static void test_blocking_io_errors(struct config config) {
      * On >2.0, QUIT will return with OK and another read(2) needed to be
      * issued to find out the socket was closed by the server. In both
      * conditions, the error will be set to EOF. */
-    assert(c->err == VALKEY_ERR_EOF &&
-           strcmp(c->errstr, "Server closed the connection") == 0);
+    assert(valkeyGetError(c) == VALKEY_ERR_EOF &&
+           strcmp(valkeyGetErrorString(c), "Server closed the connection") == 0);
 #endif
     valkeyFree(c);
 
@@ -1486,9 +1486,9 @@ static void test_blocking_io_errors(struct config config) {
     assert(valkeySetTimeout(c, tv) == VALKEY_OK);
     int respcode = valkeyGetReply(c, &_reply);
 #ifndef _WIN32
-    test_cond(respcode == VALKEY_ERR && c->err == VALKEY_ERR_IO && errno == EAGAIN);
+    test_cond(respcode == VALKEY_ERR && valkeyGetError(c) == VALKEY_ERR_IO && errno == EAGAIN);
 #else
-    test_cond(respcode == VALKEY_ERR && c->err == VALKEY_ERR_TIMEOUT);
+    test_cond(respcode == VALKEY_ERR && valkeyGetError(c) == VALKEY_ERR_TIMEOUT);
 #endif
     valkeyFree(c);
 }
@@ -1521,7 +1521,7 @@ static void test_invalid_timeout_errors(struct config config) {
         valkeyTestPanic("Unknown connection type!");
     }
 
-    test_cond(c != NULL && c->err == VALKEY_ERR_IO && strcmp(c->errstr, "Invalid timeout specified") == 0);
+    test_cond(c != NULL && valkeyGetError(c) == VALKEY_ERR_IO && strcmp(valkeyGetErrorString(c), "Invalid timeout specified") == 0);
     valkeyFree(c);
 
     test("Set error when an invalid timeout sec value is used during connect: ");
@@ -1549,7 +1549,7 @@ static void test_invalid_timeout_errors(struct config config) {
         valkeyTestPanic("Unknown connection type!");
     }
 
-    test_cond(c != NULL && c->err == VALKEY_ERR_IO && strcmp(c->errstr, "Invalid timeout specified") == 0);
+    test_cond(c != NULL && valkeyGetError(c) == VALKEY_ERR_IO && strcmp(valkeyGetErrorString(c), "Invalid timeout specified") == 0);
     valkeyFree(c);
 }
 
@@ -1898,7 +1898,7 @@ static void test_pubsub_handling(struct config config) {
     /* Connect */
     valkeyOptions options = get_server_tcp_options(config);
     valkeyAsyncContext *ac = valkeyAsyncConnectWithOptions(&options);
-    assert(ac != NULL && ac->err == 0);
+    assert(ac != NULL && valkeyAsyncGetError(ac) == 0);
     valkeyLibeventAttach(ac, base);
 
     /* Start subscribe */
@@ -1931,7 +1931,7 @@ static void test_sharded_pubsub_handling(struct config config) {
     /* Connect */
     valkeyOptions options = get_server_tcp_cluster_options(config);
     valkeyAsyncContext *ac = valkeyAsyncConnectWithOptions(&options);
-    assert(ac != NULL && ac->err == 0);
+    assert(ac != NULL && valkeyAsyncGetError(ac) == 0);
     valkeyLibeventAttach(ac, base);
 
     /* Start subscribe */
@@ -1964,7 +1964,7 @@ static void test_sharded_pubsub_error_handling(struct config config) {
     /* Connect */
     valkeyOptions options = get_server_tcp_cluster_options(config);
     valkeyAsyncContext *ac = valkeyAsyncConnectWithOptions(&options);
-    assert(ac != NULL && ac->err == 0);
+    assert(ac != NULL && valkeyAsyncGetError(ac) == 0);
     valkeyLibeventAttach(ac, base);
 
     /* Start subscribe */
@@ -2000,7 +2000,7 @@ static void test_sharded_pubsub_crossslot_handling(struct config config) {
     /* Connect */
     valkeyOptions options = get_server_tcp_cluster_options(config);
     valkeyAsyncContext *ac = valkeyAsyncConnectWithOptions(&options);
-    assert(ac != NULL && ac->err == 0);
+    assert(ac != NULL && valkeyAsyncGetError(ac) == 0);
     valkeyLibeventAttach(ac, base);
 
     /* Start subscribe */
@@ -2039,7 +2039,7 @@ static void test_pubsub_handling_resp3(struct config config) {
     /* Connect */
     valkeyOptions options = get_server_tcp_options(config);
     valkeyAsyncContext *ac = valkeyAsyncConnectWithOptions(&options);
-    assert(ac != NULL && ac->err == 0);
+    assert(ac != NULL && valkeyAsyncGetError(ac) == 0);
     valkeyLibeventAttach(ac, base);
 
     /* Not expecting any push messages in this test */
@@ -2082,7 +2082,7 @@ static void test_sharded_pubsub_handling_resp3(struct config config) {
     /* Connect */
     valkeyOptions options = get_server_tcp_cluster_options(config);
     valkeyAsyncContext *ac = valkeyAsyncConnectWithOptions(&options);
-    assert(ac != NULL && ac->err == 0);
+    assert(ac != NULL && valkeyAsyncGetError(ac) == 0);
     valkeyLibeventAttach(ac, base);
 
     /* Not expecting any push messages in this test */
@@ -2163,7 +2163,7 @@ static void test_command_timeout_during_pubsub(struct config config) {
     /* Connect */
     valkeyOptions options = get_server_tcp_options(config);
     valkeyAsyncContext *ac = valkeyAsyncConnectWithOptions(&options);
-    assert(ac != NULL && ac->err == 0);
+    assert(ac != NULL && valkeyAsyncGetError(ac) == 0);
     valkeyLibeventAttach(ac, base);
 
     /* Configure a command timeout */
@@ -2268,7 +2268,7 @@ static void test_pubsub_multiple_channels(struct config config) {
     /* Connect */
     valkeyOptions options = get_server_tcp_options(config);
     valkeyAsyncContext *ac = valkeyAsyncConnectWithOptions(&options);
-    assert(ac != NULL && ac->err == 0);
+    assert(ac != NULL && valkeyAsyncGetError(ac) == 0);
     valkeyLibeventAttach(ac, base);
 
     /* Not expecting any push messages in this test */
@@ -2345,7 +2345,7 @@ static void test_monitor(struct config config) {
     /* Connect */
     valkeyOptions options = get_server_tcp_options(config);
     valkeyAsyncContext *ac = valkeyAsyncConnectWithOptions(&options);
-    assert(ac != NULL && ac->err == 0);
+    assert(ac != NULL && valkeyAsyncGetError(ac) == 0);
     valkeyLibeventAttach(ac, base);
 
     /* Not expecting any push messages in this test */
@@ -2402,28 +2402,28 @@ static void asCleanup(void *data) {
 
 static void commandCallback(struct valkeyAsyncContext *ac, void *_reply, void *_privdata);
 
-static void connectCallback(valkeyAsyncContext *c, int status) {
-    struct _astest *t = (struct _astest *)c->data;
+static void connectCallback(valkeyAsyncContext *ac, int status) {
+    struct _astest *t = (struct _astest *)ac->data;
     assert(t == &astest);
     assert(t->connects == 0);
-    t->err = c->err;
-    memcpy(t->errstr, c->errstr, sizeof(t->errstr));
+    t->err = valkeyAsyncGetError(ac);
+    memcpy(t->errstr, valkeyAsyncGetErrorString(ac), sizeof(t->errstr));
     t->connects++;
     t->connect_status = status;
     t->connected = status == VALKEY_OK ? 1 : -1;
 
     if (t->testno == ASTEST_ISSUE_931) {
         /* disconnect again */
-        valkeyAsyncDisconnect(c);
+        valkeyAsyncDisconnect(ac);
     } else if (t->testno == ASTEST_ISSUE_931_PING) {
-        valkeyAsyncCommand(c, commandCallback, NULL, "PING");
+        valkeyAsyncCommand(ac, commandCallback, NULL, "PING");
     }
 }
-static void disconnectCallback(const valkeyAsyncContext *c, int status) {
-    assert(c->data == (void *)&astest);
+static void disconnectCallback(const valkeyAsyncContext *ac, int status) {
+    assert(ac->data == (void *)&astest);
     assert(astest.disconnects == 0);
-    astest.err = c->err;
-    memcpy(astest.errstr, c->errstr, sizeof(astest.errstr));
+    astest.err = valkeyAsyncGetError(ac);
+    memcpy(astest.errstr, valkeyAsyncGetErrorString(ac), sizeof(astest.errstr));
     astest.disconnects++;
     astest.disconnect_status = status;
     astest.connected = 0;
@@ -2434,8 +2434,8 @@ static void commandCallback(struct valkeyAsyncContext *ac, void *_reply, void *_
     struct _astest *t = (struct _astest *)ac->data;
     assert(t == &astest);
     (void)_privdata;
-    t->err = ac->err;
-    memcpy(t->errstr, ac->errstr, sizeof(t->errstr));
+    t->err = valkeyAsyncGetError(ac);
+    memcpy(t->errstr, valkeyAsyncGetErrorString(ac), sizeof(t->errstr));
     t->counter++;
     if (t->testno == ASTEST_PINGPONG || t->testno == ASTEST_ISSUE_931_PING) {
         assert(reply != NULL && reply->type == VALKEY_REPLY_STATUS && strcmp(reply->str, "PONG") == 0);
@@ -2511,14 +2511,14 @@ static void as_printerr(void) {
 
 static void test_async_polling(struct config config) {
     int status;
-    valkeyAsyncContext *c;
+    valkeyAsyncContext *ac;
     struct config defaultconfig = config;
 
     test("Async connect: ");
-    c = do_aconnect(config, ASTEST_CONNECT);
-    assert(c);
+    ac = do_aconnect(config, ASTEST_CONNECT);
+    assert(ac);
     while (astest.connected == 0)
-        valkeyPollTick(c, 0.1);
+        valkeyPollTick(ac, 0.1);
     assert(astest.connects == 1);
     ASASSERT(astest.connect_status == VALKEY_OK);
     assert(astest.disconnects == 0);
@@ -2526,7 +2526,7 @@ static void test_async_polling(struct config config) {
 
     test("Async free after connect: ");
     assert(astest.ac != NULL);
-    valkeyAsyncFree(c);
+    valkeyAsyncFree(ac);
     assert(astest.disconnects == 1);
     assert(astest.ac == NULL);
     test_cond(astest.disconnect_status == VALKEY_OK);
@@ -2536,11 +2536,11 @@ static void test_async_polling(struct config config) {
         test("Async connect timeout: ");
         config.tcp.host = "192.168.254.254"; /* blackhole ip */
         config.connect_timeout.tv_usec = 100000;
-        c = do_aconnect(config, ASTEST_CONN_TIMEOUT);
-        assert(c);
-        assert(c->err == 0);
+        ac = do_aconnect(config, ASTEST_CONN_TIMEOUT);
+        assert(ac);
+        assert(valkeyAsyncGetError(ac) == 0);
         while (astest.connected == 0)
-            valkeyPollTick(c, 0.1);
+            valkeyPollTick(ac, 0.1);
         assert(astest.connected == -1);
         /*
          * freeing should not be done, clearing should have happened.
@@ -2553,47 +2553,47 @@ static void test_async_polling(struct config config) {
 
     /* Test a ping/pong after connection */
     test("Async PING/PONG: ");
-    c = do_aconnect(config, ASTEST_PINGPONG);
+    ac = do_aconnect(config, ASTEST_PINGPONG);
     while (astest.connected == 0)
-        valkeyPollTick(c, 0.1);
-    status = valkeyAsyncCommand(c, commandCallback, NULL, "PING");
+        valkeyPollTick(ac, 0.1);
+    status = valkeyAsyncCommand(ac, commandCallback, NULL, "PING");
     assert(status == VALKEY_OK);
     while (astest.ac)
-        valkeyPollTick(c, 0.1);
+        valkeyPollTick(ac, 0.1);
     test_cond(astest.pongs == 1);
 
     /* Test a ping/pong after connection that didn't time out. */
     if (config.type == CONN_TCP || config.type == CONN_TLS) {
         test("Async PING/PONG after connect timeout: ");
         config.connect_timeout.tv_usec = 10000; /* 10ms  */
-        c = do_aconnect(config, ASTEST_PINGPONG_TIMEOUT);
+        ac = do_aconnect(config, ASTEST_PINGPONG_TIMEOUT);
         while (astest.connected == 0)
-            valkeyPollTick(c, 0.1);
+            valkeyPollTick(ac, 0.1);
         /* sleep 0.1 s, allowing old timeout to arrive */
         millisleep(10);
-        status = valkeyAsyncCommand(c, commandCallback, NULL, "PING");
+        status = valkeyAsyncCommand(ac, commandCallback, NULL, "PING");
         assert(status == VALKEY_OK);
         while (astest.ac)
-            valkeyPollTick(c, 0.1);
+            valkeyPollTick(ac, 0.1);
         test_cond(astest.pongs == 2);
         config = defaultconfig;
     }
 
     /* Test disconnect from an on_connect callback */
     test("Disconnect from onConnected callback (Issue #931): ");
-    c = do_aconnect(config, ASTEST_ISSUE_931);
+    ac = do_aconnect(config, ASTEST_ISSUE_931);
     while (astest.disconnects == 0)
-        valkeyPollTick(c, 0.1);
+        valkeyPollTick(ac, 0.1);
     assert(astest.connected == 0);
     assert(astest.connects == 1);
     test_cond(astest.disconnects == 1);
 
     /* Test ping/pong from an on_connect callback */
     test("Ping/Pong from onConnected callback (Issue #931): ");
-    c = do_aconnect(config, ASTEST_ISSUE_931_PING);
+    ac = do_aconnect(config, ASTEST_ISSUE_931_PING);
     /* connect callback issues ping, response callback destroys context */
     while (astest.ac)
-        valkeyPollTick(c, 0.1);
+        valkeyPollTick(ac, 0.1);
     assert(astest.connected == 0);
     assert(astest.connects == 1);
     assert(astest.disconnects == 1);
diff --git a/tests/clusterclient.c b/tests/clusterclient.c
index 97517db2..b12ae031 100644
--- a/tests/clusterclient.c
+++ b/tests/clusterclient.c
@@ -99,8 +99,8 @@ int main(int argc, char **argv) {
     }
 
     valkeyClusterContext *cc = valkeyClusterConnectWithOptions(&options);
-    if (cc == NULL || cc->err) {
-        printf("Connect error: %s\n", cc ? cc->errstr : "OOM");
+    if (cc == NULL || valkeyClusterGetError(cc)) {
+        printf("Connect error: %s\n", cc ? valkeyClusterGetErrorString(cc) : "OOM");
         exit(2);
     }
 
@@ -129,8 +129,8 @@ int main(int argc, char **argv) {
             while ((node = valkeyClusterNodeNext(&ni)) != NULL) {
                 valkeyReply *reply =
                     valkeyClusterCommandToNode(cc, node, command);
-                if (!reply || cc->err) {
-                    printf("error: %s\n", cc->errstr);
+                if (!reply || valkeyClusterGetError(cc)) {
+                    printf("error: %s\n", valkeyClusterGetErrorString(cc));
                 } else {
                     printReply(reply);
                 }
@@ -142,8 +142,8 @@ int main(int argc, char **argv) {
             }
         } else {
             valkeyReply *reply = valkeyClusterCommand(cc, command);
-            if (!reply || cc->err) {
-                printf("error: %s\n", cc->errstr);
+            if (!reply || valkeyClusterGetError(cc)) {
+                printf("error: %s\n", valkeyClusterGetErrorString(cc));
             } else {
                 printReply(reply);
             }
diff --git a/tests/clusterclient_async.c b/tests/clusterclient_async.c
index f8f000be..854a4c52 100644
--- a/tests/clusterclient_async.c
+++ b/tests/clusterclient_async.c
@@ -83,8 +83,8 @@ void replyCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
     intptr_t cmd_id = (intptr_t)privdata; /* Id to corresponding cmd */
 
     if (reply == NULL) {
-        if (acc->err) {
-            printf("error: %s\n", acc->errstr);
+        if (valkeyClusterAsyncGetError(acc)) {
+            printf("error: %s\n", valkeyClusterAsyncGetErrorString(acc));
         } else {
             printf("unknown error\n");
         }
@@ -163,7 +163,7 @@ void sendNextCommand(evutil_socket_t fd, short kind, void *arg) {
                 int status = valkeyClusterAsyncCommandToNode(
                     acc, node, replyCallback, (void *)((intptr_t)num_running),
                     cmd);
-                ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+                ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
                 num_running++;
             }
         } else {
@@ -172,7 +172,7 @@ void sendNextCommand(evutil_socket_t fd, short kind, void *arg) {
             if (status == VALKEY_OK) {
                 num_running++;
             } else {
-                printf("error: %s\n", acc->errstr);
+                printf("error: %s\n", valkeyClusterAsyncGetErrorString(acc));
 
                 /* Schedule a read from stdin and handle next command. */
                 struct timeval timeout = {0, 10};
@@ -286,8 +286,8 @@ int main(int argc, char **argv) {
     valkeyClusterOptionsUseLibevent(&options, base);
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
-    if (acc == NULL || acc->err != 0) {
-        printf("Connect error: %s\n", acc ? acc->errstr : "OOM");
+    if (acc == NULL || valkeyClusterAsyncGetError(acc) != 0) {
+        printf("Connect error: %s\n", acc ? valkeyClusterAsyncGetErrorString(acc) : "OOM");
         exit(2);
     }
 
diff --git a/tests/ct_async.c b/tests/ct_async.c
index 5af0e88d..a356dbfe 100644
--- a/tests/ct_async.c
+++ b/tests/ct_async.c
@@ -11,7 +11,7 @@
 void getCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
     UNUSED(privdata);
     valkeyReply *reply = (valkeyReply *)r;
-    ASSERT_MSG(reply != NULL, acc->errstr);
+    ASSERT_MSG(reply != NULL, valkeyClusterAsyncGetErrorString(acc));
 
     /* Disconnect after receiving the first reply to GET */
     valkeyClusterAsyncDisconnect(acc);
@@ -20,16 +20,16 @@ void getCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
 void setCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
     UNUSED(privdata);
     valkeyReply *reply = (valkeyReply *)r;
-    ASSERT_MSG(reply != NULL, acc->errstr);
+    ASSERT_MSG(reply != NULL, valkeyClusterAsyncGetErrorString(acc));
 }
 
 void connectCallback(valkeyAsyncContext *ac, int status) {
-    ASSERT_MSG(status == VALKEY_OK, ac->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyAsyncGetErrorString(ac));
     printf("Connected to %s:%d\n", ac->c.tcp.host, ac->c.tcp.port);
 }
 
 void disconnectCallback(const valkeyAsyncContext *ac, int status) {
-    ASSERT_MSG(status == VALKEY_OK, ac->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyAsyncGetErrorString(ac));
     printf("Disconnected from %s:%d\n", ac->c.tcp.host, ac->c.tcp.port);
 }
 
@@ -45,20 +45,20 @@ void eventCallback(const valkeyClusterContext *cc, int event, void *privdata) {
         int status;
         status = valkeyClusterAsyncCommand(acc, setCallback, (char *)"ID",
                                            "SET key12345 value");
-        ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+        ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
         /* This command will trigger a disconnect in its reply callback. */
         status = valkeyClusterAsyncCommand(acc, getCallback, (char *)"ID",
                                            "GET key12345");
-        ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+        ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
         status = valkeyClusterAsyncCommand(acc, setCallback, (char *)"ID",
                                            "SET key23456 value2");
-        ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+        ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
         status = valkeyClusterAsyncCommand(acc, getCallback, (char *)"ID",
                                            "GET key23456");
-        ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+        ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
     }
 }
 
@@ -73,7 +73,7 @@ int main(void) {
     valkeyClusterOptionsUseLibevent(&options, base);
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
-    assert(acc && acc->err == 0);
+    assert(acc && valkeyClusterAsyncGetError(acc) == 0);
 
     event_base_dispatch(base);
 
diff --git a/tests/ct_async_glib.c b/tests/ct_async_glib.c
index 34c5c89b..0eef781b 100644
--- a/tests/ct_async_glib.c
+++ b/tests/ct_async_glib.c
@@ -11,13 +11,13 @@ static GMainLoop *mainloop;
 void setCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
     UNUSED(privdata);
     valkeyReply *reply = (valkeyReply *)r;
-    ASSERT_MSG(reply != NULL, acc->errstr);
+    ASSERT_MSG(reply != NULL, valkeyClusterAsyncGetErrorString(acc));
 }
 
 void getCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
     UNUSED(privdata);
     valkeyReply *reply = (valkeyReply *)r;
-    ASSERT_MSG(reply != NULL, acc->errstr);
+    ASSERT_MSG(reply != NULL, valkeyClusterAsyncGetErrorString(acc));
 
     /* Disconnect after receiving the first reply to GET */
     valkeyClusterAsyncDisconnect(acc);
@@ -25,12 +25,12 @@ void getCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
 }
 
 void connectCallback(valkeyAsyncContext *ac, int status) {
-    ASSERT_MSG(status == VALKEY_OK, ac->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyAsyncGetErrorString(ac));
     printf("Connected to %s:%d\n", ac->c.tcp.host, ac->c.tcp.port);
 }
 
 void disconnectCallback(const valkeyAsyncContext *ac, int status) {
-    ASSERT_MSG(status == VALKEY_OK, ac->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyAsyncGetErrorString(ac));
     printf("Disconnected from %s:%d\n", ac->c.tcp.host, ac->c.tcp.port);
 }
 
@@ -50,14 +50,14 @@ int main(int argc, char **argv) {
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
     assert(acc);
-    ASSERT_MSG(acc->err == 0, acc->errstr);
+    ASSERT_MSG(valkeyClusterAsyncGetError(acc) == 0, valkeyClusterAsyncGetErrorString(acc));
 
     int status;
     status = valkeyClusterAsyncCommand(acc, setCallback, (char *)"id", "SET key value");
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     status = valkeyClusterAsyncCommand(acc, getCallback, (char *)"id", "GET key");
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     g_main_loop_run(mainloop);
 
diff --git a/tests/ct_async_libev.c b/tests/ct_async_libev.c
index 0a89562f..52b4d644 100644
--- a/tests/ct_async_libev.c
+++ b/tests/ct_async_libev.c
@@ -9,25 +9,25 @@
 void setCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
     UNUSED(privdata);
     valkeyReply *reply = (valkeyReply *)r;
-    ASSERT_MSG(reply != NULL, acc->errstr);
+    ASSERT_MSG(reply != NULL, valkeyClusterAsyncGetErrorString(acc));
 }
 
 void getCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
     UNUSED(privdata);
     valkeyReply *reply = (valkeyReply *)r;
-    ASSERT_MSG(reply != NULL, acc->errstr);
+    ASSERT_MSG(reply != NULL, valkeyClusterAsyncGetErrorString(acc));
 
     /* Disconnect after receiving the first reply to GET */
     valkeyClusterAsyncDisconnect(acc);
 }
 
 void connectCallback(valkeyAsyncContext *ac, int status) {
-    ASSERT_MSG(status == VALKEY_OK, ac->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyAsyncGetErrorString(ac));
     printf("Connected to %s:%d\n", ac->c.tcp.host, ac->c.tcp.port);
 }
 
 void disconnectCallback(const valkeyAsyncContext *ac, int status) {
-    ASSERT_MSG(status == VALKEY_OK, ac->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyAsyncGetErrorString(ac));
     printf("Disconnected from %s:%d\n", ac->c.tcp.host, ac->c.tcp.port);
 }
 
@@ -44,16 +44,16 @@ int main(int argc, char **argv) {
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
     assert(acc);
-    ASSERT_MSG(acc->err == 0, acc->errstr);
+    ASSERT_MSG(valkeyClusterAsyncGetError(acc) == 0, valkeyClusterAsyncGetErrorString(acc));
 
     int status;
     status = valkeyClusterAsyncCommand(acc, setCallback, (char *)"ID",
                                        "SET key value");
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     status =
         valkeyClusterAsyncCommand(acc, getCallback, (char *)"ID", "GET key");
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     ev_loop(EV_DEFAULT_ 0);
 
diff --git a/tests/ct_async_libuv.c b/tests/ct_async_libuv.c
index 8bb22d7c..167bdcdb 100644
--- a/tests/ct_async_libuv.c
+++ b/tests/ct_async_libuv.c
@@ -10,25 +10,25 @@
 void setCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
     UNUSED(privdata);
     valkeyReply *reply = (valkeyReply *)r;
-    ASSERT_MSG(reply != NULL, acc->errstr);
+    ASSERT_MSG(reply != NULL, valkeyClusterAsyncGetErrorString(acc));
 }
 
 void getCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
     UNUSED(privdata);
     valkeyReply *reply = (valkeyReply *)r;
-    ASSERT_MSG(reply != NULL, acc->errstr);
+    ASSERT_MSG(reply != NULL, valkeyClusterAsyncGetErrorString(acc));
 
     /* Disconnect after receiving the first reply to GET */
     valkeyClusterAsyncDisconnect(acc);
 }
 
 void connectCallback(valkeyAsyncContext *ac, int status) {
-    ASSERT_MSG(status == VALKEY_OK, ac->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyAsyncGetErrorString(ac));
     printf("Connected to %s:%d\n", ac->c.tcp.host, ac->c.tcp.port);
 }
 
 void disconnectCallback(const valkeyAsyncContext *ac, int status) {
-    ASSERT_MSG(status == VALKEY_OK, ac->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyAsyncGetErrorString(ac));
     printf("Disconnected from %s:%d\n", ac->c.tcp.host, ac->c.tcp.port);
 }
 
@@ -47,16 +47,16 @@ int main(int argc, char **argv) {
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
     assert(acc);
-    ASSERT_MSG(acc->err == 0, acc->errstr);
+    ASSERT_MSG(valkeyClusterAsyncGetError(acc) == 0, valkeyClusterAsyncGetErrorString(acc));
 
     int status;
     status = valkeyClusterAsyncCommand(acc, setCallback, (char *)"ID",
                                        "SET key value");
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     status =
         valkeyClusterAsyncCommand(acc, getCallback, (char *)"ID", "GET key");
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     uv_run(loop, UV_RUN_DEFAULT);
 
diff --git a/tests/ct_commands.c b/tests/ct_commands.c
index cf3e5e35..71c35313 100644
--- a/tests/ct_commands.c
+++ b/tests/ct_commands.c
@@ -467,7 +467,7 @@ int main(void) {
     options.connect_timeout = &timeout;
 
     valkeyClusterContext *cc = valkeyClusterConnectWithOptions(&options);
-    ASSERT_MSG(cc && cc->err == 0, cc ? cc->errstr : "OOM");
+    ASSERT_MSG(cc && valkeyClusterGetError(cc) == 0, cc ? valkeyClusterGetErrorString(cc) : "OOM");
     load_valkey_version(cc);
 
     test_bitfield(cc);
diff --git a/tests/ct_connection.c b/tests/ct_connection.c
index cf5278ae..1d5996c6 100644
--- a/tests/ct_connection.c
+++ b/tests/ct_connection.c
@@ -35,7 +35,7 @@ void test_unsupported_option(void) {
 
     valkeyClusterContext *cc = valkeyClusterConnectWithOptions(&options);
     assert(cc);
-    assert(strcmp(cc->errstr, "Unsupported options") == 0);
+    assert(strcmp(valkeyClusterGetErrorString(cc), "Unsupported options") == 0);
 
     valkeyClusterFree(cc);
 }
@@ -49,7 +49,7 @@ void test_password_ok(void) {
     options.connect_callback = connect_callback;
 
     valkeyClusterContext *cc = valkeyClusterConnectWithOptions(&options);
-    ASSERT_MSG(cc && cc->err == 0, cc ? cc->errstr : "OOM");
+    ASSERT_MSG(cc && valkeyClusterGetError(cc) == 0, cc ? valkeyClusterGetErrorString(cc) : "OOM");
     assert(connect_success_counter == 1); // for CLUSTER SLOTS
     load_valkey_version(cc);
     assert(connect_success_counter == 2); // for checking valkey version
@@ -77,11 +77,11 @@ void test_password_wrong(void) {
     valkeyClusterContext *cc = valkeyClusterConnectWithOptions(&options);
     assert(cc);
 
-    assert(cc->err == VALKEY_ERR_OTHER);
+    assert(valkeyClusterGetError(cc) == VALKEY_ERR_OTHER);
     if (valkey_version_less_than(6, 0))
-        assert(strcmp(cc->errstr, "ERR invalid password") == 0);
+        assert(strcmp(valkeyClusterGetErrorString(cc), "ERR invalid password") == 0);
     else
-        assert(strncmp(cc->errstr, "WRONGPASS", 9) == 0);
+        assert(strncmp(valkeyClusterGetErrorString(cc), "WRONGPASS", 9) == 0);
 
     valkeyClusterFree(cc);
 }
@@ -96,8 +96,8 @@ void test_password_missing(void) {
     valkeyClusterContext *cc = valkeyClusterConnectWithOptions(&options);
     assert(cc);
 
-    assert(cc->err == VALKEY_ERR_OTHER);
-    assert(strncmp(cc->errstr, "NOAUTH", 6) == 0);
+    assert(valkeyClusterGetError(cc) == VALKEY_ERR_OTHER);
+    assert(strncmp(valkeyClusterGetErrorString(cc), "NOAUTH", 6) == 0);
 
     valkeyClusterFree(cc);
 }
@@ -115,7 +115,7 @@ void test_username_ok(void) {
     options.password = CLUSTER_PASSWORD;
 
     valkeyClusterContext *cc = valkeyClusterConnectWithOptions(&options);
-    ASSERT_MSG(cc && cc->err == 0, cc ? cc->errstr : "OOM");
+    ASSERT_MSG(cc && valkeyClusterGetError(cc) == 0, cc ? valkeyClusterGetErrorString(cc) : "OOM");
 
     // Test connection
     valkeyReply *reply = valkeyClusterCommand(cc, "SET key1 Hello");
@@ -183,8 +183,8 @@ void test_connect_timeout(void) {
 
     valkeyClusterContext *cc = valkeyClusterConnectWithOptions(&options);
     assert(cc);
-    assert(cc->err == VALKEY_ERR_IO);
-    assert(strcmp(cc->errstr, "Connection timed out") == 0);
+    assert(valkeyClusterGetError(cc) == VALKEY_ERR_IO);
+    assert(strcmp(valkeyClusterGetErrorString(cc), "Connection timed out") == 0);
     assert(connect_success_counter == 0);
     assert(connect_failure_counter == 1);
     reset_counters();
@@ -201,7 +201,7 @@ void test_command_timeout(void) {
     options.command_timeout = &timeout;
 
     valkeyClusterContext *cc = valkeyClusterConnectWithOptions(&options);
-    ASSERT_MSG(cc && cc->err == 0, cc ? cc->errstr : "OOM");
+    ASSERT_MSG(cc && valkeyClusterGetError(cc) == 0, cc ? valkeyClusterGetErrorString(cc) : "OOM");
 
     valkeyClusterNodeIterator ni;
     valkeyClusterInitNodeIterator(&ni, cc);
@@ -212,7 +212,7 @@ void test_command_timeout(void) {
     valkeyReply *reply;
     reply = valkeyClusterCommandToNode(cc, node, "DEBUG SLEEP 0.2");
     assert(reply == NULL);
-    assert(cc->err == VALKEY_ERR_IO);
+    assert(valkeyClusterGetError(cc) == VALKEY_ERR_IO);
 
     /* Make sure debug sleep is done before leaving testcase */
     for (int i = 0; i < 20; ++i) {
@@ -229,7 +229,7 @@ void test_command_timeout(void) {
 /* Connect and configure a command timeout while connected. */
 void test_command_timeout_set_while_connected(void) {
     valkeyClusterContext *cc = valkeyClusterConnect(CLUSTER_NODE);
-    ASSERT_MSG(cc && cc->err == 0, cc ? cc->errstr : "OOM");
+    ASSERT_MSG(cc && valkeyClusterGetError(cc) == 0, cc ? valkeyClusterGetErrorString(cc) : "OOM");
 
     valkeyClusterNodeIterator ni;
     valkeyClusterInitNodeIterator(&ni, cc);
@@ -247,7 +247,7 @@ void test_command_timeout_set_while_connected(void) {
 
     reply = valkeyClusterCommandToNode(cc, node, "DEBUG SLEEP 0.2");
     assert(reply == NULL);
-    assert(cc->err == VALKEY_ERR_IO);
+    assert(valkeyClusterGetError(cc) == VALKEY_ERR_IO);
 
     /* Make sure debug sleep is done before leaving testcase */
     for (int i = 0; i < 20; ++i) {
@@ -283,12 +283,12 @@ void disconnectCallback(const valkeyAsyncContext *ac, int status) {
 }
 
 // Callback for async commands, verifies the valkeyReply
-void commandCallback(valkeyClusterAsyncContext *cc, void *r, void *privdata) {
+void commandCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
     valkeyReply *reply = (valkeyReply *)r;
     ExpectedResult *expect = (ExpectedResult *)privdata;
     if (expect->noreply) {
         assert(reply == NULL);
-        assert(strcmp(cc->errstr, expect->errstr) == 0);
+        assert(strcmp(valkeyClusterAsyncGetErrorString(acc), expect->errstr) == 0);
     } else {
         assert(reply != NULL);
         assert(reply->type == expect->type);
@@ -301,7 +301,7 @@ void commandCallback(valkeyClusterAsyncContext *cc, void *r, void *privdata) {
         }
     }
     if (expect->disconnect)
-        valkeyClusterAsyncDisconnect(cc);
+        valkeyClusterAsyncDisconnect(acc);
 }
 
 // Connecting to a password protected cluster using
@@ -318,7 +318,7 @@ void test_async_password_ok(void) {
     valkeyClusterOptionsUseLibevent(&options, base);
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
-    ASSERT_MSG(acc && acc->err == 0, acc ? acc->errstr : "OOM");
+    ASSERT_MSG(acc && valkeyClusterAsyncGetError(acc) == 0, acc ? valkeyClusterAsyncGetErrorString(acc) : "OOM");
 
     // Test connection
     ExpectedResult r = {
@@ -345,18 +345,18 @@ void test_async_password_wrong(void) {
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
     assert(acc);
-    assert(acc->err == VALKEY_ERR_OTHER);
+    assert(valkeyClusterAsyncGetError(acc) == VALKEY_ERR_OTHER);
     if (valkey_version_less_than(6, 0))
-        assert(strcmp(acc->errstr, "ERR invalid password") == 0);
+        assert(strcmp(valkeyClusterAsyncGetErrorString(acc), "ERR invalid password") == 0);
     else
-        assert(strncmp(acc->errstr, "WRONGPASS", 9) == 0);
+        assert(strncmp(valkeyClusterAsyncGetErrorString(acc), "WRONGPASS", 9) == 0);
 
     // No connection
     ExpectedResult r;
     int ret = valkeyClusterAsyncCommand(acc, commandCallback, &r, "SET key1 Hello");
     assert(ret == VALKEY_ERR);
-    assert(acc->err == VALKEY_ERR_OTHER);
-    assert(strcmp(acc->errstr, "slotmap not available") == 0);
+    assert(valkeyClusterAsyncGetError(acc) == VALKEY_ERR_OTHER);
+    assert(strcmp(valkeyClusterAsyncGetErrorString(acc), "slotmap not available") == 0);
 
     valkeyClusterAsyncFree(acc);
     event_base_free(base);
@@ -377,15 +377,15 @@ void test_async_password_missing(void) {
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
     assert(acc);
-    assert(acc->err == VALKEY_ERR_OTHER);
-    assert(strncmp(acc->errstr, "NOAUTH", 6) == 0);
+    assert(valkeyClusterAsyncGetError(acc) == VALKEY_ERR_OTHER);
+    assert(strncmp(valkeyClusterAsyncGetErrorString(acc), "NOAUTH", 6) == 0);
 
     // No connection
     ExpectedResult r;
     int ret = valkeyClusterAsyncCommand(acc, commandCallback, &r, "SET key1 Hello");
     assert(ret == VALKEY_ERR);
-    assert(acc->err == VALKEY_ERR_OTHER);
-    assert(strcmp(acc->errstr, "slotmap not available") == 0);
+    assert(valkeyClusterAsyncGetError(acc) == VALKEY_ERR_OTHER);
+    assert(strcmp(valkeyClusterAsyncGetErrorString(acc), "slotmap not available") == 0);
 
     valkeyClusterAsyncFree(acc);
     event_base_free(base);
@@ -410,8 +410,8 @@ void test_async_username_ok(void) {
     // Connect using wrong username should fail
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
     assert(acc);
-    assert(acc->err == VALKEY_ERR_OTHER);
-    assert(strncmp(acc->errstr, "WRONGPASS invalid username-password pair",
+    assert(valkeyClusterAsyncGetError(acc) == VALKEY_ERR_OTHER);
+    assert(strncmp(valkeyClusterAsyncGetErrorString(acc), "WRONGPASS invalid username-password pair",
                    40) == 0);
     valkeyClusterAsyncFree(acc);
 
@@ -421,7 +421,7 @@ void test_async_username_ok(void) {
     // Connect using correct username should pass
     acc = valkeyClusterAsyncConnectWithOptions(&options);
     assert(acc);
-    assert(acc->err == 0);
+    assert(valkeyClusterAsyncGetError(acc) == 0);
 
     // Test connection
     ExpectedResult r = {
@@ -509,8 +509,8 @@ void test_async_connect_timeout(void) {
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
     assert(acc);
-    assert(acc->err == VALKEY_ERR_IO);
-    assert(strcmp(acc->errstr, "Connection timed out") == 0);
+    assert(valkeyClusterAsyncGetError(acc) == VALKEY_ERR_IO);
+    assert(strcmp(valkeyClusterAsyncGetErrorString(acc), "Connection timed out") == 0);
 
     event_base_dispatch(base);
 
@@ -530,7 +530,7 @@ void test_async_command_timeout(void) {
     valkeyClusterOptionsUseLibevent(&options, base);
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
-    ASSERT_MSG(acc && acc->err == 0, acc ? acc->errstr : "OOM");
+    ASSERT_MSG(acc && valkeyClusterAsyncGetError(acc) == 0, acc ? valkeyClusterAsyncGetErrorString(acc) : "OOM");
 
     valkeyClusterNodeIterator ni;
     valkeyClusterInitNodeIterator(&ni, &acc->cc);
diff --git a/tests/ct_connection_ipv6.c b/tests/ct_connection_ipv6.c
index 02723c1f..5abb6ead 100644
--- a/tests/ct_connection_ipv6.c
+++ b/tests/ct_connection_ipv6.c
@@ -17,7 +17,7 @@ void test_successful_ipv6_connection(void) {
     options.connect_timeout = &timeout;
 
     valkeyClusterContext *cc = valkeyClusterConnectWithOptions(&options);
-    ASSERT_MSG(cc && cc->err == 0, cc ? cc->errstr : "OOM");
+    ASSERT_MSG(cc && valkeyClusterGetError(cc) == 0, cc ? valkeyClusterGetErrorString(cc) : "OOM");
 
     valkeyReply *reply;
     reply = (valkeyReply *)valkeyClusterCommand(cc, "SET key_ipv6 value");
diff --git a/tests/ct_out_of_memory_handling.c b/tests/ct_out_of_memory_handling.c
index d4b78d81..80028b01 100644
--- a/tests/ct_out_of_memory_handling.c
+++ b/tests/ct_out_of_memory_handling.c
@@ -77,15 +77,13 @@ static void *vk_realloc_fail(void *ptr, size_t size) {
 void prepare_allocation_test(valkeyClusterContext *cc,
                              int _successfulAllocations) {
     successfulAllocations = _successfulAllocations;
-    cc->err = 0;
-    memset(cc->errstr, '\0', strlen(cc->errstr));
+    valkeyClusterClearError(cc);
 }
 
 void prepare_allocation_test_async(valkeyClusterAsyncContext *acc,
                                    int _successfulAllocations) {
     successfulAllocations = _successfulAllocations;
-    acc->err = 0;
-    memset(acc->errstr, '\0', strlen(acc->errstr));
+    valkeyClusterAsyncClearError(acc);
 }
 
 /* Helper */
@@ -133,14 +131,14 @@ void test_alloc_failure_handling(void) {
             successfulAllocations = i;
             cc = valkeyClusterConnectWithOptions(&options);
             assert(cc);
-            ASSERT_STR_EQ(cc->errstr, "Out of memory");
+            ASSERT_STR_EQ(valkeyClusterGetErrorString(cc), "Out of memory");
             valkeyClusterFree(cc);
         }
         // Skip iteration 100 to 159 since sdscatfmt give leak warnings during OOM.
 
         successfulAllocations = 160;
         cc = valkeyClusterConnectWithOptions(&options);
-        assert(cc && cc->err == 0);
+        assert(cc && valkeyClusterGetError(cc) == 0);
     }
 
     // Command
@@ -152,7 +150,7 @@ void test_alloc_failure_handling(void) {
             prepare_allocation_test(cc, i);
             reply = (valkeyReply *)valkeyClusterCommand(cc, cmd);
             assert(reply == NULL);
-            ASSERT_STR_EQ(cc->errstr, "Out of memory");
+            ASSERT_STR_EQ(valkeyClusterGetErrorString(cc), "Out of memory");
         }
 
         prepare_allocation_test(cc, 33);
@@ -174,7 +172,7 @@ void test_alloc_failure_handling(void) {
             prepare_allocation_test(cc, i);
             reply = valkeyClusterCommandToNode(cc, node, cmd);
             assert(reply == NULL);
-            ASSERT_STR_EQ(cc->errstr, "Out of memory");
+            ASSERT_STR_EQ(valkeyClusterGetErrorString(cc), "Out of memory");
         }
 
         // Successful command
@@ -193,7 +191,7 @@ void test_alloc_failure_handling(void) {
             prepare_allocation_test(cc, i);
             result = valkeyClusterAppendCommand(cc, cmd);
             assert(result == VALKEY_ERR);
-            ASSERT_STR_EQ(cc->errstr, "Out of memory");
+            ASSERT_STR_EQ(valkeyClusterGetErrorString(cc), "Out of memory");
 
             valkeyClusterReset(cc);
         }
@@ -208,7 +206,7 @@ void test_alloc_failure_handling(void) {
             prepare_allocation_test(cc, i);
             result = valkeyClusterGetReply(cc, (void *)&reply);
             assert(result == VALKEY_ERR);
-            ASSERT_STR_EQ(cc->errstr, "Out of memory");
+            ASSERT_STR_EQ(valkeyClusterGetErrorString(cc), "Out of memory");
 
             valkeyClusterReset(cc);
         }
@@ -237,7 +235,7 @@ void test_alloc_failure_handling(void) {
             prepare_allocation_test(cc, i);
             result = valkeyClusterAppendCommandToNode(cc, node, cmd);
             assert(result == VALKEY_ERR);
-            ASSERT_STR_EQ(cc->errstr, "Out of memory");
+            ASSERT_STR_EQ(valkeyClusterGetErrorString(cc), "Out of memory");
 
             valkeyClusterReset(cc);
         }
@@ -252,7 +250,7 @@ void test_alloc_failure_handling(void) {
             prepare_allocation_test(cc, i);
             result = valkeyClusterGetReply(cc, (void *)&reply);
             assert(result == VALKEY_ERR);
-            ASSERT_STR_EQ(cc->errstr, "Out of memory");
+            ASSERT_STR_EQ(valkeyClusterGetErrorString(cc), "Out of memory");
 
             valkeyClusterReset(cc);
         }
@@ -322,7 +320,7 @@ void test_alloc_failure_handling(void) {
             prepare_allocation_test(cc, i);
             reply = valkeyClusterCommand(cc, "GET foo");
             assert(reply == NULL);
-            ASSERT_STR_EQ(cc->errstr, "Out of memory");
+            ASSERT_STR_EQ(valkeyClusterGetErrorString(cc), "Out of memory");
         }
 
         /* Test ASK reply handling without OOM */
@@ -351,7 +349,7 @@ void test_alloc_failure_handling(void) {
             prepare_allocation_test(cc, i);
             reply = valkeyClusterCommand(cc, "GET foo");
             assert(reply == NULL);
-            ASSERT_STR_EQ(cc->errstr, "Out of memory");
+            ASSERT_STR_EQ(valkeyClusterGetErrorString(cc), "Out of memory");
         }
 
         /* Test MOVED reply handling without OOM */
@@ -468,14 +466,14 @@ void test_alloc_failure_handling_async(void) {
             successfulAllocations = i;
             acc = valkeyClusterAsyncConnectWithOptions(&options);
             assert(acc != NULL);
-            ASSERT_STR_EQ(acc->errstr, "Out of memory");
+            ASSERT_STR_EQ(valkeyClusterAsyncGetErrorString(acc), "Out of memory");
             valkeyClusterAsyncFree(acc);
         }
         // Skip iteration 100 to 156 since sdscatfmt give leak warnings during OOM.
 
         successfulAllocations = 157;
         acc = valkeyClusterAsyncConnectWithOptions(&options);
-        assert(acc && acc->err == 0);
+        assert(acc && valkeyClusterAsyncGetError(acc) == 0);
     }
 
     // Async command 1
@@ -488,15 +486,15 @@ void test_alloc_failure_handling_async(void) {
             result = valkeyClusterAsyncCommand(acc, commandCallback, &r1, cmd1);
             assert(result == VALKEY_ERR);
             if (i != 34) {
-                ASSERT_STR_EQ(acc->errstr, "Out of memory");
+                ASSERT_STR_EQ(valkeyClusterAsyncGetErrorString(acc), "Out of memory");
             } else {
-                ASSERT_STR_EQ(acc->errstr, "Failed to attach event adapter");
+                ASSERT_STR_EQ(valkeyClusterAsyncGetErrorString(acc), "Failed to attach event adapter");
             }
         }
 
         prepare_allocation_test_async(acc, 35);
         result = valkeyClusterAsyncCommand(acc, commandCallback, &r1, cmd1);
-        ASSERT_MSG(result == VALKEY_OK, acc->errstr);
+        ASSERT_MSG(result == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
     }
 
     // Async command 2
@@ -509,14 +507,14 @@ void test_alloc_failure_handling_async(void) {
             prepare_allocation_test_async(acc, i);
             result = valkeyClusterAsyncCommand(acc, commandCallback, &r2, cmd2);
             assert(result == VALKEY_ERR);
-            ASSERT_STR_EQ(acc->errstr, "Out of memory");
+            ASSERT_STR_EQ(valkeyClusterAsyncGetErrorString(acc), "Out of memory");
         }
 
         /* Skip iteration 12, errstr not set by libvalkey when valkeyFormatSdsCommandArgv() fails. */
 
         prepare_allocation_test_async(acc, 13);
         result = valkeyClusterAsyncCommand(acc, commandCallback, &r2, cmd2);
-        ASSERT_MSG(result == VALKEY_OK, acc->errstr);
+        ASSERT_MSG(result == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
     }
 
     prepare_allocation_test_async(acc, 7);
diff --git a/tests/ct_pipeline.c b/tests/ct_pipeline.c
index 7d55a7c8..6d715100 100644
--- a/tests/ct_pipeline.c
+++ b/tests/ct_pipeline.c
@@ -16,19 +16,19 @@ void test_pipeline(void) {
     options.initial_nodes = CLUSTER_NODE;
 
     valkeyClusterContext *cc = valkeyClusterConnectWithOptions(&options);
-    ASSERT_MSG(cc && cc->err == 0, cc ? cc->errstr : "OOM");
+    ASSERT_MSG(cc && valkeyClusterGetError(cc) == 0, cc ? valkeyClusterGetErrorString(cc) : "OOM");
 
     int status;
     status = valkeyClusterAppendCommand(cc, "SET foo one");
-    ASSERT_MSG(status == VALKEY_OK, cc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterGetErrorString(cc));
     status = valkeyClusterAppendCommand(cc, "SET bar two");
-    ASSERT_MSG(status == VALKEY_OK, cc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterGetErrorString(cc));
     status = valkeyClusterAppendCommand(cc, "GET foo");
-    ASSERT_MSG(status == VALKEY_OK, cc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterGetErrorString(cc));
     status = valkeyClusterAppendCommand(cc, "GET bar");
-    ASSERT_MSG(status == VALKEY_OK, cc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterGetErrorString(cc));
     status = valkeyClusterAppendCommand(cc, "SUNION a b");
-    ASSERT_MSG(status == VALKEY_OK, cc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterGetErrorString(cc));
 
     valkeyReply *reply;
     valkeyClusterGetReply(cc, (void *)&reply); // reply for: SET foo one
@@ -102,33 +102,33 @@ void test_async_pipeline(void) {
     valkeyClusterOptionsUseLibevent(&options, base);
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
-    ASSERT_MSG(acc && acc->err == 0, acc ? acc->errstr : "OOM");
+    ASSERT_MSG(acc && valkeyClusterAsyncGetError(acc) == 0, acc ? valkeyClusterAsyncGetErrorString(acc) : "OOM");
 
     int status;
     ExpectedResult r1 = {.type = VALKEY_REPLY_STATUS, .str = "OK"};
     status =
         valkeyClusterAsyncCommand(acc, commandCallback, &r1, "SET foo six");
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     ExpectedResult r2 = {.type = VALKEY_REPLY_STATUS, .str = "OK"};
     status =
         valkeyClusterAsyncCommand(acc, commandCallback, &r2, "SET bar ten");
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     ExpectedResult r3 = {.type = VALKEY_REPLY_STRING, .str = "six"};
     status = valkeyClusterAsyncCommand(acc, commandCallback, &r3, "GET foo");
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     ExpectedResult r4 = {.type = VALKEY_REPLY_STRING, .str = "ten"};
     status = valkeyClusterAsyncCommand(acc, commandCallback, &r4, "GET bar");
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     ExpectedResult r5 = {
         .type = VALKEY_REPLY_ERROR,
         .str = "CROSSSLOT Keys in request don't hash to the same slot",
         .disconnect = true};
     status = valkeyClusterAsyncCommand(acc, commandCallback, &r5, "SUNION a b");
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     event_base_dispatch(base);
 
diff --git a/tests/ct_specific_nodes.c b/tests/ct_specific_nodes.c
index 7eedcbb3..3ad787b7 100644
--- a/tests/ct_specific_nodes.c
+++ b/tests/ct_specific_nodes.c
@@ -185,7 +185,7 @@ void test_pipeline_to_single_node(valkeyClusterContext *cc) {
     assert(node);
 
     status = valkeyClusterAppendCommandToNode(cc, node, "DBSIZE");
-    ASSERT_MSG(status == VALKEY_OK, cc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterGetErrorString(cc));
 
     // Trigger send of pipeline commands
     valkeyClusterGetReply(cc, (void *)&reply);
@@ -202,7 +202,7 @@ void test_pipeline_to_all_nodes(valkeyClusterContext *cc) {
     valkeyClusterNode *node;
     while ((node = valkeyClusterNodeNext(&ni)) != NULL) {
         int status = valkeyClusterAppendCommandToNode(cc, node, "DBSIZE");
-        ASSERT_MSG(status == VALKEY_OK, cc->errstr);
+        ASSERT_MSG(status == VALKEY_OK, valkeyClusterGetErrorString(cc));
     }
 
     // Get replies from 3 node cluster
@@ -234,13 +234,13 @@ void test_pipeline_transaction(valkeyClusterContext *cc) {
     assert(node);
 
     status = valkeyClusterAppendCommandToNode(cc, node, "MULTI");
-    ASSERT_MSG(status == VALKEY_OK, cc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterGetErrorString(cc));
     status = valkeyClusterAppendCommandToNode(cc, node, "SET foo 199");
-    ASSERT_MSG(status == VALKEY_OK, cc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterGetErrorString(cc));
     status = valkeyClusterAppendCommandToNode(cc, node, "INCR foo");
-    ASSERT_MSG(status == VALKEY_OK, cc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterGetErrorString(cc));
     status = valkeyClusterAppendCommandToNode(cc, node, "EXEC");
-    ASSERT_MSG(status == VALKEY_OK, cc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterGetErrorString(cc));
 
     // Trigger send of pipeline commands
     {
@@ -287,12 +287,12 @@ void disconnectCallback(const valkeyAsyncContext *ac, int status) {
 }
 
 // Callback for async commands, verifies the valkeyReply
-void commandCallback(valkeyClusterAsyncContext *cc, void *r, void *privdata) {
+void commandCallback(valkeyClusterAsyncContext *acc, void *r, void *privdata) {
     valkeyReply *reply = (valkeyReply *)r;
     ExpectedResult *expect = (ExpectedResult *)privdata;
     if (expect->noreply) {
         assert(reply == NULL);
-        assert(strcmp(cc->errstr, expect->errstr) == 0);
+        assert(strcmp(valkeyClusterAsyncGetErrorString(acc), expect->errstr) == 0);
     } else {
         assert(reply != NULL);
         assert(reply->type == expect->type);
@@ -314,7 +314,7 @@ void commandCallback(valkeyClusterAsyncContext *cc, void *r, void *privdata) {
         }
     }
     if (expect->disconnect)
-        valkeyClusterAsyncDisconnect(cc);
+        valkeyClusterAsyncDisconnect(acc);
 }
 
 void test_async_to_single_node(void) {
@@ -329,7 +329,7 @@ void test_async_to_single_node(void) {
     valkeyClusterOptionsUseLibevent(&options, base);
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
-    ASSERT_MSG(acc && acc->err == 0, acc ? acc->errstr : "OOM");
+    ASSERT_MSG(acc && valkeyClusterAsyncGetError(acc) == 0, acc ? valkeyClusterAsyncGetErrorString(acc) : "OOM");
 
     valkeyClusterNodeIterator ni;
     valkeyClusterInitNodeIterator(&ni, &acc->cc);
@@ -340,7 +340,7 @@ void test_async_to_single_node(void) {
     ExpectedResult r1 = {.type = VALKEY_REPLY_INTEGER, .disconnect = true};
     status = valkeyClusterAsyncCommandToNode(acc, node, commandCallback, &r1,
                                              "DBSIZE");
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     event_base_dispatch(base);
 
@@ -360,7 +360,7 @@ void test_async_formatted_to_single_node(void) {
     valkeyClusterOptionsUseLibevent(&options, base);
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
-    ASSERT_MSG(acc && acc->err == 0, acc ? acc->errstr : "OOM");
+    ASSERT_MSG(acc && valkeyClusterAsyncGetError(acc) == 0, acc ? valkeyClusterAsyncGetErrorString(acc) : "OOM");
 
     valkeyClusterNodeIterator ni;
     valkeyClusterInitNodeIterator(&ni, &acc->cc);
@@ -372,7 +372,7 @@ void test_async_formatted_to_single_node(void) {
     char command[] = "*1\r\n$6\r\nDBSIZE\r\n";
     status = valkeyClusterAsyncFormattedCommandToNode(
         acc, node, commandCallback, &r1, command, strlen(command));
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     event_base_dispatch(base);
 
@@ -392,7 +392,7 @@ void test_async_command_argv_to_single_node(void) {
     valkeyClusterOptionsUseLibevent(&options, base);
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
-    ASSERT_MSG(acc && acc->err == 0, acc ? acc->errstr : "OOM");
+    ASSERT_MSG(acc && valkeyClusterAsyncGetError(acc) == 0, acc ? valkeyClusterAsyncGetErrorString(acc) : "OOM");
 
     valkeyClusterNodeIterator ni;
     valkeyClusterInitNodeIterator(&ni, &acc->cc);
@@ -404,7 +404,7 @@ void test_async_command_argv_to_single_node(void) {
     status = valkeyClusterAsyncCommandArgvToNode(
         acc, node, commandCallback, &r1, 1, (const char *[]){"DBSIZE"},
         (size_t[]){6});
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     event_base_dispatch(base);
 
@@ -424,7 +424,7 @@ void test_async_to_all_nodes(void) {
     valkeyClusterOptionsUseLibevent(&options, base);
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
-    ASSERT_MSG(acc && acc->err == 0, acc ? acc->errstr : "OOM");
+    ASSERT_MSG(acc && valkeyClusterAsyncGetError(acc) == 0, acc ? valkeyClusterAsyncGetErrorString(acc) : "OOM");
 
     valkeyClusterNodeIterator ni;
     valkeyClusterInitNodeIterator(&ni, &acc->cc);
@@ -437,7 +437,7 @@ void test_async_to_all_nodes(void) {
 
         status = valkeyClusterAsyncCommandToNode(acc, node, commandCallback,
                                                  &r1, "DBSIZE");
-        ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+        ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
     }
 
     // Normal command to trigger disconnect
@@ -464,7 +464,7 @@ void test_async_transaction(void) {
     valkeyClusterOptionsUseLibevent(&options, base);
 
     valkeyClusterAsyncContext *acc = valkeyClusterAsyncConnectWithOptions(&options);
-    ASSERT_MSG(acc && acc->err == 0, acc ? acc->errstr : "OOM");
+    ASSERT_MSG(acc && valkeyClusterAsyncGetError(acc) == 0, acc ? valkeyClusterAsyncGetErrorString(acc) : "OOM");
 
     valkeyClusterNode *node = valkeyClusterGetNodeByKey(&acc->cc, (char *)"foo");
     assert(node);
@@ -473,24 +473,24 @@ void test_async_transaction(void) {
     ExpectedResult r1 = {.type = VALKEY_REPLY_STATUS, .str = "OK"};
     status = valkeyClusterAsyncCommandToNode(acc, node, commandCallback, &r1,
                                              "MULTI");
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     ExpectedResult r2 = {.type = VALKEY_REPLY_STATUS, .str = "QUEUED"};
     status = valkeyClusterAsyncCommandToNode(acc, node, commandCallback, &r2,
                                              "SET foo 99");
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     ExpectedResult r3 = {.type = VALKEY_REPLY_STATUS, .str = "QUEUED"};
     status = valkeyClusterAsyncCommandToNode(acc, node, commandCallback, &r3,
                                              "INCR foo");
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     /* The EXEC command will return an array with result from 2 queued commands. */
     ExpectedResult r4 = {
         .type = VALKEY_REPLY_ARRAY, .elements = 2, .disconnect = true};
     status = valkeyClusterAsyncCommandToNode(acc, node, commandCallback, &r4,
                                              "EXEC ");
-    ASSERT_MSG(status == VALKEY_OK, acc->errstr);
+    ASSERT_MSG(status == VALKEY_OK, valkeyClusterAsyncGetErrorString(acc));
 
     event_base_dispatch(base);
 
@@ -504,7 +504,7 @@ int main(void) {
     options.max_retry = 1;
 
     valkeyClusterContext *cc = valkeyClusterConnectWithOptions(&options);
-    ASSERT_MSG(cc && cc->err == 0, cc ? cc->errstr : "OOM");
+    ASSERT_MSG(cc && valkeyClusterGetError(cc) == 0, cc ? valkeyClusterGetErrorString(cc) : "OOM");
     load_valkey_version(cc);
 
     // Synchronous API
diff --git a/tests/test_utils.c b/tests/test_utils.c
index 1e95c4e3..f411fc71 100644
--- a/tests/test_utils.c
+++ b/tests/test_utils.c
@@ -22,7 +22,7 @@ void load_valkey_version(valkeyClusterContext *cc) {
         goto abort;
 
     reply = valkeyClusterCommandToNode(cc, node, "INFO");
-    if (reply == NULL || cc->err || reply->type != VALKEY_REPLY_STRING)
+    if (reply == NULL || valkeyClusterGetError(cc) || reply->type != VALKEY_REPLY_STRING)
         goto abort;
     if ((s = strstr(reply->str, VALKEY_VERSION_FIELD)) != NULL)
         s += strlen(VALKEY_VERSION_FIELD);
diff --git a/tests/ut_slotmap_update.c b/tests/ut_slotmap_update.c
index b4e452e7..3e5ac745 100644
--- a/tests/ut_slotmap_update.c
+++ b/tests/ut_slotmap_update.c
@@ -466,7 +466,7 @@ void test_parse_cluster_nodes_with_parse_error(void) {
     nodes = parse_cluster_nodes(cc, c, reply);
     freeReplyObject(reply);
     assert(nodes == NULL);
-    assert(cc->err == VALKEY_ERR_OTHER);
+    assert(valkeyClusterGetError(cc) == VALKEY_ERR_OTHER);
     valkeyClusterClearError(cc);
 
     /* Missing port. */
@@ -475,7 +475,7 @@ void test_parse_cluster_nodes_with_parse_error(void) {
     nodes = parse_cluster_nodes(cc, c, reply);
     freeReplyObject(reply);
     assert(nodes == NULL);
-    assert(cc->err == VALKEY_ERR_OTHER);
+    assert(valkeyClusterGetError(cc) == VALKEY_ERR_OTHER);
     valkeyClusterClearError(cc);
 
     /* Missing port and cport. */
@@ -484,7 +484,7 @@ void test_parse_cluster_nodes_with_parse_error(void) {
     nodes = parse_cluster_nodes(cc, c, reply);
     freeReplyObject(reply);
     assert(nodes == NULL);
-    assert(cc->err == VALKEY_ERR_OTHER);
+    assert(valkeyClusterGetError(cc) == VALKEY_ERR_OTHER);
     valkeyClusterClearError(cc);
 
     /* Invalid port. */
@@ -493,7 +493,7 @@ void test_parse_cluster_nodes_with_parse_error(void) {
     nodes = parse_cluster_nodes(cc, c, reply);
     freeReplyObject(reply);
     assert(nodes == NULL);
-    assert(cc->err == VALKEY_ERR_OTHER);
+    assert(valkeyClusterGetError(cc) == VALKEY_ERR_OTHER);
     valkeyClusterClearError(cc);
 
     valkeyFree(c);