diff --git a/api/acl.go b/api/acl.go
index 81735bdb07..0f44494dda 100644
--- a/api/acl.go
+++ b/api/acl.go
@@ -489,12 +489,14 @@ func (c *Client) ACL() *ACL {
 // to get the first management token.
 func (a *ACL) Bootstrap() (*ACLToken, *WriteMeta, error) {
 	r := a.c.newRequest("PUT", "/v1/acl/bootstrap")
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	wm := &WriteMeta{RequestTime: rtt}
 	var out ACLToken
 	if err := decodeBody(resp, &out); err != nil {
@@ -510,11 +512,14 @@ func (a *ACL) Create(acl *ACLEntry, q *WriteOptions) (string, *WriteMeta, error)
 	r := a.c.newRequest("PUT", "/v1/acl/create")
 	r.setWriteOptions(q)
 	r.obj = acl
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return "", nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return "", nil, err
+	}
 
 	wm := &WriteMeta{RequestTime: rtt}
 	var out struct{ ID string }
@@ -531,12 +536,14 @@ func (a *ACL) Update(acl *ACLEntry, q *WriteOptions) (*WriteMeta, error) {
 	r := a.c.newRequest("PUT", "/v1/acl/update")
 	r.setWriteOptions(q)
 	r.obj = acl
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	wm := &WriteMeta{RequestTime: rtt}
 	return wm, nil
 }
@@ -547,10 +554,13 @@ func (a *ACL) Update(acl *ACLEntry, q *WriteOptions) (*WriteMeta, error) {
 func (a *ACL) Destroy(id string, q *WriteOptions) (*WriteMeta, error) {
 	r := a.c.newRequest("PUT", "/v1/acl/destroy/"+id)
 	r.setWriteOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	closeResponseBody(resp)
 
 	wm := &WriteMeta{RequestTime: rtt}
@@ -563,11 +573,14 @@ func (a *ACL) Destroy(id string, q *WriteOptions) (*WriteMeta, error) {
 func (a *ACL) Clone(id string, q *WriteOptions) (string, *WriteMeta, error) {
 	r := a.c.newRequest("PUT", "/v1/acl/clone/"+id)
 	r.setWriteOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return "", nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return "", nil, err
+	}
 
 	wm := &WriteMeta{RequestTime: rtt}
 	var out struct{ ID string }
@@ -583,12 +596,14 @@ func (a *ACL) Clone(id string, q *WriteOptions) (string, *WriteMeta, error) {
 func (a *ACL) Info(id string, q *QueryOptions) (*ACLEntry, *QueryMeta, error) {
 	r := a.c.newRequest("GET", "/v1/acl/info/"+id)
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
 	qm.RequestTime = rtt
@@ -609,12 +624,14 @@ func (a *ACL) Info(id string, q *QueryOptions) (*ACLEntry, *QueryMeta, error) {
 func (a *ACL) List(q *QueryOptions) ([]*ACLEntry, *QueryMeta, error) {
 	r := a.c.newRequest("GET", "/v1/acl/list")
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
 	qm.RequestTime = rtt
@@ -630,12 +647,14 @@ func (a *ACL) List(q *QueryOptions) ([]*ACLEntry, *QueryMeta, error) {
 func (a *ACL) Replication(q *QueryOptions) (*ACLReplicationStatus, *QueryMeta, error) {
 	r := a.c.newRequest("GET", "/v1/acl/replication")
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
 	qm.RequestTime = rtt
@@ -653,12 +672,14 @@ func (a *ACL) TokenCreate(token *ACLToken, q *WriteOptions) (*ACLToken, *WriteMe
 	r := a.c.newRequest("PUT", "/v1/acl/token")
 	r.setWriteOptions(q)
 	r.obj = token
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	wm := &WriteMeta{RequestTime: rtt}
 	var out ACLToken
 	if err := decodeBody(resp, &out); err != nil {
@@ -678,12 +699,14 @@ func (a *ACL) TokenUpdate(token *ACLToken, q *WriteOptions) (*ACLToken, *WriteMe
 	r := a.c.newRequest("PUT", "/v1/acl/token/"+token.AccessorID)
 	r.setWriteOptions(q)
 	r.obj = token
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	wm := &WriteMeta{RequestTime: rtt}
 	var out ACLToken
 	if err := decodeBody(resp, &out); err != nil {
@@ -705,12 +728,14 @@ func (a *ACL) TokenClone(tokenID string, description string, q *WriteOptions) (*
 	r := a.c.newRequest("PUT", "/v1/acl/token/"+tokenID+"/clone")
 	r.setWriteOptions(q)
 	r.obj = struct{ Description string }{description}
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	wm := &WriteMeta{RequestTime: rtt}
 	var out ACLToken
 	if err := decodeBody(resp, &out); err != nil {
@@ -725,10 +750,13 @@ func (a *ACL) TokenClone(tokenID string, description string, q *WriteOptions) (*
 func (a *ACL) TokenDelete(tokenID string, q *WriteOptions) (*WriteMeta, error) {
 	r := a.c.newRequest("DELETE", "/v1/acl/token/"+tokenID)
 	r.setWriteOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	closeResponseBody(resp)
 
 	wm := &WriteMeta{RequestTime: rtt}
@@ -740,12 +768,14 @@ func (a *ACL) TokenDelete(tokenID string, q *WriteOptions) (*WriteMeta, error) {
 func (a *ACL) TokenRead(tokenID string, q *QueryOptions) (*ACLToken, *QueryMeta, error) {
 	r := a.c.newRequest("GET", "/v1/acl/token/"+tokenID)
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
 	qm.RequestTime = rtt
@@ -764,12 +794,14 @@ func (a *ACL) TokenRead(tokenID string, q *QueryOptions) (*ACLToken, *QueryMeta,
 func (a *ACL) TokenReadSelf(q *QueryOptions) (*ACLToken, *QueryMeta, error) {
 	r := a.c.newRequest("GET", "/v1/acl/token/self")
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
 	qm.RequestTime = rtt
@@ -787,12 +819,14 @@ func (a *ACL) TokenReadSelf(q *QueryOptions) (*ACLToken, *QueryMeta, error) {
 func (a *ACL) TokenList(q *QueryOptions) ([]*ACLTokenListEntry, *QueryMeta, error) {
 	r := a.c.newRequest("GET", "/v1/acl/tokens")
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
 	qm.RequestTime = rtt
@@ -813,12 +847,14 @@ func (a *ACL) PolicyCreate(policy *ACLPolicy, q *WriteOptions) (*ACLPolicy, *Wri
 	r := a.c.newRequest("PUT", "/v1/acl/policy")
 	r.setWriteOptions(q)
 	r.obj = policy
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	wm := &WriteMeta{RequestTime: rtt}
 	var out ACLPolicy
 	if err := decodeBody(resp, &out); err != nil {
@@ -838,12 +874,14 @@ func (a *ACL) PolicyUpdate(policy *ACLPolicy, q *WriteOptions) (*ACLPolicy, *Wri
 	r := a.c.newRequest("PUT", "/v1/acl/policy/"+policy.ID)
 	r.setWriteOptions(q)
 	r.obj = policy
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	wm := &WriteMeta{RequestTime: rtt}
 	var out ACLPolicy
 	if err := decodeBody(resp, &out); err != nil {
@@ -857,11 +895,14 @@ func (a *ACL) PolicyUpdate(policy *ACLPolicy, q *WriteOptions) (*ACLPolicy, *Wri
 func (a *ACL) PolicyDelete(policyID string, q *WriteOptions) (*WriteMeta, error) {
 	r := a.c.newRequest("DELETE", "/v1/acl/policy/"+policyID)
 	r.setWriteOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	wm := &WriteMeta{RequestTime: rtt}
 	return wm, nil
@@ -871,12 +912,14 @@ func (a *ACL) PolicyDelete(policyID string, q *WriteOptions) (*WriteMeta, error)
 func (a *ACL) PolicyRead(policyID string, q *QueryOptions) (*ACLPolicy, *QueryMeta, error) {
 	r := a.c.newRequest("GET", "/v1/acl/policy/"+policyID)
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
 	qm.RequestTime = rtt
@@ -893,11 +936,15 @@ func (a *ACL) PolicyRead(policyID string, q *QueryOptions) (*ACLPolicy, *QueryMe
 func (a *ACL) PolicyReadByName(policyName string, q *QueryOptions) (*ACLPolicy, *QueryMeta, error) {
 	r := a.c.newRequest("GET", "/v1/acl/policy/name/"+url.QueryEscape(policyName))
 	r.setQueryOptions(q)
-	found, rtt, resp, err := requireNotFoundOrOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	found, resp, err := requireNotFoundOrOK(resp)
+	if err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -920,12 +967,14 @@ func (a *ACL) PolicyReadByName(policyName string, q *QueryOptions) (*ACLPolicy,
 func (a *ACL) PolicyList(q *QueryOptions) ([]*ACLPolicyListEntry, *QueryMeta, error) {
 	r := a.c.newRequest("GET", "/v1/acl/policies")
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
 	qm.RequestTime = rtt
@@ -945,11 +994,15 @@ func (a *ACL) RulesTranslate(rules io.Reader) (string, error) {
 	r := a.c.newRequest("POST", "/v1/acl/rules/translate")
 	r.body = rules
 	r.header.Set("Content-Type", "text/plain")
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return "", err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return "", err
+	}
+
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
 	qm.RequestTime = rtt
@@ -969,11 +1022,14 @@ func (a *ACL) RulesTranslate(rules io.Reader) (string, error) {
 // when legacy ACL support is removed.
 func (a *ACL) RulesTranslateToken(tokenID string) (string, error) {
 	r := a.c.newRequest("GET", "/v1/acl/rules/translate/"+tokenID)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return "", err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return "", err
+	}
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
 	qm.RequestTime = rtt
@@ -996,12 +1052,14 @@ func (a *ACL) RoleCreate(role *ACLRole, q *WriteOptions) (*ACLRole, *WriteMeta,
 	r := a.c.newRequest("PUT", "/v1/acl/role")
 	r.setWriteOptions(q)
 	r.obj = role
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	wm := &WriteMeta{RequestTime: rtt}
 	var out ACLRole
 	if err := decodeBody(resp, &out); err != nil {
@@ -1021,12 +1079,14 @@ func (a *ACL) RoleUpdate(role *ACLRole, q *WriteOptions) (*ACLRole, *WriteMeta,
 	r := a.c.newRequest("PUT", "/v1/acl/role/"+role.ID)
 	r.setWriteOptions(q)
 	r.obj = role
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	wm := &WriteMeta{RequestTime: rtt}
 	var out ACLRole
 	if err := decodeBody(resp, &out); err != nil {
@@ -1040,10 +1100,13 @@ func (a *ACL) RoleUpdate(role *ACLRole, q *WriteOptions) (*ACLRole, *WriteMeta,
 func (a *ACL) RoleDelete(roleID string, q *WriteOptions) (*WriteMeta, error) {
 	r := a.c.newRequest("DELETE", "/v1/acl/role/"+roleID)
 	r.setWriteOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	closeResponseBody(resp)
 
 	wm := &WriteMeta{RequestTime: rtt}
@@ -1054,11 +1117,15 @@ func (a *ACL) RoleDelete(roleID string, q *WriteOptions) (*WriteMeta, error) {
 func (a *ACL) RoleRead(roleID string, q *QueryOptions) (*ACLRole, *QueryMeta, error) {
 	r := a.c.newRequest("GET", "/v1/acl/role/"+roleID)
 	r.setQueryOptions(q)
-	found, rtt, resp, err := requireNotFoundOrOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	found, resp, err := requireNotFoundOrOK(resp)
+	if err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -1080,11 +1147,15 @@ func (a *ACL) RoleRead(roleID string, q *QueryOptions) (*ACLRole, *QueryMeta, er
 func (a *ACL) RoleReadByName(roleName string, q *QueryOptions) (*ACLRole, *QueryMeta, error) {
 	r := a.c.newRequest("GET", "/v1/acl/role/name/"+url.QueryEscape(roleName))
 	r.setQueryOptions(q)
-	found, rtt, resp, err := requireNotFoundOrOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	found, resp, err := requireNotFoundOrOK(resp)
+	if err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -1108,12 +1179,14 @@ func (a *ACL) RoleReadByName(roleName string, q *QueryOptions) (*ACLRole, *Query
 func (a *ACL) RoleList(q *QueryOptions) ([]*ACLRole, *QueryMeta, error) {
 	r := a.c.newRequest("GET", "/v1/acl/roles")
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
 	qm.RequestTime = rtt
@@ -1134,12 +1207,14 @@ func (a *ACL) AuthMethodCreate(method *ACLAuthMethod, q *WriteOptions) (*ACLAuth
 	r := a.c.newRequest("PUT", "/v1/acl/auth-method")
 	r.setWriteOptions(q)
 	r.obj = method
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	wm := &WriteMeta{RequestTime: rtt}
 	var out ACLAuthMethod
 	if err := decodeBody(resp, &out); err != nil {
@@ -1158,12 +1233,14 @@ func (a *ACL) AuthMethodUpdate(method *ACLAuthMethod, q *WriteOptions) (*ACLAuth
 	r := a.c.newRequest("PUT", "/v1/acl/auth-method/"+url.QueryEscape(method.Name))
 	r.setWriteOptions(q)
 	r.obj = method
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	wm := &WriteMeta{RequestTime: rtt}
 	var out ACLAuthMethod
 	if err := decodeBody(resp, &out); err != nil {
@@ -1181,10 +1258,13 @@ func (a *ACL) AuthMethodDelete(methodName string, q *WriteOptions) (*WriteMeta,
 
 	r := a.c.newRequest("DELETE", "/v1/acl/auth-method/"+url.QueryEscape(methodName))
 	r.setWriteOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	closeResponseBody(resp)
 
 	wm := &WriteMeta{RequestTime: rtt}
@@ -1199,11 +1279,15 @@ func (a *ACL) AuthMethodRead(methodName string, q *QueryOptions) (*ACLAuthMethod
 
 	r := a.c.newRequest("GET", "/v1/acl/auth-method/"+url.QueryEscape(methodName))
 	r.setQueryOptions(q)
-	found, rtt, resp, err := requireNotFoundOrOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	found, resp, err := requireNotFoundOrOK(resp)
+	if err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -1227,12 +1311,14 @@ func (a *ACL) AuthMethodRead(methodName string, q *QueryOptions) (*ACLAuthMethod
 func (a *ACL) AuthMethodList(q *QueryOptions) ([]*ACLAuthMethodListEntry, *QueryMeta, error) {
 	r := a.c.newRequest("GET", "/v1/acl/auth-methods")
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
 	qm.RequestTime = rtt
@@ -1255,12 +1341,14 @@ func (a *ACL) BindingRuleCreate(rule *ACLBindingRule, q *WriteOptions) (*ACLBind
 	r := a.c.newRequest("PUT", "/v1/acl/binding-rule")
 	r.setWriteOptions(q)
 	r.obj = rule
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	wm := &WriteMeta{RequestTime: rtt}
 	var out ACLBindingRule
 	if err := decodeBody(resp, &out); err != nil {
@@ -1280,12 +1368,14 @@ func (a *ACL) BindingRuleUpdate(rule *ACLBindingRule, q *WriteOptions) (*ACLBind
 	r := a.c.newRequest("PUT", "/v1/acl/binding-rule/"+rule.ID)
 	r.setWriteOptions(q)
 	r.obj = rule
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	wm := &WriteMeta{RequestTime: rtt}
 	var out ACLBindingRule
 	if err := decodeBody(resp, &out); err != nil {
@@ -1299,11 +1389,14 @@ func (a *ACL) BindingRuleUpdate(rule *ACLBindingRule, q *WriteOptions) (*ACLBind
 func (a *ACL) BindingRuleDelete(bindingRuleID string, q *WriteOptions) (*WriteMeta, error) {
 	r := a.c.newRequest("DELETE", "/v1/acl/binding-rule/"+bindingRuleID)
 	r.setWriteOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	wm := &WriteMeta{RequestTime: rtt}
 	return wm, nil
@@ -1313,11 +1406,15 @@ func (a *ACL) BindingRuleDelete(bindingRuleID string, q *WriteOptions) (*WriteMe
 func (a *ACL) BindingRuleRead(bindingRuleID string, q *QueryOptions) (*ACLBindingRule, *QueryMeta, error) {
 	r := a.c.newRequest("GET", "/v1/acl/binding-rule/"+bindingRuleID)
 	r.setQueryOptions(q)
-	found, rtt, resp, err := requireNotFoundOrOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	found, resp, err := requireNotFoundOrOK(resp)
+	if err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -1342,12 +1439,14 @@ func (a *ACL) BindingRuleList(methodName string, q *QueryOptions) ([]*ACLBinding
 		r.params.Set("authmethod", methodName)
 	}
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
 	qm.RequestTime = rtt
@@ -1365,12 +1464,14 @@ func (a *ACL) Login(auth *ACLLoginParams, q *WriteOptions) (*ACLToken, *WriteMet
 	r.setWriteOptions(q)
 	r.obj = auth
 
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	wm := &WriteMeta{RequestTime: rtt}
 	var out ACLToken
 	if err := decodeBody(resp, &out); err != nil {
@@ -1383,10 +1484,13 @@ func (a *ACL) Login(auth *ACLLoginParams, q *WriteOptions) (*ACLToken, *WriteMet
 func (a *ACL) Logout(q *WriteOptions) (*WriteMeta, error) {
 	r := a.c.newRequest("POST", "/v1/acl/logout")
 	r.setWriteOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	closeResponseBody(resp)
 
 	wm := &WriteMeta{RequestTime: rtt}
@@ -1403,11 +1507,14 @@ func (a *ACL) OIDCAuthURL(auth *ACLOIDCAuthURLParams, q *WriteOptions) (string,
 	r.setWriteOptions(q)
 	r.obj = auth
 
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return "", nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return "", nil, err
+	}
 
 	wm := &WriteMeta{RequestTime: rtt}
 	var out aclOIDCAuthURLResponse
@@ -1438,12 +1545,14 @@ func (a *ACL) OIDCCallback(auth *ACLOIDCCallbackParams, q *WriteOptions) (*ACLTo
 	r.setWriteOptions(q)
 	r.obj = auth
 
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	wm := &WriteMeta{RequestTime: rtt}
 	var out ACLToken
 	if err := decodeBody(resp, &out); err != nil {
diff --git a/api/agent.go b/api/agent.go
index feac04e7e7..032446af47 100644
--- a/api/agent.go
+++ b/api/agent.go
@@ -441,11 +441,14 @@ func (c *Client) Agent() *Agent {
 // information about itself
 func (a *Agent) Self() (map[string]map[string]interface{}, error) {
 	r := a.c.newRequest("GET", "/v1/agent/self")
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	var out map[string]map[string]interface{}
 	if err := decodeBody(resp, &out); err != nil {
@@ -459,12 +462,14 @@ func (a *Agent) Self() (map[string]map[string]interface{}, error) {
 // a operator:read ACL token.
 func (a *Agent) Host() (map[string]interface{}, error) {
 	r := a.c.newRequest("GET", "/v1/agent/host")
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	var out map[string]interface{}
 	if err := decodeBody(resp, &out); err != nil {
 		return nil, err
@@ -476,12 +481,14 @@ func (a *Agent) Host() (map[string]interface{}, error) {
 // its current internal metric data
 func (a *Agent) Metrics() (*MetricsInfo, error) {
 	r := a.c.newRequest("GET", "/v1/agent/metrics")
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	var out *MetricsInfo
 	if err := decodeBody(resp, &out); err != nil {
 		return nil, err
@@ -495,21 +502,27 @@ func (a *Agent) Metrics() (*MetricsInfo, error) {
 func (a *Agent) MetricsStream(ctx context.Context) (io.ReadCloser, error) {
 	r := a.c.newRequest("GET", "/v1/agent/metrics/stream")
 	r.ctx = ctx
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	return resp.Body, nil
 }
 
 // Reload triggers a configuration reload for the agent we are connected to.
 func (a *Agent) Reload() error {
 	r := a.c.newRequest("PUT", "/v1/agent/reload")
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -544,12 +557,14 @@ func (a *Agent) ChecksWithFilterOpts(filter string, q *QueryOptions) (map[string
 	r := a.c.newRequest("GET", "/v1/agent/checks")
 	r.setQueryOptions(q)
 	r.filterQuery(filter)
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	var out map[string]*AgentCheck
 	if err := decodeBody(resp, &out); err != nil {
 		return nil, err
@@ -574,12 +589,14 @@ func (a *Agent) ServicesWithFilterOpts(filter string, q *QueryOptions) (map[stri
 	r := a.c.newRequest("GET", "/v1/agent/services")
 	r.setQueryOptions(q)
 	r.filterQuery(filter)
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	var out map[string]*AgentService
 	if err := decodeBody(resp, &out); err != nil {
 		return nil, err
@@ -678,12 +695,14 @@ func (a *Agent) AgentHealthServiceByNameOpts(service string, q *QueryOptions) (s
 func (a *Agent) Service(serviceID string, q *QueryOptions) (*AgentService, *QueryMeta, error) {
 	r := a.c.newRequest("GET", "/v1/agent/service/"+serviceID)
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
 	qm.RequestTime = rtt
@@ -703,12 +722,14 @@ func (a *Agent) Members(wan bool) ([]*AgentMember, error) {
 	if wan {
 		r.params.Set("wan", "1")
 	}
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	var out []*AgentMember
 	if err := decodeBody(resp, &out); err != nil {
 		return nil, err
@@ -725,12 +746,14 @@ func (a *Agent) MembersOpts(opts MembersOpts) ([]*AgentMember, error) {
 		r.params.Set("wan", "1")
 	}
 
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	var out []*AgentMember
 	if err := decodeBody(resp, &out); err != nil {
 		return nil, err
@@ -761,11 +784,14 @@ func (a *Agent) serviceRegister(service *AgentServiceRegistration, opts ServiceR
 	if opts.ReplaceExistingChecks {
 		r.params.Set("replace-existing-checks", "true")
 	}
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -773,11 +799,14 @@ func (a *Agent) serviceRegister(service *AgentServiceRegistration, opts ServiceR
 // the local agent
 func (a *Agent) ServiceDeregister(serviceID string) error {
 	r := a.c.newRequest("PUT", "/v1/agent/service/deregister/"+serviceID)
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -786,11 +815,14 @@ func (a *Agent) ServiceDeregister(serviceID string) error {
 func (a *Agent) ServiceDeregisterOpts(serviceID string, q *QueryOptions) error {
 	r := a.c.newRequest("PUT", "/v1/agent/service/deregister/"+serviceID)
 	r.setQueryOptions(q)
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -841,11 +873,14 @@ func (a *Agent) updateTTL(checkID, note, status string) error {
 	endpoint := fmt.Sprintf("/v1/agent/check/%s/%s", status, checkID)
 	r := a.c.newRequest("PUT", endpoint)
 	r.params.Set("note", note)
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -891,11 +926,14 @@ func (a *Agent) UpdateTTLOpts(checkID, output, status string, q *QueryOptions) e
 		Output: output,
 	}
 
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -904,11 +942,14 @@ func (a *Agent) UpdateTTLOpts(checkID, output, status string, q *QueryOptions) e
 func (a *Agent) CheckRegister(check *AgentCheckRegistration) error {
 	r := a.c.newRequest("PUT", "/v1/agent/check/register")
 	r.obj = check
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -923,11 +964,14 @@ func (a *Agent) CheckDeregister(checkID string) error {
 func (a *Agent) CheckDeregisterOpts(checkID string, q *QueryOptions) error {
 	r := a.c.newRequest("PUT", "/v1/agent/check/deregister/"+checkID)
 	r.setQueryOptions(q)
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -938,33 +982,42 @@ func (a *Agent) Join(addr string, wan bool) error {
 	if wan {
 		r.params.Set("wan", "1")
 	}
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
 // Leave is used to have the agent gracefully leave the cluster and shutdown
 func (a *Agent) Leave() error {
 	r := a.c.newRequest("PUT", "/v1/agent/leave")
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
 // ForceLeave is used to have the agent eject a failed node
 func (a *Agent) ForceLeave(node string) error {
 	r := a.c.newRequest("PUT", "/v1/agent/force-leave/"+node)
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -973,11 +1026,14 @@ func (a *Agent) ForceLeave(node string) error {
 func (a *Agent) ForceLeavePrune(node string) error {
 	r := a.c.newRequest("PUT", "/v1/agent/force-leave/"+node)
 	r.params.Set("prune", "1")
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -986,12 +1042,14 @@ func (a *Agent) ForceLeavePrune(node string) error {
 func (a *Agent) ConnectAuthorize(auth *AgentAuthorizeParams) (*AgentAuthorize, error) {
 	r := a.c.newRequest("POST", "/v1/agent/connect/authorize")
 	r.obj = auth
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	var out AgentAuthorize
 	if err := decodeBody(resp, &out); err != nil {
 		return nil, err
@@ -1003,11 +1061,14 @@ func (a *Agent) ConnectAuthorize(auth *AgentAuthorizeParams) (*AgentAuthorize, e
 func (a *Agent) ConnectCARoots(q *QueryOptions) (*CARootList, *QueryMeta, error) {
 	r := a.c.newRequest("GET", "/v1/agent/connect/ca/roots")
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -1024,12 +1085,14 @@ func (a *Agent) ConnectCARoots(q *QueryOptions) (*CARootList, *QueryMeta, error)
 func (a *Agent) ConnectCALeaf(serviceID string, q *QueryOptions) (*LeafCert, *QueryMeta, error) {
 	r := a.c.newRequest("GET", "/v1/agent/connect/ca/leaf/"+serviceID)
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(a.c.doRequest(r))
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
 	qm.RequestTime = rtt
@@ -1052,11 +1115,14 @@ func (a *Agent) EnableServiceMaintenanceOpts(serviceID, reason string, q *QueryO
 	r.setQueryOptions(q)
 	r.params.Set("enable", "true")
 	r.params.Set("reason", reason)
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -1070,11 +1136,14 @@ func (a *Agent) DisableServiceMaintenanceOpts(serviceID string, q *QueryOptions)
 	r := a.c.newRequest("PUT", "/v1/agent/service/maintenance/"+serviceID)
 	r.setQueryOptions(q)
 	r.params.Set("enable", "false")
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -1084,11 +1153,14 @@ func (a *Agent) EnableNodeMaintenance(reason string) error {
 	r := a.c.newRequest("PUT", "/v1/agent/maintenance")
 	r.params.Set("enable", "true")
 	r.params.Set("reason", reason)
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -1097,11 +1169,14 @@ func (a *Agent) EnableNodeMaintenance(reason string) error {
 func (a *Agent) DisableNodeMaintenance() error {
 	r := a.c.newRequest("PUT", "/v1/agent/maintenance")
 	r.params.Set("enable", "false")
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -1127,10 +1202,13 @@ func (a *Agent) monitor(loglevel string, logJSON bool, stopCh <-chan struct{}, q
 	if logJSON {
 		r.params.Set("logjson", "true")
 	}
-	_, resp, err := requireOK(a.c.doRequest(r))
+	_, resp, err := a.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	logCh := make(chan string, 64)
 	go func() {
 		defer closeResponseBody(resp)
@@ -1237,20 +1315,18 @@ func (a *Agent) updateTokenOnce(target, token string, q *WriteOptions) (*WriteMe
 	r.setWriteOptions(q)
 	r.obj = &AgentToken{Token: token}
 
-	rtt, resp, err := requireOK(a.c.doRequest(r))
-	wm := &WriteMeta{RequestTime: rtt}
-
+	rtt, resp, err := a.c.doRequest(r)
 	if err != nil {
-		// if the error was bc of a non 200 response
-		// from requireOK
+		return nil, 500, err
+	}
+	defer closeResponseBody(resp)
+	wm := &WriteMeta{RequestTime: rtt}
+	if err := requireOK(resp); err != nil {
 		var statusE StatusError
 		if errors.As(err, &statusE) {
 			return wm, statusE.Code, statusE
 		}
-		// otherwise, the error came via doRequest
-		return nil, 500, err
+		return nil, 0, err
 	}
-	defer closeResponseBody(resp)
-
 	return wm, resp.StatusCode, nil
 }
diff --git a/api/api.go b/api/api.go
index 3063618744..47830f25e2 100644
--- a/api/api.go
+++ b/api/api.go
@@ -981,12 +981,14 @@ func (c *Client) doRequest(r *request) (time.Duration, *http.Response, error) {
 func (c *Client) query(endpoint string, out interface{}, q *QueryOptions) (*QueryMeta, error) {
 	r := c.newRequest("GET", endpoint)
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(c.doRequest(r))
+	rtt, resp, err := c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
-
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
 	qm.RequestTime = rtt
@@ -1003,11 +1005,14 @@ func (c *Client) write(endpoint string, in, out interface{}, q *WriteOptions) (*
 	r := c.newRequest("PUT", endpoint)
 	r.setWriteOptions(q)
 	r.obj = in
-	rtt, resp, err := requireOK(c.doRequest(r))
+	rtt, resp, err := c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	wm := &WriteMeta{RequestTime: rtt}
 	if out != nil {
@@ -1098,29 +1103,22 @@ func encodeBody(obj interface{}) (io.Reader, error) {
 }
 
 // requireOK is used to wrap doRequest and check for a 200
-func requireOK(d time.Duration, resp *http.Response, e error) (time.Duration, *http.Response, error) {
-	return requireHttpCodes(d, resp, e, 200)
+func requireOK(resp *http.Response) error {
+	return requireHttpCodes(resp, 200)
 }
 
 // requireHttpCodes checks for the "allowable" http codes for a response
-func requireHttpCodes(d time.Duration, resp *http.Response, e error, httpCodes ...int) (time.Duration, *http.Response, error) {
-	if e != nil {
-		if resp != nil {
-			closeResponseBody(resp)
-		}
-		return d, nil, e
-	}
-
+func requireHttpCodes(resp *http.Response, httpCodes ...int) error {
 	// if there is an http code that we require, return w no error
 	for _, httpCode := range httpCodes {
 		if resp.StatusCode == httpCode {
-			return d, resp, nil
+			return nil
 		}
 	}
 
 	// if we reached here, then none of the http codes in resp matched any that we expected
 	// so err out
-	return d, nil, generateUnexpectedResponseCodeError(resp)
+	return generateUnexpectedResponseCodeError(resp)
 }
 
 // closeResponseBody reads resp.Body until EOF, and then closes it. The read
@@ -1151,19 +1149,13 @@ func generateUnexpectedResponseCodeError(resp *http.Response) error {
 	return StatusError{Code: resp.StatusCode, Body: trimmed}
 }
 
-func requireNotFoundOrOK(d time.Duration, resp *http.Response, e error) (bool, time.Duration, *http.Response, error) {
-	if e != nil {
-		if resp != nil {
-			closeResponseBody(resp)
-		}
-		return false, d, nil, e
-	}
+func requireNotFoundOrOK(resp *http.Response) (bool, *http.Response, error) {
 	switch resp.StatusCode {
 	case 200:
-		return true, d, resp, nil
+		return true, resp, nil
 	case 404:
-		return false, d, resp, nil
+		return false, resp, nil
 	default:
-		return false, d, nil, generateUnexpectedResponseCodeError(resp)
+		return false, nil, generateUnexpectedResponseCodeError(resp)
 	}
 }
diff --git a/api/catalog.go b/api/catalog.go
index 1820fdf1ff..80ae325eac 100644
--- a/api/catalog.go
+++ b/api/catalog.go
@@ -124,11 +124,14 @@ func (c *Catalog) Register(reg *CatalogRegistration, q *WriteOptions) (*WriteMet
 	r := c.c.newRequest("PUT", "/v1/catalog/register")
 	r.setWriteOptions(q)
 	r.obj = reg
-	rtt, resp, err := requireOK(c.c.doRequest(r))
+	rtt, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	wm := &WriteMeta{}
 	wm.RequestTime = rtt
@@ -140,11 +143,14 @@ func (c *Catalog) Deregister(dereg *CatalogDeregistration, q *WriteOptions) (*Wr
 	r := c.c.newRequest("PUT", "/v1/catalog/deregister")
 	r.setWriteOptions(q)
 	r.obj = dereg
-	rtt, resp, err := requireOK(c.c.doRequest(r))
+	rtt, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	wm := &WriteMeta{}
 	wm.RequestTime = rtt
@@ -155,11 +161,14 @@ func (c *Catalog) Deregister(dereg *CatalogDeregistration, q *WriteOptions) (*Wr
 // Datacenters is used to query for all the known datacenters
 func (c *Catalog) Datacenters() ([]string, error) {
 	r := c.c.newRequest("GET", "/v1/catalog/datacenters")
-	_, resp, err := requireOK(c.c.doRequest(r))
+	_, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	var out []string
 	if err := decodeBody(resp, &out); err != nil {
@@ -172,11 +181,14 @@ func (c *Catalog) Datacenters() ([]string, error) {
 func (c *Catalog) Nodes(q *QueryOptions) ([]*Node, *QueryMeta, error) {
 	r := c.c.newRequest("GET", "/v1/catalog/nodes")
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(c.c.doRequest(r))
+	rtt, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -193,11 +205,14 @@ func (c *Catalog) Nodes(q *QueryOptions) ([]*Node, *QueryMeta, error) {
 func (c *Catalog) Services(q *QueryOptions) (map[string][]string, *QueryMeta, error) {
 	r := c.c.newRequest("GET", "/v1/catalog/services")
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(c.c.doRequest(r))
+	rtt, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -250,11 +265,14 @@ func (c *Catalog) service(service string, tags []string, q *QueryOptions, connec
 			r.params.Add("tag", tag)
 		}
 	}
-	rtt, resp, err := requireOK(c.c.doRequest(r))
+	rtt, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -271,11 +289,14 @@ func (c *Catalog) service(service string, tags []string, q *QueryOptions, connec
 func (c *Catalog) Node(node string, q *QueryOptions) (*CatalogNode, *QueryMeta, error) {
 	r := c.c.newRequest("GET", "/v1/catalog/node/"+node)
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(c.c.doRequest(r))
+	rtt, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -295,11 +316,14 @@ func (c *Catalog) Node(node string, q *QueryOptions) (*CatalogNode, *QueryMeta,
 func (c *Catalog) NodeServiceList(node string, q *QueryOptions) (*CatalogNodeServiceList, *QueryMeta, error) {
 	r := c.c.newRequest("GET", "/v1/catalog/node-services/"+node)
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(c.c.doRequest(r))
+	rtt, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -316,11 +340,14 @@ func (c *Catalog) NodeServiceList(node string, q *QueryOptions) (*CatalogNodeSer
 func (c *Catalog) GatewayServices(gateway string, q *QueryOptions) ([]*GatewayService, *QueryMeta, error) {
 	r := c.c.newRequest("GET", "/v1/catalog/gateway-services/"+gateway)
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(c.c.doRequest(r))
+	rtt, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
diff --git a/api/config_entry.go b/api/config_entry.go
index dc6646f442..e2986e72eb 100644
--- a/api/config_entry.go
+++ b/api/config_entry.go
@@ -380,12 +380,14 @@ func (conf *ConfigEntries) Get(kind string, name string, q *QueryOptions) (Confi
 
 	r := conf.c.newRequest("GET", fmt.Sprintf("/v1/config/%s/%s", kind, name))
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(conf.c.doRequest(r))
+	rtt, resp, err := conf.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
-
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -405,12 +407,14 @@ func (conf *ConfigEntries) List(kind string, q *QueryOptions) ([]ConfigEntry, *Q
 
 	r := conf.c.newRequest("GET", fmt.Sprintf("/v1/config/%s", kind))
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(conf.c.doRequest(r))
+	rtt, resp, err := conf.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
-
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -444,11 +448,14 @@ func (conf *ConfigEntries) set(entry ConfigEntry, params map[string]string, w *W
 		r.params.Set(param, value)
 	}
 	r.obj = entry
-	rtt, resp, err := requireOK(conf.c.doRequest(r))
+	rtt, resp, err := conf.c.doRequest(r)
 	if err != nil {
 		return false, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return false, nil, err
+	}
 
 	var buf bytes.Buffer
 	if _, err := io.Copy(&buf, resp.Body); err != nil {
@@ -467,11 +474,14 @@ func (conf *ConfigEntries) Delete(kind string, name string, w *WriteOptions) (*W
 
 	r := conf.c.newRequest("DELETE", fmt.Sprintf("/v1/config/%s/%s", kind, name))
 	r.setWriteOptions(w)
-	rtt, resp, err := requireOK(conf.c.doRequest(r))
+	rtt, resp, err := conf.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	wm := &WriteMeta{RequestTime: rtt}
 	return wm, nil
 }
diff --git a/api/connect_ca.go b/api/connect_ca.go
index 37e53d96e6..4ab2fb7107 100644
--- a/api/connect_ca.go
+++ b/api/connect_ca.go
@@ -133,11 +133,14 @@ type LeafCert struct {
 func (h *Connect) CARoots(q *QueryOptions) (*CARootList, *QueryMeta, error) {
 	r := h.c.newRequest("GET", "/v1/connect/ca/roots")
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(h.c.doRequest(r))
+	rtt, resp, err := h.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -154,11 +157,14 @@ func (h *Connect) CARoots(q *QueryOptions) (*CARootList, *QueryMeta, error) {
 func (h *Connect) CAGetConfig(q *QueryOptions) (*CAConfig, *QueryMeta, error) {
 	r := h.c.newRequest("GET", "/v1/connect/ca/configuration")
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(h.c.doRequest(r))
+	rtt, resp, err := h.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -176,11 +182,14 @@ func (h *Connect) CASetConfig(conf *CAConfig, q *WriteOptions) (*WriteMeta, erro
 	r := h.c.newRequest("PUT", "/v1/connect/ca/configuration")
 	r.setWriteOptions(q)
 	r.obj = conf
-	rtt, resp, err := requireOK(h.c.doRequest(r))
+	rtt, resp, err := h.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	wm := &WriteMeta{}
 	wm.RequestTime = rtt
diff --git a/api/connect_intention.go b/api/connect_intention.go
index d1f0b6530c..34dc69b895 100644
--- a/api/connect_intention.go
+++ b/api/connect_intention.go
@@ -166,11 +166,14 @@ type IntentionCheck struct {
 func (h *Connect) Intentions(q *QueryOptions) ([]*Intention, *QueryMeta, error) {
 	r := h.c.newRequest("GET", "/v1/connect/intentions")
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(h.c.doRequest(r))
+	rtt, resp, err := h.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -255,11 +258,14 @@ func (h *Connect) IntentionDeleteExact(source, destination string, q *WriteOptio
 	r.params.Set("source", source)
 	r.params.Set("destination", destination)
 
-	rtt, resp, err := requireOK(h.c.doRequest(r))
+	rtt, resp, err := h.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	qm := &WriteMeta{}
 	qm.RequestTime = rtt
@@ -273,11 +279,14 @@ func (h *Connect) IntentionDeleteExact(source, destination string, q *WriteOptio
 func (h *Connect) IntentionDelete(id string, q *WriteOptions) (*WriteMeta, error) {
 	r := h.c.newRequest("DELETE", "/v1/connect/intentions/"+id)
 	r.setWriteOptions(q)
-	rtt, resp, err := requireOK(h.c.doRequest(r))
+	rtt, resp, err := h.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	qm := &WriteMeta{}
 	qm.RequestTime = rtt
@@ -299,11 +308,14 @@ func (h *Connect) IntentionMatch(args *IntentionMatch, q *QueryOptions) (map[str
 	for _, name := range args.Names {
 		r.params.Add("name", name)
 	}
-	rtt, resp, err := requireOK(h.c.doRequest(r))
+	rtt, resp, err := h.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -326,11 +338,14 @@ func (h *Connect) IntentionCheck(args *IntentionCheck, q *QueryOptions) (bool, *
 	if args.SourceType != "" {
 		r.params.Set("source-type", string(args.SourceType))
 	}
-	rtt, resp, err := requireOK(h.c.doRequest(r))
+	rtt, resp, err := h.c.doRequest(r)
 	if err != nil {
 		return false, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return false, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -351,11 +366,14 @@ func (c *Connect) IntentionUpsert(ixn *Intention, q *WriteOptions) (*WriteMeta,
 	r.params.Set("source", maybePrefixNamespace(ixn.SourceNS, ixn.SourceName))
 	r.params.Set("destination", maybePrefixNamespace(ixn.DestinationNS, ixn.DestinationName))
 	r.obj = ixn
-	rtt, resp, err := requireOK(c.c.doRequest(r))
+	rtt, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	wm := &WriteMeta{}
 	wm.RequestTime = rtt
@@ -378,11 +396,14 @@ func (c *Connect) IntentionCreate(ixn *Intention, q *WriteOptions) (string, *Wri
 	r := c.c.newRequest("POST", "/v1/connect/intentions")
 	r.setWriteOptions(q)
 	r.obj = ixn
-	rtt, resp, err := requireOK(c.c.doRequest(r))
+	rtt, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return "", nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return "", nil, err
+	}
 
 	wm := &WriteMeta{}
 	wm.RequestTime = rtt
@@ -402,11 +423,14 @@ func (c *Connect) IntentionUpdate(ixn *Intention, q *WriteOptions) (*WriteMeta,
 	r := c.c.newRequest("PUT", "/v1/connect/intentions/"+ixn.ID)
 	r.setWriteOptions(q)
 	r.obj = ixn
-	rtt, resp, err := requireOK(c.c.doRequest(r))
+	rtt, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	wm := &WriteMeta{}
 	wm.RequestTime = rtt
diff --git a/api/coordinate.go b/api/coordinate.go
index b0f59eea6f..7ef6ce2744 100644
--- a/api/coordinate.go
+++ b/api/coordinate.go
@@ -34,11 +34,14 @@ func (c *Client) Coordinate() *Coordinate {
 // pool.
 func (c *Coordinate) Datacenters() ([]*CoordinateDatacenterMap, error) {
 	r := c.c.newRequest("GET", "/v1/coordinate/datacenters")
-	_, resp, err := requireOK(c.c.doRequest(r))
+	_, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	var out []*CoordinateDatacenterMap
 	if err := decodeBody(resp, &out); err != nil {
@@ -51,11 +54,14 @@ func (c *Coordinate) Datacenters() ([]*CoordinateDatacenterMap, error) {
 func (c *Coordinate) Nodes(q *QueryOptions) ([]*CoordinateEntry, *QueryMeta, error) {
 	r := c.c.newRequest("GET", "/v1/coordinate/nodes")
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(c.c.doRequest(r))
+	rtt, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -73,11 +79,14 @@ func (c *Coordinate) Update(coord *CoordinateEntry, q *WriteOptions) (*WriteMeta
 	r := c.c.newRequest("PUT", "/v1/coordinate/update")
 	r.setWriteOptions(q)
 	r.obj = coord
-	rtt, resp, err := requireOK(c.c.doRequest(r))
+	rtt, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	wm := &WriteMeta{}
 	wm.RequestTime = rtt
@@ -89,11 +98,14 @@ func (c *Coordinate) Update(coord *CoordinateEntry, q *WriteOptions) (*WriteMeta
 func (c *Coordinate) Node(node string, q *QueryOptions) ([]*CoordinateEntry, *QueryMeta, error) {
 	r := c.c.newRequest("GET", "/v1/coordinate/node/"+node)
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(c.c.doRequest(r))
+	rtt, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
diff --git a/api/debug.go b/api/debug.go
index 326ac3bc83..0dfbfd846b 100644
--- a/api/debug.go
+++ b/api/debug.go
@@ -25,11 +25,14 @@ func (c *Client) Debug() *Debug {
 // Heap returns a pprof heap dump
 func (d *Debug) Heap() ([]byte, error) {
 	r := d.c.newRequest("GET", "/debug/pprof/heap")
-	_, resp, err := requireOK(d.c.doRequest(r))
+	_, resp, err := d.c.doRequest(r)
 	if err != nil {
 		return nil, fmt.Errorf("error making request: %s", err)
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	// We return a raw response because we're just passing through a response
 	// from the pprof handlers
@@ -48,11 +51,14 @@ func (d *Debug) Profile(seconds int) ([]byte, error) {
 	// Capture a profile for the specified number of seconds
 	r.params.Set("seconds", strconv.Itoa(seconds))
 
-	_, resp, err := requireOK(d.c.doRequest(r))
+	_, resp, err := d.c.doRequest(r)
 	if err != nil {
 		return nil, fmt.Errorf("error making request: %s", err)
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	// We return a raw response because we're just passing through a response
 	// from the pprof handlers
@@ -73,11 +79,13 @@ func (d *Debug) PProf(ctx context.Context, name string, seconds int) (io.ReadClo
 	// Capture a profile for the specified number of seconds
 	r.params.Set("seconds", strconv.Itoa(seconds))
 
-	_, resp, err := requireOK(d.c.doRequest(r))
+	_, resp, err := d.c.doRequest(r)
 	if err != nil {
 		return nil, fmt.Errorf("error making request: %s", err)
 	}
-
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	return resp.Body, nil
 }
 
@@ -88,11 +96,14 @@ func (d *Debug) Trace(seconds int) ([]byte, error) {
 	// Capture a trace for the specified number of seconds
 	r.params.Set("seconds", strconv.Itoa(seconds))
 
-	_, resp, err := requireOK(d.c.doRequest(r))
+	_, resp, err := d.c.doRequest(r)
 	if err != nil {
 		return nil, fmt.Errorf("error making request: %s", err)
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	// We return a raw response because we're just passing through a response
 	// from the pprof handlers
@@ -108,11 +119,14 @@ func (d *Debug) Trace(seconds int) ([]byte, error) {
 func (d *Debug) Goroutine() ([]byte, error) {
 	r := d.c.newRequest("GET", "/debug/pprof/goroutine")
 
-	_, resp, err := requireOK(d.c.doRequest(r))
+	_, resp, err := d.c.doRequest(r)
 	if err != nil {
 		return nil, fmt.Errorf("error making request: %s", err)
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	// We return a raw response because we're just passing through a response
 	// from the pprof handlers
diff --git a/api/discovery_chain.go b/api/discovery_chain.go
index b78e6c3c42..29bda85912 100644
--- a/api/discovery_chain.go
+++ b/api/discovery_chain.go
@@ -38,12 +38,14 @@ func (d *DiscoveryChain) Get(name string, opts *DiscoveryChainOptions, q *QueryO
 	if method == "POST" {
 		r.obj = opts
 	}
-
-	rtt, resp, err := requireOK(d.c.doRequest(r))
+	rtt, resp, err := d.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
diff --git a/api/event.go b/api/event.go
index 1da41375cd..ceded65981 100644
--- a/api/event.go
+++ b/api/event.go
@@ -47,11 +47,14 @@ func (e *Event) Fire(params *UserEvent, q *WriteOptions) (string, *WriteMeta, er
 	}
 	r.header.Set("Content-Type", "application/octet-stream")
 
-	rtt, resp, err := requireOK(e.c.doRequest(r))
+	rtt, resp, err := e.c.doRequest(r)
 	if err != nil {
 		return "", nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return "", nil, err
+	}
 
 	wm := &WriteMeta{RequestTime: rtt}
 	var out UserEvent
@@ -71,11 +74,14 @@ func (e *Event) List(name string, q *QueryOptions) ([]*UserEvent, *QueryMeta, er
 	if name != "" {
 		r.params.Set("name", name)
 	}
-	rtt, resp, err := requireOK(e.c.doRequest(r))
+	rtt, resp, err := e.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
diff --git a/api/health.go b/api/health.go
index b94043857e..2785c4c91c 100644
--- a/api/health.go
+++ b/api/health.go
@@ -231,11 +231,14 @@ func (c *Client) Health() *Health {
 func (h *Health) Node(node string, q *QueryOptions) (HealthChecks, *QueryMeta, error) {
 	r := h.c.newRequest("GET", "/v1/health/node/"+node)
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(h.c.doRequest(r))
+	rtt, resp, err := h.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -252,11 +255,14 @@ func (h *Health) Node(node string, q *QueryOptions) (HealthChecks, *QueryMeta, e
 func (h *Health) Checks(service string, q *QueryOptions) (HealthChecks, *QueryMeta, error) {
 	r := h.c.newRequest("GET", "/v1/health/checks/"+service)
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(h.c.doRequest(r))
+	rtt, resp, err := h.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -329,11 +335,14 @@ func (h *Health) service(service string, tags []string, passingOnly bool, q *Que
 	if passingOnly {
 		r.params.Set(HealthPassing, "1")
 	}
-	rtt, resp, err := requireOK(h.c.doRequest(r))
+	rtt, resp, err := h.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -359,11 +368,14 @@ func (h *Health) State(state string, q *QueryOptions) (HealthChecks, *QueryMeta,
 	}
 	r := h.c.newRequest("GET", "/v1/health/state/"+state)
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(h.c.doRequest(r))
+	rtt, resp, err := h.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
diff --git a/api/kv.go b/api/kv.go
index 300a73ece4..47dfa66944 100644
--- a/api/kv.go
+++ b/api/kv.go
@@ -129,8 +129,11 @@ func (k *KV) getInternal(key string, params map[string]string, q *QueryOptions)
 		r.params.Set(param, val)
 	}
 	rtt, resp, err := k.c.doRequest(r)
-	rtt, resp, err = requireHttpCodes(rtt, resp, err, 200, 404)
+	if err != nil {
+		return nil, nil, err
+	}
 
+	err = requireHttpCodes(resp, 200, 404)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -206,11 +209,14 @@ func (k *KV) put(key string, params map[string]string, body []byte, q *WriteOpti
 	}
 	r.body = bytes.NewReader(body)
 	r.header.Set("Content-Type", "application/octet-stream")
-	rtt, resp, err := requireOK(k.c.doRequest(r))
+	rtt, resp, err := k.c.doRequest(r)
 	if err != nil {
 		return false, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return false, nil, err
+	}
 
 	qm := &WriteMeta{}
 	qm.RequestTime = rtt
@@ -250,11 +256,14 @@ func (k *KV) deleteInternal(key string, params map[string]string, q *WriteOption
 	for param, val := range params {
 		r.params.Set(param, val)
 	}
-	rtt, resp, err := requireOK(k.c.doRequest(r))
+	rtt, resp, err := k.c.doRequest(r)
 	if err != nil {
 		return false, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return false, nil, err
+	}
 
 	qm := &WriteMeta{}
 	qm.RequestTime = rtt
diff --git a/api/namespace.go b/api/namespace.go
index 20f6c8d5cf..96e26728c5 100644
--- a/api/namespace.go
+++ b/api/namespace.go
@@ -63,11 +63,14 @@ func (n *Namespaces) Create(ns *Namespace, q *WriteOptions) (*Namespace, *WriteM
 	r := n.c.newRequest("PUT", "/v1/namespace")
 	r.setWriteOptions(q)
 	r.obj = ns
-	rtt, resp, err := requireOK(n.c.doRequest(r))
+	rtt, resp, err := n.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	wm := &WriteMeta{RequestTime: rtt}
 	var out Namespace
@@ -86,11 +89,14 @@ func (n *Namespaces) Update(ns *Namespace, q *WriteOptions) (*Namespace, *WriteM
 	r := n.c.newRequest("PUT", "/v1/namespace/"+ns.Name)
 	r.setWriteOptions(q)
 	r.obj = ns
-	rtt, resp, err := requireOK(n.c.doRequest(r))
+	rtt, resp, err := n.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	wm := &WriteMeta{RequestTime: rtt}
 	var out Namespace
@@ -105,11 +111,15 @@ func (n *Namespaces) Read(name string, q *QueryOptions) (*Namespace, *QueryMeta,
 	var out Namespace
 	r := n.c.newRequest("GET", "/v1/namespace/"+name)
 	r.setQueryOptions(q)
-	found, rtt, resp, err := requireNotFoundOrOK(n.c.doRequest(r))
+	rtt, resp, err := n.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	found, resp, err := requireNotFoundOrOK(resp)
+	if err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -128,11 +138,14 @@ func (n *Namespaces) Read(name string, q *QueryOptions) (*Namespace, *QueryMeta,
 func (n *Namespaces) Delete(name string, q *WriteOptions) (*WriteMeta, error) {
 	r := n.c.newRequest("DELETE", "/v1/namespace/"+name)
 	r.setWriteOptions(q)
-	rtt, resp, err := requireOK(n.c.doRequest(r))
+	rtt, resp, err := n.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	wm := &WriteMeta{RequestTime: rtt}
 	return wm, nil
@@ -142,11 +155,14 @@ func (n *Namespaces) List(q *QueryOptions) ([]*Namespace, *QueryMeta, error) {
 	var out []*Namespace
 	r := n.c.newRequest("GET", "/v1/namespaces")
 	r.setQueryOptions(q)
-	rtt, resp, err := requireOK(n.c.doRequest(r))
+	rtt, resp, err := n.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
diff --git a/api/operator_area.go b/api/operator_area.go
index 5476f5c5b4..f9fa1339e2 100644
--- a/api/operator_area.go
+++ b/api/operator_area.go
@@ -89,11 +89,14 @@ func (op *Operator) AreaCreate(area *Area, q *WriteOptions) (string, *WriteMeta,
 	r := op.c.newRequest("POST", "/v1/operator/area")
 	r.setWriteOptions(q)
 	r.obj = area
-	rtt, resp, err := requireOK(op.c.doRequest(r))
+	rtt, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return "", nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return "", nil, err
+	}
 
 	wm := &WriteMeta{}
 	wm.RequestTime = rtt
@@ -110,11 +113,14 @@ func (op *Operator) AreaUpdate(areaID string, area *Area, q *WriteOptions) (stri
 	r := op.c.newRequest("PUT", "/v1/operator/area/"+areaID)
 	r.setWriteOptions(q)
 	r.obj = area
-	rtt, resp, err := requireOK(op.c.doRequest(r))
+	rtt, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return "", nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return "", nil, err
+	}
 
 	wm := &WriteMeta{}
 	wm.RequestTime = rtt
@@ -150,11 +156,14 @@ func (op *Operator) AreaList(q *QueryOptions) ([]*Area, *QueryMeta, error) {
 func (op *Operator) AreaDelete(areaID string, q *WriteOptions) (*WriteMeta, error) {
 	r := op.c.newRequest("DELETE", "/v1/operator/area/"+areaID)
 	r.setWriteOptions(q)
-	rtt, resp, err := requireOK(op.c.doRequest(r))
+	rtt, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	wm := &WriteMeta{}
 	wm.RequestTime = rtt
@@ -167,11 +176,14 @@ func (op *Operator) AreaJoin(areaID string, addresses []string, q *WriteOptions)
 	r := op.c.newRequest("PUT", "/v1/operator/area/"+areaID+"/join")
 	r.setWriteOptions(q)
 	r.obj = addresses
-	rtt, resp, err := requireOK(op.c.doRequest(r))
+	rtt, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	wm := &WriteMeta{}
 	wm.RequestTime = rtt
diff --git a/api/operator_autopilot.go b/api/operator_autopilot.go
index 99b02faab8..6ab5769709 100644
--- a/api/operator_autopilot.go
+++ b/api/operator_autopilot.go
@@ -297,11 +297,14 @@ func (d *ReadableDuration) UnmarshalJSON(raw []byte) (err error) {
 func (op *Operator) AutopilotGetConfiguration(q *QueryOptions) (*AutopilotConfiguration, error) {
 	r := op.c.newRequest("GET", "/v1/operator/autopilot/configuration")
 	r.setQueryOptions(q)
-	_, resp, err := requireOK(op.c.doRequest(r))
+	_, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	var out AutopilotConfiguration
 	if err := decodeBody(resp, &out); err != nil {
@@ -316,11 +319,14 @@ func (op *Operator) AutopilotSetConfiguration(conf *AutopilotConfiguration, q *W
 	r := op.c.newRequest("PUT", "/v1/operator/autopilot/configuration")
 	r.setWriteOptions(q)
 	r.obj = conf
-	_, resp, err := requireOK(op.c.doRequest(r))
+	_, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -332,11 +338,14 @@ func (op *Operator) AutopilotCASConfiguration(conf *AutopilotConfiguration, q *W
 	r.setWriteOptions(q)
 	r.params.Set("cas", strconv.FormatUint(conf.ModifyIndex, 10))
 	r.obj = conf
-	_, resp, err := requireOK(op.c.doRequest(r))
+	_, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return false, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return false, err
+	}
 
 	var buf bytes.Buffer
 	if _, err := io.Copy(&buf, resp.Body); err != nil {
@@ -353,16 +362,15 @@ func (op *Operator) AutopilotServerHealth(q *QueryOptions) (*OperatorHealthReply
 	r.setQueryOptions(q)
 
 	// we use 429 status to indicate unhealthiness
-	d, resp, err := op.c.doRequest(r)
-	_, resp, err = requireHttpCodes(d, resp, err, 200, 429)
-
+	_, resp, err := op.c.doRequest(r)
+	if err != nil {
+		return nil, err
+	}
+	defer closeResponseBody(resp)
+	err = requireHttpCodes(resp, 200, 429)
 	if err != nil {
-		if resp != nil {
-			closeResponseBody(resp)
-		}
 		return nil, err
 	}
-
 	defer closeResponseBody(resp)
 
 	var out OperatorHealthReply
@@ -375,11 +383,14 @@ func (op *Operator) AutopilotServerHealth(q *QueryOptions) (*OperatorHealthReply
 func (op *Operator) AutopilotState(q *QueryOptions) (*AutopilotState, error) {
 	r := op.c.newRequest("GET", "/v1/operator/autopilot/state")
 	r.setQueryOptions(q)
-	_, resp, err := requireOK(op.c.doRequest(r))
+	_, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	var out AutopilotState
 	if err := decodeBody(resp, &out); err != nil {
diff --git a/api/operator_keyring.go b/api/operator_keyring.go
index baad70eedb..15f319bb11 100644
--- a/api/operator_keyring.go
+++ b/api/operator_keyring.go
@@ -36,11 +36,14 @@ func (op *Operator) KeyringInstall(key string, q *WriteOptions) error {
 	r.obj = keyringRequest{
 		Key: key,
 	}
-	_, resp, err := requireOK(op.c.doRequest(r))
+	_, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -48,11 +51,14 @@ func (op *Operator) KeyringInstall(key string, q *WriteOptions) error {
 func (op *Operator) KeyringList(q *QueryOptions) ([]*KeyringResponse, error) {
 	r := op.c.newRequest("GET", "/v1/operator/keyring")
 	r.setQueryOptions(q)
-	_, resp, err := requireOK(op.c.doRequest(r))
+	_, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	var out []*KeyringResponse
 	if err := decodeBody(resp, &out); err != nil {
@@ -68,11 +74,14 @@ func (op *Operator) KeyringRemove(key string, q *WriteOptions) error {
 	r.obj = keyringRequest{
 		Key: key,
 	}
-	_, resp, err := requireOK(op.c.doRequest(r))
+	_, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -83,10 +92,13 @@ func (op *Operator) KeyringUse(key string, q *WriteOptions) error {
 	r.obj = keyringRequest{
 		Key: key,
 	}
-	_, resp, err := requireOK(op.c.doRequest(r))
+	_, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
diff --git a/api/operator_license.go b/api/operator_license.go
index 73e5051bad..7b654317ca 100644
--- a/api/operator_license.go
+++ b/api/operator_license.go
@@ -62,11 +62,14 @@ func (op *Operator) LicenseGetSigned(q *QueryOptions) (string, error) {
 	r := op.c.newRequest("GET", "/v1/operator/license")
 	r.params.Set("signed", "1")
 	r.setQueryOptions(q)
-	_, resp, err := requireOK(op.c.doRequest(r))
+	_, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return "", err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return "", err
+	}
 
 	data, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
@@ -85,11 +88,14 @@ func (op *Operator) LicenseReset(opts *WriteOptions) (*LicenseReply, error) {
 	var reply LicenseReply
 	r := op.c.newRequest("DELETE", "/v1/operator/license")
 	r.setWriteOptions(opts)
-	_, resp, err := requireOK(op.c.doRequest(r))
+	_, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
-	defer resp.Body.Close()
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 	if err := decodeBody(resp, &reply); err != nil {
 		return nil, err
 	}
@@ -105,11 +111,14 @@ func (op *Operator) LicensePut(license string, opts *WriteOptions) (*LicenseRepl
 	r := op.c.newRequest("PUT", "/v1/operator/license")
 	r.setWriteOptions(opts)
 	r.body = strings.NewReader(license)
-	_, resp, err := requireOK(op.c.doRequest(r))
+	_, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
-	defer resp.Body.Close()
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	if err := decodeBody(resp, &reply); err != nil {
 		return nil, err
diff --git a/api/operator_raft.go b/api/operator_raft.go
index 0bfb85d000..1b48fdcd9b 100644
--- a/api/operator_raft.go
+++ b/api/operator_raft.go
@@ -40,11 +40,14 @@ type RaftConfiguration struct {
 func (op *Operator) RaftGetConfiguration(q *QueryOptions) (*RaftConfiguration, error) {
 	r := op.c.newRequest("GET", "/v1/operator/raft/configuration")
 	r.setQueryOptions(q)
-	_, resp, err := requireOK(op.c.doRequest(r))
+	_, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	var out RaftConfiguration
 	if err := decodeBody(resp, &out); err != nil {
@@ -62,12 +65,14 @@ func (op *Operator) RaftRemovePeerByAddress(address string, q *WriteOptions) err
 
 	r.params.Set("address", address)
 
-	_, resp, err := requireOK(op.c.doRequest(r))
+	_, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -79,11 +84,13 @@ func (op *Operator) RaftRemovePeerByID(id string, q *WriteOptions) error {
 
 	r.params.Set("id", id)
 
-	_, resp, err := requireOK(op.c.doRequest(r))
+	_, resp, err := op.c.doRequest(r)
 	if err != nil {
 		return err
 	}
-
-	closeResponseBody(resp)
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
diff --git a/api/partition.go b/api/partition.go
index 359f3713bd..2b6bed8e55 100644
--- a/api/partition.go
+++ b/api/partition.go
@@ -49,11 +49,14 @@ func (p *Partitions) Create(ctx context.Context, partition *AdminPartition, q *W
 	r.setWriteOptions(q)
 	r.ctx = ctx
 	r.obj = partition
-	rtt, resp, err := requireOK(p.c.doRequest(r))
+	rtt, resp, err := p.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
-	defer resp.Body.Close()
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	wm := &WriteMeta{RequestTime: rtt}
 	var out AdminPartition
@@ -73,11 +76,14 @@ func (p *Partitions) Update(ctx context.Context, partition *AdminPartition, q *W
 	r.setWriteOptions(q)
 	r.ctx = ctx
 	r.obj = partition
-	rtt, resp, err := requireOK(p.c.doRequest(r))
+	rtt, resp, err := p.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
-	defer resp.Body.Close()
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	wm := &WriteMeta{RequestTime: rtt}
 	var out AdminPartition
@@ -93,11 +99,15 @@ func (p *Partitions) Read(ctx context.Context, name string, q *QueryOptions) (*A
 	r := p.c.newRequest("GET", "/v1/partition/"+name)
 	r.setQueryOptions(q)
 	r.ctx = ctx
-	found, rtt, resp, err := requireNotFoundOrOK(p.c.doRequest(r))
+	rtt, resp, err := p.c.doRequest(r)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer closeResponseBody(resp)
+	found, resp, err := requireNotFoundOrOK(resp)
 	if err != nil {
 		return nil, nil, err
 	}
-	defer resp.Body.Close()
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -117,11 +127,14 @@ func (p *Partitions) Delete(ctx context.Context, name string, q *WriteOptions) (
 	r := p.c.newRequest("DELETE", "/v1/partition/"+name)
 	r.setWriteOptions(q)
 	r.ctx = ctx
-	rtt, resp, err := requireOK(p.c.doRequest(r))
+	rtt, resp, err := p.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
-	resp.Body.Close()
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	wm := &WriteMeta{RequestTime: rtt}
 	return wm, nil
@@ -132,11 +145,14 @@ func (p *Partitions) List(ctx context.Context, q *QueryOptions) (*AdminPartition
 	r := p.c.newRequest("GET", "/v1/partitions")
 	r.setQueryOptions(q)
 	r.ctx = ctx
-	rtt, resp, err := requireOK(p.c.doRequest(r))
+	rtt, resp, err := p.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
-	defer resp.Body.Close()
+	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
diff --git a/api/prepared_query.go b/api/prepared_query.go
index 5b2d5a5d18..b3dd7be6f2 100644
--- a/api/prepared_query.go
+++ b/api/prepared_query.go
@@ -154,11 +154,14 @@ func (c *PreparedQuery) Create(query *PreparedQueryDefinition, q *WriteOptions)
 	r := c.c.newRequest("POST", "/v1/query")
 	r.setWriteOptions(q)
 	r.obj = query
-	rtt, resp, err := requireOK(c.c.doRequest(r))
+	rtt, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return "", nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return "", nil, err
+	}
 
 	wm := &WriteMeta{}
 	wm.RequestTime = rtt
@@ -200,11 +203,14 @@ func (c *PreparedQuery) Get(queryID string, q *QueryOptions) ([]*PreparedQueryDe
 func (c *PreparedQuery) Delete(queryID string, q *WriteOptions) (*WriteMeta, error) {
 	r := c.c.newRequest("DELETE", "/v1/query/"+queryID)
 	r.setWriteOptions(q)
-	rtt, resp, err := requireOK(c.c.doRequest(r))
+	rtt, resp, err := c.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	wm := &WriteMeta{}
 	wm.RequestTime = rtt
diff --git a/api/snapshot.go b/api/snapshot.go
index 0c8294f37c..b526b79c3b 100644
--- a/api/snapshot.go
+++ b/api/snapshot.go
@@ -23,10 +23,13 @@ func (s *Snapshot) Save(q *QueryOptions) (io.ReadCloser, *QueryMeta, error) {
 	r := s.c.newRequest("GET", "/v1/snapshot")
 	r.setQueryOptions(q)
 
-	rtt, resp, err := requireOK(s.c.doRequest(r))
+	rtt, resp, err := s.c.doRequest(r)
 	if err != nil {
 		return nil, nil, err
 	}
+	if err := requireOK(resp); err != nil {
+		return nil, nil, err
+	}
 
 	qm := &QueryMeta{}
 	parseQueryMeta(resp, qm)
@@ -40,9 +43,12 @@ func (s *Snapshot) Restore(q *WriteOptions, in io.Reader) error {
 	r.body = in
 	r.header.Set("Content-Type", "application/octet-stream")
 	r.setWriteOptions(q)
-	_, _, err := requireOK(s.c.doRequest(r))
+	_, resp, err := s.c.doRequest(r)
 	if err != nil {
 		return err
 	}
+	if err := requireOK(resp); err != nil {
+		return err
+	}
 	return nil
 }
diff --git a/api/status.go b/api/status.go
index 2a81b9b5fe..86f943bc76 100644
--- a/api/status.go
+++ b/api/status.go
@@ -18,11 +18,14 @@ func (s *Status) LeaderWithQueryOptions(q *QueryOptions) (string, error) {
 		r.setQueryOptions(q)
 	}
 
-	_, resp, err := requireOK(s.c.doRequest(r))
+	_, resp, err := s.c.doRequest(r)
 	if err != nil {
 		return "", err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return "", err
+	}
 
 	var leader string
 	if err := decodeBody(resp, &leader); err != nil {
@@ -43,11 +46,14 @@ func (s *Status) PeersWithQueryOptions(q *QueryOptions) ([]string, error) {
 		r.setQueryOptions(q)
 	}
 
-	_, resp, err := requireOK(s.c.doRequest(r))
+	_, resp, err := s.c.doRequest(r)
 	if err != nil {
 		return nil, err
 	}
 	defer closeResponseBody(resp)
+	if err := requireOK(resp); err != nil {
+		return nil, err
+	}
 
 	var peers []string
 	if err := decodeBody(resp, &peers); err != nil {