diff --git a/.golangci.yml b/.golangci.yml
index 3ec52004..6c887ac9 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -34,6 +34,7 @@ linters:
     - asasalint
     - asciicheck
     - bidichk
+    - containedctx
     - contextcheck
     - copyloopvar
     - dupword
diff --git a/client/nginx.go b/client/nginx.go
index 7a76d41c..3d868c0e 100644
--- a/client/nginx.go
+++ b/client/nginx.go
@@ -38,7 +38,6 @@ var (
 	defaultBackup      = false
 	defaultDown        = false
 	defaultWeight      = 1
-	defaultTimeout     = 10 * time.Second
 )
 
 var (
@@ -55,7 +54,6 @@ type NginxClient struct {
 	apiEndpoint string
 	apiVersion  int
 	checkAPI    bool
-	ctxTimeout  time.Duration
 }
 
 type Option func(*NginxClient)
@@ -590,13 +588,6 @@ func WithCheckAPI() Option {
 	}
 }
 
-// WithTimeout sets the timeout per request for the client.
-func WithTimeout(duration time.Duration) Option {
-	return func(o *NginxClient) {
-		o.ctxTimeout = duration
-	}
-}
-
 // NewNginxClient creates a new NginxClient.
 func NewNginxClient(apiEndpoint string, opts ...Option) (*NginxClient, error) {
 	c := &NginxClient{
@@ -604,7 +595,6 @@ func NewNginxClient(apiEndpoint string, opts ...Option) (*NginxClient, error) {
 		apiEndpoint: apiEndpoint,
 		apiVersion:  APIVersion,
 		checkAPI:    false,
-		ctxTimeout:  defaultTimeout,
 	}
 
 	for _, opt := range opts {
@@ -619,12 +609,10 @@ func NewNginxClient(apiEndpoint string, opts ...Option) (*NginxClient, error) {
 		return nil, fmt.Errorf("API version %v: %w by the client", c.apiVersion, ErrNotSupported)
 	}
 
-	if c.ctxTimeout <= 0 {
-		return nil, fmt.Errorf("timeout %q needs to be greater than 0: %w", c.ctxTimeout, ErrInvalidTimeout)
-	}
-
 	if c.checkAPI {
-		versions, err := c.getAPIVersions(c.httpClient, apiEndpoint)
+		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+		versions, err := c.getAPIVersions(ctx, c.httpClient, apiEndpoint)
 		if err != nil {
 			return nil, fmt.Errorf("error accessing the API: %w", err)
 		}
@@ -653,8 +641,8 @@ func versionSupported(n int) bool {
 }
 
 // GetMaxAPIVersion returns the maximum API version supported by the server and the client.
-func (client *NginxClient) GetMaxAPIVersion() (int, error) {
-	serverVersions, err := client.getAPIVersions(client.httpClient, client.apiEndpoint)
+func (client *NginxClient) GetMaxAPIVersion(ctx context.Context) (int, error) {
+	serverVersions, err := client.getAPIVersions(ctx, client.httpClient, client.apiEndpoint)
 	if err != nil {
 		return 0, fmt.Errorf("failed to get max API version: %w", err)
 	}
@@ -669,10 +657,7 @@ func (client *NginxClient) GetMaxAPIVersion() (int, error) {
 	return maxServerVersion, nil
 }
 
-func (client *NginxClient) getAPIVersions(httpClient *http.Client, endpoint string) (*versions, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), client.ctxTimeout)
-	defer cancel()
-
+func (client *NginxClient) getAPIVersions(ctx context.Context, httpClient *http.Client, endpoint string) (*versions, error) {
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create a get request: %w", err)
@@ -733,17 +718,17 @@ func readAPIErrorResponse(respBody io.ReadCloser) (*apiErrorResponse, error) {
 }
 
 // CheckIfUpstreamExists checks if the upstream exists in NGINX. If the upstream doesn't exist, it returns the error.
-func (client *NginxClient) CheckIfUpstreamExists(upstream string) error {
-	_, err := client.GetHTTPServers(upstream)
+func (client *NginxClient) CheckIfUpstreamExists(ctx context.Context, upstream string) error {
+	_, err := client.GetHTTPServers(ctx, upstream)
 	return err
 }
 
 // GetHTTPServers returns the servers of the upstream from NGINX.
-func (client *NginxClient) GetHTTPServers(upstream string) ([]UpstreamServer, error) {
+func (client *NginxClient) GetHTTPServers(ctx context.Context, upstream string) ([]UpstreamServer, error) {
 	path := fmt.Sprintf("http/upstreams/%v/servers", upstream)
 
 	var servers []UpstreamServer
-	err := client.get(path, &servers)
+	err := client.get(ctx, path, &servers)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get the HTTP servers of upstream %v: %w", upstream, err)
 	}
@@ -752,8 +737,8 @@ func (client *NginxClient) GetHTTPServers(upstream string) ([]UpstreamServer, er
 }
 
 // AddHTTPServer adds the server to the upstream.
-func (client *NginxClient) AddHTTPServer(upstream string, server UpstreamServer) error {
-	id, err := client.getIDOfHTTPServer(upstream, server.Server)
+func (client *NginxClient) AddHTTPServer(ctx context.Context, upstream string, server UpstreamServer) error {
+	id, err := client.getIDOfHTTPServer(ctx, upstream, server.Server)
 	if err != nil {
 		return fmt.Errorf("failed to add %v server to %v upstream: %w", server.Server, upstream, err)
 	}
@@ -762,7 +747,7 @@ func (client *NginxClient) AddHTTPServer(upstream string, server UpstreamServer)
 	}
 
 	path := fmt.Sprintf("http/upstreams/%v/servers/", upstream)
-	err = client.post(path, &server)
+	err = client.post(ctx, path, &server)
 	if err != nil {
 		return fmt.Errorf("failed to add %v server to %v upstream: %w", server.Server, upstream, err)
 	}
@@ -771,8 +756,8 @@ func (client *NginxClient) AddHTTPServer(upstream string, server UpstreamServer)
 }
 
 // DeleteHTTPServer the server from the upstream.
-func (client *NginxClient) DeleteHTTPServer(upstream string, server string) error {
-	id, err := client.getIDOfHTTPServer(upstream, server)
+func (client *NginxClient) DeleteHTTPServer(ctx context.Context, upstream string, server string) error {
+	id, err := client.getIDOfHTTPServer(ctx, upstream, server)
 	if err != nil {
 		return fmt.Errorf("failed to remove %v server from  %v upstream: %w", server, upstream, err)
 	}
@@ -781,7 +766,7 @@ func (client *NginxClient) DeleteHTTPServer(upstream string, server string) erro
 	}
 
 	path := fmt.Sprintf("http/upstreams/%v/servers/%v", upstream, id)
-	err = client.delete(path, http.StatusOK)
+	err = client.delete(ctx, path, http.StatusOK)
 	if err != nil {
 		return fmt.Errorf("failed to remove %v server from %v upstream: %w", server, upstream, err)
 	}
@@ -793,8 +778,8 @@ func (client *NginxClient) DeleteHTTPServer(upstream string, server string) erro
 // Servers that are in the slice, but don't exist in NGINX will be added to NGINX.
 // Servers that aren't in the slice, but exist in NGINX, will be removed from NGINX.
 // Servers that are in the slice and exist in NGINX, but have different parameters, will be updated.
-func (client *NginxClient) UpdateHTTPServers(upstream string, servers []UpstreamServer) (added []UpstreamServer, deleted []UpstreamServer, updated []UpstreamServer, err error) {
-	serversInNginx, err := client.GetHTTPServers(upstream)
+func (client *NginxClient) UpdateHTTPServers(ctx context.Context, upstream string, servers []UpstreamServer) (added []UpstreamServer, deleted []UpstreamServer, updated []UpstreamServer, err error) {
+	serversInNginx, err := client.GetHTTPServers(ctx, upstream)
 	if err != nil {
 		return nil, nil, nil, fmt.Errorf("failed to update servers of %v upstream: %w", upstream, err)
 	}
@@ -809,21 +794,21 @@ func (client *NginxClient) UpdateHTTPServers(upstream string, servers []Upstream
 	toAdd, toDelete, toUpdate := determineUpdates(formattedServers, serversInNginx)
 
 	for _, server := range toAdd {
-		err := client.AddHTTPServer(upstream, server)
+		err := client.AddHTTPServer(ctx, upstream, server)
 		if err != nil {
 			return nil, nil, nil, fmt.Errorf("failed to update servers of %v upstream: %w", upstream, err)
 		}
 	}
 
 	for _, server := range toDelete {
-		err := client.DeleteHTTPServer(upstream, server.Server)
+		err := client.DeleteHTTPServer(ctx, upstream, server.Server)
 		if err != nil {
 			return nil, nil, nil, fmt.Errorf("failed to update servers of %v upstream: %w", upstream, err)
 		}
 	}
 
 	for _, server := range toUpdate {
-		err := client.UpdateHTTPServer(upstream, server)
+		err := client.UpdateHTTPServer(ctx, upstream, server)
 		if err != nil {
 			return nil, nil, nil, fmt.Errorf("failed to update servers of %v upstream: %w", upstream, err)
 		}
@@ -911,8 +896,8 @@ func determineUpdates(updatedServers []UpstreamServer, nginxServers []UpstreamSe
 	return
 }
 
-func (client *NginxClient) getIDOfHTTPServer(upstream string, name string) (int, error) {
-	servers, err := client.GetHTTPServers(upstream)
+func (client *NginxClient) getIDOfHTTPServer(ctx context.Context, upstream string, name string) (int, error) {
+	servers, err := client.GetHTTPServers(ctx, upstream)
 	if err != nil {
 		return -1, fmt.Errorf("error getting id of server %v of upstream %v: %w", name, upstream, err)
 	}
@@ -926,14 +911,7 @@ func (client *NginxClient) getIDOfHTTPServer(upstream string, name string) (int,
 	return -1, nil
 }
 
-func (client *NginxClient) get(path string, data interface{}) error {
-	timeoutCtx, cancel := context.WithTimeout(context.Background(), client.ctxTimeout)
-	defer cancel()
-
-	return client.getWithContext(timeoutCtx, path, data)
-}
-
-func (client *NginxClient) getWithContext(ctx context.Context, path string, data interface{}) error {
+func (client *NginxClient) get(ctx context.Context, path string, data interface{}) error {
 	url := fmt.Sprintf("%v/%v/%v", client.apiEndpoint, client.apiVersion, path)
 
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
@@ -964,14 +942,7 @@ func (client *NginxClient) getWithContext(ctx context.Context, path string, data
 	return nil
 }
 
-func (client *NginxClient) post(path string, input interface{}) error {
-	timeoutCtx, cancel := context.WithTimeout(context.Background(), client.ctxTimeout)
-	defer cancel()
-
-	return client.postWithContext(timeoutCtx, path, input)
-}
-
-func (client *NginxClient) postWithContext(ctx context.Context, path string, input interface{}) error {
+func (client *NginxClient) post(ctx context.Context, path string, input interface{}) error {
 	url := fmt.Sprintf("%v/%v/%v", client.apiEndpoint, client.apiVersion, path)
 
 	jsonInput, err := json.Marshal(input)
@@ -1000,14 +971,7 @@ func (client *NginxClient) postWithContext(ctx context.Context, path string, inp
 	return nil
 }
 
-func (client *NginxClient) delete(path string, expectedStatusCode int) error {
-	timeoutCtx, cancel := context.WithTimeout(context.Background(), client.ctxTimeout)
-	defer cancel()
-
-	return client.deleteWithContext(timeoutCtx, path, expectedStatusCode)
-}
-
-func (client *NginxClient) deleteWithContext(ctx context.Context, path string, expectedStatusCode int) error {
+func (client *NginxClient) delete(ctx context.Context, path string, expectedStatusCode int) error {
 	path = fmt.Sprintf("%v/%v/%v/", client.apiEndpoint, client.apiVersion, path)
 
 	req, err := http.NewRequestWithContext(ctx, http.MethodDelete, path, nil)
@@ -1029,14 +993,7 @@ func (client *NginxClient) deleteWithContext(ctx context.Context, path string, e
 	return nil
 }
 
-func (client *NginxClient) patch(path string, input interface{}, expectedStatusCode int) error {
-	timeoutCtx, cancel := context.WithTimeout(context.Background(), client.ctxTimeout)
-	defer cancel()
-
-	return client.patchWithContext(timeoutCtx, path, input, expectedStatusCode)
-}
-
-func (client *NginxClient) patchWithContext(ctx context.Context, path string, input interface{}, expectedStatusCode int) error {
+func (client *NginxClient) patch(ctx context.Context, path string, input interface{}, expectedStatusCode int) error {
 	path = fmt.Sprintf("%v/%v/%v/", client.apiEndpoint, client.apiVersion, path)
 
 	jsonInput, err := json.Marshal(input)
@@ -1064,17 +1021,17 @@ func (client *NginxClient) patchWithContext(ctx context.Context, path string, in
 }
 
 // CheckIfStreamUpstreamExists checks if the stream upstream exists in NGINX. If the upstream doesn't exist, it returns the error.
-func (client *NginxClient) CheckIfStreamUpstreamExists(upstream string) error {
-	_, err := client.GetStreamServers(upstream)
+func (client *NginxClient) CheckIfStreamUpstreamExists(ctx context.Context, upstream string) error {
+	_, err := client.GetStreamServers(ctx, upstream)
 	return err
 }
 
 // GetStreamServers returns the stream servers of the upstream from NGINX.
-func (client *NginxClient) GetStreamServers(upstream string) ([]StreamUpstreamServer, error) {
+func (client *NginxClient) GetStreamServers(ctx context.Context, upstream string) ([]StreamUpstreamServer, error) {
 	path := fmt.Sprintf("stream/upstreams/%v/servers", upstream)
 
 	var servers []StreamUpstreamServer
-	err := client.get(path, &servers)
+	err := client.get(ctx, path, &servers)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get stream servers of upstream server %v: %w", upstream, err)
 	}
@@ -1082,8 +1039,8 @@ func (client *NginxClient) GetStreamServers(upstream string) ([]StreamUpstreamSe
 }
 
 // AddStreamServer adds the stream server to the upstream.
-func (client *NginxClient) AddStreamServer(upstream string, server StreamUpstreamServer) error {
-	id, err := client.getIDOfStreamServer(upstream, server.Server)
+func (client *NginxClient) AddStreamServer(ctx context.Context, upstream string, server StreamUpstreamServer) error {
+	id, err := client.getIDOfStreamServer(ctx, upstream, server.Server)
 	if err != nil {
 		return fmt.Errorf("failed to add %v stream server to %v upstream: %w", server.Server, upstream, err)
 	}
@@ -1092,7 +1049,7 @@ func (client *NginxClient) AddStreamServer(upstream string, server StreamUpstrea
 	}
 
 	path := fmt.Sprintf("stream/upstreams/%v/servers/", upstream)
-	err = client.post(path, &server)
+	err = client.post(ctx, path, &server)
 	if err != nil {
 		return fmt.Errorf("failed to add %v stream server to %v upstream: %w", server.Server, upstream, err)
 	}
@@ -1100,8 +1057,8 @@ func (client *NginxClient) AddStreamServer(upstream string, server StreamUpstrea
 }
 
 // DeleteStreamServer the server from the upstream.
-func (client *NginxClient) DeleteStreamServer(upstream string, server string) error {
-	id, err := client.getIDOfStreamServer(upstream, server)
+func (client *NginxClient) DeleteStreamServer(ctx context.Context, upstream string, server string) error {
+	id, err := client.getIDOfStreamServer(ctx, upstream, server)
 	if err != nil {
 		return fmt.Errorf("failed to remove %v stream server from  %v upstream: %w", server, upstream, err)
 	}
@@ -1110,7 +1067,7 @@ func (client *NginxClient) DeleteStreamServer(upstream string, server string) er
 	}
 
 	path := fmt.Sprintf("stream/upstreams/%v/servers/%v", upstream, id)
-	err = client.delete(path, http.StatusOK)
+	err = client.delete(ctx, path, http.StatusOK)
 	if err != nil {
 		return fmt.Errorf("failed to remove %v stream server from %v upstream: %w", server, upstream, err)
 	}
@@ -1121,8 +1078,8 @@ func (client *NginxClient) DeleteStreamServer(upstream string, server string) er
 // Servers that are in the slice, but don't exist in NGINX will be added to NGINX.
 // Servers that aren't in the slice, but exist in NGINX, will be removed from NGINX.
 // Servers that are in the slice and exist in NGINX, but have different parameters, will be updated.
-func (client *NginxClient) UpdateStreamServers(upstream string, servers []StreamUpstreamServer) (added []StreamUpstreamServer, deleted []StreamUpstreamServer, updated []StreamUpstreamServer, err error) {
-	serversInNginx, err := client.GetStreamServers(upstream)
+func (client *NginxClient) UpdateStreamServers(ctx context.Context, upstream string, servers []StreamUpstreamServer) (added []StreamUpstreamServer, deleted []StreamUpstreamServer, updated []StreamUpstreamServer, err error) {
+	serversInNginx, err := client.GetStreamServers(ctx, upstream)
 	if err != nil {
 		return nil, nil, nil, fmt.Errorf("failed to update stream servers of %v upstream: %w", upstream, err)
 	}
@@ -1136,21 +1093,21 @@ func (client *NginxClient) UpdateStreamServers(upstream string, servers []Stream
 	toAdd, toDelete, toUpdate := determineStreamUpdates(formattedServers, serversInNginx)
 
 	for _, server := range toAdd {
-		err := client.AddStreamServer(upstream, server)
+		err := client.AddStreamServer(ctx, upstream, server)
 		if err != nil {
 			return nil, nil, nil, fmt.Errorf("failed to update stream servers of %v upstream: %w", upstream, err)
 		}
 	}
 
 	for _, server := range toDelete {
-		err := client.DeleteStreamServer(upstream, server.Server)
+		err := client.DeleteStreamServer(ctx, upstream, server.Server)
 		if err != nil {
 			return nil, nil, nil, fmt.Errorf("failed to update stream servers of %v upstream: %w", upstream, err)
 		}
 	}
 
 	for _, server := range toUpdate {
-		err := client.UpdateStreamServer(upstream, server)
+		err := client.UpdateStreamServer(ctx, upstream, server)
 		if err != nil {
 			return nil, nil, nil, fmt.Errorf("failed to update stream servers of %v upstream: %w", upstream, err)
 		}
@@ -1159,8 +1116,8 @@ func (client *NginxClient) UpdateStreamServers(upstream string, servers []Stream
 	return toAdd, toDelete, toUpdate, nil
 }
 
-func (client *NginxClient) getIDOfStreamServer(upstream string, name string) (int, error) {
-	servers, err := client.GetStreamServers(upstream)
+func (client *NginxClient) getIDOfStreamServer(ctx context.Context, upstream string, name string) (int, error) {
+	servers, err := client.GetStreamServers(ctx, upstream)
 	if err != nil {
 		return -1, fmt.Errorf("error getting id of stream server %v of upstream %v: %w", name, upstream, err)
 	}
@@ -1252,14 +1209,14 @@ func determineStreamUpdates(updatedServers []StreamUpstreamServer, nginxServers
 	return
 }
 
-// GetStatsWithContext gets process, slab, connection, request, ssl, zone, stream zone, upstream and stream upstream related stats from the NGINX Plus API.
-func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, error) {
+// GetStats gets process, slab, connection, request, ssl, zone, stream zone, upstream and stream upstream related stats from the NGINX Plus API.
+func (client *NginxClient) GetStats(ctx context.Context) (*Stats, error) {
 	initialGroup, initialCtx := errgroup.WithContext(ctx)
 	var mu sync.Mutex
 	stats := defaultStats()
 	// Collecting initial stats
 	initialGroup.Go(func() error {
-		endpoints, err := client.GetAvailableEndpointsWithContext(initialCtx)
+		endpoints, err := client.GetAvailableEndpoints(initialCtx)
 		if err != nil {
 			return fmt.Errorf("failed to get available Endpoints: %w", err)
 		}
@@ -1271,7 +1228,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 	})
 
 	initialGroup.Go(func() error {
-		nginxInfo, err := client.GetNginxInfoWithContext(initialCtx)
+		nginxInfo, err := client.GetNginxInfo(initialCtx)
 		if err != nil {
 			return fmt.Errorf("failed to get NGINX info: %w", err)
 		}
@@ -1284,7 +1241,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 	})
 
 	initialGroup.Go(func() error {
-		caches, err := client.GetCachesWithContext(initialCtx)
+		caches, err := client.GetCaches(initialCtx)
 		if err != nil {
 			return fmt.Errorf("failed to get Caches: %w", err)
 		}
@@ -1297,7 +1254,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 	})
 
 	initialGroup.Go(func() error {
-		processes, err := client.GetProcessesWithContext(initialCtx)
+		processes, err := client.GetProcesses(initialCtx)
 		if err != nil {
 			return fmt.Errorf("failed to get Process information: %w", err)
 		}
@@ -1310,7 +1267,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 	})
 
 	initialGroup.Go(func() error {
-		slabs, err := client.GetSlabsWithContext(initialCtx)
+		slabs, err := client.GetSlabs(initialCtx)
 		if err != nil {
 			return fmt.Errorf("failed to get Slabs: %w", err)
 		}
@@ -1323,7 +1280,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 	})
 
 	initialGroup.Go(func() error {
-		httpRequests, err := client.GetHTTPRequestsWithContext(initialCtx)
+		httpRequests, err := client.GetHTTPRequests(initialCtx)
 		if err != nil {
 			return fmt.Errorf("failed to get HTTP Requests: %w", err)
 		}
@@ -1336,7 +1293,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 	})
 
 	initialGroup.Go(func() error {
-		ssl, err := client.GetSSLWithContext(initialCtx)
+		ssl, err := client.GetSSL(initialCtx)
 		if err != nil {
 			return fmt.Errorf("failed to get SSL: %w", err)
 		}
@@ -1349,7 +1306,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 	})
 
 	initialGroup.Go(func() error {
-		serverZones, err := client.GetServerZonesWithContext(initialCtx)
+		serverZones, err := client.GetServerZones(initialCtx)
 		if err != nil {
 			return fmt.Errorf("failed to get Server Zones: %w", err)
 		}
@@ -1362,7 +1319,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 	})
 
 	initialGroup.Go(func() error {
-		upstreams, err := client.GetUpstreamsWithContext(initialCtx)
+		upstreams, err := client.GetUpstreams(initialCtx)
 		if err != nil {
 			return fmt.Errorf("failed to get Upstreams: %w", err)
 		}
@@ -1375,7 +1332,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 	})
 
 	initialGroup.Go(func() error {
-		locationZones, err := client.GetLocationZonesWithContext(initialCtx)
+		locationZones, err := client.GetLocationZones(initialCtx)
 		if err != nil {
 			return fmt.Errorf("failed to get Location Zones: %w", err)
 		}
@@ -1388,7 +1345,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 	})
 
 	initialGroup.Go(func() error {
-		resolvers, err := client.GetResolversWithContext(initialCtx)
+		resolvers, err := client.GetResolvers(initialCtx)
 		if err != nil {
 			return fmt.Errorf("failed to get Resolvers: %w", err)
 		}
@@ -1401,7 +1358,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 	})
 
 	initialGroup.Go(func() error {
-		httpLimitRequests, err := client.GetHTTPLimitReqsWithContext(initialCtx)
+		httpLimitRequests, err := client.GetHTTPLimitReqs(initialCtx)
 		if err != nil {
 			return fmt.Errorf("failed to get HTTPLimitRequests: %w", err)
 		}
@@ -1414,7 +1371,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 	})
 
 	initialGroup.Go(func() error {
-		httpLimitConnections, err := client.GetHTTPConnectionsLimitWithContext(initialCtx)
+		httpLimitConnections, err := client.GetHTTPConnectionsLimit(initialCtx)
 		if err != nil {
 			return fmt.Errorf("failed to get HTTPLimitConnections: %w", err)
 		}
@@ -1427,7 +1384,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 	})
 
 	initialGroup.Go(func() error {
-		workers, err := client.GetWorkersWithContext(initialCtx)
+		workers, err := client.GetWorkers(initialCtx)
 		if err != nil {
 			return fmt.Errorf("failed to get Workers: %w", err)
 		}
@@ -1448,7 +1405,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 		availableStreamGroup, asgCtx := errgroup.WithContext(ctx)
 
 		availableStreamGroup.Go(func() error {
-			streamEndpoints, err := client.GetAvailableStreamEndpointsWithContext(asgCtx)
+			streamEndpoints, err := client.GetAvailableStreamEndpoints(asgCtx)
 			if err != nil {
 				return fmt.Errorf("failed to get available Stream Endpoints: %w", err)
 			}
@@ -1468,7 +1425,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 
 		if slices.Contains(stats.streamEndpoints, "server_zones") {
 			streamGroup.Go(func() error {
-				streamServerZones, err := client.GetStreamServerZonesWithContext(sgCtx)
+				streamServerZones, err := client.GetStreamServerZones(sgCtx)
 				if err != nil {
 					return fmt.Errorf("failed to get streamServerZones: %w", err)
 				}
@@ -1483,7 +1440,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 
 		if slices.Contains(stats.streamEndpoints, "upstreams") {
 			streamGroup.Go(func() error {
-				streamUpstreams, err := client.GetStreamUpstreamsWithContext(sgCtx)
+				streamUpstreams, err := client.GetStreamUpstreams(sgCtx)
 				if err != nil {
 					return fmt.Errorf("failed to get StreamUpstreams: %w", err)
 				}
@@ -1498,7 +1455,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 
 		if slices.Contains(stats.streamEndpoints, "limit_conns") {
 			streamGroup.Go(func() error {
-				streamConnectionsLimit, err := client.GetStreamConnectionsLimitWithContext(sgCtx)
+				streamConnectionsLimit, err := client.GetStreamConnectionsLimit(sgCtx)
 				if err != nil {
 					return fmt.Errorf("failed to get StreamLimitConnections: %w", err)
 				}
@@ -1511,7 +1468,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 			})
 
 			streamGroup.Go(func() error {
-				streamZoneSync, err := client.GetStreamZoneSyncWithContext(sgCtx)
+				streamZoneSync, err := client.GetStreamZoneSync(sgCtx)
 				if err != nil {
 					return fmt.Errorf("failed to get StreamZoneSync: %w", err)
 				}
@@ -1534,7 +1491,7 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 
 	connectionsGroup.Go(func() error {
 		// replace this call with a context specific call
-		connections, err := client.GetConnectionsWithContext(cgCtx)
+		connections, err := client.GetConnections(cgCtx)
 		if err != nil {
 			return fmt.Errorf("failed to get connections: %w", err)
 		}
@@ -1553,155 +1510,100 @@ func (client *NginxClient) GetStatsWithContext(ctx context.Context) (*Stats, err
 	return &stats.Stats, nil
 }
 
-// GetStats gets process, slab, connection, request, ssl, zone, stream zone, upstream and stream upstream related stats from the NGINX Plus API.
-func (client *NginxClient) GetStats() (*Stats, error) {
-	return client.GetStatsWithContext(context.Background())
-}
-
 // GetAvailableEndpoints returns available endpoints in the API.
-func (client *NginxClient) GetAvailableEndpoints() ([]string, error) {
-	return client.GetAvailableEndpointsWithContext(context.Background())
-}
-
-// GetAvailableEndpointsWithContext returns available endpoints in the API.
-func (client *NginxClient) GetAvailableEndpointsWithContext(ctx context.Context) ([]string, error) {
+func (client *NginxClient) GetAvailableEndpoints(ctx context.Context) ([]string, error) {
 	var endpoints []string
-	err := client.getWithContext(ctx, "", &endpoints)
+	err := client.get(ctx, "", &endpoints)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get endpoints: %w", err)
 	}
 	return endpoints, nil
 }
 
-// GetAvailableStreamEndpoints returns available stream endpoints in the API.
-func (client *NginxClient) GetAvailableStreamEndpoints() ([]string, error) {
-	return client.GetAvailableStreamEndpointsWithContext(context.Background())
-}
-
-// GetAvailableStreamEndpointsWithContext returns available stream endpoints in the API with a context.
-func (client *NginxClient) GetAvailableStreamEndpointsWithContext(ctx context.Context) ([]string, error) {
+// GetAvailableStreamEndpoints returns available stream endpoints in the API with a context.
+func (client *NginxClient) GetAvailableStreamEndpoints(ctx context.Context) ([]string, error) {
 	var endpoints []string
-	err := client.getWithContext(ctx, "stream", &endpoints)
+	err := client.get(ctx, "stream", &endpoints)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get endpoints: %w", err)
 	}
 	return endpoints, nil
 }
 
-// GetNginxInfo returns Nginx stats.
-func (client *NginxClient) GetNginxInfo() (*NginxInfo, error) {
-	return client.GetNginxInfoWithContext(context.Background())
-}
-
-// GetNginxInfoWithContext returns Nginx stats with a context.
-func (client *NginxClient) GetNginxInfoWithContext(ctx context.Context) (*NginxInfo, error) {
+// GetNginxInfo returns Nginx stats with a context.
+func (client *NginxClient) GetNginxInfo(ctx context.Context) (*NginxInfo, error) {
 	var info NginxInfo
-	err := client.getWithContext(ctx, "nginx", &info)
+	err := client.get(ctx, "nginx", &info)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get info: %w", err)
 	}
 	return &info, nil
 }
 
-// GetCaches returns Cache stats.
-func (client *NginxClient) GetCaches() (*Caches, error) {
-	return client.GetCachesWithContext(context.Background())
-}
-
-// GetCachesWithContext returns Cache stats with a context.
-func (client *NginxClient) GetCachesWithContext(ctx context.Context) (*Caches, error) {
+// GetCaches returns Cache stats with a context.
+func (client *NginxClient) GetCaches(ctx context.Context) (*Caches, error) {
 	var caches Caches
-	err := client.getWithContext(ctx, "http/caches", &caches)
+	err := client.get(ctx, "http/caches", &caches)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get caches: %w", err)
 	}
 	return &caches, nil
 }
 
-// GetSlabs returns Slabs stats.
-func (client *NginxClient) GetSlabs() (*Slabs, error) {
-	return client.GetSlabsWithContext(context.Background())
-}
-
-// GetSlabsWithContext returns Slabs stats with a context.
-func (client *NginxClient) GetSlabsWithContext(ctx context.Context) (*Slabs, error) {
+// GetSlabs returns Slabs stats with a context.
+func (client *NginxClient) GetSlabs(ctx context.Context) (*Slabs, error) {
 	var slabs Slabs
-	err := client.getWithContext(ctx, "slabs", &slabs)
+	err := client.get(ctx, "slabs", &slabs)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get slabs: %w", err)
 	}
 	return &slabs, nil
 }
 
-// GetConnections returns Connections stats.
-func (client *NginxClient) GetConnections() (*Connections, error) {
-	return client.GetConnectionsWithContext(context.Background())
-}
-
-// GetConnectionsWithContext returns Connections stats with a context.
-func (client *NginxClient) GetConnectionsWithContext(ctx context.Context) (*Connections, error) {
+// GetConnections returns Connections stats with a context.
+func (client *NginxClient) GetConnections(ctx context.Context) (*Connections, error) {
 	var cons Connections
-	err := client.getWithContext(ctx, "connections", &cons)
+	err := client.get(ctx, "connections", &cons)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get connections: %w", err)
 	}
 	return &cons, nil
 }
 
-// GetHTTPRequests returns http/requests stats.
-func (client *NginxClient) GetHTTPRequests() (*HTTPRequests, error) {
-	return client.GetHTTPRequestsWithContext(context.Background())
-}
-
-// GetHTTPRequestsWithContext returns http/requests stats with a context.
-func (client *NginxClient) GetHTTPRequestsWithContext(ctx context.Context) (*HTTPRequests, error) {
+// GetHTTPRequests returns http/requests stats with a context.
+func (client *NginxClient) GetHTTPRequests(ctx context.Context) (*HTTPRequests, error) {
 	var requests HTTPRequests
-	err := client.getWithContext(ctx, "http/requests", &requests)
+	err := client.get(ctx, "http/requests", &requests)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get http requests: %w", err)
 	}
 	return &requests, nil
 }
 
-// GetSSL returns SSL stats.
-func (client *NginxClient) GetSSL() (*SSL, error) {
-	return client.GetSSLWithContext(context.Background())
-}
-
-// GetSSLWithContext returns SSL stats with a context.
-func (client *NginxClient) GetSSLWithContext(ctx context.Context) (*SSL, error) {
+// GetSSL returns SSL stats with a context.
+func (client *NginxClient) GetSSL(ctx context.Context) (*SSL, error) {
 	var ssl SSL
-	err := client.getWithContext(ctx, "ssl", &ssl)
+	err := client.get(ctx, "ssl", &ssl)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get ssl: %w", err)
 	}
 	return &ssl, nil
 }
 
-// GetServerZones returns http/server_zones stats.
-func (client *NginxClient) GetServerZones() (*ServerZones, error) {
-	return client.GetServerZonesWithContext(context.Background())
-}
-
-// GetServerZonesWithContext returns http/server_zones stats with a context.
-func (client *NginxClient) GetServerZonesWithContext(ctx context.Context) (*ServerZones, error) {
+// GetServerZones returns http/server_zones stats with a context.
+func (client *NginxClient) GetServerZones(ctx context.Context) (*ServerZones, error) {
 	var zones ServerZones
-	err := client.getWithContext(ctx, "http/server_zones", &zones)
+	err := client.get(ctx, "http/server_zones", &zones)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get server zones: %w", err)
 	}
 	return &zones, err
 }
 
-// GetStreamServerZones returns stream/server_zones stats.
-func (client *NginxClient) GetStreamServerZones() (*StreamServerZones, error) {
-	return client.GetStreamServerZonesWithContext(context.Background())
-}
-
-// GetStreamServerZonesWithContext returns stream/server_zones stats with a context.
-func (client *NginxClient) GetStreamServerZonesWithContext(ctx context.Context) (*StreamServerZones, error) {
+// GetStreamServerZones returns stream/server_zones stats with a context.
+func (client *NginxClient) GetStreamServerZones(ctx context.Context) (*StreamServerZones, error) {
 	var zones StreamServerZones
-	err := client.getWithContext(ctx, "stream/server_zones", &zones)
+	err := client.get(ctx, "stream/server_zones", &zones)
 	if err != nil {
 		var ie *internalError
 		if errors.As(err, &ie) {
@@ -1714,30 +1616,20 @@ func (client *NginxClient) GetStreamServerZonesWithContext(ctx context.Context)
 	return &zones, err
 }
 
-// GetUpstreams returns http/upstreams stats.
-func (client *NginxClient) GetUpstreams() (*Upstreams, error) {
-	return client.GetUpstreamsWithContext(context.Background())
-}
-
-// GetUpstreamsWithContext returns http/upstreams stats with a context.
-func (client *NginxClient) GetUpstreamsWithContext(ctx context.Context) (*Upstreams, error) {
+// GetUpstreams returns http/upstreams stats with a context.
+func (client *NginxClient) GetUpstreams(ctx context.Context) (*Upstreams, error) {
 	var upstreams Upstreams
-	err := client.getWithContext(ctx, "http/upstreams", &upstreams)
+	err := client.get(ctx, "http/upstreams", &upstreams)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get upstreams: %w", err)
 	}
 	return &upstreams, nil
 }
 
-// GetStreamUpstreams returns stream/upstreams stats.
-func (client *NginxClient) GetStreamUpstreams() (*StreamUpstreams, error) {
-	return client.GetStreamUpstreamsWithContext(context.Background())
-}
-
-// GetStreamUpstreamsWithContext returns stream/upstreams stats with a context.
-func (client *NginxClient) GetStreamUpstreamsWithContext(ctx context.Context) (*StreamUpstreams, error) {
+// GetStreamUpstreams returns stream/upstreams stats with a context.
+func (client *NginxClient) GetStreamUpstreams(ctx context.Context) (*StreamUpstreams, error) {
 	var upstreams StreamUpstreams
-	err := client.getWithContext(ctx, "stream/upstreams", &upstreams)
+	err := client.get(ctx, "stream/upstreams", &upstreams)
 	if err != nil {
 		var ie *internalError
 		if errors.As(err, &ie) {
@@ -1750,15 +1642,10 @@ func (client *NginxClient) GetStreamUpstreamsWithContext(ctx context.Context) (*
 	return &upstreams, nil
 }
 
-// GetStreamZoneSync returns stream/zone_sync stats.
-func (client *NginxClient) GetStreamZoneSync() (*StreamZoneSync, error) {
-	return client.GetStreamZoneSyncWithContext(context.Background())
-}
-
-// GetStreamZoneSyncWithContext returns stream/zone_sync stats with a context.
-func (client *NginxClient) GetStreamZoneSyncWithContext(ctx context.Context) (*StreamZoneSync, error) {
+// GetStreamZoneSync returns stream/zone_sync stats with a context.
+func (client *NginxClient) GetStreamZoneSync(ctx context.Context) (*StreamZoneSync, error) {
 	var streamZoneSync StreamZoneSync
-	err := client.getWithContext(ctx, "stream/zone_sync", &streamZoneSync)
+	err := client.get(ctx, "stream/zone_sync", &streamZoneSync)
 	if err != nil {
 		var ie *internalError
 		if errors.As(err, &ie) {
@@ -1772,18 +1659,13 @@ func (client *NginxClient) GetStreamZoneSyncWithContext(ctx context.Context) (*S
 	return &streamZoneSync, err
 }
 
-// GetLocationZones returns http/location_zones stats.
-func (client *NginxClient) GetLocationZones() (*LocationZones, error) {
-	return client.GetLocationZonesWithContext(context.Background())
-}
-
-// GetLocationZonesWithContext returns http/location_zones stats with a context.
-func (client *NginxClient) GetLocationZonesWithContext(ctx context.Context) (*LocationZones, error) {
+// GetLocationZones returns http/location_zones stats with a context.
+func (client *NginxClient) GetLocationZones(ctx context.Context) (*LocationZones, error) {
 	var locationZones LocationZones
 	if client.apiVersion < 5 {
 		return &locationZones, nil
 	}
-	err := client.getWithContext(ctx, "http/location_zones", &locationZones)
+	err := client.get(ctx, "http/location_zones", &locationZones)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get location zones: %w", err)
 	}
@@ -1791,18 +1673,13 @@ func (client *NginxClient) GetLocationZonesWithContext(ctx context.Context) (*Lo
 	return &locationZones, err
 }
 
-// GetResolvers returns Resolvers stats.
-func (client *NginxClient) GetResolvers() (*Resolvers, error) {
-	return client.GetResolversWithContext(context.Background())
-}
-
-// GetResolversWithContext returns Resolvers stats with a context.
-func (client *NginxClient) GetResolversWithContext(ctx context.Context) (*Resolvers, error) {
+// GetResolvers returns Resolvers stats with a context.
+func (client *NginxClient) GetResolvers(ctx context.Context) (*Resolvers, error) {
 	var resolvers Resolvers
 	if client.apiVersion < 5 {
 		return &resolvers, nil
 	}
-	err := client.getWithContext(ctx, "resolvers", &resolvers)
+	err := client.get(ctx, "resolvers", &resolvers)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get resolvers: %w", err)
 	}
@@ -1810,15 +1687,10 @@ func (client *NginxClient) GetResolversWithContext(ctx context.Context) (*Resolv
 	return &resolvers, err
 }
 
-// GetProcesses returns Processes stats.
-func (client *NginxClient) GetProcesses() (*Processes, error) {
-	return client.GetProcessesWithContext(context.Background())
-}
-
-// GetProcessesWithContext returns Processes stats with a context.
-func (client *NginxClient) GetProcessesWithContext(ctx context.Context) (*Processes, error) {
+// GetProcesses returns Processes stats with a context.
+func (client *NginxClient) GetProcesses(ctx context.Context) (*Processes, error) {
 	var processes Processes
-	err := client.getWithContext(ctx, "processes", &processes)
+	err := client.get(ctx, "processes", &processes)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get processes: %w", err)
 	}
@@ -1833,16 +1705,16 @@ type KeyValPairs map[string]string
 type KeyValPairsByZone map[string]KeyValPairs
 
 // GetKeyValPairs fetches key/value pairs for a given HTTP zone.
-func (client *NginxClient) GetKeyValPairs(zone string) (KeyValPairs, error) {
-	return client.getKeyValPairs(zone, httpContext)
+func (client *NginxClient) GetKeyValPairs(ctx context.Context, zone string) (KeyValPairs, error) {
+	return client.getKeyValPairs(ctx, zone, httpContext)
 }
 
 // GetStreamKeyValPairs fetches key/value pairs for a given Stream zone.
-func (client *NginxClient) GetStreamKeyValPairs(zone string) (KeyValPairs, error) {
-	return client.getKeyValPairs(zone, streamContext)
+func (client *NginxClient) GetStreamKeyValPairs(ctx context.Context, zone string) (KeyValPairs, error) {
+	return client.getKeyValPairs(ctx, zone, streamContext)
 }
 
-func (client *NginxClient) getKeyValPairs(zone string, stream bool) (KeyValPairs, error) {
+func (client *NginxClient) getKeyValPairs(ctx context.Context, zone string, stream bool) (KeyValPairs, error) {
 	base := "http"
 	if stream {
 		base = "stream"
@@ -1853,7 +1725,7 @@ func (client *NginxClient) getKeyValPairs(zone string, stream bool) (KeyValPairs
 
 	path := fmt.Sprintf("%v/keyvals/%v", base, zone)
 	var keyValPairs KeyValPairs
-	err := client.get(path, &keyValPairs)
+	err := client.get(ctx, path, &keyValPairs)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get keyvals for %v/%v zone: %w", base, zone, err)
 	}
@@ -1861,16 +1733,16 @@ func (client *NginxClient) getKeyValPairs(zone string, stream bool) (KeyValPairs
 }
 
 // GetAllKeyValPairs fetches all key/value pairs for all HTTP zones.
-func (client *NginxClient) GetAllKeyValPairs() (KeyValPairsByZone, error) {
-	return client.getAllKeyValPairs(httpContext)
+func (client *NginxClient) GetAllKeyValPairs(ctx context.Context) (KeyValPairsByZone, error) {
+	return client.getAllKeyValPairs(ctx, httpContext)
 }
 
 // GetAllStreamKeyValPairs fetches all key/value pairs for all Stream zones.
-func (client *NginxClient) GetAllStreamKeyValPairs() (KeyValPairsByZone, error) {
-	return client.getAllKeyValPairs(streamContext)
+func (client *NginxClient) GetAllStreamKeyValPairs(ctx context.Context) (KeyValPairsByZone, error) {
+	return client.getAllKeyValPairs(ctx, streamContext)
 }
 
-func (client *NginxClient) getAllKeyValPairs(stream bool) (KeyValPairsByZone, error) {
+func (client *NginxClient) getAllKeyValPairs(ctx context.Context, stream bool) (KeyValPairsByZone, error) {
 	base := "http"
 	if stream {
 		base = "stream"
@@ -1878,7 +1750,7 @@ func (client *NginxClient) getAllKeyValPairs(stream bool) (KeyValPairsByZone, er
 
 	path := fmt.Sprintf("%v/keyvals", base)
 	var keyValPairsByZone KeyValPairsByZone
-	err := client.get(path, &keyValPairsByZone)
+	err := client.get(ctx, path, &keyValPairsByZone)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get keyvals for all %v zones: %w", base, err)
 	}
@@ -1886,16 +1758,16 @@ func (client *NginxClient) getAllKeyValPairs(stream bool) (KeyValPairsByZone, er
 }
 
 // AddKeyValPair adds a new key/value pair to a given HTTP zone.
-func (client *NginxClient) AddKeyValPair(zone string, key string, val string) error {
-	return client.addKeyValPair(zone, key, val, httpContext)
+func (client *NginxClient) AddKeyValPair(ctx context.Context, zone string, key string, val string) error {
+	return client.addKeyValPair(ctx, zone, key, val, httpContext)
 }
 
 // AddStreamKeyValPair adds a new key/value pair to a given Stream zone.
-func (client *NginxClient) AddStreamKeyValPair(zone string, key string, val string) error {
-	return client.addKeyValPair(zone, key, val, streamContext)
+func (client *NginxClient) AddStreamKeyValPair(ctx context.Context, zone string, key string, val string) error {
+	return client.addKeyValPair(ctx, zone, key, val, streamContext)
 }
 
-func (client *NginxClient) addKeyValPair(zone string, key string, val string, stream bool) error {
+func (client *NginxClient) addKeyValPair(ctx context.Context, zone string, key string, val string, stream bool) error {
 	base := "http"
 	if stream {
 		base = "stream"
@@ -1906,7 +1778,7 @@ func (client *NginxClient) addKeyValPair(zone string, key string, val string, st
 
 	path := fmt.Sprintf("%v/keyvals/%v", base, zone)
 	input := KeyValPairs{key: val}
-	err := client.post(path, &input)
+	err := client.post(ctx, path, &input)
 	if err != nil {
 		return fmt.Errorf("failed to add key value pair for %v/%v zone: %w", base, zone, err)
 	}
@@ -1914,16 +1786,16 @@ func (client *NginxClient) addKeyValPair(zone string, key string, val string, st
 }
 
 // ModifyKeyValPair modifies the value of an existing key in a given HTTP zone.
-func (client *NginxClient) ModifyKeyValPair(zone string, key string, val string) error {
-	return client.modifyKeyValPair(zone, key, val, httpContext)
+func (client *NginxClient) ModifyKeyValPair(ctx context.Context, zone string, key string, val string) error {
+	return client.modifyKeyValPair(ctx, zone, key, val, httpContext)
 }
 
 // ModifyStreamKeyValPair modifies the value of an existing key in a given Stream zone.
-func (client *NginxClient) ModifyStreamKeyValPair(zone string, key string, val string) error {
-	return client.modifyKeyValPair(zone, key, val, streamContext)
+func (client *NginxClient) ModifyStreamKeyValPair(ctx context.Context, zone string, key string, val string) error {
+	return client.modifyKeyValPair(ctx, zone, key, val, streamContext)
 }
 
-func (client *NginxClient) modifyKeyValPair(zone string, key string, val string, stream bool) error {
+func (client *NginxClient) modifyKeyValPair(ctx context.Context, zone string, key string, val string, stream bool) error {
 	base := "http"
 	if stream {
 		base = "stream"
@@ -1934,7 +1806,7 @@ func (client *NginxClient) modifyKeyValPair(zone string, key string, val string,
 
 	path := fmt.Sprintf("%v/keyvals/%v", base, zone)
 	input := KeyValPairs{key: val}
-	err := client.patch(path, &input, http.StatusNoContent)
+	err := client.patch(ctx, path, &input, http.StatusNoContent)
 	if err != nil {
 		return fmt.Errorf("failed to update key value pair for %v/%v zone: %w", base, zone, err)
 	}
@@ -1942,18 +1814,18 @@ func (client *NginxClient) modifyKeyValPair(zone string, key string, val string,
 }
 
 // DeleteKeyValuePair deletes the key/value pair for a key in a given HTTP zone.
-func (client *NginxClient) DeleteKeyValuePair(zone string, key string) error {
-	return client.deleteKeyValuePair(zone, key, httpContext)
+func (client *NginxClient) DeleteKeyValuePair(ctx context.Context, zone string, key string) error {
+	return client.deleteKeyValuePair(ctx, zone, key, httpContext)
 }
 
 // DeleteStreamKeyValuePair deletes the key/value pair for a key in a given Stream zone.
-func (client *NginxClient) DeleteStreamKeyValuePair(zone string, key string) error {
-	return client.deleteKeyValuePair(zone, key, streamContext)
+func (client *NginxClient) DeleteStreamKeyValuePair(ctx context.Context, zone string, key string) error {
+	return client.deleteKeyValuePair(ctx, zone, key, streamContext)
 }
 
 // To delete a key/value pair you set the value to null via the API,
 // then NGINX+ will delete the key.
-func (client *NginxClient) deleteKeyValuePair(zone string, key string, stream bool) error {
+func (client *NginxClient) deleteKeyValuePair(ctx context.Context, zone string, key string, stream bool) error {
 	base := "http"
 	if stream {
 		base = "stream"
@@ -1967,7 +1839,7 @@ func (client *NginxClient) deleteKeyValuePair(zone string, key string, stream bo
 	keyval[key] = nil
 
 	path := fmt.Sprintf("%v/keyvals/%v", base, zone)
-	err := client.patch(path, &keyval, http.StatusNoContent)
+	err := client.patch(ctx, path, &keyval, http.StatusNoContent)
 	if err != nil {
 		return fmt.Errorf("failed to remove key values pair for %v/%v zone: %w", base, zone, err)
 	}
@@ -1975,16 +1847,16 @@ func (client *NginxClient) deleteKeyValuePair(zone string, key string, stream bo
 }
 
 // DeleteKeyValPairs deletes all the key-value pairs in a given HTTP zone.
-func (client *NginxClient) DeleteKeyValPairs(zone string) error {
-	return client.deleteKeyValPairs(zone, httpContext)
+func (client *NginxClient) DeleteKeyValPairs(ctx context.Context, zone string) error {
+	return client.deleteKeyValPairs(ctx, zone, httpContext)
 }
 
 // DeleteStreamKeyValPairs deletes all the key-value pairs in a given Stream zone.
-func (client *NginxClient) DeleteStreamKeyValPairs(zone string) error {
-	return client.deleteKeyValPairs(zone, streamContext)
+func (client *NginxClient) DeleteStreamKeyValPairs(ctx context.Context, zone string) error {
+	return client.deleteKeyValPairs(ctx, zone, streamContext)
 }
 
-func (client *NginxClient) deleteKeyValPairs(zone string, stream bool) error {
+func (client *NginxClient) deleteKeyValPairs(ctx context.Context, zone string, stream bool) error {
 	base := "http"
 	if stream {
 		base = "stream"
@@ -1994,7 +1866,7 @@ func (client *NginxClient) deleteKeyValPairs(zone string, stream bool) error {
 	}
 
 	path := fmt.Sprintf("%v/keyvals/%v", base, zone)
-	err := client.delete(path, http.StatusNoContent)
+	err := client.delete(ctx, path, http.StatusNoContent)
 	if err != nil {
 		return fmt.Errorf("failed to remove all key value pairs for %v/%v zone: %w", base, zone, err)
 	}
@@ -2002,10 +1874,10 @@ func (client *NginxClient) deleteKeyValPairs(zone string, stream bool) error {
 }
 
 // UpdateHTTPServer updates the server of the upstream.
-func (client *NginxClient) UpdateHTTPServer(upstream string, server UpstreamServer) error {
+func (client *NginxClient) UpdateHTTPServer(ctx context.Context, upstream string, server UpstreamServer) error {
 	path := fmt.Sprintf("http/upstreams/%v/servers/%v", upstream, server.ID)
 	server.ID = 0
-	err := client.patch(path, &server, http.StatusOK)
+	err := client.patch(ctx, path, &server, http.StatusOK)
 	if err != nil {
 		return fmt.Errorf("failed to update %v server to %v upstream: %w", server.Server, upstream, err)
 	}
@@ -2014,10 +1886,10 @@ func (client *NginxClient) UpdateHTTPServer(upstream string, server UpstreamServ
 }
 
 // UpdateStreamServer updates the stream server of the upstream.
-func (client *NginxClient) UpdateStreamServer(upstream string, server StreamUpstreamServer) error {
+func (client *NginxClient) UpdateStreamServer(ctx context.Context, upstream string, server StreamUpstreamServer) error {
 	path := fmt.Sprintf("stream/upstreams/%v/servers/%v", upstream, server.ID)
 	server.ID = 0
-	err := client.patch(path, &server, http.StatusOK)
+	err := client.patch(ctx, path, &server, http.StatusOK)
 	if err != nil {
 		return fmt.Errorf("failed to update %v stream server to %v upstream: %w", server.Server, upstream, err)
 	}
@@ -2046,54 +1918,39 @@ func addPortToServer(server string) string {
 	return fmt.Sprintf("%v:%v", server, defaultServerPort)
 }
 
-// GetHTTPLimitReqs returns http/limit_reqs stats.
-func (client *NginxClient) GetHTTPLimitReqs() (*HTTPLimitRequests, error) {
-	return client.GetHTTPLimitReqsWithContext(context.Background())
-}
-
-// GetHTTPLimitReqsWithContext returns http/limit_reqs stats with a context.
-func (client *NginxClient) GetHTTPLimitReqsWithContext(ctx context.Context) (*HTTPLimitRequests, error) {
+// GetHTTPLimitReqs returns http/limit_reqs stats with a context.
+func (client *NginxClient) GetHTTPLimitReqs(ctx context.Context) (*HTTPLimitRequests, error) {
 	var limitReqs HTTPLimitRequests
 	if client.apiVersion < 6 {
 		return &limitReqs, nil
 	}
-	err := client.getWithContext(ctx, "http/limit_reqs", &limitReqs)
+	err := client.get(ctx, "http/limit_reqs", &limitReqs)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get http limit requests: %w", err)
 	}
 	return &limitReqs, nil
 }
 
-// GetHTTPConnectionsLimit returns http/limit_conns stats.
-func (client *NginxClient) GetHTTPConnectionsLimit() (*HTTPLimitConnections, error) {
-	return client.GetHTTPConnectionsLimitWithContext(context.Background())
-}
-
-// GetHTTPConnectionsLimitWithContext returns http/limit_conns stats with a context.
-func (client *NginxClient) GetHTTPConnectionsLimitWithContext(ctx context.Context) (*HTTPLimitConnections, error) {
+// GetHTTPConnectionsLimit returns http/limit_conns stats with a context.
+func (client *NginxClient) GetHTTPConnectionsLimit(ctx context.Context) (*HTTPLimitConnections, error) {
 	var limitConns HTTPLimitConnections
 	if client.apiVersion < 6 {
 		return &limitConns, nil
 	}
-	err := client.getWithContext(ctx, "http/limit_conns", &limitConns)
+	err := client.get(ctx, "http/limit_conns", &limitConns)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get http connections limit: %w", err)
 	}
 	return &limitConns, nil
 }
 
-// GetStreamConnectionsLimit returns stream/limit_conns stats.
-func (client *NginxClient) GetStreamConnectionsLimit() (*StreamLimitConnections, error) {
-	return client.GetStreamConnectionsLimitWithContext(context.Background())
-}
-
-// GetStreamConnectionsLimitWithContext returns stream/limit_conns stats with a context.
-func (client *NginxClient) GetStreamConnectionsLimitWithContext(ctx context.Context) (*StreamLimitConnections, error) {
+// GetStreamConnectionsLimit returns stream/limit_conns stats with a context.
+func (client *NginxClient) GetStreamConnectionsLimit(ctx context.Context) (*StreamLimitConnections, error) {
 	var limitConns StreamLimitConnections
 	if client.apiVersion < 6 {
 		return &limitConns, nil
 	}
-	err := client.getWithContext(ctx, "stream/limit_conns", &limitConns)
+	err := client.get(ctx, "stream/limit_conns", &limitConns)
 	if err != nil {
 		var ie *internalError
 		if errors.As(err, &ie) {
@@ -2107,17 +1964,12 @@ func (client *NginxClient) GetStreamConnectionsLimitWithContext(ctx context.Cont
 }
 
 // GetWorkers returns workers stats.
-func (client *NginxClient) GetWorkers() ([]*Workers, error) {
-	return client.GetWorkersWithContext(context.Background())
-}
-
-// GetWorkersWithContext returns workers stats with a context.
-func (client *NginxClient) GetWorkersWithContext(ctx context.Context) ([]*Workers, error) {
+func (client *NginxClient) GetWorkers(ctx context.Context) ([]*Workers, error) {
 	var workers []*Workers
 	if client.apiVersion < 9 {
 		return workers, nil
 	}
-	err := client.getWithContext(ctx, "workers", &workers)
+	err := client.get(ctx, "workers", &workers)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get workers: %w", err)
 	}
diff --git a/client/nginx_test.go b/client/nginx_test.go
index 0ad650c9..655b3f82 100644
--- a/client/nginx_test.go
+++ b/client/nginx_test.go
@@ -8,7 +8,6 @@ import (
 	"strings"
 	"sync"
 	"testing"
-	"time"
 )
 
 func TestDetermineUpdates(t *testing.T) {
@@ -581,27 +580,6 @@ func TestClientWithAPIVersion(t *testing.T) {
 	}
 }
 
-func TestClientWithTimeout(t *testing.T) {
-	t.Parallel()
-	// Test creating a new client with a supported API version on the client
-	client, err := NewNginxClient("http://api-url", WithTimeout(1*time.Second))
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if client == nil {
-		t.Fatalf("client is nil")
-	}
-
-	// Test creating a new client with an invalid duration
-	client, err = NewNginxClient("http://api-url", WithTimeout(-1*time.Second))
-	if err == nil {
-		t.Fatalf("expected error, but got nil")
-	}
-	if client != nil {
-		t.Fatalf("expected client to be nil, but got %v", client)
-	}
-}
-
 func TestClientWithHTTPClient(t *testing.T) {
 	t.Parallel()
 	// Test creating a new client passing a custom HTTP client
@@ -624,21 +602,6 @@ func TestClientWithHTTPClient(t *testing.T) {
 }
 
 func TestGetStats_NoStreamEndpoint(t *testing.T) {
-	tests := []struct {
-		ctx  context.Context
-		name string
-	}{
-		{
-			ctx:  nil,
-			name: "no context test",
-		},
-		{
-			ctx:  context.Background(),
-			name: "with context test",
-		},
-	}
-	var err error
-	var client *NginxClient
 	var writeLock sync.Mutex
 
 	t.Parallel()
@@ -649,19 +612,19 @@ func TestGetStats_NoStreamEndpoint(t *testing.T) {
 		switch {
 		case r.RequestURI == "/":
 
-			_, err = w.Write([]byte(`[4, 5, 6, 7, 8, 9]`))
+			_, err := w.Write([]byte(`[4, 5, 6, 7, 8, 9]`))
 			if err != nil {
 				t.Fatalf("unexpected error: %v", err)
 			}
 		case r.RequestURI == "/7/":
-			_, err = w.Write([]byte(`["nginx","processes","connections","slabs","http","resolvers","ssl"]`))
+			_, err := w.Write([]byte(`["nginx","processes","connections","slabs","http","resolvers","ssl"]`))
 			if err != nil {
 				t.Fatalf("unexpected error: %v", err)
 			}
 		case strings.HasPrefix(r.RequestURI, "/7/stream"):
 			t.Fatal("Stream endpoint should not be called since it does not exist.")
 		default:
-			_, err = w.Write([]byte(`{}`))
+			_, err := w.Write([]byte(`{}`))
 			if err != nil {
 				t.Fatalf("unexpected error: %v", err)
 			}
@@ -670,7 +633,7 @@ func TestGetStats_NoStreamEndpoint(t *testing.T) {
 	defer ts.Close()
 
 	// Test creating a new client with a supported API version on the server
-	client, err = NewNginxClient(ts.URL, WithAPIVersion(7), WithCheckAPI())
+	client, err := NewNginxClient(ts.URL, WithAPIVersion(7), WithCheckAPI())
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -678,19 +641,9 @@ func TestGetStats_NoStreamEndpoint(t *testing.T) {
 		t.Fatalf("client is nil")
 	}
 
-	var stats *Stats
-	for _, test := range tests {
-		if test.ctx == nil {
-			stats, err = client.GetStats()
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-		} else {
-			stats, err = client.GetStatsWithContext(test.ctx)
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-		}
+	stats, err := client.GetStats(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
 	}
 
 	if !reflect.DeepEqual(stats.StreamServerZones, StreamServerZones{}) {
@@ -708,20 +661,6 @@ func TestGetStats_NoStreamEndpoint(t *testing.T) {
 }
 
 func TestGetStats_SSL(t *testing.T) {
-	tests := []struct {
-		ctx  context.Context
-		name string
-	}{
-		{
-			ctx:  nil,
-			name: "no context test",
-		},
-		{
-			ctx:  context.Background(),
-			name: "with context test",
-		},
-	}
-
 	t.Parallel()
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		switch {
@@ -778,41 +717,30 @@ func TestGetStats_SSL(t *testing.T) {
 		t.Fatalf("client is nil")
 	}
 
-	var stats *Stats
-
-	for _, test := range tests {
-		if test.ctx == nil {
-			stats, err = client.GetStats()
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-		} else {
-			stats, err = client.GetStatsWithContext(test.ctx)
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-		}
+	stats, err := client.GetStats(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
 
-		testStats := SSL{
-			Handshakes:       79572,
-			HandshakesFailed: 21025,
-			SessionReuses:    15762,
-			NoCommonProtocol: 4,
-			NoCommonCipher:   2,
-			HandshakeTimeout: 0,
-			PeerRejectedCert: 0,
-			VerifyFailures: VerifyFailures{
-				NoCert:           0,
-				ExpiredCert:      2,
-				RevokedCert:      1,
-				HostnameMismatch: 2,
-				Other:            1,
-			},
-		}
+	testStats := SSL{
+		Handshakes:       79572,
+		HandshakesFailed: 21025,
+		SessionReuses:    15762,
+		NoCommonProtocol: 4,
+		NoCommonCipher:   2,
+		HandshakeTimeout: 0,
+		PeerRejectedCert: 0,
+		VerifyFailures: VerifyFailures{
+			NoCert:           0,
+			ExpiredCert:      2,
+			RevokedCert:      1,
+			HostnameMismatch: 2,
+			Other:            1,
+		},
+	}
 
-		if !reflect.DeepEqual(stats.SSL, testStats) {
-			t.Fatalf("SSL stats: expected %v, actual %v", testStats, stats.SSL)
-		}
+	if !reflect.DeepEqual(stats.SSL, testStats) {
+		t.Fatalf("SSL stats: expected %v, actual %v", testStats, stats.SSL)
 	}
 }
 
@@ -839,7 +767,7 @@ func TestGetMaxAPIVersionServer(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
-	maxVer, err := c.GetMaxAPIVersion()
+	maxVer, err := c.GetMaxAPIVersion(context.Background())
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -871,7 +799,7 @@ func TestGetMaxAPIVersionClient(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
-	maxVer, err := c.GetMaxAPIVersion()
+	maxVer, err := c.GetMaxAPIVersion(context.Background())
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
diff --git a/tests/client_no_stream_test.go b/tests/client_no_stream_test.go
index cb29d465..525e3694 100644
--- a/tests/client_no_stream_test.go
+++ b/tests/client_no_stream_test.go
@@ -1,6 +1,7 @@
 package tests
 
 import (
+	"context"
 	"testing"
 
 	"github.com/nginxinc/nginx-plus-go-client/client"
@@ -16,8 +17,8 @@ func TestStatsNoStream(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Error connecting to nginx: %v", err)
 	}
-
-	stats, err := c.GetStats()
+	ctx := context.Background()
+	stats, err := c.GetStats(ctx)
 	if err != nil {
 		t.Errorf("Error getting stats: %v", err)
 	}
diff --git a/tests/client_test.go b/tests/client_test.go
index 627631e1..bb97609a 100644
--- a/tests/client_test.go
+++ b/tests/client_test.go
@@ -1,6 +1,7 @@
 package tests
 
 import (
+	"context"
 	"net"
 	"reflect"
 	"testing"
@@ -46,13 +47,14 @@ func TestStreamClient(t *testing.T) {
 	}
 
 	// test adding a stream server
+	ctx := context.Background()
 
-	err = c.AddStreamServer(streamUpstream, streamServer)
+	err = c.AddStreamServer(ctx, streamUpstream, streamServer)
 	if err != nil {
 		t.Fatalf("Error when adding a server: %v", err)
 	}
 
-	err = c.AddStreamServer(streamUpstream, streamServer)
+	err = c.AddStreamServer(ctx, streamUpstream, streamServer)
 
 	if err == nil {
 		t.Errorf("Adding a duplicated server succeeded")
@@ -60,17 +62,17 @@ func TestStreamClient(t *testing.T) {
 
 	// test deleting a stream server
 
-	err = c.DeleteStreamServer(streamUpstream, streamServer.Server)
+	err = c.DeleteStreamServer(ctx, streamUpstream, streamServer.Server)
 	if err != nil {
 		t.Fatalf("Error when deleting a server: %v", err)
 	}
 
-	err = c.DeleteStreamServer(streamUpstream, streamServer.Server)
+	err = c.DeleteStreamServer(ctx, streamUpstream, streamServer.Server)
 	if err == nil {
 		t.Errorf("Deleting a nonexisting server succeeded")
 	}
 
-	streamServers, err := c.GetStreamServers(streamUpstream)
+	streamServers, err := c.GetStreamServers(ctx, streamUpstream)
 	if err != nil {
 		t.Errorf("Error getting stream servers: %v", err)
 	}
@@ -91,7 +93,7 @@ func TestStreamClient(t *testing.T) {
 		},
 	}
 
-	streamAdded, streamDeleted, streamUpdated, err := c.UpdateStreamServers(streamUpstream, streamServers1)
+	streamAdded, streamDeleted, streamUpdated, err := c.UpdateStreamServers(ctx, streamUpstream, streamServers1)
 	if err != nil {
 		t.Fatalf("Error when updating servers: %v", err)
 	}
@@ -107,7 +109,7 @@ func TestStreamClient(t *testing.T) {
 
 	// test getting servers
 
-	streamServers, err = c.GetStreamServers(streamUpstream)
+	streamServers, err = c.GetStreamServers(ctx, streamUpstream)
 	if err != nil {
 		t.Fatalf("Error when getting servers: %v", err)
 	}
@@ -117,7 +119,7 @@ func TestStreamClient(t *testing.T) {
 
 	// updating with the same servers
 
-	added, deleted, updated, err := c.UpdateStreamServers(streamUpstream, streamServers1)
+	added, deleted, updated, err := c.UpdateStreamServers(ctx, streamUpstream, streamServers1)
 	if err != nil {
 		t.Fatalf("Error when updating servers: %v", err)
 	}
@@ -144,7 +146,7 @@ func TestStreamClient(t *testing.T) {
 	// updating one server with only one different parameter
 	streamServers[1].SlowStart = newSlowStart
 
-	added, deleted, updated, err = c.UpdateStreamServers(streamUpstream, streamServers)
+	added, deleted, updated, err = c.UpdateStreamServers(ctx, streamUpstream, streamServers)
 	if err != nil {
 		t.Fatalf("Error when updating server with different parameters: %v", err)
 	}
@@ -158,7 +160,7 @@ func TestStreamClient(t *testing.T) {
 		t.Errorf("The number of updated servers %v != 2", len(updated))
 	}
 
-	streamServers, err = c.GetStreamServers(streamUpstream)
+	streamServers, err = c.GetStreamServers(ctx, streamUpstream)
 	if err != nil {
 		t.Fatalf("Error when getting servers: %v", err)
 	}
@@ -209,7 +211,7 @@ func TestStreamClient(t *testing.T) {
 
 	// updating with 2 new servers, 1 existing
 
-	added, deleted, updated, err = c.UpdateStreamServers(streamUpstream, streamServers2)
+	added, deleted, updated, err = c.UpdateStreamServers(ctx, streamUpstream, streamServers2)
 	if err != nil {
 		t.Fatalf("Error when updating servers: %v", err)
 	}
@@ -225,7 +227,7 @@ func TestStreamClient(t *testing.T) {
 
 	// updating with zero servers - removing
 
-	added, deleted, updated, err = c.UpdateStreamServers(streamUpstream, []client.StreamUpstreamServer{})
+	added, deleted, updated, err = c.UpdateStreamServers(ctx, streamUpstream, []client.StreamUpstreamServer{})
 	if err != nil {
 		t.Fatalf("Error when updating servers: %v", err)
 	}
@@ -241,7 +243,7 @@ func TestStreamClient(t *testing.T) {
 
 	// test getting servers again
 
-	servers, err := c.GetStreamServers(streamUpstream)
+	servers, err := c.GetStreamServers(ctx, streamUpstream)
 	if err != nil {
 		t.Fatalf("Error when getting servers: %v", err)
 	}
@@ -273,11 +275,13 @@ func TestStreamUpstreamServer(t *testing.T) {
 		Backup:      &backup,
 		Down:        &down,
 	}
-	err = c.AddStreamServer(streamUpstream, streamServer)
+	ctx := context.Background()
+
+	err = c.AddStreamServer(ctx, streamUpstream, streamServer)
 	if err != nil {
 		t.Errorf("Error adding upstream server: %v", err)
 	}
-	servers, err := c.GetStreamServers(streamUpstream)
+	servers, err := c.GetStreamServers(ctx, streamUpstream)
 	if err != nil {
 		t.Fatalf("Error getting stream servers: %v", err)
 	}
@@ -292,7 +296,7 @@ func TestStreamUpstreamServer(t *testing.T) {
 	}
 
 	// remove stream upstream servers
-	_, _, _, err = c.UpdateStreamServers(streamUpstream, []client.StreamUpstreamServer{})
+	_, _, _, err = c.UpdateStreamServers(ctx, streamUpstream, []client.StreamUpstreamServer{})
 	if err != nil {
 		t.Errorf("Couldn't remove servers: %v", err)
 	}
@@ -305,13 +309,13 @@ func TestClient(t *testing.T) {
 	}
 
 	// test checking an upstream for existence
-
-	err = c.CheckIfUpstreamExists(upstream)
+	ctx := context.Background()
+	err = c.CheckIfUpstreamExists(ctx, upstream)
 	if err != nil {
 		t.Fatalf("Error when checking an upstream for existence: %v", err)
 	}
 
-	err = c.CheckIfUpstreamExists("random")
+	err = c.CheckIfUpstreamExists(ctx, "random")
 	if err == nil {
 		t.Errorf("Nonexisting upstream exists")
 	}
@@ -322,12 +326,12 @@ func TestClient(t *testing.T) {
 
 	// test adding a http server
 
-	err = c.AddHTTPServer(upstream, server)
+	err = c.AddHTTPServer(ctx, upstream, server)
 	if err != nil {
 		t.Fatalf("Error when adding a server: %v", err)
 	}
 
-	err = c.AddHTTPServer(upstream, server)
+	err = c.AddHTTPServer(ctx, upstream, server)
 
 	if err == nil {
 		t.Errorf("Adding a duplicated server succeeded")
@@ -335,12 +339,12 @@ func TestClient(t *testing.T) {
 
 	// test deleting a http server
 
-	err = c.DeleteHTTPServer(upstream, server.Server)
+	err = c.DeleteHTTPServer(ctx, upstream, server.Server)
 	if err != nil {
 		t.Fatalf("Error when deleting a server: %v", err)
 	}
 
-	err = c.DeleteHTTPServer(upstream, server.Server)
+	err = c.DeleteHTTPServer(ctx, upstream, server.Server)
 	if err == nil {
 		t.Errorf("Deleting a nonexisting server succeeded")
 	}
@@ -358,7 +362,7 @@ func TestClient(t *testing.T) {
 		},
 	}
 
-	added, deleted, updated, err := c.UpdateHTTPServers(upstream, servers1)
+	added, deleted, updated, err := c.UpdateHTTPServers(ctx, upstream, servers1)
 	if err != nil {
 		t.Fatalf("Error when updating servers: %v", err)
 	}
@@ -374,7 +378,7 @@ func TestClient(t *testing.T) {
 
 	// test getting servers
 
-	servers, err := c.GetHTTPServers(upstream)
+	servers, err := c.GetHTTPServers(ctx, upstream)
 	if err != nil {
 		t.Fatalf("Error when getting servers: %v", err)
 	}
@@ -386,7 +390,7 @@ func TestClient(t *testing.T) {
 
 	// updating with the same servers
 
-	added, deleted, updated, err = c.UpdateHTTPServers(upstream, servers1)
+	added, deleted, updated, err = c.UpdateHTTPServers(ctx, upstream, servers1)
 	if err != nil {
 		t.Fatalf("Error when updating servers: %v", err)
 	}
@@ -413,7 +417,7 @@ func TestClient(t *testing.T) {
 	// updating one server with only one different parameter
 	servers[1].SlowStart = newSlowStart
 
-	added, deleted, updated, err = c.UpdateHTTPServers(upstream, servers)
+	added, deleted, updated, err = c.UpdateHTTPServers(ctx, upstream, servers)
 	if err != nil {
 		t.Fatalf("Error when updating server with different parameters: %v", err)
 	}
@@ -427,7 +431,7 @@ func TestClient(t *testing.T) {
 		t.Errorf("The number of updated servers %v != 2", len(updated))
 	}
 
-	servers, err = c.GetHTTPServers(upstream)
+	servers, err = c.GetHTTPServers(ctx, upstream)
 	if err != nil {
 		t.Fatalf("Error when getting servers: %v", err)
 	}
@@ -478,7 +482,7 @@ func TestClient(t *testing.T) {
 
 	// updating with 2 new servers, 1 existing
 
-	added, deleted, updated, err = c.UpdateHTTPServers(upstream, servers2)
+	added, deleted, updated, err = c.UpdateHTTPServers(ctx, upstream, servers2)
 	if err != nil {
 		t.Fatalf("Error when updating servers: %v", err)
 	}
@@ -494,7 +498,7 @@ func TestClient(t *testing.T) {
 
 	// updating with zero servers - removing
 
-	added, deleted, updated, err = c.UpdateHTTPServers(upstream, []client.UpstreamServer{})
+	added, deleted, updated, err = c.UpdateHTTPServers(ctx, upstream, []client.UpstreamServer{})
 	if err != nil {
 		t.Fatalf("Error when updating servers: %v", err)
 	}
@@ -510,7 +514,7 @@ func TestClient(t *testing.T) {
 
 	// test getting servers again
 
-	servers, err = c.GetHTTPServers(upstream)
+	servers, err = c.GetHTTPServers(ctx, upstream)
 	if err != nil {
 		t.Fatalf("Error when getting servers: %v", err)
 	}
@@ -543,11 +547,12 @@ func TestUpstreamServer(t *testing.T) {
 		Backup:      &backup,
 		Down:        &down,
 	}
-	err = c.AddHTTPServer(upstream, server)
+	ctx := context.Background()
+	err = c.AddHTTPServer(ctx, upstream, server)
 	if err != nil {
 		t.Errorf("Error adding upstream server: %v", err)
 	}
-	servers, err := c.GetHTTPServers(upstream)
+	servers, err := c.GetHTTPServers(ctx, upstream)
 	if err != nil {
 		t.Fatalf("Error getting HTTPServers: %v", err)
 	}
@@ -562,7 +567,7 @@ func TestUpstreamServer(t *testing.T) {
 	}
 
 	// remove upstream servers
-	_, _, _, err = c.UpdateHTTPServers(upstream, []client.UpstreamServer{})
+	_, _, _, err = c.UpdateHTTPServers(ctx, upstream, []client.UpstreamServer{})
 	if err != nil {
 		t.Errorf("Couldn't remove servers: %v", err)
 	}
@@ -577,12 +582,13 @@ func TestStats(t *testing.T) {
 	server := client.UpstreamServer{
 		Server: "127.0.0.1:8080",
 	}
-	err = c.AddHTTPServer(upstream, server)
+	ctx := context.Background()
+	err = c.AddHTTPServer(ctx, upstream, server)
 	if err != nil {
 		t.Errorf("Error adding upstream server: %v", err)
 	}
 
-	stats, err := c.GetStats()
+	stats, err := c.GetStats(ctx)
 	if err != nil {
 		t.Errorf("Error getting stats: %v", err)
 	}
@@ -703,7 +709,7 @@ func TestStats(t *testing.T) {
 	}
 
 	// cleanup upstream servers
-	_, _, _, err = c.UpdateHTTPServers(upstream, []client.UpstreamServer{})
+	_, _, _, err = c.UpdateHTTPServers(ctx, upstream, []client.UpstreamServer{})
 	if err != nil {
 		t.Errorf("Couldn't remove servers: %v", err)
 	}
@@ -733,11 +739,12 @@ func TestUpstreamServerDefaultParameters(t *testing.T) {
 		Weight:      &defaultWeight,
 		Service:     "",
 	}
-	err = c.AddHTTPServer(upstream, server)
+	ctx := context.Background()
+	err = c.AddHTTPServer(ctx, upstream, server)
 	if err != nil {
 		t.Errorf("Error adding upstream server: %v", err)
 	}
-	servers, err := c.GetHTTPServers(upstream)
+	servers, err := c.GetHTTPServers(ctx, upstream)
 	if err != nil {
 		t.Fatalf("Error getting HTTPServers: %v", err)
 	}
@@ -752,7 +759,7 @@ func TestUpstreamServerDefaultParameters(t *testing.T) {
 	}
 
 	// remove upstream servers
-	_, _, _, err = c.UpdateHTTPServers(upstream, []client.UpstreamServer{})
+	_, _, _, err = c.UpdateHTTPServers(ctx, upstream, []client.UpstreamServer{})
 	if err != nil {
 		t.Errorf("Couldn't remove servers: %v", err)
 	}
@@ -767,7 +774,8 @@ func TestStreamStats(t *testing.T) {
 	server := client.StreamUpstreamServer{
 		Server: "127.0.0.1:8080",
 	}
-	err = c.AddStreamServer(streamUpstream, server)
+	ctx := context.Background()
+	err = c.AddStreamServer(ctx, streamUpstream, server)
 	if err != nil {
 		t.Errorf("Error adding stream upstream server: %v", err)
 	}
@@ -781,7 +789,7 @@ func TestStreamStats(t *testing.T) {
 	// wait for health checks
 	time.Sleep(50 * time.Millisecond)
 
-	stats, err := c.GetStats()
+	stats, err := c.GetStats(ctx)
 	if err != nil {
 		t.Errorf("Error getting stats: %v", err)
 	}
@@ -829,7 +837,7 @@ func TestStreamStats(t *testing.T) {
 	}
 
 	// cleanup stream upstream servers
-	_, _, _, err = c.UpdateStreamServers(streamUpstream, []client.StreamUpstreamServer{})
+	_, _, _, err = c.UpdateStreamServers(ctx, streamUpstream, []client.StreamUpstreamServer{})
 	if err != nil {
 		t.Errorf("Couldn't remove stream servers: %v", err)
 	}
@@ -857,11 +865,12 @@ func TestStreamUpstreamServerDefaultParameters(t *testing.T) {
 		Weight:      &defaultWeight,
 		Service:     "",
 	}
-	err = c.AddStreamServer(streamUpstream, streamServer)
+	ctx := context.Background()
+	err = c.AddStreamServer(ctx, streamUpstream, streamServer)
 	if err != nil {
 		t.Errorf("Error adding upstream server: %v", err)
 	}
-	streamServers, err := c.GetStreamServers(streamUpstream)
+	streamServers, err := c.GetStreamServers(ctx, streamUpstream)
 	if err != nil {
 		t.Fatalf("Error getting stream servers: %v", err)
 	}
@@ -876,7 +885,7 @@ func TestStreamUpstreamServerDefaultParameters(t *testing.T) {
 	}
 
 	// cleanup stream upstream servers
-	_, _, _, err = c.UpdateStreamServers(streamUpstream, []client.StreamUpstreamServer{})
+	_, _, _, err = c.UpdateStreamServers(ctx, streamUpstream, []client.StreamUpstreamServer{})
 	if err != nil {
 		t.Errorf("Couldn't remove stream servers: %v", err)
 	}
@@ -889,13 +898,14 @@ func TestKeyValue(t *testing.T) {
 		t.Fatalf("Error connecting to nginx: %v", err)
 	}
 
-	err = c.AddKeyValPair(zoneName, "key1", "val1")
+	ctx := context.Background()
+	err = c.AddKeyValPair(ctx, zoneName, "key1", "val1")
 	if err != nil {
 		t.Errorf("Couldn't set keyvals: %v", err)
 	}
 
 	var keyValPairs client.KeyValPairs
-	keyValPairs, err = c.GetKeyValPairs(zoneName)
+	keyValPairs, err = c.GetKeyValPairs(ctx, zoneName)
 	if err != nil {
 		t.Errorf("Couldn't get keyvals for zone: %v, err: %v", zoneName, err)
 	}
@@ -906,7 +916,7 @@ func TestKeyValue(t *testing.T) {
 		t.Errorf("maps are not equal. expected: %+v, got: %+v", expectedKeyValPairs, keyValPairs)
 	}
 
-	keyValuPairsByZone, err := c.GetAllKeyValPairs()
+	keyValuPairsByZone, err := c.GetAllKeyValPairs(ctx)
 	if err != nil {
 		t.Errorf("Couldn't get keyvals, %v", err)
 	}
@@ -919,12 +929,12 @@ func TestKeyValue(t *testing.T) {
 
 	// modify keyval
 	expectedKeyValPairs["key1"] = "valModified1"
-	err = c.ModifyKeyValPair(zoneName, "key1", "valModified1")
+	err = c.ModifyKeyValPair(ctx, zoneName, "key1", "valModified1")
 	if err != nil {
 		t.Errorf("couldn't set keyval: %v", err)
 	}
 
-	keyValPairs, err = c.GetKeyValPairs(zoneName)
+	keyValPairs, err = c.GetKeyValPairs(ctx, zoneName)
 	if err != nil {
 		t.Errorf("couldn't get keyval: %v", err)
 	}
@@ -933,17 +943,17 @@ func TestKeyValue(t *testing.T) {
 	}
 
 	// error expected
-	err = c.AddKeyValPair(zoneName, "key1", "valModified1")
+	err = c.AddKeyValPair(ctx, zoneName, "key1", "valModified1")
 	if err == nil {
 		t.Errorf("adding same key/val should result in error")
 	}
 
-	err = c.AddKeyValPair(zoneName, "key2", "val2")
+	err = c.AddKeyValPair(ctx, zoneName, "key2", "val2")
 	if err != nil {
 		t.Errorf("error adding another key/val pair: %v", err)
 	}
 
-	err = c.DeleteKeyValuePair(zoneName, "key1")
+	err = c.DeleteKeyValuePair(ctx, zoneName, "key1")
 	if err != nil {
 		t.Errorf("error deleting key")
 	}
@@ -951,7 +961,7 @@ func TestKeyValue(t *testing.T) {
 	expectedKeyValPairs2 := client.KeyValPairs{
 		"key2": "val2",
 	}
-	keyValPairs, err = c.GetKeyValPairs(zoneName)
+	keyValPairs, err = c.GetKeyValPairs(ctx, zoneName)
 	if err != nil {
 		t.Errorf("couldn't get keyval: %v", err)
 	}
@@ -959,12 +969,12 @@ func TestKeyValue(t *testing.T) {
 		t.Errorf("didn't delete key1 %+v", keyValPairs)
 	}
 
-	err = c.DeleteKeyValPairs(zoneName)
+	err = c.DeleteKeyValPairs(ctx, zoneName)
 	if err != nil {
 		t.Errorf("couldn't delete all: %v", err)
 	}
 
-	keyValPairs, err = c.GetKeyValPairs(zoneName)
+	keyValPairs, err = c.GetKeyValPairs(ctx, zoneName)
 	if err != nil {
 		t.Errorf("couldn't get keyval: %v", err)
 	}
@@ -973,7 +983,7 @@ func TestKeyValue(t *testing.T) {
 	}
 
 	// error expected
-	err = c.ModifyKeyValPair(zoneName, "key1", "val1")
+	err = c.ModifyKeyValPair(ctx, zoneName, "key1", "val1")
 	if err == nil {
 		t.Errorf("modifying nonexistent key/val should result in error")
 	}
@@ -985,13 +995,13 @@ func TestKeyValueStream(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Error connecting to nginx: %v", err)
 	}
-
-	err = c.AddStreamKeyValPair(zoneName, "key1", "val1")
+	ctx := context.Background()
+	err = c.AddStreamKeyValPair(ctx, zoneName, "key1", "val1")
 	if err != nil {
 		t.Errorf("Couldn't set keyvals: %v", err)
 	}
 
-	keyValPairs, err := c.GetStreamKeyValPairs(zoneName)
+	keyValPairs, err := c.GetStreamKeyValPairs(ctx, zoneName)
 	if err != nil {
 		t.Errorf("Couldn't get keyvals for zone: %v, err: %v", zoneName, err)
 	}
@@ -1002,7 +1012,7 @@ func TestKeyValueStream(t *testing.T) {
 		t.Errorf("maps are not equal. expected: %+v, got: %+v", expectedKeyValPairs, keyValPairs)
 	}
 
-	keyValPairsByZone, err := c.GetAllStreamKeyValPairs()
+	keyValPairsByZone, err := c.GetAllStreamKeyValPairs(ctx)
 	if err != nil {
 		t.Errorf("Couldn't get keyvals, %v", err)
 	}
@@ -1016,12 +1026,12 @@ func TestKeyValueStream(t *testing.T) {
 
 	// modify keyval
 	expectedKeyValPairs["key1"] = "valModified1"
-	err = c.ModifyStreamKeyValPair(zoneName, "key1", "valModified1")
+	err = c.ModifyStreamKeyValPair(ctx, zoneName, "key1", "valModified1")
 	if err != nil {
 		t.Errorf("couldn't set keyval: %v", err)
 	}
 
-	keyValPairs, err = c.GetStreamKeyValPairs(zoneName)
+	keyValPairs, err = c.GetStreamKeyValPairs(ctx, zoneName)
 	if err != nil {
 		t.Errorf("couldn't get keyval: %v", err)
 	}
@@ -1030,22 +1040,22 @@ func TestKeyValueStream(t *testing.T) {
 	}
 
 	// error expected
-	err = c.AddStreamKeyValPair(zoneName, "key1", "valModified1")
+	err = c.AddStreamKeyValPair(ctx, zoneName, "key1", "valModified1")
 	if err == nil {
 		t.Errorf("adding same key/val should result in error")
 	}
 
-	err = c.AddStreamKeyValPair(zoneName, "key2", "val2")
+	err = c.AddStreamKeyValPair(ctx, zoneName, "key2", "val2")
 	if err != nil {
 		t.Errorf("error adding another key/val pair: %v", err)
 	}
 
-	err = c.DeleteStreamKeyValuePair(zoneName, "key1")
+	err = c.DeleteStreamKeyValuePair(ctx, zoneName, "key1")
 	if err != nil {
 		t.Errorf("error deleting key")
 	}
 
-	keyValPairs, err = c.GetStreamKeyValPairs(zoneName)
+	keyValPairs, err = c.GetStreamKeyValPairs(ctx, zoneName)
 	if err != nil {
 		t.Errorf("couldn't get keyval: %v", err)
 	}
@@ -1056,12 +1066,12 @@ func TestKeyValueStream(t *testing.T) {
 		t.Errorf("didn't delete key1 %+v", keyValPairs)
 	}
 
-	err = c.DeleteStreamKeyValPairs(zoneName)
+	err = c.DeleteStreamKeyValPairs(ctx, zoneName)
 	if err != nil {
 		t.Errorf("couldn't delete all: %v", err)
 	}
 
-	keyValPairs, err = c.GetStreamKeyValPairs(zoneName)
+	keyValPairs, err = c.GetStreamKeyValPairs(ctx, zoneName)
 	if err != nil {
 		t.Errorf("couldn't get keyval: %v", err)
 	}
@@ -1070,7 +1080,7 @@ func TestKeyValueStream(t *testing.T) {
 	}
 
 	// error expected
-	err = c.ModifyStreamKeyValPair(zoneName, "key1", "valModified")
+	err = c.ModifyStreamKeyValPair(ctx, zoneName, "key1", "valModified")
 	if err == nil {
 		t.Errorf("modifying nonexistent key/val should result in error")
 	}
@@ -1086,8 +1096,8 @@ func TestStreamZoneSync(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Error connecting to nginx: %v", err)
 	}
-
-	err = c1.AddStreamKeyValPair(streamZoneSync, "key1", "val1")
+	ctx := context.Background()
+	err = c1.AddStreamKeyValPair(ctx, streamZoneSync, "key1", "val1")
 	if err != nil {
 		t.Errorf("Couldn't set keyvals: %v", err)
 	}
@@ -1095,7 +1105,7 @@ func TestStreamZoneSync(t *testing.T) {
 	// wait for nodes to sync information of synced zones
 	time.Sleep(5 * time.Second)
 
-	statsC1, err := c1.GetStats()
+	statsC1, err := c1.GetStats(ctx)
 	if err != nil {
 		t.Errorf("Error getting stats: %v", err)
 	}
@@ -1135,7 +1145,7 @@ func TestStreamZoneSync(t *testing.T) {
 		t.Errorf("Sync zone %v missing in stats", streamZoneSync)
 	}
 
-	statsC2, err := c2.GetStats()
+	statsC2, err := c2.GetStats(ctx)
 	if err != nil {
 		t.Errorf("Error getting stats: %v", err)
 	}
@@ -1225,7 +1235,8 @@ func TestUpstreamServerWithDrain(t *testing.T) {
 	}
 
 	// Get existing upstream servers
-	servers, err := c.GetHTTPServers("test-drain")
+	ctx := context.Background()
+	servers, err := c.GetHTTPServers(ctx, "test-drain")
 	if err != nil {
 		t.Fatalf("Error getting HTTPServers: %v", err)
 	}